nyuuzyou/wikis huggingface dataset:
Hao

Hao is a language based on placing sets of Wang tiles on a 1-D tape discovered by User:Orby in April 2018.
==Hao==
A Hao machine consists of a tile set and a tape.
===Tiles===
Each tile has a color for each cardinal direction (north, south, east, and west). If we map each color we wish to use to a unique non-negative integer, then we can use the Cantor pairing function
 f(x, y) := ((x + y) * (x + y + 1)) / 2 + y
to assign each tile a unique non-negative integer. Thus, we define the Hao number of a tile as 
 f(n, f(s, f(e, w))
where n, s, e, and w are the non-negative integers we've mapped to the color on the north, south, east, and west sides of the tile, respectively. See here for a Javascript implementation to help you map back and forth.
===Tape===
In theory, the tape is unbounded on both sides. In practice, the tape contains a finite number of cells. Each cell of the tape is occupied by a tile from the tile set. Tiles may not be rotated or reoriented in any way. The east color of cell i must match the west color of cell i + 1. In the case of a finite tape, boundary conditions are periodic (that is, if there are n cells, then the west color of cell 0 must match the east color of cell n).
===Computing a step===
When a step is computed, each cell is overwritten in such a manner that the south color of the current value matches the north color of the new value (while preserving the constraint on the east and west colors of adjacent cells). If there is not a unique successor for the current state of the tape, the machine halts.
===Turing completeness===
A Hao machine is capable of simulating the Turing complete one dimensional cellular automaton rule 110, and therefore is itself Turing complete. Consider the tile set S = {229, 44, 3158, 54, 1538, 1539, 14876, 18144}
If we consider the north color of each tile to be equivalent to the color of the cellular automaton in that cell, then there is a unique Hao tape representation for each automaton state. If we compute successive steps in Hao, we are in fact simulating rule 110.
Category:Languages
Category:2018
Category:Turing complete
Category:Non-textual
Happy Fantasy

Happy Fantasy is a Golden sunrise derivative which supports function names (mnemomics for arrays of bits).
== Overview ==
Syntax is identical to Golden sunrise, but all identifiers are enumerated and replaced with sequences of bits according to the User:Hakerh400/Prefix-free serialization algorithm for Arbitrary-sized non-negative integer. Then the resulting source code is interpreted as a Golden sunrise program.
Also, all rules that are not specified will be implicitly defined to produce empty strings.
== Examples ==
=== Add n zeros after n-th 1 ===
 main - (add(remove.))
 remove 0 - (remove.)
 remove 1 - 1(remove.)
 add 1 - 10(extract.)(add.0)
 extract 0 - 0(extract.)
 extract 1 - (extract.)
It translates to the following Golden sunrise program:
 0 - (100(101.))
 1010 - (101.)
 1011 - 1(101.)
 1001 - 10(11.)(100.0)
 110 - 0(11.)
 111 - (11.)
 # - /
 1# - /
 10# - /
 101# - /
 1000 - /
 100# - /
 11# - /
== Interpreters ==
Interpreter
Category:Languages
Category:Turing complete
Category:Implemented
Category:2020
Har(d)

Har(d) is an esolang created by User:LEOMOK. It is inspired by the constructed language Kay(f)bop(t). It uses an infinite stack of arbitrary-precision rational numbers, as well as a global array.
==Syntax==
Each instruction takes an argument in Har(d). A program is written like this:
 instruction(arg)instruction(arg)...
Arguments are rational numbers, with bignum numerators and denominators, like 123, 0.456 and 78/9.
==Instructions==
In each instruction, A is the argument, and [n] is the 0-indexed nth stack item.
Basic
 . - Push A to the stack.
 + - top = top + [A], then remove [A]
 - - top = top - [A], then remove [A]
 * - top = top * [A], then remove [A]
 / - top = top / [A], then remove [A]
 \ - top = int(top / [A]), then remove [A]. /(1) is an idiom for truncating the top stack item.
 % - top = top % [A], then remove [A]
 & - top = int(top) AND int([A]) (bitwise), then remove [A]
 | - top = int(top) OR int([A]) (bitwise), then remove [A]
 ~ - top = NOT int([A]) (bitwise), then remove [A]
 ^ - top = int(top) XOR int([A]) (bitwise), then remove [A]
 $ - Pop [A]
 : - Duplicate [A]
 ; - Swap [A] and top
 [ - Print [A] as nunmber
 ] - Print [A] as Unicode character
 { - Input number into [A]
 } - Input Unicode character into [A]
 p - array([A]) = top
 g - Push array([A]) to stack.
Control flow
 @ - Goto A
 # - Label A
 < - If top < 0 goto A
 > - If top > 0 goto A
 = - If top = 0 goto A
 ' - Goblins. Jump to last @ and excute next instruction.
 " - Terminate program instruction with exit code [A].
Comments are indicated in parentheses.
Category:LanguagesCategory:Stack-basedCategory:UnimplementedCategory:Thematic
Harder

Harder is BF but harder
== Instructions ==
 * flip the current bit
 ~ set current bit to 0 or 1 based on input
 ` output current bit
 [c] run c if current bit is 1
 {c} run c if current bit is 0
 > move to the right current bit
 < move to the left current bit
 @ if current bit is 1, go to the [ or { based on nesting
 # if current bit is 0, go to the [ or { based on nesting
 $ go to the [ or { based on nesting
=== Unary cat ===
 ~[`~@] is also ,[.,] in BF
