nyuuzyou/wikis huggingface dataset:
Hyperamicus

Hyperamicus is a functional programming language defined by David Madore in his 2015-11-16 blog article “Qu'est-ce qu'une machine hyperarithmétique ?” which is non-computable and strictly more powerful than Turing machines.
The motivation why this language came to being is that David wanted to give a precise definition for a larger computability class called “hyperarithmetic function” by defining this programming language. To ensure that the definition of Hyperamicus is correct and understandible, he first defined a Turing-equivalent language Amicus, and then an extension that turns that language to Hyperamicus.
== Definition ==
The basic data type of Hyperamicus is natural numbers of unbounded size, but these numbers are usually treated as representing recursive lists in the Lisp sense. The empty list <> is represented by the number 0, the list <a: d> with head a and tail d is represented as the number 2**a * (2 * d + 1), and in general a finite list <v1, v2, …, vk> is represented as <v1: <v2: <… <vk, <>>…>>>, or 2**v1 + 2**(v1+v2+1) + … + 2**(v1+v2+…+vk+(k-1)). This construction makes every natural number a list.
Programs are represented as a number (list), operate on a single input argument which is also a number (list), and give a single number (list) as the result. There is no IO or other side effects. Evaluation is defined by the following recursive definition, where E(p, v) = y means that the program p on the input v evaluates to the value y. 
;Rule 0. :E(<0>, v) = v
;Rule 1. :E(<1, c>, v) = c
;Rule 2. :E(<2>, <n: r>) = 1 + n
;Rule 3. :E(<3, n>, <v1: <v2: <…, <vn:d>…>>>) = vn, provided 0 < n
;Rule 4. :E(<4>, <m, n, u, v>>) = (if m == n then u else v)
;Rule 5. :E(<5, f, g1, …, gn>, v) = E(f, <E(g1, v), …, E(gn, v)>)
;Rule 6. :E(<6>, <h: r>) = E(h, r)
;Rule 7. 
:E(<7>, <f>) = 0 if E(<f>, <i>) = 0 for all natural numbers i, and
:E(<7>, <f>) = 1 if E(<f>, <i>) is defined (terminates) for all natural numbers i and E(<f>, <j>) ≠ 0 for at least one natural number j.
Rule 5 is valid for any natural number n. As a special case, E(<5, f>) = E(f, <>) = E(f, 0).
== Notes ==
* The addition of rule 7 is the only way this language differs from Amicus. This is the rule that makes the language uncomputable. Any Amycus program is also a Hyperamicus program, and on inputs where the result of running Amycus is defined for this program, Hyperamicus gives the same result.
* The rules that Amicus article defines for abstraction elimination to transform lambda calculus expressions to Amicus still work if lambda calculus is expanded with new primitives so that some of the functions are non-computable, so the technique described there can also be used to program Hyperamicus. This is not immediate, because Amicus is capable of reading and interpreting its own programs, so you could use techniques that do not extend to Hyperamicus. 
* David doesn't give a name for this language, so User:B_jonas gave the name “Hyperamicus”.
Category:LanguagesCategory:UncomputableCategory:Functional paradigmCategory:2015Category:No IOCategory:Unimplemented
Hyperbrain

Hyperbrain is the ultimate programming language invented by User:Ttulka to decide any problem in the multiverse.
It consists of an infinite instruction set that operates on an unbounded tape of binary cells.
The instruction set forms an infinite hierarchy of ordered levels, where level 0 is Boolfuck without IO, with the instruction * generating a truly random value (0 or 1) into the current cell.
 Generates a random number:
 
 +[*>+]
Starting from level 1, the instruction set expands with oracle instructions that determine whether the given program of a lower level sets the current cell to 1 after it halts. The answer (1 or 0) is stored in the current cell.
Level	Instruction set	Meaning
0 	+<>[]* 	Boolfuck w/o IO w/ a random generator
1 	? 	Oracle for level 0
2 	?? 	Oracle for level 1
3 	??? 	Oracle for level 2
... 	... 	...
The instruction ? takes a non-empty program as input that follows immediately after until the next ? instruction appears.
 Answers 0:
 
 ?+[]?
This means that oracle instructions of the same level cannot be nested.
 Two sequential oracles answer 0 and 1:
 
 ?+[]??+[+]?
