nyuuzyou/wikis huggingface dataset:
Generic

Generic is a WIP language made by User:Tailcalled in a way that makes many concepts from Category Theory easy to define.
== Concepts ==
The main elements in the language are currently concepts. They are a way to define something in an extremely abstract way. They are a bit like interfaces or typeclasses, and are used in some of the same areas as typeclasses, but are more first-class.
Defining the concept 'Category' from category theory is done this way:
 concept Category
 obj in coll
 hom(A in obj, B in obj) in coll
 id(A in obj) in hom(A, A)
 compose(A in obj, B in obj, C in obj, f in hom(A, B), g in hom(B, C)) in hom(A, C)
'coll' is the collection of most (possibly all?) collections. Explaining each line:
 concept Category
This basically names the concept. The compiler/interpreter has to make a global collection called 'Category'.
 obj in coll
This line states that every category has a collection called 'obj'.
 hom(A in obj, B in obj) in coll
This means that there is a set for every two elements in obj. That collection is referred to as hom(A, B).
 id(A in obj) in hom(A, A)
This states that there is an element in hom(A, A) for element A in obj.
 compose(A in obj, B in obj, C in obj, f in hom(A, B), g in hom(B, C)) in hom(A, C)
This states that for every three elements A, B, C in obj, and every element in hom(A, B) and every element in hom(B, C), there is an element in hom(A, C).
One example of how concepts are more first-class than typeclasses can be seen in this definition of functors:
 concept Functor
 src in Category
 dst in Category
 F(A in src.obj) in dst.obj
 f(A in src.obj, B in src.obj, m in src.hom(A, B)) in dst.hom(F(A), F(B))
This functor has two categories, src and dst, defined like this:
 src in Category
 dst in Category
Category is the collection of all categories. Accessing a part of a specific implementation of a concept can also be done:
 F(A in src.obj) in dst.obj
This maps every element of obj in the category src to an element of obj in dst.
== Actual Code ==
Tailcalled has currently not designed any kind of way to actually code something, but he's working on it.
== Collections ==
Tailcalled has not yet decided on whether to use set theory, type theory or something completely different, which is why he used the word 'collection' instead of set or type. Collections might be declared with a syntax like this:
 coll List given (A in coll)
 with () -- () is the empty product
 given
 head in A
 tail in List(A)
 be
 with (head, tail)