Category:Languages Category:Brainfuck derivatives Category:Cell-based Category:Low-level Category:Unimplemented Category:Turing complete
Hardlang

Hardlang is based on a single accumulator A, which is exactly one word in length. Constants are very hard to represent in it. At the start of a program, A = 0.
==Instructions==
These are the language's instructions:
* !: Inversion: This instruction inverts all bits in the accumulator.
* <: Shift Right: This instruction shifts every bit in A one place to the right. The leftmost bit becomes a zero and the rightmost bit is discarded.
After every operation, hardlang will output the content of the accumulator.
==Example programs==
Under a nibble:
0:
1:!<!
2:!<!<
3:!<<!
4:!<!<<
5:!<!<!<!
6:!<<!<
7:!<<<!
8:!<<<
9:!<<!<!
10:!<!<!<
11:!<!<<!
12:!<<
13:!<!<!
14:!<
15:!
==Interpreter==
Written in JavaScript (66 bytes). Pass it the program as an argument. Don't pass a.
 var hardlang=(c,a=0)=>c.map(h=>{h=="!"&&(a=~a);h=="<"&&(a>>=1);});
Category:Languages
Category:2019
Category:Implemented
Category:Total
Category:Unknown computational class
Category:Unusable for programming
Hargfak

This is like brainfuck, but has main pointer, sub pointer (points to same memory space but may be different position), and one main stack.
These command are same as brainfuck:
 +-,.<>[]
These command are new commands:
 *{};:()@!&#$=~|`'%
