nyuuzyou/wikis huggingface dataset:
Asvi

:The creator of this esolang did leave from esolangs wiki. Please help us by adding some more information.
== Introduction ==
The Asvi programming language was made to have a Virtual Machine, that is similar to Assembly code, Turing complete and esoteric at the same time.
=== Syntax ===
Asvi instructions are just 2 character, without parameters, so it would be really easy to make an interpreter.
=== File extensions ===
Asvi file extensions are .asvi and .avmc.
:.asvi is for storing source code
:.avmc is for storing the Asvi Virtual Machine code
=== How data is stored ===
Asvi stores data with a stack, a heap, an accumulator abbreviated as acc and some pointer registers.
This is serious business man, specially because there is 2 characters for 1 instruction so you would need to use the entire Unicode table. For legal reasons that was a joke
=== Registers ===
:Program counter abbreviated as PC register:
::A register that stores the char that is running right now.
:Auxiliar Accumulator abbreviated as auc register:
::A register that is an auxiliar accumulator.
== Abbreviations ==
Word 	Abbreviation
Program Counter	pc
Accumulator 	acc
== Instructions ==
=== Registers manipulation ===
Instruction	Result 	Description
xa 	aux = (aux + 1) 	Increments the aux register
xd 	aux = (aux - 1) 	Decrements the aux register
ai 	acc = (acc + 1) 	Increments the acc register
ad 	acc = (acc - 1) 	Decrements the acc register
pc 	pc = acc 	Set the PC register to the acc register
ms 	mem[acc] = aux 	Can't explain
ma 	mem[acc] = (mem[acc] + aux)	Increments the memory location pointed by acc
== Final notes ==
=== Program stores in the same memory ===
The memory of the program and code of the program is stored in the same memory.
The code of the program is stored in numbers, a number means an instruction, this is the instruction table:
Number 	Equivalent to
Ejemplo	Ejemplo
Ejemplo	Ejemplo
== .avmc File extension ==
== Implementations ==
This is on WIP so there is a no interpreter, If I would make a change I would need to make the interpreter again
Category:Languages
Category:2020
Category:Turing complete
Category:Unimplemented
Category:Low-level
At some land

At some land(ATSML not be confused with A Tiny Self-Modifying language) is a fungeoid by User:ChuckEsoteric08.
==Description==
It has 1 stack and 1 accumulator as memory and 31 commmands. When IP goes out of bounds halt
===Commands===
Commands 	Operations
><v^ 	same as in other 2-dimensional languages.
/\ 	Mirrors
0123456789	Push that digit to the stack
+-*! 	pop two numbers, a and b, push b<op>a(! is a division)
id 	increment and decrement accumulator.
:% 	duplicate top element and swap top two elements
;, 	Commands that skip next command if zero. First is for stack and second for accumulator
'` 	move element from the top to bottom and from bottom to top
? 	ask for input and push its ASCII character to the stack
. 	output top of the stack as ASCII character
@ 	stops the program
==Examples==
===Hello, world!===
The following program prints the message “Hello, World!” to the standard output:
 >09+9+9+9+9+9+9+9+ .v
 v <
 >09+9+9+9+9+9+9+9+9+9+9+2+ .v
 v <
 >09+9+9+9+9+9+9+9+9+9+9+9+ .v
 v <
 >09+9+9+9+9+9+9+9+9+9+9+9+ .v
 v <
 >09+9+9+9+9+9+9+9+9+9+9+9+3+.v
 v <
 >09+9+9+9+8+ .v
 v <
 >09+9+9+5+ .v
 v <
 >09+9+9+9+9+9+9+9+9+6+ .v
 v <
 >09+9+9+9+9+9+9+9+9+9+9+9+3+.v
 v <
 >09+9+9+9+9+9+9+9+9+9+9+9+6+.v
 v <
 >09+9+9+9+9+9+9+9+9+9+9+9+ .v
 v <
 >09+9+9+9+9+9+9+9+9+9+9+1+ .v
 v <
 >09+9+9+6+ .@