This makes anything of the form (a, (b, (c, (d, (e, (f, ())))))) a list iff a-f are all in one collection. A collection of disjoint unions could be defined like this:
 coll Sum given (A in coll, B in coll)
 given
 fst in A
 be
 with (#false, fst)
 given
 snd in B
 be
 with (#true, snd)
This system would probably require something that's equivalent to dependent typing.
Category:Ideas Category:Languages Category:Works-in-Progress
GenericLang

GenericLang is an esolang made by Quadril-Is which was intended to be generic but it didn't.
It was created while trying to find a good language to code in Python on a phone.
== Instructions ==
=== Literals ===
Command	Name 	Meaning
0-9 	Number literal	Pushes the number to the stack (90 pushes 90, not 9 and 0)
No strings because I can't find a single non-golfing language that does something with these.
=== I/O ===
Command	Name 	Meaning
I 	Input 	Takes a number from input and pushes it.
O 	Output	Pops the top of the stack and outputs it.
=== Stack manipulation ===
Command	Name 	Meaning
~ 	Discard	Pop the top of the stack.
: 	Dupe 	Duplicate the top of the stack.
$ 	Swap 	Swaps the top two items.
=== Branching and Control Flow ===
Command	Name 	Meaning
! 	Skip 	Skips the next command.
? 	Conditional Skip	Pops the top of the stack and skips the next command if it's 0.
j 	Jump 	Pops the top of the stack abd jumps to that character.
=== Arithmetic ===
Command	Name 	Meaning
+ 	Increment	Adds 1 to the top of the stack.
- 	Decrement	Subtrscts 1 from the top of the stack.
I have spent too much time on this so these are the only 2 arithmetic commands you get.
Category:Languages
Generic 2D Befunge

Generic 2D Befunge is a language created in 2018 by User:Alikberov. It is, as the name suggests, a generic 2-Dimensional befunge-based language. It operates on both a 2-Dimensional variant of Befunge's tape as well as using a 2-Dimensional program.
==Language Overview==
Generic 2D Befunge is basically just graphical 2D-space with 10 colors. The commands are as such:
Color 	Command
BlacK 	Keen
Blue 	Branch
Green 	Gate
Cyan 	Call
Red 	Register
Magenta	...
Yellow 	Yield
White 	When
Silver 	Stop
==History==
Generic 2D Befunge was created by Alikberoff in 2018. There hasn't been much time for history to be made.
==Examples==
As Generic 2D Befunge is not compatible with Befunge.
CodePen jsFiddle
Category:Two-dimensional languages
Category:Languages
Category:2018
Genome

Genome Code is a language developed by Digerati. The commands are only: A, T, C, and G.
==Commands==
* TATA: Tells the "cell" to turn the trait on.
* ATAT: Tells the "cell" to turn the trait off.
* ATG: Tells the "cell" to create a protein.
* ATC: Tells the "cell" what "amino acids" to access to build a protein.
* TGA: Tells the "cell" to stop creating a protein.
===Amino Acids===
Syntaxing Amino Acids is not very hard once you know how.
# Write the Base (O or NH).
# Write any elements (This'll consists of C, H, N, O, P, or Ph)
# Write any subelements (This'll consist of C, H, N, or O)
Base...
* O= Character variable
* NH= Interger Variable
Elements...
* C= Equal to
* H= Greater than
* N= Less than
* O= Unequal to
* P= Equal to or Greater than
* Ph= Equal to or less than
Subelements...
* C= EXACTLY (case sensitive and "1" isn't "01")
* H= Any interger greater than
* N= Any interger less than
* O= Inexact (case insensitive and "1" is "01")
Example:
 NH-C-C a & 1
 means:
 a is an integer variable that is EXACTLY equal to 1
Category:Languages Category:Thematic
GeoFuck

What a program does only depends on where you are and the length of the program.
==Translation==
GeoFuck first takes your exact latitude and longitude as a pair of real numbers (north and east are positive, south and west are negative). For example, 12.34°N 56.78°W becomes (12.34,-56.78).
Then add 90 to the latitude and divide by 180. For example, 12.34 becomes 0.5685555555555556 (there are an infinite number of digits that are omitted here).
Then add 180 to the latitude and divide by 360. For example, -56.78 becomes 0.3422777777777778 (there are an infinite number of digits that are omitted here).
Then the decimal numbers are translated to PoeticFuck by repeating this procedure n times (Where n is the length of the program):
# Take the highest digit that's not taken before from fractional part of one of the number, the latitude is taken first, and then the longitude, and then the latitude, etc.
# Translate it into code:
1 +
2 -
3 >
4 <
5 ,
6 .
7 [
8 ]
9 ?
0 ;
For example, if the program is 5 bytes long and the numbers are 0.5685555555555556 and 0.3422777777777778, it translates to ,>.<].
At some locations, such as the North Pole, the result of this procedure is undefined, so GeoFuck will cause undefined behavior.
==Examples==
===Cat program===
 aaaaa
It only works in some locations, e.g.: 12.24°N 90°E.
Category:Languages
Category:Brainfuck derivatives
Category:2025
Category:Unimplemented
Geography table

Geography table is an esolang based on this:
Insert an image from the Belarusian 7th grade book page 20 image 7 becuase the image that was here is copyrighted
created by User:Ractangle
==Syntax==
Every program must start with a start form (or a start command). Bellow the start form, we have groups.
Groups can have unlimited amount of nodes.
Groups has forms which are
* Conditionals
* Actions
* Action part of conditionals
and
* Variables
==Hello, world!==
Category:Languages Category:2024 Category:Non-textual
Geometry Dash

Geometry Dash (GD) is a Turing-complete 2013 platformer game created by Robert Topala. At first glance, how could a platformer game be Turing-complete. Well, GD has a level editor where you can make your own levels. There are "triggers" that can cause actions to occur in the level. Using these triggers, you can create loops and if statements.
==Implementations==
Geometry Dash 2.2, which is on Steam, the App Store, and Google Play.
==Legal issues with alternate implementations==
DISCLAIMER: User:Purah126, who wrote this section, is not a lawyer.
Since Geometry Dash is a copyrighted game, it could be illegal to write a full implementation yourself. However, implementations only considering triggers are probably fine. Since SPWN has not been taken down, compilers to it are probably fine. Alternate IDE's could also encounter legal issues.
==Files==
Your GD save files contain a file named "CCLocalLevels.dat" which contains your saved levels. Programs should ideally be distributed using this format.
I have devised another format, which is saved in .esogd files.
Programs must be of the form id [integer].
This is interpreted as a Geometry Dash level ID. By pressing the "create", then "search", then typing in the ID and searching, it is possible to get the level corresponding to the ID. It is also possible by sending requests to boomlings.com as documented here.
==Computational class==
It is Turing-complete as shown by this program:
id 69434308
This emulates Brainfuck which is known to be Turing-complete. It is bounded, but can be adjusted to be unbounded.
==Example programs==
=== Small game engine ===
 id 106785428
Requires version 2.200 or higher.
==Documentation==
Documentation for the GD level editor is available here.
Category:Turing_complete
Category:Implemented
Category:2013
Geometryjunp

geometryjunp is an esoteric programming language named after the 2013 platformer game Geometry Dash. It is also a brainfuck substitution language with some extra commands.
Character	Command
□ 	Begin the program.
] 	End the program.
_ 	Increment the cell.
▲ 	Decrement the cell.
⦾ 	Start a loop.
■ 	End loop if the cell value is 0.
› 	Print the cell value as ASCII character.
» 	Take user input and store it to the current cell.
▴ 	Switch to the left cell.
◢ 	Switch to the right cell.
== Example Programs ==
=== Cat program ===
 □»⦾›»■]