The oracle instruction does not execute the input program; thus, the tape remains unchanged, and only the answer from the oracle is provided.
For example, the tape is [..., 1, 1, 0, ...] after executing the following program ("..." denotes an infinite sequence of zeros):
 +>+>?+[>+]?
With higher levels, oracle instructions are denoted by the symbol ? in unary format. The oracle instructions are interpreted greedily from lower to higher levels.
For instance, this program, consisting of one level 2 oracle instruction followed by a level 1 program (containing two oracle instructions), sets the tape to [..., 1, ...]:
 ???+[]??+[+]+???
== Examples ==
=== Halting problem ===
To solve the halting problem generically, a program can be aligned with code that always sets the current bit to 1:
 ?program[+]+?
=== Three-level oracles ===
Answers 1:
 ???+??+?+??????
Answers 0:
 ???+[??+[?+[]?+]??+]???
=== Hello, World! ===
In a rather peculiar way:
 ?+??+[]??+[]??+??+[]??+[]??+[]??+??+??+[]??+[]??+??+[]??+??+??+??+[]??+??+??+[]??+[]??+??+??+[]??+??+??+[]?
 ?+[]??+??+??+[]??+??+??+??+??+[]??+??+[]??+??+??+[]??+[]??+[]??+??+[]??+[]??+[]??+[]??+[]??+??+[]??+??+[]??
 +??+??+??+??+??+[]??+??+??+??+??+??+??+??+[]??+[]??+??+[]??+??+??+[]??+??+??+[]??+[]??+??+??+[]??+[]??+??+[
 ]??+[]??+[]??+??+[]??+[]??+[]??+[]??+?
=== The answer to life, the universe, and everything ===
 ?+?>?+[]?>?++?>?+[+]?>?*[+]+[]?
Category:Languages Category:Low-level Category:Cell-based Category:No IO Category:Uncomputable Category:Brainfuck derivatives Category:Unimplemented Category:2024
Hyperinotoidion

Hyperinotoidion is just brainfuck but with "a" that that clears all cells and "+" is replaced by "i". "/" starts string mode, it will see the ascii character, put it in the cell and then go right. "*" ends string mode.
Category:Turing tarpits 
Category:Low-level 
Category:Cell-based 
Category:Implemented 
Category:Languages
Category:Brainfuck
Category:2024
Category:Turing complete
Category:Joke languages
Hyperon

Hyperon is a hypercomputable programming language that is strictly more powerful than Turing machine. It is a brainfuck derivative with the ability to solve the Halting problem.
== Memory ==
Same memory model as in brainfuck (8-bit cells, unlimited tape).
== Instructions ==
* > - Increment the data pointer
* < - Decrement the data pointer
* + - Increment the current cell
* - - Decrement the current cell
* , - Read a character from stdin and put it to the current cell
* . - Output a character from the current cell
* [*] - Repeat instructions inside brackets while the current cell is non-zero
* {*} - If the instructions inside braces halt in finite time, increment the current cell, otherwise do nothing
Current cell is the cell pointed by the data pointer. Here * means that anything can be there.
== Examples ==
These examples describe only the last instruction, because we assume the reader is familiar with previous instructions.
For example, {} (empty content between braces) is identical to + instruction, because there are no instructions inside, so it will halt in finite time, and thus it is equivalent to incrementing the current cell.
Another example: {-}. It is also equivalent to +, because whatever happens inside {*} does not have effects to the surrounding code (memory will not be changed and data pointer will also remain unchanged after exiting the {*} braces, except incrementing the memory cell if the content halts). Also, any I/O that is performed inside {*} will be reset when we exit {*}.
This is equivalent to the cat program:
 ,[
 {[-]+[...,.,.,,,>>>>>>[-]+]} // Just to show that this has no effects
 .,
 ]
Braces can also be nested, like {{}}. It is important to note that {*} is a single instruction (unlike [*]) and takes a single tick, so {{*}} is identical to +, independently of the content inside (because the inner {*} takes a single tick, and thus halts in finite time).
== References ==
Category:Languages
Category:Uncomputable
Category:Brainfuck_derivatives
Category:Unimplemented
Category:2020
Hyperspace (Archived)

