nyuuzyou/wikis huggingface dataset:
Headache (brainfuck derivative)

==Commands==
Headache is a double stack based language with only a few commands. It has no other way to store data than its two stacks. Both stacks start empty. You can only work with one stack at a time.
It is called headache because of the amount of switching, restacking, moving, and shuffling needed to get anything done.
A peek from an empty stack produces 1.
A pop from an empty stack produces 0.
< Pushes a pop from Stack B onto Stack A (top value of b is moved to a)
> Pushes a peek from Stack A onto Stack B (copies top of a onto b)
^ Discards the top value of Stack A. (pop if it matters)
v Swaps the top values of Stack A and Stack B. (pop both)
+ a = a + b (adds top of b to the top of a) (peek only)
- a = a - b (subtracts top of b from the top of a) (peek only)
. Pop value from Stack A to output
, Push value from input to Stack A
@ Switch Stacks (a is now b, and b is now a)
{ if a == b, Jump to after corresponding } (peek)
} if a != b, Jump to after corresponding { (peek)
LAME COMMANDS:
! Places a 1 on the top of stack A.
# Places a number with the size of each stack on top of the corresponding stack.
The stacks usually hold 32 bit integers.
If there is no corresponding { or }, ignore it.
Adding from an empty stack, produces a 1. Since it is peeking.
If say, top of Stack A is 4, and Stack B is empty, a + will produce 5. If both are empty, a + will push 1 to Stack A.
====Hello World (Branchless)====
There is likely a more optimal way
+>+>+>+@^@+>@^^@v<@+++++++v<++>@<.+++v@<v@<@-><><.+++++++>>><<<..+++><.<>+<
v@<@+++><.>++<v@<@-<<@v<v<@+.><.+++..-.@^^+.
====GNU Cat====
+vv{,.}
====Fibonacci Sequence====
====Multiply Program====
Takes the numbers on the top of both the stacks and multiplies them. Places the multiplied number on top of Stack A. Consumes both numbers.
!>-><<@<<<{@<<@v<v<@-<<<+@<<v@<v@<<}^@^<@^^@
==Useful snippets (Branchless)==
These all work on Stack A, unless otherwise specified.
Swap top 2 values
Shorter >^v<
Faster @<v@<
Copy the top values of both stacks
><@><@
====Invert N====
Invert top 3 values
@<v<v@<v<
Invert top 4 values
@<v<v<v@<v<v@<v@<<
Invert top 5 values
@<v<v<v<v@<v<v<v@<v<v@<v<<
Invert top 6 values
@<v<v<v<v<v@<v<v<v<v@<v<v<v@<v<v@<v@<<<
====Bring to Top====
These are usually shorter than the inversions
Bring 3rd from top value to top (top 2 [3])
@<<@v<v<
Bring 4th from top value to top (top 2 3 [4])
@<<<@v<v<v<
Bring 5th from top value to top (top 2 3 4 [5])
@<<<<@v<v<v<v<
Bring 6th from top value to top (top 2 3 4 5 [6])
@<<<<<@v<v<v<v<v<
==Conversion from brainfuck==
This simple conversion of BF to headache demonstrates that this subset of the language is Turing complete.
 Brainfuck Headache
 Init <
 > <
 < >^
 + !>^+<^
 - !>^-<^
 [ !>-<^>^{<^
 ] !>-<^>^}<^
 . ><.
 , ^,
==Links==
MindGrind - Headache Editor (Java Jar, with source) 
See also - Another Headache Language 
Category:Brainfuck derivatives
Category:Low-level
Category:Turing complete
Category:Stack-based
Category:Languages 
Category:Implemented 
Category:2009
Headache (lang that compiles to brainfuck)

: For other uses, see Headache.
The Headache programming language is a Turing Complete language for generating brainfuck programs. 
It borrows most of its syntax from C. 
It is open source and its repository can be found here.
== Purpose ==
Headache was designed to be the most lightweight technology to compile brainfuck programs.
One can be download Headache simple typing into a unix terminal 
 
 git clone https://github.com/LucasMW/Headache
 make
 make install
== Examples == 
 void main() {
 @"Hello World\n"; 
 }
 
would be compiled into:
 [-]+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 +++++++++++.+++++++++++++++++++++++++++++.+++++++..+++.--------------
 -----------------------------------------------------------------.+++++++++++++++
 ++++++++++++++++++++++++++++++++++++++++.+++++++++++++++++++++++
 +.+++.------.--------.-----------------------------------------------------------------
 -------------------------.[-]Printing string
 void main(){
 	byte a;
 	byte b;
 	byte c;
 	byte d;
 	a = (10*6+3)/7; /* 63/7 = 9 */
 	b = (10*23-5*23)/23; /* 5*23/23 = 5 */
 	c = 0/0+10/10; /* 0/0 converts to zero in headache */
 	d = a/a + b/b + c/c;
 	@"a: "; @a; @"\n";
 	@"b: "; @b; @"\n";
 	@"c: "; @c; @"\n";
 	@"d: "; @d; @"\n";
 }
would run:
 a: 9
 b: 5
 c: 1
 d: 3
 
== Tools and Developer Environment ==
It's compiler, hac, is capable of transpiling headache programs into brainfuck. The generated brainfuck programs can be run in any decent 8 bit brainfuck interpreter.
Headache is also bundled with a custom brainfuck interpreter that includes extra features useful for debugging
Headache is also bundled with an expander program. This program can transform 8 bit brainfuck programs into 16 bit programs, 32 bit programs and so on.
Last, but not least, Headache is bundled with bfalgoConverter program, an utility for converting Brainfuck Algorithms webpage's sample pseudocode into bfalgo() calls inside Headache's source code, i.e. is a tool for developers to make it easier to update Headache with new algorithms.
== See also ==
Official wiki
Category:Programming techniques
Category:Brainfuck
Category:Implemented
Category:Languages
Headsecks

Headsecks is a brainfuck equivalent in which each character of the source code is interpreted as its ordinal value modulo 8, from which the instruction to execute is determined. It was designed and implemented by User: andkerosine in May 2012.
== Overview ==
The conversion from Headsecks to brainfuck is, technically, up to the implementer. In the interest of compatibility, however, it is strongly recommended that the following mapping be adhered to:
  ord mod 8  	0	1	2	3	4	5	6	7
  brainfuck  	+	-	<	>	.	,	[	]
This particular arrangement was a design decision, as it optimally maps spaces, tabs, and newlines to (reasonably) sane instructions, should one desire aesthetic spacing. Of course, there are (by definition) no limits regarding the structure one can impose on Headsecks code, and so the choice of separators (if any) is entirely open.
== Syntax ==
Mathematicians have yet to discover a natural number which results in a negative remainder when divided by 8; as such, every possible string of characters is a valid (though not necessarily computable) Headsecks program. Here, for instance, are 16 different ways of writing the simplest infinite loop (+[]):
PҾз	ʀҖΟ	ȨжƧ	ŸϞç	ʠÞз	Űņп	ӠǶΧ	àӎɇ	ɘŮӯ	@Ǯȿ	аҞϧ	¸Ҟć	ϠӶ·	ψȮȷ	Ɉʖ·	ϘφÇ
== Examples ==
==== Hello World (Trigrams dialect) ====
☰☰☰☰☰☰☰☰☰☰☶☳☰☰☰☰☰☰☰☳☰☰☰☰☰☰☰☰☰☰☳☰☰☰☳☰☲☲☲☲☱☷☳☰☰☴☳☰☴☰☰☰☰☰☰☰☴☴☰☰☰☴☳☰☰☴
☲☰☰☰☰☰☰☰☰☰☰☰☰☰☰☰☴☳☴☰☰☰☴☱☱☱☱☱☱☴☱☱☱☱☱☱☱☱☴☳☰☴☳☴
Note the use of an explicit newline to decrement the data pointer.
==== Konnichi wa (Kana dialect) ====
ビるィせセコびせかルゎチこるビびッセッべゃ゛ッびんんルィ゛ィらィんニスゃヘ゠だヰヒたヱィホゃかにつめこゃッっカッニほっほゃレひゴぴずもオげずやずオぺオヲず゜コんるニ゛ヴビぼケるニレよこコにルほこかコにャニコほッゴリぺ゚をぺぢヲなゲりりぺぴペぢなペゲぢひひゔべラが
==== Cat program ====
A repeating cat program which terminates if confronted with a null character input, and whose paregal constitutes the brainfuck code ,.[,.], constitutes the following:
 EDFEDG
== Implementations ==
At present, only the reference implementation exists. You should improve this unfortunate situation.
* Common Lisp implementation of the Headsecks programming language. Please note that the concrete character set deployed constitutes a dependency on the Common Lisp implementation; in corollary, Unicode support may or may not be a feature incorporated in the personal environment. The interpreter at hand has been developed and tested with Steel Bank Common Lisp (SBCL) version 1.1.4 as part of the Lisp Cabinet 0.3.5 bundle.
* Python implementation of the esolang by User:None1. (Hint: Use ! to separate code and input)
Category:Languages Category:Brainfuck equivalents Category:Brainfuck derivatives Category:2012 Category:Implemented Category:Brainfuck derivatives Category:Turing complete Category:Turing tarpits Category:Cell-based Category:Low-level
HeartForth

HeartForth is a language released on Valentine's Day (February 14) of 2015 by User:NeilK. It is an Emoji stack language, which source-translates to a JavaScript implementation of Forth.
== Examples ==
In standard Forth:
 : factorial 0 swap begin dup 1 - dup 1 = until begin * over 0 = until swap drop ;
 5 factorial .
 >> 120 
In HeartForth:
 >> 120
== Advantages ==
* Extremely compact. 
* Clean visual separation between program and data. 
* Whitespace agnostic.
* Fully internationalized.
== Disadvantages ==
* None.
== External resources ==
*Github repository
*NeilK.net blog entry
Category:Languages
Category:Stack-based
Category:2015
Heav esolang g(ood)

Heav esolang g(ood) is an esolang. The details are implementation defined.
== Example programs ==
Hello world:
::srC-[)2GLb#>?f[*Uwk@:#k_1.v#:wMWJco:YsrC-Jco:Y[)2GLb#@:#kJco:Y_1.v>?f[#:wMW#:wMWsrC-@:#kv=g/WsrC-v=g/W@:#k[)2GLb#@:#k>?f[>?f[[)2GLb#v=g/W=<il[)2GLb##:wMW=<ilJco:Y[)2GLb#srC-[)2GLb#>?f[[)2GLb#_1.vv=g/Wv=g/Wv=g/Wv=g/W_1.v_1.vsrC-@:#k#:wMWv=g/Wv=g/W[)2GLb#Jco:Yv=g/W@:#kJco:Y@:#k@:#k#:wMW#:wMW
Cat program:
::srC-[)2GLb#srC-=<il[)2GLb#=<ilo-k1[)2GLb##:wMW[)2GLb#0gAt0gAt[)2GLb#=<il`E5VN=<il`E5VN=<ilsrC-=<il
Hebe Script

Hebe Script is a simple scripting language that allows for the creation of little applets for the Hera Runtime. It has the CommonSystem library preloaded, and it does not have a App object, so it does not need a "When app.run = True" main method.
==How to copy a file to the floopy disk==
 if get DiskSpace with "a:\";or "b:\"
 Higher Than FileSize with PublicArg-1
 call CopyFile with PublicArg-1 with (get IsAvailable with "a:\";or "b:\") 
 End
 End
PublicArg are the parameters that the script received.
Category:Languages
Heck

Heck is a programing language designed such that source code is expressible as a hexadecimal number. It was created by User:PixelatedStarfish in 2021. The esolang is designed such that the uninitiated will utter "What the heck?!" upon attempting to read source. 
The language was initially conceived as similar to Lenguage, such that a hexadecimal value would be converted to binary and evaluated at a low level. 
==Operations in Heck==
Heck is stack based. The following operations can modify the stack.
 Caption text
Operation 	Desc
0 	ADD V to val at top of stack
1 	SUB V from val at top of stack
2 	GOTO L (Label)
3 	LABEL L
4 	GOTO L if 0
5 	GOTO L if Stack Empty
6 	Push V
7 	Pop
8 	Print top val as char
9 	Print top val in decimal
A 	Print top val in hex
B 	Duplicate top value and push
C 	Shuffle stack
D 	Empty stack
E 	Sum top two values then push
F 	End Program
<explicit comment>	A comment
==Syntax and Grammar==
===Syntax===
*An operation is denoted by a single character ranging in value from 0 to F (0 to 16 in decimal).
*Some operations take a single two character argument ranging from 00 to FF (00 to 255 in decimal). 
*An operation followed by an argument is called a codon, which cannot exceed three characters. 
*A character that is part of an argument is not interpreted as an operation. 
*Whitespace and non-hex characters are ignored. Comments are explicitly indicted by angle brackets. < >. 
===Grammar in EBNF===
 Program ::= {{Op} | {Codon}} 
 Codon ::= Op, Arg
 Op ::= Val
 Arg ::= Val, Val 
 Val ::= ‘0’ | ‘1’ | ‘2’ | ‘3’ | ‘4’ | ‘5’ | ‘6’ | ‘7’ | ‘8’ | ‘9’ | ‘A’ | ‘B’ | ‘C’ | ‘D’ | ‘E’ | ‘F’
==Program Examples==
For debugging purposes, a parse string is included in the interpreter output such that codons and operations are separated by a slash. 
===Hello World===
 6488645864C864C864F86208657864F8652864C86448
 Parse: 648/8/645/8/64C/8/64C/8/64F/8/620/8/657/8/64F/8/652/8/64C/8/644/8/
===Truth Machine===
 6003009401200301
 Parse: 600/300/9/401/200/301/
===Random Number (1 - 10)===
 60160260360460560660760860960AC9
 Parse: 601/602/603/604/605/606/607/608/609/60A/C/9/
==Proof of Turing Completeness==
This proof of Turing Completeness shows that Heck is translatable to bf to establish Turing Completeness.
The unbounded stack of values is comparable to the unbounded tape of a Turing machine. A value on the stack can store an integer, which is more than sufficient to act as a bf cell. For all intents and purposes, the value at the top of the stack is pointed to and can be modified.
To translate between the two languages, use this table. (Note XX and YY stand in for hex values.)
 Conversion Table 
Heck 	bf	Desc
7 	> 	increment
6XX 	< 	decrement
001 	+ 	add 1 to cell
101 	- 	take 1 from cell
8 	. 	Output ASCII value at cell
6XX 	, 	Take input at (next) cell
4XX 	[ 	Jump past ' ] ' (to label X)
4XX 2YY 3YY	] 	goto ' [ ' (label Y) if cell is greater than 0
==External Links==
*Official Interpreter (Java)
*Official Repl (Java)
Category:Implemented Category:Stack-based Category:2021 Category:Turing complete Category:Languages
Helios

Helios is a stack based esolang created by User:ArthroStar11. It is designed to work in Starstuff by User:PixelatedStarfish such that any file can create a valid program, albeit not necessarily useful or functional.
== Data Structure ==
the only data structure in Helios is a stack of 32-bit signed integers.
== command list ==
NOTE: since this language is written for use in Starstuff, commands will be listed by the bytecode generated by a Starstuff to Helios compiler
ALSO NOTE: when variables a and b are mentioned it refers to popping a then b off the stack
* 0 to 9 push const
** pushes corresponding number to the stack
* 10 loop
** defines the start of a loop, runs code continuously as long as the value popped off the stack is non-zero, can be nested
* 11 end loop
** defines the end of a loop
* 12 add
** pushes b+a onto the stack
* 13 subtract
** pushes b-a onto the stack
* 14 multiply
** pushes b*a onto the stack
* 15 divide
** pushes b/a onto the stack
* 16 modulo
** pushes b%a onto the stack
* 17 greater than
** pushes 1 onto the stack if a > b otherwise pushes 0
* 18 less than
** pushes 1 onto the stack if a < b otherwise pushes 0
* 19 equal to
** pushes 1 onto the stack if a == b otherwise pushes 0
* 20 not
** pops top value off the stack pushes 1 onto the stack if the value is 0 otherwise pushes 0
* 21 print char
** pops top value off the stack and prints to the console as a character
* 22 print num
** pops top value off the stack and prints to the console as a 32-bit signed integer
* 23 scan char
** pushes user input onto the stack as a character
* 24 scan num
** pushes user input onto the stack as a 32-bit signed integer
* 25 duplicate
** pops top value off the stack and pushes two copies onto the stack
* 26 discard
** throws away top value of the stack
== Sample Programs (using modulo compiler) ==
Prints "HI"
 ?>DOK7BK
truth machine
 NO@OOLAL
false machine
 NJO@OOJLAJL
Print 99 to 0
 ??D??BB7BO@7COOLA
Alternate 99 to 0 to show the power of Starstuff
 ?$zZuB'7BO
 7C4OL\
== Implementation ==
ArthroStar11's Interpreter and Starstuff to Helios modulo compiler (C++ source)
Category:Languages
Category:Low-level
Category:Unknown computational class
Category:2021
Category:Implemented
Category:Stack-based
Hell

Hell also known as T, is a esolang that was created by user Alanmalan
its interpreter can be found here
Hell has two comands
 o :: no op, adds 1 to cycle and does not execute anything
 r :: operates based on the curent number of the cycle, after performing operation also adds 1 to the cycle pool
T also has a temporary memory to the value of 1 byte
and a tape, with the length of 16
the first character in codes will aways be ignored
Cycle number executions
0 :: kills the program
1 :: prints ASCII character based on the temporary memory
2 :: adds one to the tape pointer
3 :: subtracts one from the tape pointer
4 :: gets a single character input and stores it directly onto the tape
5 :: adds one to the current cell
6 :: subtracts one from the current cell
7 :: saves the index of the part of the code for later usage
8 :: goes back to the saved index until the current pointer cell is 0
9 :: copies the value from the temporary memory to the current cell
10 :: copies the value of the current cell to the temporary memory
11 :: prints out number based on the current cell
12 :: Beeps, frequency is based on the number inside the temporary memory times 10, lenght is based on the number in the current cell times 10
Hell.js

Hell is an esoteric subset of the JavaScript programming language that uses JavaScript's built in Proxy feature to run code.
Hell code is identical to JavaScript code, except each character is a reference to a proxy. Alphabetical characters are referenced via dot notation, while other characters are referenced via bracket notation.
Because Hell is built around references on a JavaScript object, your code can have newlines almost anywhere.
Hell has a limitation on program size due to recursion limits, however this has been worked around by passing arrays of Hell code to the builder.
Hell has also been ported to C# by the Hell creators, as Hell.cs.
== Sample Programs ==
Here is a simple Hello, World! in Hell:
_.c.o.n.s.o.l.e["."].l.o.g["("]["'"].H.e.l.l.o[","][" "].W.o.r.l.d["!"]["'"][")"]
Note that the _ can be other characters in practice, but convention is to use _.
== External Resources ==
https://hell.js.org
Category:Languages Category:Implemented Category:Esoteric subset
Hell69

:Due to technical limitations, the title of this page is incorrect. The actual name is pronounced "Hell69" or just Hell69 ( ͡° ͜ʖ ͡°).
This is an esoteric programming language made by User:Areallycoolusername.
== Name Origin ==
The reason the language is named "Hell", is because coding in this language is supposed to be hell. The name is multiplied to the 69th power as a joke and to symbolize difficulty.
== Instructions ==
In order to code anything in this language, you have to find the ASCII Hex codes for the character you want to print and multiply it by 69 ( ͡° ͜ʖ ͡°). All zeros in the code is now a 69. For example, the Hex code for "A" is 0x41. 0x41 multiplied by 69 is 0x2829 and the 0 is replaced with 69 making it 69x2829. If the Hex code includes a letter, (not including x present in all codes) replace it with the next letter in the alphabet. For example, the Hex code for "J" is 0x4a. The code in this language would be 69x276b. You can print things by typing the characters hell codes by themselves. When coding you have to put "/-/31169" before and after each Hell code.
== Hello World Program ==
The following program prints “Hello, World!” to the standard output:
 /-/3116969x3312/-/3116969x4485/-/3116969x414d/-/3116969x414d/-/3116969x414g/-/3116969x138d/-/31169
 69x13869/-/3116969x3933/-/3116969x414g/-/3116969x4968/-/3116969x414d/-/3116969x4416/-/3116969x1449/-/31169
==Interpreter==
* Common Lisp implementation of the Hell69 programming language.
Category:Languages Category:Implemented Category:Joke languages Category:2019
Hellhole

Hellhole is a programming language I developed using thue that compiles to brainfuck you can find it here for the code snack IDE app you can interpret it with your favorite interpreter for Thue it even comes with sample programs but the thing with Hellhole is every time you use a command it modifies the memory in some way that you can't control and please note when interpreting your programs you use them through the input box and then you run the brainfuck code in the program state in your favorite brainfuck interpreter
Hello

Hello is a joke esoteric programing language with only one instruction, 'h', which will print out the string "Hello World". Hello was created by Anne Veling.
The language was designed to be very easy to learn and implement.
==Example program==
The following program prints out "Hello World".
 h
==Notes on quines==
If it was case insensitive, and all unknown characters were ignored, then it would be easy to make a quine using this program. (Maybe even two quines. Or an infinite number.)
 Hello World
One consideration is that if we require exactly the source string as output from the quine, then this is the only possible one. If, on the other hand, we did not mind if the case were changed (after all, the output would still compile and run just fine), there would be 210 = 1024 quines: one for each possible combination of capitalised and uncapitalised letters (actually, it's a permutation with repetition). All this, of course, also assumes that we only call h once in the programme; in reality we can just write a quine twice in a row and get another, making the actual number of quines infinite:
 Hello WorldHello World
However, this example (and the previous one) would not work due to the fact that Hello doesn't understand "H" as a command, unlike Hello++, which was invented for this purpose; thus, it is impossible to make a true (i.e. case-sensitive) quine in Hello.
Note that an infinite amount of Quines can still be constructed via the Hello++ Esolang and it is just by adding infinitely many "Hello World"s to the end.
==Interpreter==
 i = input("Enter Command: ") 
 if i != 'h':
 	print("ERROR!")
 else:
 	print("Hello World")
This interpreter of Hello was written by Zayne in Python3.5
This interpreter by User:A (golfed and optimized) prints error instructions as True, which is currently the shortest interpreter:
 print('h'!=input()or"Hello World")
In Python 2:
 print'h'!=raw_input()or"Hello World"
User:B has dramatically improved the memory and disk footprints of the first interpreter written in Python 3:
 if'h'==input(">"):print("Hello World")
and has ported it to Python 2 at the cost of increased mass storage usage:
 if'h'==raw_input(">"):print"Hello World"
User:PythonshellDebugwindow has made an implementation allowing for quines in Python 3.9:
 print("Hello World"*input().lower().count("h"))
User:Squidmanescape wrote some Hello interpreters in Gray Snail. This one only works if the entire input is "h".
 INPUT h?
 GOTO is_h h [h?]
 OUTPUT "Error"
 GOTO end a a
 is_h
 OUTPUT "Hello World"
 end
This one works if 'h' is in front.
 INPUT h_start
 POP h? h_start [h_start]
 GOTO is_h h [h?]
 OUTPUT "Error"
 GOTO end a a
 is_h
 OUTPUT "Hello World"
 end
This is a scratch interpreter:
Hello scratch interpreter.png|Scratch Interpreter
==See also==
* HQ9+
* Hello, world!
* HelloWorld
* Hello++
==External resources==
* Hello programming language page
* Hello / Hello++ to C converter
Category:Languages
Category:Joke languages
Category:Unusable for programming
Category:Output only
Category:Unknown year
Hello! Hello Again!

Hello! Hello Again! or H!HA! is an esolang created by User:None1.
==Commands==
It has only 3 commands:
Hello, prints Hello, World! with a line feed.
Again! jumps to the start of program.
World! is a NOP.
Commands are separated by spaces, and invalid commands echo themselves.
Since it only has commands for printing, doing nothing and restricted infinite loop, it obviously cannot be used for real programming.
==Example Programs==
===Hello World===
 Hello,
===Quine===
 Hello, World!
A much simpler one:
 a
===Infinite loop===
 Again!
===Infinite Hello World===
The program prints out Hello, World! over and over. 
 Hello, Again!
==Implementations==
*Python Implementation Provide program as input. Crashes relatively quickly if Again! is in the program (If you don't want it to crash, you can add import sys;sys.setrecursionlimit(2147483647) in the start of the program).
Category:Languages
Category:Joke languages
Category:Unusable for programming
Category:Output only
Category:Implemented