===Truth-machine===
A truth-machine is implemented in this program:
 □»›⦾◢_◢_▴▴▲■◢◢◢________________________________________________⦾▴▴▲◢◢▲■▴▴⦾◢›▴■]
===Hello, world!===
The following program displays the message “Hello World!” in the standard output:
 □________⦾◢____⦾◢__◢___◢___◢_▴▴▴▴▲■◢_◢_◢▲◢◢_⦾▴■▴▲■◢◢›◢▲▲▲›_______››___›◢◢›▴▲›▴›___›▲▲▲▲▲▲›▲▲▲▲▲▲▲▲›◢◢_›◢__›]
== External links ==
* Wikipedia:Geometry Dash
* Common Lisp implementation of the geometryjunp programming language. Please note that the concrete character set deployed constitutes a dependency on the Common Lisp implementation; in corollary, Unicode support may or may not be a feature incorporated in the personal environment. The interpreter at hand has been developed and tested with Steel Bank Common Lisp (SBCL) version 1.1.4 as part of the Lisp Cabinet 0.3.5 bundle.
Category:Turing tarpits 
Category:Low-level 
Category:Cell-based 
Category:Implemented 
Category:Languages
Category:Thematic
Category:Brainfuck derivatives
Category:2022
Category:Turing complete
Ger

Ger is a stack-based esolang.
Strings in Ger start with a semicolon and a space.
Instructions
Ger has 8 instructions: 
ger: Outputs the next line of code
GER: Gets input and pushes it to the stack
Ger: Outputs and pops the top value from the stack
ge_r: Branches amount of lines forward if the 2 top values of the stack are the same then pops those values
g_er: Same as g_er but goes backwards
G_er: Duplicates top of the stack
gEr: Pushes to stack what you typed on the next line of code
geR: Delay for the number of seconds typed on the next line of code
Examples
Hello World:
 ger
 ; Hello, World!
 ger
 ; insert_newline
Cat:
 GER
 Ger
Implementations
* Interpreter By Helo211 (Me!)
Category:Implemented Category:Languages Category:Stack-based Category:2022
Getterlang

