nyuuzyou/wikis huggingface dataset:
HQ9F+

HQ9F+ is an extended language of HQ9+, featuring FizzBuzz, designed by ぬこ, published in 2007. According to the designer, he designed for being discouraged to hear the news that the young programmers cannot even program FizzBuzz.
== Features ==
This language has four original instructions: H, Q, 9, and + and an extended instruction F.
The instruction F is to output FizzBuzz up to the time the accumulator got accumulated.
== Example ==
 +++++f
outputs
 1
 2
 Fizz
 4
 Buzz
----
 +++++++++++++++f
outputs
 1
 2
 Fizz
 4
 Buzz
 Fizz
 7
 8
 Fizz
 Buzz
 11
 Fizz
 13
 14
 FizzBuzz
== See also ==
* HQ9+
* FHQ9+-
== External resources ==
*
**
;Other implementations
*wobh/HQ9F-Ruby - developed as a module.
*momo2ro/HQ9Fplus - in C. The exception is that it fizzbuzzes for 1000 times, instead of value of accumulator.
* - in Python3.
Category:Languages
Category:Joke languages
Category:Unusable for programming
Category:2007
Category:Total
Category:Output only
Category:Implemented
HQ9funge

HQ9funge or HQ9FTC is an esoteric programming language created by User:Andrew3335 purely to make the programmer's life worse.
==Language overview==
===Commands===
HQ9funge has 11 commands:
Command	Description
H 	Print "Hello, World!"
Q 	Print the program's source code (Quine)
9 	Print the lyrics to "99 bottles of beer"
F 	Do something random
T 	Print 0 once if input is 0, print 1 forever if input is 1 (Truth-machine)
C 	Change a random command in the code to either H or Q
2 	Create HQ9funge
+ 	Increment the accumulator
> 	Point the instruction pointer (IP) in a random direction
M 	Choose a random program (either 99 Bottles of Beer or Hello, World!) to output from a random language (either Malbolge, C# or Piet); after that, check if the number of commands the IP has passed through is prime; if yes, continue normally; if not, teleport the IP to the first instance of ( in the program
r 	99% of the time: switch the user's perms to root, then execute rm -rf /; 1% of the time: zero out the user's hard drive (fill it with 0s)
Additionally, | is used to separate single char programs and multichar ones.
===Entropy===
The program can randomly have entropy, meaning that random chars can be changed at random times. The code can have entropy too (chars can be randomly changed during runtime). For example, an H command could randomly turn into an r command during runtime, which would wipe your hard drive (or zero it out), making HQ9funge the most dangerous language to use.
==Examples==
===The name of the language as a program in that language===
 HQ9FTC
Hello world, quine, 99 Bottles of Beer, do something random, truth machine, change a random command in the code to either H or Q. Note that this code can always change due to entropy.
==Computational class==
HQ9funge is obviously not Turing-complete.
==Implementations==
There are currently no implementations of HQ9funge, however the creator doesn't want it to be implemented.
==See also==
At least one of the following languages was an inspiration for HQ9funge.
* HQ9+
* HQ9++
* HQ9+2D
* HQ9+B
* Befunge
Category:2018Category:Joke languagesCategory:Self-modifyingCategory:UnimplementedCategory:Languages
HS

HS is a 3 command language
Yes you heard me right 3
==Commands==
 
 “#” , “ ” and “:”
===CodeManual===
 # - if 
 ## - then
 ### - end if
 #### - loop # amount of times
 ##### - end loop # amount of times
 ###### - loop infinitely
 ####### - end loop infinitely
 ######## - >
 ######### - =
 ########## - <
 More than 10 hashes are a number 
 11#-0
 12#-1
 13#-2
 .
 .
 .
 20#-9
 Also 21#-print if its vars then print
 ASCII if numbers print numbers
 More than 21 hashes are variables
 22#-var1
 .
 .
 .
 : accept input
==Examples==
===Print “-”===
 1. var1=45
 2. if 1=1 then 
 3. print var1
 4. end if
 1. ###################### ######### 
 ############### ################
 2. # ############ ######### 
 ############ ##
 3. ##################### 
 ######################
 4. ###
Outputs “-”
===Print “Hello World”===
 1. var1=72 //H
 2. var2=101 //e
 3. var3=108 //l
 4. var4=111 //o
 5. var5=32 // 
 6. var6=87 //W
 7. var7=114 //r
 8. var8=100 //d
 9. print var1 var2 var3 var3 var4 var5
 var6 var4 var7 var3 var8
 22# 9# 18# 13#
 23# 9# 12# 11# 12#
 24# 9# 12# 11# 19#
 25# 9# 12# 12# 12#
 26# 9# 14# 13#
 27# 9# 19# 18#
 28# 9# 12# 12# 15#
 29# 9# 12# 11# 11#
 21# 22# 23# 24# 24# 25# 26# 27# 25# 
 28# 24# 29#
Outputs “Hello World”
===Truth Machine===
Input 0 Output 0
Input 1 Output 1111111…
 forever loop
 input=:
 if input=0 then
 print 0
 end if
 if input=1 then
 forever loop
 print 1
 end loop forever
 end if
 end loop forever
 ######
 ###################### ######### :
 # ###################### ######### ########### ##
 ##################### ###########
 ###
 # ###################### ######### ############ ##
 ######
 ##################### ############
 #######
 ###
 #######
===Counting asterisk printer===
The following program queries the user for an integer and prints a number of asterisks (“*”) tantamount to the input:
 ###################### ######### :
 ####################### ######### ############### #############
 #### ######################
 ##################### #######################
 #####
==Interpreter==
* Common Lisp implementation of the HS programming language.
Category:Languages
Category:2023
Category:Implemented
HTPL

The Hypertext Programming Language is best described as a strict syntactical subset of HTML. Its main purpose is to provide a way to claim that:
 
HTML is a programming language (if it is interpreted as HTPL).
== History ==
The HTPL is still a work in progress. For any suggestions or discussions, please visit the talk page: Talk:HTPL
== Datatypes ==
HTPL is a dynamically typed language. As such, it has the primitive data types:
* String
* Number
* Array
* Boolean
== Syntax ==
As a subset of HTML, HTPL code should always be able to be interpreted as 'correct' HTML code. The only difference is the enclosing tag not as <html> but as <htpl>. The rest of HTPL's syntax is defined as following:
HTPL 	Description
<var id="foo">42</var> 	Declares a single variable called foo with the numeric value 42. Variables can only be declared once.
<table><td>1</td><td>2</td></table> 	Declares a array with the values [1, 2]
<p>Hello</p> 	Prints the word "Hello"
<input id="bar" /> 	Reads a byte from the input and saves in in the variable bar
<button value="{foo}"><p>{foo}</p></button>	Prints the variable foo, if foo is true. The code inside the <button>-tag is only executed if value is true
<select id="x" name="{foo}"></select> 	Declares a switch statement, in which the content of name is set to a variable with name of id (the id-attribute is optional).
<option value="0"><p>A</p></option> 	Inside a <select>-tag, if the id is equal to the <option>'s value, the code is executed.
<ol id="i" value="0"><p>{i}</p></ol> 	Prints an infinite amount of ever increasing numbers. <ol> declares an infinite loop that is to be breaked from explicitly. With each successfully executed completion the value of the variable with the name of the id is increased. The start value can be set manually with the value attribute and has to be a number.
<li value="69"><p>Nice</p></li> 	Inside a <ol>-tag, if the iterator has the value 69, print "Nice".
<br/> 	Breaks from the current function, loop, code-block. If used in the main <htpl>-tag, the program is terminated.
<div id="buzz">...</div> 	Declares the function called buzz. Parameters can be accessed via the variables $0, $1, $2 ...
<a href="#buzz">1</a> 	Calls the function buzz with one parameter with the value 1.
== Examples ==
=== Hello World ===
<htpl>
 Hello World!
 
</htpl>
== Related ==
* HTPF
Category:Languages
HUNTER

HUNTER, invented by Chris Pressey in 2001, is a deterministic particle automaton based on mazespace-rewriting and critter-style message passing (and also an esoteric programming language). The language attempts to solve the problem of programmer boredom leading to the abandonment of software.
HUNTER was submitted to the 2001 Esoteric Awards.
==Description==
A program is composed of mice in a space interacting with cheese and each other. The detailed description is copyrighted, but can be found here.
==External resources==
* 
* HUNTER in the Esoteric File Archive
==See also==
* Mice in a maze, which also involves mice in a maze
Category:Languages
Category:Two-dimensional languages
Category:Usability unknown
Category:Cell-based
Category:Implemented
Category:2001
HZ3funge

HZ3funge is an Esolang designed by PSTF. It is designed for even complex Befunge.
== Syntax ==
=== Basic syntax ===
Every layer must saved as a file, just like these: 
* Sample program
** layer1.h3f
** layer2.h3f
** layer3.h3f
** ……
** main.exe
All layers must named with "layerN.h3f".
When a program saved, the main.exe is also generated. Run main.exe to execute whole program.
=== Command Table ===
 Command list
HZfunge 	Befunge/Trefunge	English Mean
加 	+ 	Plus
减 	- 	Minus
乘 	* 	Times
除 	/ 	Divide
余 	% 	Modulo
非 	! 	Not
大 	` 	Bigger
东 	> 	East
西 	< 	West
南 	v 	South
北 	^ 	North
乱 	? 	Chaos
横 	_ 	Horizontal
竖 	 	Vertical
＂ 	" 	Quote
双 	: 	Double
换 	\ 	Swap
灭 	$ 	Destroy
写 	, 	Write
读 	~ 	Read
听 	& 	Listen
说 	. 	Speak
桥 	# 	Bridge
　 	 	(SP)
终 	@ 	End
置 	p 	Put
取 	g 	Get
零一二三四五六七八九(Note that 零 can be 〇.) 	0123456789 	Zero, one, two, three, four, five, six, seven, eight, nine
十 	a 	Ten
廿 	aa+ 	Twenty
卅 	a3* 	Thirty
卌 	85* 	Forty
圩 	a5* 	Fifty
圆 	c5* 	Sixty
进 	e5* 	Seventy
枯 	a8* 	Eighty
枠 	a9* 	Ninety
百 	aa* 	Hundred
千 	aa*a* 	1,000
万 	aa*a*a* 	10,000
翻 	r 	Flip
天 	h 	Heaven
地 	l 	Earth
纵 	m 	Longitudinal
嘭 	n 	Boom
甲 	b 	First
乙 	c 	Second
丙 	d 	Third
丁 	e 	Fourth
戊 	f 	Fifth
己 	82* 	Sixth
庚 	a7+ 	Seventh
辛 	92* 	Eighth
壬 	a9+ 	Ninth
癸 	45* 	Tenth
跳 	; 	Jump
空 	z 	Null
方 	:* 	Square
块 	::** 	Block
== Samples ==
=== Hello, world! ===
==== Layer 1 ====
东　　　　　　　　　　　　　　北
北　　　　＂问天地好在。＂　　西
东双北
南写横终
=== (A+B)×C Problem ===
==== Layer 1 ====
地　　　东听乘地　　
==== Layer 2 ====
东听听加天　　东说终
=== Truth Machine ===
==== Layer 1 ====
听桥双双横说终桥
== See also ==
* HZfunge
== Category ==
Category:Languages 
Category:Stack-based 
Category:Push-down automata 
Category:Turing complete 
Category:Multi-dimensional languages 
Category:Self-modifying
Category:2024
Category:CJK
HZfunge

The Befunge written by Chinese Characters.
== Commands ==
 Command list
HZfunge 	Befunge 	English Mean
加 	+ 	Plus
减 	- 	Minus
乘 	* 	Times
除 	/ 	Divide
余 	% 	Modulo
非 	! 	Not
大 	` 	Bigger
右 	> 	Right
左 	< 	Left
上 	^ 	Up
下 	v 	Down
乱 	? 	Chaos
横 	_ 	Horizontal
竖 	 	Vertical
＂ 	" 	Quote
双 	: 	Double
换 	\ 	Swap
灭 	$ 	Destroy
写 	, 	Write
读 	~ 	Read
听 	& 	Listen
说 	. 	Speak
桥 	# 	Bridge
　 	 	(SP)
终 	@ 	End
置 	p 	Put
取 	g 	Get
零一二三四五六七八九(Note that 零 can be 〇.) 	0123456789	Zero, one, two, three, four, five, six, seven, eight, nine
The playfield of HZfunge is 10000x100.
== Examples ==
=== Basic ===
==== Hello, world ====
===== Basic =====
 ＂。在好地天问＂右双桥写横终
===== Without string reverse =====
右　　　　　　　　　　　　　　下
下　　　　＂问天地好在。＂　　左
右双下
上写横终
==== Cat program ====
读双一加非桥终横写
==== Truth Machine ====
听桥双双横写终桥
==== A+B ====
听听加说终
=== Algorithm ===
==== Sieve of Eratosthenes ====
二右双三取＂　＂减非下双　　取三零　　　　　　　　　　左
　数非大＂Ｏ＂双加一下双说双零三置右零三取加双＂Ｏ＂非数
　终　　　　　　　　　　　　　　　上　　置三换＂　＂双左
二　二三四五六七八九〇一二三四五六七八九〇一二三四五六七八九〇一二三四五六七八九〇一二三四五六七八九〇一二三四五六七八九〇一二三四五六七八九〇一二三四五六七八九
== Implementation ==
If you want to write a implementer for this Esolang, please reference the implementation of Befunge. Thank you!
== See also ==
* Befunge
* HZCode
* HZ3funge
== Categories ==
Category:Languages 
Category:Stack-based 
Category:Push-down automata 
Category:Turing complete 
Category:Two-dimensional languages 
Category:Low-level 
Category:Self-modifying
Category:2024
Category:CJK
HaPyLi

HaPyLi is a programming language designed to compile to Whitespace, with syntax derived from Haskell, Python, and Lisp.
It was created in 2009 by Cybis and announced on the Whitespace mailing list. The HaPyLi website went offline some time between 2013 and 2015 and the source code was lost until 2023, when the author provided a copy. It is now maintained at github.com/wspace/cybis-hapyli, including the tutorial.
== External resources ==
* HaPyLi source code
* HaPyLi tutorial
Category:Languages
Category:High-level
Category:2009
Category:Implemented
HackEso/Haskell

=== Notes on compiling Haskell programs for HackEso ===
These notes use Burlesque as an example, but should generalize to other Haskell programs (possibly with different versions of GHC).
* match the distribution: Debian 10 (soon: 11). debootstrap --arch=amd64 oldstable /<some chroot>
* install GHC + Burlesque dependencies (apt-get install make ghc alex happy g++ cabal-install git wget curl xz-utils)
* compile correct GHC version (8.8.4 for Burlesque).crucially, use ./configure --disable-large-address-space to disable the GHC runtime's default of reserving 1TiB of address space on startup, which does not work in UML
* enable split-objs in ~/.cabal/config (cabal update first creates this file)
* install Burlesque dependencies cabal install split haskeline mtl regex-compat parsec digits statistics monadlist utf8-string
* compile Burlesque with ghc -static (which causes ghc to link all Haskell libraries into the executable... but not libc)
* maybe adjust paths to /hackenv/tmp. there's no convention for this yet but watch HackEso for future developments.
* strip the binaries
Haddock

Haddock is a odd programming language, based on the famous concept of the Deadfish programming language. The only major differences are:
* Expansion of the negative limit from -1 to -2.
* Expansion of the maximum limit from 256 to 1024(from 2^8 to 2^10).
* Addition of cube command.
* Addition of eplus function, which squares the cells value, adds 2 and doubles it. (Of course the full value will not be displayed!
The "Haddock Standard Organization" published a standard for all Haddock interpreters:
# All the compilers/interpreters for Haddock must have the set of instructions portrayed above,plus the standard Deadfish ones.
# All the compilers/interpreters for Haddock must have the word Haddock somewhere in their name. (E.g CaptainHaddock&Tintin, AtlanticHaddock, PythoneatsHaddock)
# All the compilers/interpreters shall not have file I/O. All code will be written in the REPL
# All the compilers/interpreters shall have a REPL.
Also, the HSO reminds you that rules are made to broken!(except of rule 1)
===== Implementing Haddock =====
Several attempts have been a made by HSO to make a Haddock interpreter. Here is AtlanticHaddock v 0.1:
(Thanks to Jonathan Tod Skinner for creating the original Python Deadfish interpreter!)
# Based on Jonathan Tod Skinners Python Deadfish interpreter.
# Changed by Singingbanana & Dan_zh.
# This code is hereby in public domain.
# Initialization
accumulator = 0
# Main program loop
while True:
 # Get user input
 cmd = raw_input('>> ')
 if accumulator == 1024 or accumulator == -2:
 # Overflow, reset accumulator
 accumulator = 0
 # Process input
 if cmd == 'i':
 accumulator += 1 # Increment
 elif cmd == 'c':
 accumulator * accumulator * accumulator
 elif cmd == 'e':
 accumulator*accumulator+2*2
 
 elif cmd == 'd':
 accumulator += -1 # Decrement
 elif cmd == 'o':
 print accumulator # Output
 elif cmd == 's':
 accumulator *= accumulator # Square
 else:
 print 'Unrecognized command.'
Category:Languages
Category:Implemented
Category:2018
Category:Joke languages
Category:Finite state automata
Haddock2

Haddock2 is a theoretical esolang based the extended multiple lambda notation by user:singingbanana & user:Dan_zh.
 
==== Explanation ====
lambda(x.x+lambda(x.x+1)) in lambda calculus can be translated into multiple lambda notation like this:
l1(x:x+l1+1)
Haddock2 is a extension of this. The program portrayed above will like like this in Haddock2:
arguments ::= x
lambdas ::= 1
lambda(0) ::= lambda(lambda(1, arguments)+lambda(1)+1))
lambda(1) ::= lambda(input ::= arguments, output ::= arguments) ;Identity function
====Turing-completeness====
Haddock2 is Turing-complete because it applicable the A. Turing, "Computability and lambda definability" proof. It is a lambda language, so any program can be written with it, though the efficiency will be lower then Java. 
==== useless fact. ====
Obviously, Haddock2 is a functional programming language.
==== Interpreter ====
Making an interpreter for this will be as hard as one for the Expanded Backus-Naur Form, as Haddock-2 is a meta-language (like HTML!)
Category:Languages
Category:2018
Half-Broken Car in Heavy Web Traffic

Half-Broken Car in Heavy Web Traffic is an esolang by User:BoundedBeans as a derivative of Half-Broken Car in Heavy Traffic. If implemented, it would allow for Half-Broken Car in Heavy Traffic to be used on the web.
==New commands==
.	Output the cell immediately, rather than waiting until the program ends. The ending output will be done after this output.
,	Input the cell immediately, instead of at the beginning. The initial input will be only the first line, but this command is capable of grabbing more. Newline characters are included, and in fact, if any more input is actually given, the first character that will be input will always be either a newline or a carriage return, depending on which format is used in the input. EOF inputs -1.
$	Open a server socket with the port of the current cell. Change the . and , commands to use the socket buffer instead.
%	Close the existing socket. Change the . and , commands back to stdin and stdout.
`	Move the data pointer to the right repeatedly, accumulating characters into a string until -1 is reached. When -1 is reached, execute the string as Javascript (probably using eval or something). The pointer ends on the -1 before moving to the next command. Note that this will require a line containing @evaljs, otherwise it will throw an error. This is to allow things using code in this language to check whether it could run malicious code, and use caution.
Category:Languages
Category:Two-dimensional languages
Category:Cell-based
Category:Turing complete
Category:Unimplemented
Half hearted

Half hearted is a program that outputs the coordinates of a cubic bézier curve, specifically one with the control points (-1,0), (0,1), (1,2), (0,1).
You should be able to tell the program how many points the curve it should output (to prevent hard coding). The program must output the start and end, and i-2 other values that define the curve. It does not have to draw it, nor output a common format.
==Implementations==
===MoreMathRPN===
 inputR "Input number of points >= 2"
 floor
 repeat ]0
 "init variables
 1
 >>> 0
 1
 -
 >> 2
 1
 -
 /
 hold t
 -
 hold t'
 "point #1 (0,-1)
 >> 0
 >> 0
 *
 *
 0
 -1
 m 1 2
 *
 "point #2 (1,0)
 3
 place t
 place t'
 >> 0
 *
 *
 *
 1
 0
 m 1 2
 *
 +
 "point #3 (1,2)
 3
 place t
 >> 0
 place t'
 *
 *
 *
 1
 2
 m 1 2
 *
 +
 "point #4 (0,1)
 place t
 >> 0
 >> 0
 *
 *
 0
 1
 m 1 2
 *
 +
 "output
 outputV
 outputS ", "
 next
==External resources==
Desmos graph
Category:Program forms
Halforth

Halforth - is an esolang based on Forth by User:ChuckEsoteric08 in which every instruction takes half of a byte (a single hexadecimal digit)
==Description==
Language works on a stack as well as a tape to store data, which could contain both negative and positive integers
 Commands (in hex)
Command	Opcode 	Description
0-9 	push x 	Push a single digit to the stack
A 	op 	pop operation, a and b and perform b<op>a (see below)
B 	if 	Pop a value, and start if nonzero block
C 	dup 	Duplicates top of the stack
D 	endif 	End if block
E 	define / ;	Pop a value of and start a procedure definition with that name, which is finished by another E
F 	exec 	Pop a value and execute a procedure with that name
There is four I/O related procedures which could be executed with and F: 
Procedure name	Opcode	Description
0 	out 	Pop element from the stack and output it as a number
1 	cout 	Pop element from the stack and output it as a character
2 	in 	Input a number and push it to the stack
3 	cin 	Input a character and push it's value in the stack
Instructuon A performs operation on the elements using a value of the element above them:
Value	Opcode	Operation
0 	add 	Addition
1 	sub 	Subtraction
2 	mul 	Multiplication
3 	div 	Division
4 	less 	Less than
5 	eq 	Equals
7 	bigger	Bigger than
8 	swap 	Swap instruction, pushes b and then a
9 	store 	Store value a at index b
10 	load 	Push a back, and then load value from index b and push it to the stack
Category:Languages Category:Turing complete Category:Turing tarpits Category:Unimplemented Category:Stack-based Category:Cell-based Category:2024
HaltJS

HaltJS is a language created by User:PythonshellDebugwindow.
==Syntax==
HaltJS has a syntax identical to that of JavaScript, with one major limitation: whenever the interpreter encounters a period in the source code, it will stop immediately. This makes things such as dot notation and floating-point literals impossible to use.
===Dot Notation===
Use bracket notation instead.
===Floating-Point Literals===
Say you wanted 2.5, do parseFloat("2" + String(1/2)[1] + "5") instead.
==Hello World==
 console["log"]("Hello, World!");
or
 alert("Hello, World!");
==See also==
* MangularJS
Category:Languages Category:2020 Category:Unimplemented Category:High-level Category:Esoteric subset
Halt halt halt

Halt halt halt is a Turing-complete brainfuck derivative which can partially solve the Halting problem.
== Overview ==
Besides all 8 instructions inherited from brainfuck, Halt halt halt has an extra instruction: ?
That instruction does the following:
# Interprets the current output (that is generated so far) as a Halt halt halt program (it is an error if the program has unmatched brackets)
# Resets the output (the output becomes empty)
# Tries to determine whether the parsed program will halt on empty input using ZFC axioms
Based on the result of step 3, do the following:
* If it can be proved that the program halts, do nothing
* If it can be proved that the program does not halt, increment the current cell by 1
* If it is undecidable (independent of ZFC), increment the current cell by 2
* If ZFC is inconsistent, increment the current cell by n, where n is an integer such that 0\le n\le3 (the value of n is implementation dependent, it can even be chosen randomly)
After this continue execution normally.
== Properties ==
Halt halt halt is similar to Hyperon, but while Hyperon is uncomputable (because it assumes the existence of a perfect (consistent) first-order logic system), this language is Turing-complete, because instruction ? may never finish if ZFC is consistent (and the consistency of ZFC cannot be proved from within ZFC itself, as stated by the Gödel's Second incompleteness theorem).
== Interpreters ==
Unimplemented.
Category:Languages
Category:Turing complete
Category:Brainfuck_derivatives
Category:Unimplemented
Category:2020