And also, it is going to be impossible to draw a diagram to represent a program in this language.
The Hyperspace programming language is an unbounded-dimensional programming language. The idea is that you interpret a program like a finite state transition table, with one axis representing user input and all of the others representing program variables.
== Structure ==
A program in Hyperspace would be a vector field of n dimensions, for any n > 0. Running the program would involve getting the line where all but the input coordinates match with the starting coordinates - which are in n-1 dimensions - and then, getting the input and the n-1 dimensional hyperplane where the input coordinate equals the input, and picking the point where the two intersect. Then, repeating the process, but at the coordinates of the vector of the previous point. For example - the starting state is y=0,z=0, and you input x=3. The interpreter would check the vector of the point at x=3,y=0,z=0, say the vector was y=4,z=3, and then repeat with that, asking for input again and all that stuff.
== Computational Class ==
In such a complicated system - where, keep in mind, points like y=3.5,z=3.1 are possible - the computational class of this language is yet to be known. Is it Turing complete? Probably not.
Category:Languages Category:Multi-dimensional languages Category:Unknown computational class
HypertextingScript

HypertextingScript is a markup language based on JavaScript and HTML.
HypertextingScript's source code/compilers source code (JS/Python) are on GitHub: https://github.com/PatoFlamejanteTV/HypertextingScript/
== Syntax ==
JS with HTML elements being "functions". (e.g., h1(""), p(""), script(""))
== Programs ==
=== Hello, world ===
h1("Hello, world")
=== Alert ===
script("alert('Hi')")
=== HypertextingScript Intro ===
h1("HypertextingScript")
 
p("Thats like JS but its no JS its HypertextingScript")
p("BTW this is open-source :D")
== Implementations ==
Check HypertextingScript/Implementations.
Category:Languages Category:Markup Languages Category:2024 Category:Implemented Category:Total
HypertextingScript/Implementations

:
== Javascript ==
function htsToHtml(htsCode) {
 // Universal pattern to match all tag-like structures
 const universalTagPattern = /(\w+)\(\s*"([^"]+)"\s*\)|(\w+)\[([^\]]+)\]\(\)/g;
 // Replace function to handle dynamic tag generation
 const htmlOutput = htsCode.replace(universalTagPattern, (match, tag1, content1, tag2, attributes) => {
 if (tag1) {
 // Matches patterns like tag("content")
 return `<${tag1}>${content1}</${tag1}>`;
 } else if (tag2) {
 // Matches patterns like tag[attributes]()
 const [attributeName, attributeValue] = attributes.split('=');
 if (attributeName && attributeValue) {
 return `<${tag2} ${attributeName}="${attributeValue}">${attributeValue}</${tag2}>`; // very messy code ngl
 } else {
 console.warn(`Invalid attribute syntax: ${attributes}`);
 return match; // Leave unprocessed if the attribute syntax is incorrect
 }
 }
 return match; // Return the original match for any unexpected cases
 });
 return htmlOutput;
}
// easter egg: this im putting random comments on this bc i dont want python to be show as primary language on github :D
== Python ==
import re
def hts_to_html(hts_code):
 """
 Compile HypertextingScript (HTS) code into HTML.
 
 Parameters:
 - hts_code (str): The HTS code to be compiled.
 
 Returns:
 - str: The compiled HTML code.
 """
 
 # Universal pattern to match all tag-like structures
 universal_tag_pattern = re.compile(r"(\w+)\(\s*\"([^\"]+)\"\s*\)|(\w+)\[([^\]]+)\]\(\)")
 
 # Replace function to handle dynamic tag generation
 def replace_match(match):
 tag1, content1, tag2, attributes = match.groups()
 
 if tag1:
 # Matches patterns like tag("content")
 return f"<{tag1}>{content1}</{tag1}>"
 elif tag2:
 # Matches patterns like tag[attributes]()
 attribute_parts = attributes.split('=')
 if len(attribute_parts) == 2:
 attribute_name, attribute_value = attribute_parts
 return f"<{tag2} {attribute_name}=\"{attribute_value}\">{attribute_value}</{tag2}>"
 else:
 print(f"Warning: Invalid attribute syntax: {attributes}")
 return match.group(0) # Leave unprocessed if the attribute syntax is incorrect
 return match.group(0) # Return the original match for any unexpected cases
 
 # Apply the replacement to the HTS code
 html_output = universal_tag_pattern.sub(replace_match, hts_code)
 
 return html_output