Getterlang doesn't use numbers or literals at all, only commands and labels
= Info =
== Elements ==
Comment "C"
 Ccomment
Open "E"
 EEEECerror
Close "D"
 EEEDDEEDDEEDDD
Up "U"
 U
Goto "G"
 GEUUDCgoes to line 2
 GEUDCgoes to line 1
Get "T"
 TEUUDCgets the value of line 2 which is 3, aka UUU, also including Cthree
 UUUCthree
Label "<name>L<val>"
 aLUUU
 bLUUU
 cLTEaDTEbD
Category:Languages
GibMeRol

GibMeRol is a Brainfuck clone that replaces each command in Brainfuck with the letters GibMeRol. It was created for the sole purpose of getting its author, User:Milkman, the 'ESOLANG CREATOR' role in User:Truttle1's discord server. It didn't work.
==Commands==
GibMeRol appropriates brainfuck's octuple instruction set verbatim, simply renaming its identifiers:
Brainfuck	GibMeRol
> 	G
< 	i
+ 	b
- 	M
, 	e
. 	R
[ 	o
] 	l
==Examples==
===Hello World===
 bbbbbbbboGbbbboGbbGbbbGbbbGbiiiiMlGbGbGMGGboiliMlGGRGMMMRbbbbbbbRRbbbRGGRiMRiRbbbRMMMMMMRMMMMMMMMRGGbRGbbR
===Cat program===
An infinitely repeating cat program, which terminates on a user input equal to the null character, is demonstrated below:
 eRoeRl
===Truth-machine===
The following provides a truth-machine:
 eRoMMGboGGlioRliil
==Interpreter==
* Common Lisp implementation of the GibMeRol programming language.
Category:Languages
Category:Brainfuck equivalents
Category:2022
Category:Joke languages
Category:Turing complete
Category:Turing tarpits
Category:Low-level
Category:Implemented
Gibberish/JavaScript