===Cat program===
An infinitely repeating cat program follows:
 >?.v
 ^ <
===Truth-machine===
This program defines a truth-machine:
 ?68*-;v68*.@
 >v
 6
 8
 *
 1
 +
 .
 ^<
==Interpreter==
* Common Lisp implementation of the At some land programming language. The file contains also a code generator for producing At some land programs which print a specified message to the standard output.
Category:Languages Category:Turing complete Category:Implemented Category:Stack-based Category:Two-dimensional languages
Atom

Atom is a Turing-Complete programming language that is designed to obfuscate software. It does this skillfully by allowing line numbers to be mixed and even broken up.
== Hello World Example ==
=== Non-Obfuscated ===
> Declare Variable - Strict String - Hello World>
	*1
		D TTTTTTTTT !!!!!!!!!!!!!!!!!!!
			<<??????????<???????<??????????????<??????????????<?????????????????????????<????????????????????????????????	<<<?????????????????????????<?????????????????<????????????????????<??????????????<??????<?????????????????????????????<
	*
> Print Variable
	*2
		O T !!!!!!!!!!!!!!!!!!!
	*
=== Obfusicated ===
*2O**1DTT**2T!!!**1TTTTT**1TT!**2!!!!**1!!!!!!!!!!!!!!!!!!!**2!!**1<<??????????<???????<??????????????<??????????????<?????????????????????????<????????????????????????????????<<<?????????????????????????<??????????????**2!!!**1??<????????????????????<??????????????<??????**2!!!**1<?????????????????????????????<**2!!!**2!**1
==External Links==
* Atom Specification (PDF)
Category:Languages
Category:Turing complete
Aubergine/aubergine.hs

This is an implementation of Aubergine in Haskell by Chris Pressey. It is imperfect:
* It does not handle input at all.
* Attempts to access beyond the bounds of the program crash the interpreter. So, the quine example runs, but hits an exception at the very end. Actually, the reference interpreter does this too, and the article doesn't say what should happen in this case, so it's probably OK.
* It is written in an amateurish Haskell style.
However:
* It uses Haskell's Integer data type to simulate unbounded integers.
* I might improve it at some point.
import qualified Data.Char as Char
-- a b i program
data State = State Integer Integer Integer [Integer]
 deriving (Ord, Eq, Show)
getAt 0 (head:_) = head
getAt n (head:tail) = getAt (n-1) tail
getCharAt n l = Char.chr $ fromIntegral $ getAt n l
setAt 0 v (_:tail) = v:tail
setAt n v (head:tail) = head:setAt (n-1) v tail
getCmd (State _ _ i p) =
 (getCharAt i p, getCharAt (i+1) p, getCharAt (i+2) p)
get '1' _ = 1
get 'a' (State a _ _ _) = a
get 'b' (State _ b _ _) = b
get 'i' (State _ _ i _) = i
get 'A' (State a _ _ p) = getAt a p
get 'B' (State _ b _ p) = getAt b p
set 'a' a (State _ b i p) = State a b i p
set 'b' b (State a _ i p) = State a b i p
set 'i' i (State a b _ p) = State a b i p
set 'A' x (State a b i p) = State a b i $ setAt a x p
set 'B' x (State a b i p) = State a b i $ setAt b x p
advance (State a b i p) = State a b (i+3) p
step :: State -> IO State
step s@(State a b i p) = do
 s' <- case getCmd s of
 ('=', 'o', src) -> do
 putChar $ Char.chr $ fromIntegral $ get src s
 return s
 ('=', dest, src) -> do
 return $ set dest (get src s) s
 ('+', dest, src) -> do
 return $ set dest (get dest s + get src s) s
 ('-', dest, src) -> do
 return $ set dest (get dest s - get src s) s
 (':', dest, src) ->
 case get src s of
 0 -> do return s
 _ -> do return $ State a b (get dest s) p
 return $ advance s'