Data types:
* Number
* Code-block
* Pointer
* Stack
Notes about new commands:
* * Swap main and sub pointer
* {} Make a code-block, push to stack
* ; Push data at pointer to stack
* : Pop data from stack, put at pointer (if empty stack, no function)
* ( Move top from main stack to top of stack at sub pointer
* ) Reverse function of (
* @ Exit code-block
* ! Push main pointer to stack
* & Push empty stack to stack
* # Push zero to stack
* $ Swap top 2 values of stack
* = Saves the entire program state to a program-state stack
* ~ Discards an entry from program-state stack
* | Pops an entry from program-state stack and resets the program state to the restored state
* ` Moves entry from top of main stack of state at top of program-state stack to top of the real main stack
* ' Reverse function of `
* % Swap top 2 entry of program-state stack
Notes about old commands:
* +- To number, +- mod 256, to code-block or stack, nothing, to pointer, + as > and - as <.
* [] Empty stack, empty code-block, pointer left of main pointer, all are considered as zero.
* . To number output, to codeblock execute, to pointer to move main pointer to point at same place as this pointer.
Preprocessor:
* ?name{data} Define a macro (case sensitive!)
* name Use macro
* number command Repeated command
* // Comment until end of line
Example:
 ?out{;$:.:} // Macro to pop value from stack and output
 ?in{;,;$:} // Macro to input value and push to stack
Category: Languages
Category: Low-level
Category: Brainfuck derivatives
Category: Turing complete
Category: Unknown year
Category: Stack-based
Harmful Brainfuck

Harmful Brainfuck is a brainfuck derivative intended, but failing, to make brainfuck easier to program in. It is based on the observation that brainfuck corresponds to "structured programming" since it uses a while loop. According to the Kosaraju hierarchy structured programming is harder than programing with goto (it may require introducing extra booleans to exit complicated nested loops, there are programs whose code size blows up a lot when you do not have goto and so on).
Therefore Harmful Brainfuck replaces [] with the computed jump operator * which moves the program counter by the offset given by the current tape cell (an offset of 0 will loop forever). Harmful Brainfuck is believed not to be Turing-complete.
== Sample Program ==
The following is a ROT13 program that works for ASCII and loops forever on EOF.
 -------------------------------------------------------------------------------------------------------------------------------->
 +>
 >
 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>
 ++++>
 +++++++++++++++++++++++++++++++++++++++++>
 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>
 +>
 ++++++++++++++++++++++++++++++++++++++>
 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++<<<<<<<<<
 trampolinetrampolinetrampolinetrampolinetrampolinetrampolinetrampolinetrampolinetrampolinetrampolinetrampolinetrampolinetra
 >>,
 * >A >N >[ >a >n >{ >*<<<<<-------------------------->>>>>><<<<<<+++++++++++++>>>>>>><<<<<<<.<<fillerfillerfillerfillerfillerfillerfillerfillerfiller*
== External resources ==
* Implementation in C (this one limits cells to -256 to 255)
Category:Brainfuck derivatives
Category:Implemented
Category:2014
Category:Languages
Harmonic E♯

Harmonic E♯ is a derivative of E♯. But you can add two #s (i.e. ##) To access a tertiary function, all old commands are kept (see E♯ for info about those)
==Commands==
===Tertiary functions===
The new tertiary functions that are added in Harmonic E♯ are listed as follows. Most of them are pointless and I will not attempt to make any examples for.
 EEE EEE EEEEEEEE EEEEEEEEE EEEE EEE EEEE EEEEEEEE
# of E's	New tertiary functions
2 	Define the next line as a parameter
3 	Places the length of the rest of the queue onto the queue
4 	Change the queue to a stack, and vice versa.
5 	Do next command 7 times. EEEEE## #E# EEEEE## does the next 49 times, but 3+ of them acts like one.
6 	Clear queue
7 	Output everything in queue
8 	Set an "anchor" point in the queue. this cannot be removed and acts like it is nonexistent.
9 	Put everything above the anchor below it
10 	Put everything below the anchor above it
11 	Switch the stuff below the anchor and the stuff above the anchor.
12 	Skip to the command after this upon an error is found anywhere else. If one happens inside the command. Go to the next EEEEEEEEEEEE##. If no more exist, go to first.
13 	Negate the conditional for the next statement.
14 	Ignore the entirety of the next line
15 	Wait 10 seconds
16 	Prints a program in a random language
17 	Solve the halting problem
Category:Languages Category:Unimplemented Category:Unknown computational class
Harp (Archived)

Harp is an esoteric programming language.
== Structure ==
Harp is a language with one instruction. Every Harp program asks for an input at the beginning. Every instruction from then on has two parameters, A and B, and does this:
* If last input is equal to A, or A is the empty string
:* Ask for input
:* Go to B
* Otherwise
:* Execute the next instruction
== Interpreter ==
-- split a string into a table by a delimiter
function split(inputstr, sep)
 local t = {}
		local i = 1
		for str in string.gmatch(inputstr, "([^"..sep.."]+)") do
			if str and t and i then
				t[i] = str
				i = i + 1
			end
		end
 return t
end
-- see if the file exists
function file_exists(file)
 local f = io.open(file, "rb")
 if f then f:close() end
 return f ~= nil
end
-- get all lines from a file
function lines_from(file)
 if not file_exists(file) then return {} end
 lines = {}
 for line in io.lines(file) do
 lines[#lines + 1] = line
 end
 return lines
end
function ask()
	return io.read()
end
print("Type in the name of a file.")
local code = lines_from(ask())
local words = {}
for i,j in pairs(code) do
	words[i] = split(j, " ")
end
local input = ask()
local i = 1
while i <= #code do
	if input == "exit" then
		print("DEBUG:", "quitting...")
		return
	end
	if input == words[i][1] or words[i][1] == "" then
		print("DEBUG:", "goto", words[i][2])
		input = ask()
		i = tonumber(words[i][2]) - 1
	elseif not words[i][2] then
		print("DEBUG:", "goto", words[i][1])
		input = ask()
		i = tonumber(words[i][1]) - 1
	end
	i = i + 1
end
HashWalk

HashWalk is an esolang invented by User:Hakerh400 in 2022.
== Overview ==
Let s be the source code and let i be the input (both are arrays of bytes). Let a = 0 be an integer variable and let h = [] be an array of bytes (initially empty).
Perform the following algorithm until the program halts. Calculate the SHA-256 hash of the concatenation of s, h and i, respectively, and assign the result to h. Calculate the first byte of h modulo 3. Depending on the result, do the following:
* If the result is 0, continue
* If the result is 1, if a is 0, terminate the program, otherwise decrement a
* If the result is 2, increment a
Output the number of steps decremented by 1.
== Implementation ==
Implementation in Node.js:
<nowiki>
'use strict';
const crypto = require('crypto');
const run = (src, inp) => {
 src = Buffer.from(src);
 inp = Buffer.from(inp);
 
 let h = Buffer.alloc(0);
 let a = 1n;
 let n = -2n;
 
 while(n++, a){
 const hash = crypto.createHash('sha256');
 hash.update(Buffer.concat([src, h, inp]));
 h = hash.digest();
 a += [0n, -1n, 1n][h[0] % 3];
 }
 
 return n;
};
</nowiki>
Note: in this implementation, we initialize local variable a to 1 to simplify the loop condition, but the result is identical to the original algorithm description.
== Example ==
Program:
 aju
For the empty input, it prints 13560111. There is not much of a point to show other examples, because none of them can do anything useful. This is some random example we have chosen.
== Computational class ==
This language is strictly less powerful than Turing machine. Since SHA-256 gives a byte array of length 32, each program for a given input will either output an integer in the interval \left[0,256^{32}-1\right], or loop forever. Moreover, since SHA-256 has a maximum input length, there are only finitely many programs we can write (and each program can take finitely many inputs).
Category:Languages
Category:Implemented
Category:2022
Category:String-rewriting_paradigm
Hash function

A hash function is a function that returns the hash value of a string. Hashing means to convert a string into a number.
==Process==
This is an example hashing process:
idx(si) return si(Let's assume that a~z is 1~26)
hash[i]=(hash[i-1]*idx(si)) % mod
p and mod are both prime numbers, where p<mod
Assume that p=13, mod=101
Now let's hash the string "abc". We need an array to store the hash process (or a variable might be enough.)
hash[0]=1;
hash[1]=(hash[0]*13+2)%101=15;
hash[2]=(hash[1]*13+3)%101=97;
So, "abc"'s hash value is 97.
Sometimes, the hashing process will return the same value from different strings. Refer to https://www.planetmath.org/goodhashtableprimes for more information.
==C example==
unsigned hash(const char a[static 1])
{
 unsigned h = 0;
 for (size_t i = 0; a[i] != '\0'; i++)
 h = 65 * h + a[i];
 return h;
}
Category:Program forms
Hashell

Hashell(pronounced as hash-hell) is a version of Haskell that's "hell" to use. it is a very minimal Haskell subset.
== the subset ==
Hashell permits only these chars: =>\[]().:`-?x_*&
== operators ==
with this subset you can create some operators:
 (.).(.) which takes a one-parameter function on the left and a two-parameter function on the right, and yields a new two-parameter function that passes the result of the right-hand function to the left-hand one(cant be used in pure form must be variable)
 >>= which is haskell bind operator
 (:[]) a function that takes a value and produces the singleton list containing that value
 (&&&) takes two functions and makes a tuple updater
 (***) takes two functions and makes a tuple-making function out of them
 . the same as B from Combinatory logic(lol)
 
and heres some operators that idk what they do:
 >>
 :> 
== Complexity class ==
Hashell is universal for SKI combinatory logic:
 -- I
 xxxx = \x -> x
 -- K
 xxxx = \x _ -> x
 -- S
 xxxx = \x xx xxx -> (x xxx) (xx xxx)
 -- Y
 xxxx = \xx x -> x (xx x)
Note that, since Haskell's type system is still in place, only well-typed expressions can be provided; the Turing bird is not legal. However, a lazy Y combinator is available.
Category:Languages Category:Esoteric subset Category:2024 Category:Functional paradigm
Hashes

### is an esoteric programming language by User:Dagoth Ur, Mad God based on :///. To run a ### program, type a #.
==Example==
###b#ott#les#of#b#eer o#n t#he #w#all#, ###lovely ###[[Esme]]ralda ###o#n ###t#h#e #b#ee#r...
Category:Languages Category:Joke languages
Haxell

Haxell is an esolang invented by User:Hakerh400 in 2024.
== Overview ==
Haxell is similar to Haskell, but there are few differences:
* File name and module name are unrelated. Relative import paths are supported. For example import Data.List imports built-in module Data.List, while import "./data/list" imports the local file list.hs from the directory data relative to the current file (not to the current working directory of the compiler invocation). Imports from parent directory are also supported import "../../util". If the path represents a directory, then index.hs file is imported from that directory. Quotes are optional.
* Compiler flag -trans-imports allows transitive imports (module exports itself as well as all imported modules).
* Infix operator # is used instead of $.
* In a do block, the let x = expr syntax behaves exactly as x <- pure # expr (no indentation quirks, unlike in Haskell).
* Snake case is recommended instead of camel case for user-defined functions.
== External resources ==
* Gitlab
Category:Languages
Category:2024
Category:Turing complete
Category:Functional paradigm
Category:Implemented
Hcbf

hcbf is an esoteric programming language conceived (and delivered by Caesarian section!) by Pierpaolo Giacomin (User:Yrz) at 15:39 CET, June 29th, 2005. It is a version of Brainfuck in which the memory is structured like a four-dimensional hypercube (a.k.a. a tesseract.)
==Storage==
Unlike Brainfuck's tape, hcbf's hypercube memory is defined to be bounded and cyclically closed, so that if one edge of the hypercube is reached, the data pointer "warps around" to the other edge, similar to Befunge. The size of memory is defined by the implementation; in the reference implementation, the hypercube size is 100x100x100x100. Each cell is byte-sized.
Because memory is a hypercube, the position of the data pointer can be given by four coordinates (X,Y,Z,T).
==Instruction set==
The hcbf instruction set is the same as the Brainfuck instruction set, with the addition of the @ instruction.
The @ instruction allows the program to change the axis in the hypercube along which the > and < instructions move the data pointer. Initially the pointer moves along the X axis. Executing @ once makes it move along the Y axis; another execution makes it move along the Z axis; another execution makes it use the T axis; then it goes back to the X axis.
A summary of the entire instruction set follows:
Instruction	Description
@ 	Change direction of the pointer inc/dec.
> 	Increment the pointer.
< 	Decrement the pointer.
+ 	Increment the byte at the pointer.
- 	Decrement the byte at the pointer.
. 	Output the byte at the pointer.
, 	Input a byte and store it in the byte at the pointer.
[ 	Jump forward past the matching ] if the byte at the pointer is zero.
] 	Jump backward to the matching [ unless the byte at the pointer is zero.
Category:Languages
Category:Low-level
Category:Brainfuck derivatives
Category:Implemented
Category:Cell-based
Category:Multi-dimensional languages
Category:2005
HeacunQ9+×

HeacunQ9+× is an esoteric programming language derived from HQ9+, and was made by AmNow.
== Commands ==
Number	Command	Description
1. 	H 	Print the message “Hello, World!”.
2. 	E 	Execute the most recently set function, if such is defined.
3. 	A 	Initiate a new function containing the contents between A and the next A, if there already is a function defined, override it.
4. 	C 	Take the math expression from this C to the next C, evaluate it, and set it to the accumulator.
5. 	U 	If the accumulator is -1, input the accumulator with a number, else output it as a number.
6. 	N 	Like U, but with ASCII characters and not numbers.
7. 	Q 	Print the program source code.
8. 	9 	Print the lyrics to “99 Bottles Of Beer On The Wall”.
9. 	+ 	Increment the accumulator by 1.
10. 	× 	E, but only if the accumulator is a truthy value, that is, not equal to 0.
== Programs ==
=== Truth-machine ===
 C-1CUAUEA×U
=== Cat program ===
 AC-1CNNEAE
=== Quine ===
 Q
=== Hello, world! ===
 H
==Interpreter==
* Common Lisp implementation of the HeacunQ9+× programming language.
Category:LanguagesCategory:2022Category:UnimplementedCategory:Unusable for programming Category:Implemented