Gibberish/JavaScript is a Gibberish derivative.
== Escape sequence ==
See also completed list
escape sequence 	output 	output’s ASCII code
$h 	backspace 	8
$_ 	newline 	10
$e 	escape 	27
$( 	{ 	123
$) 	} 	125
$[ 	< 	60
$] 	> 	62
$! 	| 	124
$$ 	$ 	36
$p 	% 	37
$a 	& 	38
$q 	= 	61
$' 	" 	34
$` 	^ 	94
$s 	space 	32
$/ 	\ 	92
$x8F 	unicode character U+008F	143
${calc:0:1+2*3}${get:0}	 	
== Example ==
=== Comment ===
 ${: anything}
=== Concatenate string program ===
 ${cat:}
=== Hello, World! ===
A "Hello, World!" program and quine:
 Hello, World!
A slightly more elaborate "Hello, world!":
 ${echo:Hello, World!}
 ${alert:Hello, World!}
palindrome version:
 Hello, World!${:{$!dlroW ,olleH
 }:}
 ${set:teg}${calc:tes:"Hello, World!"//"!dlroW ,olleH":set:clac}${get:tes}$
=== 99 bottles of beer ===
${calc:0:
var a = " bottle";
var b = " of beer";
var c = " on the wall";
var d = "Take one down, pass it around,\n";
for(var e = 99, f = ""; e > 1; --e) {
 f += e + a + "s" + b + c + ",\n";
 f += e + a + "s" + b + ".\n";
 f += d;
 f += e - 1 + a + "s" + b + c + ".\n\n";
}
}${get:0}$
1 bottle of beer on the wall,
1 bottle of beer
Take one down, pass it around,
No bottles of beer on the wall.
=== Quine ===
 ${calc:0:(function(a,b){return a+String.fromCharCode(34)+a+String.fromCharCode(34,44,34)+b+String.fromCharCode(34)+b})("${calc:0:(function(a,b){return a+String.fromCharCode(34)+a+String.fromCharCode(34,44,34)+b+String.fromCharCode(34)+b})(",")}${get:0}")}${get:0}
 ${calc:0:"${calc:0:#@#.replace(/#@#/,unescape('%22$`$&$%27%22'))}${get:0}".replace(/#@#/,unescape('%22$`$&$%27%22'))}${get:0}
and shorter:
 ${recurcall:$${recurcall:$0}}
=== self interpreter ===
 ${calc:0:prompt("Input:")}${getf:0}
=== Fibonacci sequence ===
 ${calc:0:var a=0,b=1,c="",e;for(var d=0;d<60;++d){c+=b+" ";e=a+b;a=b;b=e}c}${get:0}
=== Asterisks counter ===
 ${recurcall:$${recurcall:$0}$$@1$$;*}$@1$;
=== Oscillator/Iterating quine ===
period 2:
 ${calc:0:(function(a,b,c,d){return a+String.fromCharCode(39)+b+String.fromCharCode(34)+a+String.fromCharCode(34,44,34)+b+String.fromCharCode(34,44,34)+c+String.fromCharCode(34,44,34)+d+String.fromCharCode(34)+c+String.fromCharCode(39)+d})("${calc:0:(","${calc:0:(function(a,b,c,d){return a+String.fromCharCode(39)+b+String.fromCharCode(34)+a+String.fromCharCode(34,44,34)+b+String.fromCharCode(34,44,34)+c+String.fromCharCode(34,44,34)+d+String.fromCharCode(34)+c+String.fromCharCode(39)+d})(",")}${get:0}$@1$;",")}${get:0}$@1$;")}${get:0}$@1$;
 ${recurcall:$${echo:$${recurcall:$0}$$@1$$;}$$@1$$;}$@1$;
== See also ==
* parent folder
* JSFuck
* Gibberish/JavaScript/HTML interpreter
Category:Languages
Category:2015
Category:Markup Languages
Gibberish/JavaScript/Escape sequence

:
== Printable characters ==
escape sequence	output	output’s ASCII code
$x21 	! 	33
$x22 	" 	34
$x23 	# 	35
$x24 	$ 	36
$x25 	% 	37
$x26 	& 	38
$x27 	' 	39
$x28 	( 	40
$x29 	) 	41
$x2a 	* 	42
$x2b 	+ 	43
$x2c 	, 	44
$x2d 	- 	45
$x2e 	. 	46
$x2f 	/ 	47
$x30 	0 	48
$x31 	1 	49
$x32 	2 	50
$x33 	3 	51
$x34 	4 	52
$x35 	5 	53
$x36 	6 	54
$x37 	7 	55
$x38 	8 	56
$x39 	9 	57
$x3a 	: 	58
$x3b 	; 	59
$x3c 	< 	60
$x3d 	= 	61
$x3e 	> 	62
$x3f 	? 	63
$x40 	@ 	64
$x41 	A 	65
$x42 	B 	66
$x43 	C 	67
$x44 	D 	68
$x45 	E 	69
$x46 	F 	70
$x47 	G 	71
$x48 	H 	72
$x49 	I 	73
$x4a 	J 	74
$x4b 	K 	75
$x4c 	L 	76
$x4d 	M 	77
$x4e 	N 	78
$x4f 	O 	79
$x50 	P 	80
$x51 	Q 	81
$x52 	R 	82
$x53 	S 	83
$x54 	T 	84
$x55 	U 	85
$x56 	V 	86
$x57 	W 	87
$x58 	X 	88
$x59 	Y 	89
$x5a 	Z 	90
$x5b 	[ 	91
$x5c 	\ 	92
$x5d 	] 	93
$x5e 	^ 	94
$x5f 	_ 	95
$x60 	` 	96
$x61 	a 	97
$x62 	b 	98
$x63 	c 	99
$x64 	d	100
$x65 	e	101
$x66 	f	102
$x67 	g	103
$x68 	h	104
$x69 	i	105
$x6a 	j	106
$x6b 	k	107
$x6c 	l	108
$x6d 	m	109
$x6e 	n	110
$x6f 	o	111
$x70 	p	112
$x71 	q	113
$x72 	r	114
$x73 	s	115
$x74 	t	116
$x75 	u	117
$x76 	v	118
$x77 	w	119
$x78 	x	120
$x79 	y	121
$x7a 	z	122
$x7b 	{	123
$x7c 	|	124
$x7d 	}	125
$x7e 	~	126
$xa1 	¡	161
$xa2 	¢	162
$xa3 	£	163
$xa4 	¤	164
$xa5 	¥	165
$xa6 	¦	166
$xa7 	§	167
$xa8 	¨	168
$xa9 	©	169
$xaa 	ª	170
$xab 	«	171
$xac 	¬	172
$xad 	­	173
$xae 	®	174
$xaf 	¯	175
$xb0 	°	176
$xb1 	±	177
$xb2 	²	178
$xb3 	³	179
$xb4 	´	180
$xb5 	µ	181
$xb6 	¶	182
$xb7 	·	183
$xb8 	¸	184
$xb9 	¹	185
$xba 	º	186
$xbb 	»	187
$xbc 	¼	188
$xbd 	½	189
$xbe 	¾	190
$xbf 	¿	191
$xc0 	À	192
$xc1 	Á	193
$xc2 	Â	194
$xc3 	Ã	195
$xc4 	Ä	196
$xc5 	Å	197
$xc6 	Æ	198
$xc7 	Ç	199
$xc8 	È	200
$xc9 	É	201
$xca 	Ê	202
$xcb 	Ë	203
$xcc 	Ì	204
$xcd 	Í	205
$xce 	Î	206
$xcf 	Ï	207
$xd0 	Ð	208
$xd1 	Ñ	209
$xd2 	Ò	210
$xd3 	Ó	211
$xd4 	Ô	212
$xd5 	Õ	213
$xd6 	Ö	214
$xd7 	×	215
$xd8 	Ø	216
$xd9 	Ù	217
$xda 	Ú	218
$xdb 	Û	219
$xdc 	Ü	220
$xdd 	Ý	221
$xde 	Þ	222
$xdf 	ß	223
$xe0 	à	224
$xe1 	á	225
$xe2 	â	226
$xe3 	ã	227
$xe4 	ä	228
$xe5 	å	229
$xe6 	æ	230
$xe7 	ç	231
$xe8 	è	232
$xe9 	é	233
$xea 	ê	234
$xeb 	ë	235
$xec 	ì	236
$xed 	í	237
$xee 	î	238
$xef 	ï	239
$xf0 	ð	240
$xf1 	ñ	241
$xf2 	ò	242
$xf3 	ó	243
$xf4 	ô	244
$xf5 	õ	245
$xf6 	ö	246
$xf7 	÷	247
$xf8 	ø	248
$xf9 	ù	249
$xfa 	ú	250
$xfb 	û	251
$xfc 	ü	252
$xfd 	ý	253
$xfe 	þ	254
$xff 	ÿ	255
=== Blank characters ===
Escape sequence	output 	output’s ASCII code
$x09 	[ tab ] 	9
$x0a 	[ new line ] 	10
$x0b 	[ vertical tab ]	11
$x0c 	[ clear ] 	12
$x0d 	[ enter ] 	13
$x20 	[ space ] 	32
$xa0 	[ nbsp ] 	160
== Unprintable characters ==
Escape sequence	output 	output’s ASCII code
$x07 	[ beep ] 	7
$x10 	[ data link escape ]	16
$x1b 	[ escape ] 	27
$x9b 	[ control sequence ]	155
== See also ==
Gibberish/JavaScript, parent article.
Category:Examples
Gibberish/JavaScript/HTML interpreter

