nyuuzyou/wikis huggingface dataset:
Hq9eFuck

Hq9eFuck (pronounced as "HugeFuck"), or also H9F, is a joke esoteric programming language (it's overview below is even a joke) written by Egor Promyshlennikov in 2016. Due to Hq9eFuck is a Brainfuck derivative, it is Turing-complete which makes it possible to write programs in.
==Language overview==
Hq9eFuck is a new powerful modern language.
All those mainstream useless-stuff-oriented languages are gonna die now, because
Hq9eFuck provides Brainfuck's flexability and HQ9+'s effectiveness as well as
an incredible simplicity and has even the latest version of a new fast Deep Thought computer API.
Thus now you are able to get your thought fucked as deep as never before.
===Feature overview===
# All Brainfuck instructions.
# All HQ9+ instructions.
# Deep Thought API to answer the Ultimate Question of Life, the Universe, and Everything.
# Brainfuck uses 16-bit architecture and has only 30000 bytes of memory. H9F uses the newest 32-bit architecture, so it has TWICE MORE memory - 60000 bytes.
===Syntax overview===
Same as Brainfuck's syntax. For example, this program prints "Hello, World!" 16 times:
 ++++[->++++<]>[H-]
==Brainfuck instructions==
Hq9eFuck provides all Brainfuck instructions:
* < Decrements pointer (moves left)
* > Increments pointer (moves right)
* + Increments value at pointer
* - Decrements value at pointer
* [ Starts a new loop
* ] If value at pointer is 0 moves to the next instructuion, else moves to the beginning of loop
* , Reads an ASCII character from standart input, writes to current cell
* . Writes an ASCII character to standart output from current cell
==HQ9+ instructions==
* H Prints Hello, World!
* Q Prints the programs's source - quine
* 9 Prints the 99 bottles of beer song
* + Was replaced by Brainfuck's similar instruction, but actually also increments the accumulator (value at pointer)
==Deep Thought API extension==
* DT Computes and prints an answer to the Ultimate Question of Life, the Universe, and Everything.
==Implementation==
Hq9eFuck interpreter source, C
If you make your own interpreter, feel free to leave links here.
==See also==
* Brainfuck
* HQ9+
==External resources==
* Deep Thought
Category:2016 Category:Low-level Category:Cell-based Category:Implemented Category:Turing complete Category:Joke_languages Category:Brainfuck_derivatives Category:Languages
Hsamsniarb

Hsamsniarb is a joke programming language you can't even create a "Hello, World!" program in.
(Hsamsniarb is Brainsmash backwards.)
== Overview ==
The language combines elements from Deadfish and brainfuck, in particular the former.
Following its interpreter's invocation, an initial program may be introduced by some advenient avenue, for instance the command line or an argument to the evaluating routine.
Proceeding from this first stage, a perpetual iteration is instigated, the same repeatedly queries the standard input for a single character, preceded by the prompt message >> , which is subsequently evaluated.
== Architecture ==
Hsamsniarb's architecture is developed, siclike to the syntactical and operational aspects, as an amalgam of Deadfish and brainfuck.
The entire memory comprehends a single entity, a register whose capacity amounts to an unsigned byte scalar, occupying the integer interval [0, 255], and assuming the value zero (0) at the program's inchoation. Upon any of its two bourne's transgressions, the state returns to its default of zero.
The register constitutes an appropriation from Deadfish, while its octet size most likely originates in brainfuck.
== Commands ==
An aperçu shall educate about the language's quadruple command set, the same encompasses basic arithmetics and an output facility. Non-command content is simply ignored, and does not, as is the wont of Deadfish, produce a newline display.
Hsamsniarb	Effect
+ 	Increments the register by one. If the new value exceeds 255, the register is reset to 0.
- 	Decrements the register by one. If the new value descends below 0, the register is reset to 0.
s 	Squares the register's value. If the new value exceeds 255, the register is reset to 0.
w 	Prints the register value in its verbatim numeric form to the standard output on a line of its own.
== Hsamsniarb and Deadfish ==
Hsamsniarb's descendance from Deadfish permits an equiparation of their operational facilities:
Hsamsniarb	Deadfish
+ 	i
- 	d
s 	s
w 	o
== Interpreters ==
The only current interpreter is made in Visual Basic.
Option Explicit On
Option Strict On
Module Module1
 Dim val As Integer = 0
 Sub Main()
 Dim code As String = ""
 Try : code = My.Computer.FileSystem.ReadAllText(Command().Trim(""""c))
 Catch : End Try
 For Each C As Char In code
 Interpret(C)
 Next
 While True
 Console.Write(">> ") : Interpret(Console.ReadKey.KeyChar)
 End While
 End Sub
 Sub Interpret(ByVal C As Char)
 Select Case C
 Case "+"c : val += 1 : Console.WriteLine()
 Case "-"c : val -= 1 : Console.WriteLine()
 Case "w"c : Console.WriteLine() : Console.WriteLine(val.ToString())
 Case "s"c : val = CInt(val ^ 2) : Console.WriteLine()
 End Select
 If (val < 0) Or (val > 256) Then val = 0
 End Sub
End Module
* Common Lisp implementation of the Hsamsniarb programming language.
Category:Languages
Category:Implemented
Category:Joke languages
Category:Finite state automata
Category:Unusable for programming
Category:Output only
Category:Total
HsifdaeD

hsifdaeD is an esolang by User:None1, it can do nothing but interpret Deadfish.
==Data storage==
It has an accumulator.
==Commands==
Any program in this esolang must have exactly 5 characters, or a syntax error is raised.
Command	Meaning
, 	Read a character from user input, jump to character 2-5 respectively if the input is i, d, s and o, otherwise just quit
i 	Increment accumulator and jump to the start of program
d 	Decrement accumulator and jump to the start of program
s 	Square accumulator and jump to the start of program
o 	Output accumulator and jump to the start of program
==Examples==
===Deadfish interpreter===
 ,idso
==Interpreter==
=== Python ====
from sys import exit
check_acc = False # change to True to change accumulator to 0 if it equals -1 or 256
a = 0
s = input()
if len(s) != 5:
 print("ERROR!")
 exit()
else:
 ip = 0
 jmpt = {
 "i": 1,
 "d": 2,
 "s": 3, 
 "o": 4
 }
 while ip < len(s):
 c = s[ip]
 if c == ",":
 ip = jmpt[input()[0]] # takes only first string of character input
 elif c == "i":
 a += 1
 ip = 0
 elif c == "d":
 a -= 1
 ip = 0
 elif c == "s":
 a *= a
 ip = 0
 elif c == "o":
 print(a)
 ip = 0
 if (check_acc and (a == -1 or a == 256)): a = 0
 
Category:Languages
Category:Joke languages
Huby

Huby, conceived by Joey (or j`ey), is a very easy to learn programming language.
It has one function, to print out 'Hello World!'.
It does this using the global function 'h()'. 
Each call to this function must be separated with a semicolon (;).
==Example==
The following program outputs 'Hello World!'.
 h();
==See also==
* HQ9+
* Hello
==External resources==
* 
Category: 2006
Category:Implemented
Category: Joke languages
Category: Output only
Category: Unusable for programming
Category: Languages
Huf

huf is a time consuming and useless language. Its syntax is a little similar to brain****. Made by Charlie Hough or User:Charmaster16. Functionality is similiar to EXCON.
==External resources==
Check out docs, and try it out online here(repl.it link): https://github.com/Charmaster16/huf
Category:Languages
Category:Joke languages
Category:2020
Category:Unusable for programming
Category:Total
Category:Output only
Category:Implemented
HuffPuff

A language made by Areallycoolusername. It's a Brainfuck derivative, and the only valid command "HUFFLEPUFF", and "HUFFLEPUFFLET". 
Brainfuck 	HuffPuff
+ 	HUFFLEPUFF
- 	HUFFLEPUFFLET
> 	HUFFLEPUFFHUFFLEPUFF
< 	HUFFLEPUFFLETHUFFLEPUFFLET
[ 	HUFFLEPUFFHUFFLEPUFFLET
] 	HUFFLEPUFFLETHUFFLEPUFF
, 	HUFFLEPUFFHUFFLEPUFFLETHUFFLEPUFF
. 	HUFFLEPUFFLETHUFFLEPUFFHUFFLEPUFFLET
No equivalent	HHUUFFFFLLEEPPUUFF (scrambles output.)
Category:Brainfuck derivatives
Category:Languages
Category:2019
Category:Turing complete
Category:Cell-based
Category:Unimplemented
Huh?

huh? is an esoteric programming language created by User:David.werecat where the interpreter doesn't understand what you want it to do.
== Instructions ==
Every file is a valid huh? program. The interpreter will do its best to understand the input, but will fail (100-)% of the time. If it doesn't understand something, it will do nothing and simply express its confusion. It is implied that every command does something, we're just not sure what.
== Programs ==
I try to speak the English as much as I can.
=== A valid Program ===
<nowiki>
It print the "Hello, world!" into the screen.
</nowiki>
=== Another Valid Program ===
<nowiki>
I will give you two integers (A and B). Please find the result of A+B.
</nowiki>
=== Quine ===
 Huh?
== External resources ==
* Visual Basic .NET interpreter and a sample program (no idea how it works...)
* Python 2 interpreter (Windows only)
* Python 3 interpreter (also here and here)
== Categories ==
Category:Languages
Category:Joke languages
Category:2012
Category:Unusable for programming
Category:Implemented
Category:Declarative paradigm
Category:No IO‏‎
Category:Probabilistic
Huh?++

huh?++, or huh? plus plus, is an esoteric programming language created by Kevin Friedemann (user:kfriede) based on the huh? programming language created by user:David.werecat.
== Instructions ==
Like huh?, every file is a valid huh? program. However, huh?++ boasts a 100% failure rate, and doesn't bother to tell you that it doesn't understand your input. Commands are assumed to be too difficult for huh?++ to understand. 
== IDE (by User:Yes) in batch ==
@echo off
set /p input=src:
echo
echo Program ended
pause
this is just the ඞlang interpeter without the ඞ
Category:Languages
Category:Joke languages
Category:2014
Category:Unusable for programming
Category:Implemented
Category:Declarative paradigm
Category:No IO‏‎
Category:Probabilistic
Huit interpreter

The following Python script is an incomplete Huit interpreter.
prgm = input('>Huit ')
prgm += "\0" # NUL is the EOF
# Finds the location of all jump points
names = []
points = []
j = 0
k = 0
name = ""
for i in range(0, len(prgm)):
 if k == 1 and prgm[i] != ")":
 name += prgm[i]
 if prgm[i] == "\"":
 if prgm[i-1] == "\\": # To read " but ignore \" # Bug here
 pass
 else: j = (j + 1) % 2
 if j == 0:
 if prgm[i] == "(":
 k = 1
 elif prgm[i] == ")":
 k = 0
 names.append(name)
 points.append(i)
 name = ""
replace = ['\\n','\n','\\t','\t','\\\"','\"','\\\,'\]
# Executes the program
floats = ['0','1','2','3','4','5','6','7','8','9','.','-']
input_string = ""
input_float = 0
char = 0
queue = []
inst = 0
def deq(repeat):
 for i in range(0, repeat):
 queue.pop(0)
def enq(a):
 queue.append(a)
while inst < len(prgm):
 if prgm[inst] == "+":
 enq(queue[0] + queue[1])
 deq(2)
 elif prgm[inst] == "-":
 enq(queue[0] - queue[1])
 deq(2)
 elif prgm[inst] == "*":
 enq(queue[0] * queue[1])
 deq(2)
 elif prgm[inst] == "/":
 enq(queue[0] / queue[1])
 deq(2)
 elif prgm[inst] == "%":
 queue.append(queue[0] % queue[1])
 deq(2)
 elif prgm[inst] == "&":
 read = ""
 if prgm[inst+1] == "\"":
 inst += 2
 while not (prgm[inst] == "\"" and prgm[inst-1] != "\\"): # Bug here
 read += prgm[inst]
 inst += 1
 for i in range(0, len(replace), 2): # Bug here
 read = read.replace(replace[i], replace[i+1])
 enq(read)
 else:
 inst += 1
 start = inst
 while prgm[inst] in floats:
 if prgm[inst] == '-' and inst != start:
 break # To not read minus instructions.
 read += prgm[inst]
 inst += 1
 enq(float(read))
 inst -= 1
 elif prgm[inst] == ":":
 enq(queue[0])
 elif prgm[inst] == "?":
 if len(queue) > 0:
 deq(1)
 elif prgm[inst] == "(":
 while prgm[inst] != ")":
 inst += 1
 # [] is missing
 elif prgm[inst] == ">":
 if prgm[inst+1] == "\'":
 if type(queue[0]) == float:
 queue[0] = chr(int(queue[0]))
 print(queue[0])
 deq(1)
 elif prgm[inst] == "<":
 if prgm[inst+1] == "\'":
 input_float = input('> ')
 enq(input_float)
 else:
 if input_string == "":
 input_string = input('> ')
 char = 0
 enq(input_string[char])
 char += 1
 elif prgm[inst] == "#": # Debug character
 print("inst: %s, queue: %s" % (inst, queue))
 # Add strings to input format
 else:
 pass
 inst += 1
Category:Implementations
Human textlang

Human textlang is a programming language that uses English to do stuff
= Everything you would want to know =
== Instructions ==
 Instructions
Text 	Description 	Example
Run the following in BF: 	run it in BF 	Run the following in BF: +[.+]
Make a variable that is (name) (and set it to (value))? 	define a var and maybe set it 	Make a variable that is A
The number (number) 	translate number to its word form, the only usable form of numbers here	The number 5
Make this thing to do that is (name) (and with inputs that are (a), (b), (c)...)?:(code)end 	make a function called name with maybe inputs and do code 	Make this thing to do that is Thing:Make a variable that is A and set it to five
Give (value) to the thing that called this 	equivalent to return (value) in python 	Give five to the thing that called this
Make this thing give you something that is (name) (with inputs that are (a), (b), (c)...)?:(code)end 	makes a function that returns something 	Make this thing give you something that is Thing2:Give one to the thing that called thisend
Run (name) that does something (with inputs that are (value1), (value2), (value3)...)? 	run a function that does code maybe with inputs 	Run Thing that does something
Get the thing from the thing that gives you something that is (name) (with inputs that are (value1), (value2), (value3)...)?	run a function that returns something 	Get the thing from the thing that gives you something that is Thing2
Note: (comment) 	comments the comment 	Note: this is a very inefficient programming language
less then|not (one of those)|(one of those) and (one of those)|(one of those) or (one of those)|equal to) (value2):(code)end	if statement 	If A is equal to five:Make a variable that is B and set it to A
Set (name) to (value) 	set a defined var to a value 	Set A to ten
Say (text) 	say text 	Say hello world
Say (number in word form) 	say number 	Say five
Say (name) 	say a variable, function, or something else 	Say A Note: does not say "A", it says what the variable A was previously
Say (number in word form) as a letter 	say a number as a letter 	Say sixty-five as a letter Note: prints A
Go to the next line 	say a newline 	Go to the next line
Category:Languages
Category:Pseudonatural
Hummingmusic

Hummingmusic is a language created by User:Tommyaweosme as he found himself humming music.
== Commands ==
 bum - go to dum if value on top of stack is 0 
 dum - go to bum if value on top of stack is non-0
 buh - rotate first incrementer value of stack
 duh - subtraction (top-below)
 dee - addition
 dop - adds user input to stack
 bop - outputs top of stack
 dup - duplicates top value in stack
 bup - discards top value in stack
 beep - increments incrementer
 bop - decrements decrementer
 bun - sets incrementer to top of stack (without discarding it)
 dun - adds incrementer to stack
 "" - quotes to set top values of stack to
 deep - changes stack to queue and vice versa
 baleep - terminates script
 meep - prints "meep"
 moop - prints "moop" and adds 1 to top of stack
 meedaboop - cancels next thing being printed. cancels if placed before a meep, moop, or bop. if not placed before one of those, it prints "meedaboop"
== Hello World ==
 "Hello, world!" deep bop
Or alternatively,
 "!dlorw ,olleH" bop
== Cat ==
 dop bum bop dum
== Truth machine ==
 dop bum bop dum bop baleep
== Quine ==
 meep meep moop moop meedaboop
== Interpreter ==
None yet, but the language's creator can sing programs you make.
Category:Languages Category:Stack-based Category:Queue-based Category:Pseudonatural Category:Unimplemented
Humo

Humo is a programming language with a tiny interpreter implementation and the smallest set of operations for an imperative programming language.
This is an experimental language that uses very few concepts to perform Turing complete computations.
Live demo: Humo IDE
== Interpreter ==
Here the complete interpreter implementation code (the following code executes any Humo program):
public class HumoInterpreter
{
 protected Map<CharSequence, CharSequence> productions = new HashMap<CharSequence, CharSequence>();
 public int parse(StringBuilder sourcecode, int first)
 {
 int last = first, current = first;
 for (char currentChar; last < sourcecode.length() && (currentChar = sourcecode.charAt(last++)) != '}';)
 {
 if (currentChar == '{')
 {
 current = parse(sourcecode, last);
 productions.put(sourcecode.subSequence(first, last - 1), sourcecode.subSequence(last, current - 1));
 last = first = current;
 }
 CharSequence production = productions.get(sourcecode.subSequence(current, last));
 if (production != null)
 {
 StringBuilder value = new StringBuilder(production);
 parse(value, 0);
 sourcecode.replace(current, last, value.toString());
 last = current += value.length();
 }
 }
 return last;
 }
}
== External resources ==
* Home page
Category:Languages Category:Implemented Category:Turing complete Category:Turing tarpits
Husk

Husk is a prefix-based (similar to Pyth) golf language related to Haskell.
The language is strongly typed(values are not malleable).
Most builtins have more than one independent overload of different type and different order (unlike Pyth, which requires operands to be entered in a specific order). The compiler uses heuristics to make the program well-typed: it chooses between overloads of builtins, and by inserting parenthesis and default values with certain restrictions. The language uses an 8-bit source character set unique to it.
It is optimized for Code Golf SE golf rules, so there are no IO operations, only pure functions. However, a langauge without IO is untestable, therefore IO is taken via command-line arguments and is accessible via one of the superscript number instructions.
== Design Principles ==
Husk is (the only) golfing language which fully embraces the functional paradigm. This means that there are no explicit loops, no variables, no specific structure to a Husk program other than the functions, combinators and their parameters. 
This makes Husk extremely strong on simpler challenges while still keeping it competitive on harder tasks.
Husk is "lazily" evaluated i.e. It doesn't evaluate expressions until their value is required in the program. This makes Husk work strangely at times, and sometimes wrong looking programs work perfectly.
== External Resources ==
* Husk on Try It Online!
* Husk on GitHub
Category:Languages
Category:Functional paradigm
Category:Golfing language
Category:2015
HydraLoop

Variable names can be any sequence of ASCII letters, numbers, underscores. Variable names are case-sensitive.
Comments start with * and are up to the end of the line.
Each variable stores a list, and the elements of lists are also lists. It
can also be treated as a number, the number being how many items.
Each variable initially stores a empty list.
Non-loop commands:
* X; sets X to a empty list.
* X,Y; adds a copy of the value of Y as an item at the end of X.
Loop commands:
* X[...] remembers the value of X at the beginning of the loop, and then executes ... for each leaf of X. It is a tree, for example a list such as (()()(()())) has four leafs, and a empty list () has one leaf (this is equal to how many "()" in this representation of this list).
* X,Y[...] remembers the value of X at the beginning of the loop, and then for each item of X, sets Y to a copy of that item and then executes the ... commands. For example, if X is ((())()) then it executes ... twice, first with Y set to (()) and second with Y set to the empty list ().
* X,Y,Z[...] does, while X is not empty, repeats the following steps:
*# Remember the value of X.
*# Execute the ... commands.
*# Restore the value of X.
*# Treat Y as a number, and modulo by the number of leaves of X. Find that leaf of X, where the first leaf is numbered zero, and delete that leaf.
*# If the parent of the deleted leaf is not the root, then find the parent of the parent of the deleted leaf and make Z copies of that entire branch (treating Z as a number). The copies are added at the same level of that branch. For example, (()(()())) becomes (()(())(())(())(())) in the case that Y is 2 and Z is 3. If you have ((())) that becomes ((()())) when Z is 1, regardless of what Y is (since anything modulo 1 will be zero).
Note that for the "X,Y" and "X,Y,Z" loops, they do nothing if X is empty. (However, the "X" loop still executes even if X is empty.)
It is permitted (in both loop and non-loop commands) to have some or all of the variable names to be the same (although this is not required). For example, the empty loop X,X[] causes the value of X to be replaced by a copy of the last element of X.
Spaces are also allowed between commands.
==Computational class==
The first kind of loop (leaf loop) will always terminate because the tree has a finite number of leaves; you can't add an infinite number of leaves.
The second kind of loop (item loop) will always terminate because you cannot add an infinite number of items to a list.
The third kind of loop (hydra loop) will always terminate due to the hydra theorem, which says that the "hydra game" will always terminate. (The hydra game consists of a tree and each step deleting a leaf node and adding new branches according to the rules mentioned above, until there is no more left.)
Therefore, the program is guaranteed to terminate.
==Examples==
(TODO)
Category:Languages Category:2020 Category:Total
Hyper-finite-state automaton

A Hyper-finite-state automaton or Hyper-finite-state machine is a generalization of a Finite-state automaton (which can be represented as a directed graph) that can be represented as a directed hypergraph. It is suspected that there is more than one way to implement this, so this page doesn't bother to define just one; it lists possible HFSM designs.
== Concurrent HFSM ==
One model of a Hyper-finite-state machine is to allow a normal Finite State Machine to be concurrent by making it so that, when a node follows to another node from a particular (hyper)edge, it goes to multiple states (all state that the hyperedge points to). This makes the Hyper-finite-state-machine similar to a Neural Network.
Category: Computational models
HyperGolf

HyperGolf is an idea for an esoteric programming language by User:DoggyDogWhirl.
HyperGolf would act like a golfing language, except that it would completely lack basic functions like addition in favor of needlessly complicated functions like hyperoperations. This would make it very bad at actually code golfing, though of course, that's what would make code golfing in it interesting.
==Commands==
A golfing language takes a lot of commands to be effective, so even a long list of ideas here might not be enough. This list is open to additions.
* Hyperoperations, as previously mentioned
* Quaternions
* The quadratic formula
** The quartic formula?
* Reversible logic gates like the Toffoli and Fredkin gates
** Quantum logic gates may work on matrices (lists of lists, or possibly their own type)
* Strings encoded in base 65536
* Continued fractions
* Number literals 0-9 have different values
 Number literals
Digit	Actual value
0 	0
1 	i
2 	√2
3 	1000 (10³)
4 	256
5 	
6 	τ (2π, 6.28..)
7 	
8 	Infinity
9 	362880 (9!) or 2520
Some ideas that may be less useless but still odd:
* UNTILs and UNLESSs rather than WHILEs and IFs
* Indices of sorted list
* List of all factors of a number
* Fixed point operation
* Convert integer to word form (17 -> "seventeen")