run :: State -> IO State
run s = do
 s'@(State _ _ i p) <- step s
 let size = fromIntegral $ length p
 if i >= size then return s' else run s'
parse string =
 State 0 0 0 $ map (fromIntegral . Char.ord) string
runString string = run $ parse string
Category:Implementations
AutProL

AutProL, also known as Autistic Programing Language, also called AutistF***, is a brainf*** style esolang created in 2023 by PoptartPlungerBoi. This esolang is meant to """""""""""""""""""""""""""""""portray""""""""""""""""""""""""""""""" as an autistic person.
== Keywords ==
AutProL 	Brainflakes 	Description
GOT MILK GOT MILK YES 	> 	Moves pointer to the right
JUPITUREE TWIX BAR AAH 	< 	Moves pointer to the left
HURBRAH UNICORN 	Increments the memory cell under the pointer	
PLANT MY TEETH MOMMY 	 	
Decrements the memory cell under the pointer	 	
NO I DONT WANNA BE A WERRLINU 	. 	Outputs the character signified by the cell at the pointer
EAT QUAIL MEAT CERLEEM 	, 	Inputs a character and store it in the cell at the pointer
DO I NEED 	[ 	Jump past the matching I DO NEED WOWIZER if the cell under the pointer is 0
I DO NEED WOWIZER 	] 	Jump back to the matching DO I NEED
LEEOW 	n/a 	A 10km drive to therapy
Category:Languages
AutoCorrect