:
== HTML code ==
using simplified chinese.
这是中英文混排.
Here is the interpreter link.
下面是 360 云盘的分享链接 ↓
Please click me! (提取码: 9cae / code: 9cae) 请点我啊
click “普通下载” for download.
点击“普通下载”就下载这个解释器.
== Parameters of the library ==
提取码: 9afd
Category:Implementations
Gifunk

Gifunk is a three-dimensional fungeoid created by in. It is similar to Befunk, but instead of using a static PNG image file, it uses an animated PNG or a GIF as the source code. Additional commands are used for the instruction pointer to navigate between different frames of the image. 
It is intended to be Turing-complete.
Category:LanguagesCategory:Non-textualCategory:Multi-dimensional_languagesCategory:2021Category:Turing complete
Giggle

===What is this?===
Giggle is a language designed by User:PixelatedStarfish in 2022. It is the ultimate in programming languages. It can take literally any input, convert it into text, and then convert that text into runnable source code. It's a Starstuff language, an attempt at realizing the vision of turning literally anything into runnable code, so that no one will ever be able to say "Ugh, I just can't code." ever again! So, how does this one work? Well, with the power of a stack! Behold, a language so simple it does not throw errors at all! First off let me introduce you to the accumulator!
===The Accumulator===
This is a byte that can be incremented and decremented, at the start of each program it is zero!
===The Stack===
This stack stores integers. When it gets to a size of 500, it empties, that's it!
===Interpretation===
To interpret data, convert it to ASCII text, convert each character to an integer value, and apply a mod 10 operation to produce a sequence of numbers that correspond with commands.
===Commands===
Each instruction operates in isolation. Each command can run regardless of program state.
 0 - Increment the accumulator.
 1 - Decrement the accumulator.
 2 - Push the value of the accumulator on to the stack.
 3 - Pop value of of the stack and print it as an ASCII character. 
 If the stack is empty, do nothing.
 4 - Print the absolute value of the accumulator as an ASCII character.
 5 - Set the accumulator to the value at the top of the stack and pop.
 If the stack is empty set to 0.
 6 - Increment the program counter by the value of the accumulator. 
 It should wrap to the start and end as needed.
 7 - Print a 7.
 8 - Set the accumulator to a random integer.
 9 - End program.