Category:Implementations
Hárdfish

Almost all the specifications are the same, except two:
# concatenates the rest of code to the code, then is removed from the code.
# Two consecutive same characters are allowed.
==Examples==
===Infinite loop===
 rr
The following program's source code gets longer exponetially for each instruction:
 rrr
In fact, the program's length becomes 2i+2 characters long when i instructions are executed.
Due to the fact that this esolang can implement an infinite loop and a program that grows forever, implementing this esolang means that the implementing language is not total, and has infinite memory.
==Interpreter==
===Python===
code=input()
x=0
while code:
 c=code[0]
 code=code[1:]
 if c=='i':
 x+=1
 if c=='o':
 print(x)
 if c=='r':
 code+=code
 if c=='c':
 x=(3*x+1 if x%2 else x>>1)
 if c=='q':
 x=(2*x+1 if x%3 else x//3)
 if x in (-1,256):
 x=0
==See also==
* Hardfish
* Härdfïsh
Category:Languages
Category:Implemented
Category:2023
Category:Output only
Category:Self-modifying
Category:Deadfish derivatives
Härdfïsh

Härdfïsh is a cross-over of Brainfuck and Hardfish. It introduces the , instruction from Brainfuck which
is used to input a character (ASCII) whereas EOF is represented as 257. It also has cells which can be switched by using the
<> instructions. Additionally, it introduces the possibility of loops []
which repeat everything between for as long as the current cell is not one. The r instruction from Hardfish
works on a per loop basis i.e. [iri] is executed as [iii] and [i[ir]r] is executed as [i[iii]i[iii]].
r is expanded starting at the inner most loops and then repeat until all expressions have been expanded. As with Hardfish [[,
]] and ,, and >> as well as << is illegal.
== Härdfïsh algorithms ==
=== Setting a cell to one ===
If the collatz conjecture is true then easily i[c] will set the cell to one, except if the cell is 255 because then it will wrap to 0 and
then [c] will loop forever.
== Computational class ==
|o_O|.
==See also==
* Hárdfish
Category:Languages
Category:Deadfish derivatives
Category:Brainfuck derivatives
H̱

H̱ is a variant of Chicken created by User:TheCanon2. The only valid symbols in H̱ are h, H, ẖ, and H̱, the latter two are only used to indicate the beginning of an operation.
==Memory model==
The memory model of H̱ is identical to the memory model in Chicken.
==Commands==
Opcode	Command	Action
0 	ẖ 	Halts the program
1 	H̱ 	Pushes the string "H̱" to the stack
2 	H̱h 	Add two top stack values
3 	H̱H 	Subtract two top stack values
4 	H̱hh 	Multiply two top stack values
5 	H̱hH 	Compare two top stack values for equality and push truthy or falsy result to the stack
6 	H̱Hh 	Next instruction indicates source to load from. ẖ loads from stack, H̱ loads from user input. Top of stack indicates address/index to load to stack
7 	H̱HH 	Top of stack points to address/index to store to. The value below that will be popped and stored
8 	H̱hhh 	Top of stack is a relative offset to jump to. The value below that is the condition. Conditional jump
9 	H̱hhH 	Pop x from stack and push &#x;
10+ 	 	Push the number n-10 to the stack
The Chicken opcodes are converted into binary in which 0 is h and 1 is H, with the lined h or H marking the beginning of the binary value.
Opcode 1 pushes the string "H̱" instead of the string "chicken" for no reason other than to allow for a quine.
==Examples==
===Hello, World!===
H̱hHhhH̱hHhhH̱hhH̱hhHH̱hHHH̱HHH̱hHhH̱hhhhH̱hhhhH̱hhH̱HH̱hHhH̱hhhHH̱HH̱hHhH̱hHhH̱HhHH̱hHHH̱HhhH̱HhẖH̱HH̱HHhH̱hh
H̱hHhHH̱HhHH̱hhhhH̱hHhH̱HHHH̱HhHH̱HhẖH̱hhH̱hhHhH̱hH̱hH̱hhHH̱hHHH̱HhẖH̱hH̱hHHH̱HHH̱HhhH̱HhẖH̱HhhH̱HH̱HhhH̱HHH̱Hhh
H̱HhẖH̱hHhH̱hhHHHH̱HH̱hhhH̱hHHH̱Hh
===Quine===
H̱
===Cat===
H̱hHHH̱Hhẖ
===A+B problem===
H̱hHhH̱HhH̱H̱hHhH̱HH̱HhhH̱HhH̱H̱hHhH̱HH̱h
Category:Languages
Category:Stack-based
Category:Turing complete
Category:Unimplemented
Category:2024
H🌍

H🌍 (or HWorld) is a joke esoteric programming language by User:OsmineYT and was designed in 2019. Because it only has printing and quitting commands, it can't be used for real programming.
== Commands ==
Command	Short description
h 	Prints "Hello!"
hh 	"Hello, Hello!"
w 	"World!"
ww 	"World, World!"
hw 	"Hello, World!"
wh 	"World, Hello!"
q 	Ends interpreting code
All incorrect commands will just print themselves.
== Examples of programs ==
Simple "Hello, World!" program:
 hw
A quine:
 THIS IS JUST A SIMPLE QUINE.
Shortened version:
 a
(NOTE all incorrect commands (a, b, etc.) are quines.)
A nop program:
 q
== Implementations ==
An interpreter
Another interpreter, but in Java
HWorld online interpreter in Interpret Esolangs Online ([https://none-none1.github.io/Interpret-Esolangs-Online/hworld.js JavaScript source).
A (joke) compiler, written in Python
Another interpreter and "compiler" written in Nim
Scratch interpreter:
== See also ==
* HQ9+
* Hello, world!
* HelloWorld
* Hello++
* Hello
* HELOWOR
Category:Joke languages
Category:Unusable for programming
Category:Implemented
Category:Languages
Category:Total
Category:Output only
H🌍+

H🌍+ (Or HWorld+) is a joke esoteric programming language that is an extension of H🌍. The extended parts were made by Cinnamony.
==Commands==
 h - Prints out "Hello!".
 w - Prints out "World!".
 hw - Prints out "Hello, world!".
 hh - Prints out "Hello, hello!".
 wh - Prints out "World, hello!".
 ww - Prints out "World, world!".
 hww - Prints out "Hello, world, world!".
 hwh - Prints out "Hello, world, hello!".
 hhw - Prints out "Hello, hello, world!".
 hhh - Prints out "Hello, hello, hello!".
 whh - Prints out "World, hello, hello!".
 whw - Prints out "World, hello, world!".
 wwh - Prints out "Word, word, hello!".
 www - Prints out "World, world, world!".
 hwww - Prints out "Hello, world, world, world!".
I'm pretty sure you can figure out the pattern by now.
All incorrect commands (not made of h or w) repeat themselves.
There is also:
 q - Terminates the program.
==Quine==
 THIS IS A QUINE
The uppercase "Q" does not terminate the program, and the uppercase "H" does not print "Hello," in the code.
Or, a more simple quine:
 a
==Hello World==
 hwq
==World world hello world world world hello hello hello world==
 wwhwwwhhhwq
==Nop==
 q
==Interpreter==
Here is an interpreter in C++ by User:None1:
#include<string>
#include<iostream>
using namespace std;
string s,o;
signed main(){
	getline(cin,s);
	int last=-1,first=-1;
	for(int i=0;i
Category:Languages
Category:Joke languages
Category:Unusable for programming
Category:Output only
Category:Total
Category:Implemented
H🌍++

H🌍++ (or HWorld++or HWorldFuck) is an extension of H🌍+ which is an extension of H🌍, the extended parts are created by User:None1.
==Extension==
H🌍++ runs on a string stack (initially empty).
 Extended commands in H🌍++
Command	Meaning
f 	Read a string and pushes it into stack.
u 	Pop the stack and output (does nothing if the stack is empty).
c 	Empty the stack if the stack isn't empty and the top of stack is 0 (does nothing if the stack is already empty). There is perhaps no reason to create this command except for writing a Truth Machine.
k 	Loop until the stack is empty.
! 	End of loop, matches a k.
Non-command characters push themselves as a string into the stack.
==Example Programs==
===Hello World===
 hw
===Cat Program===
 fu
A more elaborate one:
 fuck!
===Cat Program (non-terminating)===
 fkuf!
===Truth Machine===
 fcku1!0u
==Computational class==
H🌍++ is of course a push-down automaton.
Category:Languages
Category:Joke languages
Category:Unusable for programming
Category:Stack-based
Category:Push-down automata
I'm Blue

I'm Blue is a BF-derivative esolang created by User:LEOMOK. It is a list of misheard lyrics from Eiffel 65's song "Blue (Da Ba Dee)". It operates on a hypercube of an infinite number of dimensions. It is an extension of BF's tape. The datatype used is the 64-bit float.
==Syntax==
I'm Blue code is a list of functions. At the start, the last function declared is executed. They are declared like this:
 i'm blue
 [function number]
 [function contents]
 [blank line]
=== Numbers ===
Numbers are represented by writing the digits, one by one, in order. When a number is encountered, the current hypercube cell will be set to it.
 
Code 	Comment
da 	1
ba 	2
dee 	3
dah 	4
bah 	5
dea 	6
di 	7
daa 	8
da-ee	9
die 	0
doh 	point
===Commands===
 
Code 	Comment
i will bleed i will die 	Go one cell forward in current direction (>)
if i was green i would die	Go one cell back in current direction (<)
i believe i'm a guy 	Add one to current (+)
i will be like a guy 	Subtract one from current (-)
i will pee on a guy 	Add next cell to current
i will need apple pie 	Subtract next cell from current
i got beat up and died 	Multiply current cell by next
i'm in need of a dime 	Divide current cell by next
i'm a geek i'm a guy 	Modulo current cell by next
i'm in need of a diet 	Take next cell root of current cell
i'm diseased i must die 	Logarithm current cell to base of next cell
i believe i am pie 	Print as numeric value
i believe i can fly 	Print as unicode character (.)
i believe i will die 	Get input as numeric value
i believe i'm a guy 	Get input as unicode character (,)
i could eat up a diamond 	If cell is nonzero (blank line ends if statements and loops)
i could yeet up a guy 	While cell is nonzero ([])
i'm a meme i'm a mine 	Else in an if statement
i was eager to die 	Break out of while loop or end program
Example 	Example
Example 	Example
Example 	Example
Example 	Example
Example 	Example
Example 	Example
Example 	Example
Example 	Example
Example 	Example
Example 	Example
Example 	Example
Example 	Example
Example 	Example
Example 	Example
Example 	Example
Example 	Example
Example 	Example
Example 	Example
Example 	Example
Example 	Example
Example 	Example
Example 	Example
Example 	Example
Example 	Example
Example 	Example
Example 	Example
Example 	Example
Example 	Example
Example 	Example
Example 	Example
Example 	Example
Category:Languages Category:Cell-based Category:Brainfuck derivatives Category:Pseudonatural Category:Thematic
I'm lime

I'm lime was created by User:Buckets in 2025 with the purpose of either making Art block worse or potentially better.
(You cannot use 0-9 numbers, instead you must use a different way of displaying numbers.
Here are some examples: English words, Spanish words and Roman numerals.
Also you have to use a different and special numbering system every time you use a Command that needs a Number based input.)
Commands 	Instructions
Printed () 	Prints what is inside the brackets.
Hoot () 	Go to the Line number given inside of the brackets.
Let's () 	If the current variable is equals to 0, then go to what is inside the bracketsth Yeah, else Nope.
Yeah 	The True condition.
Nope 	The false Condition.
Unit 	Set the Current variable to the input.
Loudness () 	Create a new variable and name it with the Given name inside of the Brackets.
Unforeseeable ()	Change to a different named variable.
February () 	Set the current variable's number to what is Inside the brackets.
Nourishment () 	Change the current variable's number by what is inside the brackets.
Possum 	This command just prints a line feed.
and 	Ends the program.
Probably () 	Prints Specifically only numbers from what is inside Of the brackets.
"Hello, World!" Program:
 Printed (Hello, World!) and
Truth-machine Program:
 Loudness (Impulse) Unforeseeable (Impulse)
 Unit Let's (One)
 Nope Probably (I) Hoot (Trois)
 Yeah Probably (Cero) and
Category:Languages
Category:Joke languages
Category:2025