AutoCorrect is a golfed derivative of C, where every error in the code that the parser can find is corrected. Codes in AutoCorrect uses autocorrection as a way to remove characters that are arbitrarily unnecessary (such as closing brackets).
== Autocorrecting ==
Autocorrection is performed when either the parser encountered a syntax error, or when a name hasn't been declared (while alternative names exists). Autocorrection should be exhaustive; it should consider every single possible corrections.
=== Syntax errors ===
On syntax errors, the parser corrects it by adding the expected character. If multiple suggestions exists, it chooses the most prioritized one (priority system is left to be implemented in the compiler), retrying with another suggestion if it's still invalid.
=== Undeclared names ===
On undefined names, the parser corrects it by choosing a name containing the same characters in the same order. For example, function name ps could be corrected to puts or fgetpos, but not pow or sprintf.
There are priorities on choosing a name: (rules written first are prioritized)
# Suggestions with the least corrections are prioritized. For the function name ps, puts is better than printf_s.
# Suggestions with the least correction chunks are prioritized. For the function name lg, log with 1 chunk is better than ilogf with 3 chunks.
# Variable names takes priority above functions.
# On functions, consider the inputs of the functions. p("Hello, world! is better corrected to puts("Hello, world!"); instead of pow("Hello, world!");
# By default, functions from the library stdio.h, stdlib.h, and stddef.h are prioritized, however this can be configured on the compiler.
== Example codes ==
Since the compiler hasn't been implemented yet, these example codes might not work.
=== Hello, world! ===
 m({p"Hello, world!
This possibly autocorrects to:
 main(){puts("Hello, world!");}
==See also==
* FatFinger
Category:2023 Category:Unimplemented Category:Languages
AutoMouse

AutoMouse is a screen-scrubbing utility for Microsoft Windows, written by Kakuya Yamamoto. When it is combined with a suitable environment, such as Microsoft Paint, it becomes an interesting esoteric programming language.
An AutoMouse program consists of images to be recognized, and mouse actions to be taken when they are. The program can contain branches, depending on what is recognized, and loops, which can restart the recognizing process. Mouse actions such as clicking can alter the images on screen, for instance in a graphics application where clicking toggles the color of a pixel. In turn the altered image can be recognized once again, perhaps by different rules. In effect, the canvas of the paint program is used as an updatable store.
==External resources==
* 
* AutoMouse download from PCWorld
Category:Languages
Category:Implemented
Category:1998
Category:Two-dimensional languages
Category:Self-modifying
Automod-D

Automod-D, or simple Automod, is an infnite family of esolangs created by User:CreeperBomb in 2023. Each language exists on an infinitely large space of dimension D that is comprised by individual cells, preset by the programmer, & edited by the user (the edit being input). The code part is a list of rules telling how each cell should evolve based on its neighbors. Note that this isn't symmetric; for example, if in Automod-1 a 1 cell left of a 1 cell should become a 0 cell, that may not mean a 1 cell right of a 1 cell should become a 0 cell.
==Semantics==
In a rule, on the changing cell and each neighbor cell, which includes diagonals, you may give an statement relating to the cell's value. If all of the cells' statements for a rule are true, then the cell will follow the change specified by the rule; otherwise, the cell looks for later specified rules in the code it could follow. If there is no rule the cell can follow, then that cell becomes a 0 cell.
The change specified by a rule is simply an expression. It can access the values of itself and its neighbors with a cell's relative coordinates. For example, to make a 1 cell in Automod-3 become the mean of its neighbors, one way of writing the change would be \frac{\left(\sum_{n=0}^{26}\left(\operatorname{mod}\left(n,3\right)-1,\operatorname{mod}\left(\operatorname{floor}\left(\frac{n}{3}\right),3\right)-1,\operatorname{floor}\left(\frac{n}{9}\right)-1\right)\right)-1}{26}.
==Turing completeness==
Automod-1 is easily Turing complete as you can code rule 110 in it, which is known to be Turing complete. It is also easily true that for D>1, Automod must be Turing complete as you can simple ignore the extra dimensions. However, Automod-0 is less obviously Turing complete, as there is only one cell to work with; but it is also Turing complete, as you can use powers of two to have infinitely many bits to store the program and memory state for an Expressive interperter in Automod-0. Unnatural dimensions for Automod have unknown Turing completeness.
Category:Languages Category:2023 Category:Cell-based Category:Turing complete Category:Multi-dimensional languages Category:Two-dimensional languages Category:Zero-dimensional Category:Unimplemented
Awib

awib (Also Written In Brainfuck) is a compiler for the brainfuck language, written in brainfuck by Mats Linander.
awib can generate C, Go, Java, Ruby or Tcl source code, or i386 Linux ELF executables. It is an optimizing compiler, turning strings of + or - commands into single instructions. The binaries produced by awib have been said to work with FreeBSD's Linux compatibility layer.
Programs compiled with awib use wrapping 8-bit cells, and the , command does not change the current cell if EOF is read. However, awib itself has been tested on brainfuck implementations with 8-bit or 32-bit cells, and with , returning 0, -1, or no change on EOF.
awib is also polyglot in C, Tcl and bash.
==External resources==
* Also Written In Brainfuck (awib) home page
* "The Design and Implementation of awib" (PDF, 150K)
* awib on github
Category:Languages
Category:Implementations
Category:Brainfuck
Ax

Ax is a Nock derivative by mnemnion aimed for nondeterminism, a more æsthetic operator order, and sane big O.
=Specification=
This text specifies Ax, a cellular automaton for general purpose computation.
==Preamble==
 0 A noun is either an atom or a cell. An atom is any natural number.
 
 1 A cell is an ordered pair of two nouns.
 
 2 n refers to any atom. a, b, c, and d refer to nouns. 
 
 3 `Ξ` means to perform a rewrite as defined by this specification. 
 
 4 `→` shows the steps of such a reduction. All must be completed.
 
 5 `?` means the reduction is undefined.
 
 6 `:=` indicates a noun is the referent of a symbol.
 
 7 `+` refers to the operation on the natural numbers, whose identity is 0.
 
 8 `~` requires that n so defined be in the range (n1..n2), inclusive.
 
 9 [a b c] → [a [b c]]. 
 
 10 Symbols have no other semantics.
 
 11 The lemmas are reduced in ordinary arithmetic; c and d refer to atoms.
==Term==
 
 ~(1..256) := σ 
 
==Reduction==
 
===Axioms===
 
 Ξ [0] → Ξ [0] 
 
 Ξ [0 0] → Ξ [0 0]
 
 Ξ [0 0 0] → 0
 
 Ξ [0 1 0 0] → 1 
 
 Ξ [0 1 0 1] → 2
 
 Ξ [2 1 2 1] → 3
 
 Ξ [a 0 n] → n
 
 Ξ [a 1 0 n] → n + 1 
 
 Ξ [a 1 b] → Ξ [a b] → n → n + 1 
 
 Ξ [a 2 0] → ?
 
 Ξ [a 2 1] → a
 
 Ξ [[a b] 2 2] → a
 
 Ξ [[a b] 2 3] → b
 
 Ξ [a 2 (b + b)] → Ξ [Ξ [a 2 b] 2 2]
 
 Ξ [a 2 (b + b + 1)] → Ξ [Ξ [a 2 b] 2 3]
 
 Ξ [n 2 b] → Ξ [n]
 
 Ξ [3 3 [[2 1] [1 2 1]] [0 2 1]] → [3 4]
 
 Ξ [a [b c] d] → [Ξ [a b c] Ξ [a d]]
 
 Ξ [a 3 b c] → Ξ [Ξ [a b] Ξ [a c]]
 
 Ξ [a 4 b] → Ξ [a b] → [c c] → 0
 
 Ξ [a 4 b] → Ξ [a b] → [c d] → 1
 
 Ξ [a 5 b] → Ξ [[a σ] b] 
 
 Ξ [a 6 b] → Ξ [a b] → [c d] → 0
 
 Ξ [a 6 b] → Ξ [a b] → d → 1
 
===Idioms===
 
 Ξ [a 7 b c] → Ξ [a 3 b 0 c]
 
 Ξ [a 8 b c d] → Ξ [a b] → 0 → Ξ [a c]
 
 Ξ [a 8 b c d] → Ξ [a b] → 1 → Ξ [a d]
 
 Ξ [9 b c] → Ξ [a 7 [[7 [2 1] b] 2 1] c]
 
 Ξ [a 10 b c] → Ξ [a c]
 
 Ξ [a 10 [b c] d] → Ξ [a 9 c 7 [2 3] d]
 
 Ξ [a 11 b c] → Ξ [a 7 c 3 [2 1] 2 b]
 
===Crash default===
 
 Ξ [a] → Ξ [a]
 
===Lemmas===
 
 Ξ [a 12 b] → Ξ [a b] → n → n - 1
 
 Ξ [a 12 b] → Ξ [a b] → 0 → Ξ [12]
 
 Ξ [a 13 b] → Ξ [a b] → [c d] → c + d 
 
 Ξ [a 14 b] → Ξ [a b] → [c d] → c - d
 
 Ξ [a 14 b] → Ξ [a b] → [c d] → c < d → Ξ [14]
 
 Ξ [a 15 b] → Ξ [a b] → [c d] → c * d
 
 Ξ [a 16 b] → Ξ [a b] → [c d] → c / d
 
 Ξ [a 16 0] → Ξ [a b] → [c d] → d = 0 → Ξ [16]
 
 Ξ [a 17 b] → Ξ [a b] → [c d] → c % d
 
 Ξ [a 18 b] → Ξ [a b] → [c d] → c < d → 0
 
 Ξ [a 18 b] → Ξ [a b] → [c d] → c >= d → 1
 
==Expansion==
 
===Terms===
 
 7 operators
 
 0 := is
 1 := inc
 2 := ax
 3 := br
 4 := eq
 5 := fz
 6 := cel
 
 5 idioms
 
 7 := cmp
 8 := if
 9 := cnk
 10 := put
 11 := arm
 
 7 lemmas
 
 12 := dec
 13 := add
 14 := sub
 15 := mul
 16 := div
 17 := mod
 18 := lemmas
 
===Expansions===
 
 Ξ [a 12 b] → Ξ [b [cnk [is 0] [cnk [is [if [eq [br 7] [up br 6]] [br 6] [arm 2 [[br 2] [up br 6] [br 7]]]]] [arm 2 br 1]]]]
 
 etc.
 
==External resources==
* Commentary on Ax
Category:Languages Category:Nondeterministic
Axo

axo is a language inspired by Befunge, invented by Jannis Harder in 2004. "axo" is pronounced like the German words "ach so".
The axo interpreter has three modes which have slightly different operation. It uses an unlimited stack, and 2048 memory cells of 32 bit signed integers. Popping from an empty stack produces zero (0).
== Command mode ==
Command 	Description
" 	Switch to string mode.
' 	Switch to raw mode.
^, <, >, % 	Change direction to up/left/right/down.
Pop two values, and push their sum/difference/product.	
/ 	Pop two values, and push their quotient and remainder.
\ 	Exit program.
&, | 	Rotate the stack left/right (pop+enqueue/dequeue+push).
$ 	Pop a value, and change direction depending on the value mod 4.
# 	Pop a value, and skip the next command if the value is zero.
[ 	Duplicate the top of the stack.
] 	Pop a value, and discard it.
( 	Pop a value, and print it as an ASCII character to stdout.
) 	Read a character from stdin, and push its ASCII value.
{ 	Pop a value, and print it as a number to stdout.
== Raw mode ==
Command	Description
' 	Switch to command mode.
Any other character pushes its ASCII value.
== String mode ==
Command 	Description
" 	Switch to command mode.
^, <, >, % 	Change direction to up/left/right/down.
Pop two values, and push their sum/difference/product.	
/ 	Pop two values, and push their quotient and remainder.
\ 	Exit program.
$ 	Push value 10 (linebreak).
Any other character pushes its ASCII value.
==External resources==
* by Jannis Harder, written in C99 (very buggy).
* by Jannis Harder, written in C++.
* by Jannis Harder
* 99 bottles of beer in axo
Category:Languages
Category:Stack-based
Category:Queue-based
Category:Turing complete
Category:Two-dimensional languages
Category:Implemented
Category:2004
Az

az is an esoteric programming language drawing inspiration from all-over.
 a3 b5 i1
 [
 c0! ca+ cb+
 ac0+! [? a3 s"Fizz".0]
 bd0+! [? b5 s"Buzz".0]
 cd|! [? i# d0] 10.
 c1i+ c101^ ?
 ]
==Design==
* Each command is a single ascii character.
* White space is optional and comments are ( in parens ).
* There are 26 local variables named a-z.
* Specifying a variable makes it current.
* Commands always execute on the current variable.
* The previous current variable is tracked too (like a 2-cell stack).
* Integer literals are specified directly in base 10.
* String literals are supplied as double-quoted strings.
* Words of three or more letters are global named variables.
* Functions are first-class, passed as integer references.
* Zero is false. Non-zero is true.
==Commands==
Cmd 	Description
( 	Start comment
) 	End comment
a-z 	Make local variable current
A-Z 	Make outer variable current (calling scope)
"..."	current = string
0-9 	current = integer
[ 	Begin loop
? 	Break loop if current is false
] 	Repeat loop
{ 	Start function
==Fibonacci==
 a0 b1 [ b# c32.0+ ac+ ba0+ cb0+ cd100-+\ ?]
==Factorial==
 a1 b5 c0! [ ad0+ be0+ [ce+?da+] cb+ ?] a# 0
==Beer==
 d { B"s" Aa1^! [?B0] }
 e { a"#A bottle$B of beer on the wall,".10. }
 f { a"#A bottle$B of beer.".10. }
 g { a"Take one down, pass it around,".10. }
 h { b"#A bottle$B" Aa0+! [? b"No bottles" a0] b. }
 i { a" of beer on the wall.".10.. }
 a99 [ a? d; e; f; g; c0!a+ d; h; i; ] 0
==Brainfuck==
 ( 64k source, 64k tape )
 a32768@
 
 ( read source to cell 26 )
 a26 [ b,? a@0+ c1a+ ]
 
 ( tape pointer )
 a16384
 ( source pointer )
 b26
 
 ( bracket tracking )
 x { EG^! [? a1F+ z] EH^! [? a0!F+ z] }
 
 [
 b@c0+ ? (c = command)
 
 c (>) d62 ^! [? 1a+ z]
 c (<) d60 ^! [? 0!a+ z]
 c (+) d43 ^! [? 1a@+ z]
 c (-) d45 ^! [? 0!a@+ z]
 c (.) d46 ^! [? a@. z]
 c (,) d44 ^! [? a@, z]
 c ([) d91 ^! [? f1 a@d0+! [? e1 b+@e0+ g91 h93 x; f ]]
 c (]) d93 ^! [? f1 a@d0+ [? e0! b+@e0+ g93 h91 x; f ]]
 
 c1b+
 ]
==External resources==
* Language Overview
* Github Repo
Category:Languages
Category:Turing complete
Category:Low-level
AzureHeartC

AzureHeartC(or abbr as AHC) is most not esoteric in Esolangs.
It is like my VNL, but kinda modern.
If you wanna learn about this, you need to learn ArnoldC(or abbr as AC, not ACcepted)
== Syntax ==
I don't wanna talk about syntax anymore.
In fact, it is the pseudo-code, 'cause it's actually like language that we say.
== Program ==
=== Hello, world ===
 Program start.
 print("Hello, world!\n")
 Kill program.
=== A+B Problem ===
 Program start.
 defvar a, b, c -> float
 input(a)
 input(b)
 c=a+b
 print(c)
 Kill program.
=== Even or odd? ===
 Program start.
 defvar a -> int
 input(a)
 if a modulo 2 equals to 0:
 print("It is a even number.")
 else:
 print("It is a odd number.")
 endif.
 Kill program.
=== Fibonacci ===
Function fibonacci start with type int.
arguments: int N.
if N == 1:
 return 1
elif N == 2:
 return 1
elif N > 2:
 return fibonacci(N-1)+fibonacci(N-2)
else:
 return ValueError(description="What the hell did you tell me to do?!")
endif.
End Function.
Program start.
defvar a -> int
input(a)
print(fibonacci(a))
Category:Languages Category:2024 Category:Unimplemented
B-H

B-H is an esolang created by User:None1. It is brainfuck and Hello++ combined together.
==Execution==
B-H first feeds your code into a brainfuck interpreter, then feeds the output into a Hello++ interpreter. The output of the Hello++ interpreter is the final output.
==What it can do==
B-H can print Hello World or do nothing, but can't do anything else.
==Example Programs==
===Hello World===
 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
==Interpreters==
===Python===
 print("Hello World" if __import__("sys").stdin.read().count("+") in [72,104] else "")
===brainfuck===
Note: NOT made from BFFuck.
 >,[<++++++[->-------<]>-[->[-]+<]>[->-<]>+<<,]>
 -[+++++++>+<]>+[<----[->++++++++<]>[->[-]-<]]>+[->>>>>
 +[-->-[>>+>-----<<]<--<---]>-.>>>+.>>..+++[.>]<<<<.+++.------.<<-.>>>>+.
 [-]]
Category:Output only
Category:Languages
Category:Unusable for programming
Category:2023
Category:Total
Category:Joke languages
Category:Implemented