===Computational Class===
A push down automata.
GimmickLang

= GimmickLang =
== Overview ==
GimmickLang is an esoteric programming language where keywords double as variables, and commands are enclosed in curly braces `{}`. Additionally, loops have a 50% chance of sending the program back to the start, making it unpredictable.
== Example Programs ==
=== Hello World ===
 
{PRINT "Hello, World!"}
 
=== Adding Two Numbers ===
 
{INP A}
{INP B}
{ADD A B C}
{OUT C}
 
=== Loop with Random Reset ===
 
{LOOP 10}
 {PRINT "Iteration"}
{END}
{PRINT "Finished"}
 
== Special Features ==
* **Random Reset**: During any loop, there's a 50% chance the loop will send the execution back to the beginning of the program, hardcoded into the interpreter.
* **Curly Brace Requirement**: All commands must be enclosed in curly braces `{}`.
GimmickLang challenges you to code with unpredictable behavior and constraints, pushing your coding skills to the limit. CodePhantom (talk)
Gisa

Gisa is a (now unmaintained) programming language compiling to asm2bf. Albeit the last revision in 2019 and being unmaintained, the generated code still runs, due to asm2bf being fully backwards compatible. There is no manual or documentation, the compiler is written in C and it's the only reference to Gisa. The compiler output isn't optimized. 
== Examples ==
This program will display ASCII(33) - probably exclamation mark.
(
	(outb [0])
	(= 0 (+ 1 [0]))
	(= 0 (* 2 [0]))
	(= 0 (* {2 2 +} (+ 2 2)))
)
function test:
(
	(exit)
	(outb ((6) square invoke))
	({defun square (
		* dup
	)} exports)
	((
		@"end"
	) exit defmacro)
	
	({
		@"pop r2"
		@"psh r2"
		@"psh r2"
	} dup defmacro)
)
display 0123456789:
{
	(= 0 48)
	{loop {
		(outb [0])
		(= 0 (+ [0] 1))
	} (
		neq [0] (+ 48 10)
	) while}
}
macro and inline asm demonstration, prints ASCII(64).
{
	({
	 @"pop r5"
		@"psh r5"
		@"psh r5"
	} dup defmacro)
	
	((
		* dup
	) square defmacro)
	
	(outb (square 2))
}
== See also ==
* asm2bf
Category:Languages
Category:Turing complete
Category:Cell-based
Category:Stack-based
Category:Implemented
Category:Low-level
Category:2019