nyuuzyou/wikis huggingface dataset:
Gabuzomeu

Welcome !
The Gabuzomeu programming language have a syntax close to the assembly language and share lot of the interesting limitations of the Brainfuck.
Everything one needs to know is available on the GitHub README page here
For a code sample, the unavoidable "Hello world" can be written this way :
 CALC GA, #BUGAZOGA ; = 'H' = 72
 DUMP GA
 CALC BU, #BUZOBUBU ; = 'e' = 101
 DUMP BU
 CALC ZO, #BUZOMEUGA ; = 'l' = 108
 DUMP ZO
 DUMP ZO
 CALC MEU, #BUZOMEUMEU ; = 'o' = 111
 DUMP MEU
 CALC GA, #ZOGAGA ; = ' ' = 32
 DUMP GA
 CALC BU, #BUMEUBUMEU ; = 'w' = 119
 DUMP BU
 DUMP MEU
 CALC BU, #BUMEUGAZO ; = 'r' = 114
 DUMP BU
 DUMP ZO
 CALC GA, #BUZOBUGA ; = 'd' = 100
 DUMP GA
For the records, one Quine is available here, the source code is quiet long (29.755 bytes)
Have fun :p
Category:LanguagesCategory:2020Category:Turing completeCategory:Implemented
Gamelang

Gamelang uses WASD stuff to do code
= How to do stuff =
 W<dir> - move in direction of dir, WASD do ULDR up left down right, E direction does nothing
 A<number> - if current cell is number, go to D
 S<number> - add number to current cell S<WWW> is 3, S<SSS> is -3
 D<number> - set D to number, D<WWW> makes D 3, D<SSS> makes D -3
 E<dir> - run current into direction dir
 ALTF4<> - exit program
 F1<command> - set current cell to command
 F2<anything> - return current cell
 F3<anything> - return D
 F4<anything> - print anything
 F5<command> - set F5 to command
 F6<commands> - do commands then do F5
= Examples =
 F6<W<W>F5<S<W>F4<F2<>>S<W>F4<F2<>>S<W>F4<F2<>>W<S>>> #1, 2, 3
Category:Languages
Games i made up with triangle magnets that i turned into brainfuck encodings

= Twin triangles =
Twin triangles is a way to encode brainfuck.
== How it works ==
You stack two stacks of 3 brainfuck commands.
 ><
 +[
 -]
Then, you can preform these actions on it:
=== TS - topswap ===
 23 32
 11 -> 11
 11 11
=== TL - toptwoswapleft ===
 21 31
 31 -> 21
 11 11
=== TR - toptwoswapright ===
 12 13
 13 -> 12
 11 11
=== RL - reverseleft ===
 21 41
 31 -> 31
 41 21
=== RR - reverseright ===
 12 14
 13 -> 13
 14 12
== FO - fold ==
 16 65
 25 -> 14
 34 23
=== collapse ===
At the end, they "collapse" like this:
 16 
 25 -> 123456
 34 
 
 12 
 34 -> 135642
 56 
== ascii loop ==
 +[
 ].
 ++
 TLRLRRTSTLRRTRRRTLTRTSTLTRRLRRTSRLRRTRRLTSTRRLRRTRRRFO
= Colored triangle sort =
Colored triangle sort is a way of encoding brainfuck
== How it works ==
 SFn swaps first n commands
 SLn swaps last n commands
 you can have a chain of commands
 simple as that
== Ascii loop ==
 .[+]+
 SL3SF3SL3SL2SL3
Category:Brainfuck equivalents
Category:Languages
Gamma

Gamma is an esoteric programming language that is part of a series by User:Infinitehexagon on Greek esolangs that will be a derivative of the previous esolang with more commands, less commands, or modified commands. It has 3 more extra commands than Beta and a replaced command.
==Commands==
Beta➜Gamma	Description
+ 	Increment the accumulator by the amount of α(Alpha) following it.
! 	Decrement the accumulator by the amount of β(Beta) following it.
- 	reverse the value of the accumulator eg. 72->27. If the reversed value is greater than 255 then set the accumulator to 0.
$ 	output the accumulator's Unicode value mod 149,815. This means that it wraps back to zero after the last unicode value.
= 	if the Accumulator and the amount of Beta's following it equal the same value then skip 10 instructions
! 	NOT logic gate: if the Accumulator Doesn't have a value greater than 0 then skip 5 instructions
[ 	jump to the "]" instruction by the amount of times α(Alpha) follows it. (Leave blank for infinite loop)
] 	Jump back to the "[" instruction.
γ 	Duplicate the source code
% 	Reverse the source code
~ 	set the Accumulator to it's Unicode value.
== Beta Programs ==
===Hello World===
[αααααααααααααααααα+αααα]$[αααα+ααααααα]+α$+ααααααα$$+ααα$[αααααα!βββββββββββ]!β$[αα!ββββββ]$[ααααααααααα+ααααα]
$[ααα+αααααααα]$+ααα!ββββββ$[αα!ββββ]$-!β[αααα+αααααααα]+α$
===Truth machine===
+α[αααααα+αααααααα]=[$]
== Examples ==
=== Growing program (also an infinite loop) ===
 γ
The length of program grows exponentially, so it never terminates.
Category:Languages Category:Unknown computational class Category:Self-modifying Category:Uncomputable
Gammaplex

Gammaplex is an esoteric programming language designed by Lode Vandevenne. It is similar to Befunge in some respects; what makes it especially remarkable is the support for mouse input and graphical output.
==Examples==
===Hue coloration Mandelbrot renderer===
 @ 200)u150)l1a0#0}>1a{"}4#0XG v
 Mandelbrot by ^ v?,y(]0 <
 Lode Vandevenne >1a{s"sN}v
 v0.1 ^ E?,h(]1R<
 0](y2:-1.5*0.5y*:0.5-30]) \
 1](h2:-0.5h*:31]) \
 32]0)u0)u0)u0)u0) \
 >36](")34](32])35](33])32](w*33](\
 w*-30](+34])2#32](*33](*31](+35])\
 34](w*35](w*+4,?v36](16,?v7#0G \
 G0#11< >12#0G \
 >255#255#36](16*H3a}PXg 
 >128#128#128#3a}PXg 
===Simple quine===
Using the q command(By poiuy_qwert):
 25)0(q0#19(?GDDXrRE(')0#3G
===XOR Texture===
 3a>(u(xww}PRd(n,?v(") v
 By poiuy_qwert>0)u(n,?E(")dv
 ^ <
===Plasma Effect===
 3a>(128-w*u(128-w*+V1XT128*128+ww}PRd(n,?v(") v
 By poiuy_qwert >0)u(n,?E(")dv
 ^ <
===Digital Root Calculator===
 \@X"Enter Number: "XXSXrRXIcR
 \sw?;\s48-w9,?\+ ;/1wG
 \10s%48+49#/ 
 \w1a}48-iRED poiuy_qwert
==See also==
* Omegaplex
* Deltaplex
==External resources==
* Gammaplex homepage at GameDev.net
* Gammaplex at the Esoteric File Archive, including local copy of the homepage
Category:Languages
Category:Turing complete
Category:Two-dimensional languages
Category:Implemented
Category:High-level
Category:Self-modifying
Category:2004
Gammascript

gammascript is a "programming language" created by User:Ractangle. This language was also 4ME's predecessor
==Syntax==
 is the variable declaration command.
 is the string output commmand.
 is the variable output command.
 is the input. Invalid in the command.
==Examples==
===Hello, world!===
 write Hello, world!
===Cat program===
 set i = ask
 show i
==Implementation==
https://github.com/Thevitebsk/gammascript
Gandy machine

In his 1980 paper Church's Thesis and Principles for Mechanisms, Robin Gandy sets out four principles for describing computing machines in terms of assemblies of parts; any such machine described in this way can be called a Gandy machine. The principles are summarized below.
One of Gandy's claims is apparently that any device which violates these principles would invalidate the Church-Turing thesis, as it would be capable of calculating a non-computable function (or as he colourfully puts it, "displaying free will".)
Interestingly, although Gandy's intent was to make the principles widely applicable in many different domains, he rules out Newtonian mechanics because it permits "rigid rods of arbitrary lengths" which violate Principle IV.
==Gandy's Principles for Mechanisms==
===Principle I: The Form of Description===
Gandy machines are described using hereditary finite sets with labels
for their parts.
===Principle II: Principle of Limitation of Hierarchy===
The set theoretic rank of a Gandy machine is bounded. That is, there are
no assemblies which contain infinite descending chains of subassemblies.
===Principle III: Principle of Unique Reassembly===
Any Gandy machine can be assembled from parts of bounded size. The labels
of these parts uniquely determine the resulting machine.
===Principle IV: Principle of Local Causality===
Successive states of a Gandy machine can be reconstructed solely through
local cause and effect. Each region of the machine has a neighbourhood of
bounded size, and the region's next state is due only to the state of its
neighbourhood.
==External resources==
* Gandy, R. O. 1980. Church's Thesis and Principles for Mechanisms. The Kleene Symposium, eds. J Barwise et al., pp 123-148. Amsterdam: North Holland Publ. Co. (1980; ISBN 0-444-85345-6)
Category:Computational models
Gar

Gar is an esoteric programming language invented by User:masalt.
==Examples==
===Hello, world!===
 >>>>>>>>>>
 >>>>>>>
 *
 >>
 +
 >>>>>>>>>>
 :
 *
 :
 >
 +
 &
 :
 >>>>>>>>
 +
 &
 :
 >>>>>>>>
 +
 &
 :
 >>>>>>>>>>>
 +
 &
 >>>>>>>>>>
 >>>>
 *
 >>>>
 +
 &
 >>>>>>>>>>
 >>>
 *
 >>
 +
 &
 :
 >>>>>>>>>>>>>>>>>>>
 +
 &
 :
 >>>>>>>>>>>
 +
 &
 :
 >>>>>>>>>>>>>>
 +
 &
 :
 >>>>>>>>
 +
 &
 >>>>>>>>>>>
 >>>
 *
 ,,
===Infinite Loop===
 (
 )
===Quine===
If the file name is ".gar"
 >>>>
 >>>>>>>>>>
 *
 >>>>>>
 +
 >>>>>>>>>>
 :
 *
 :
 >>>
 +
 &
 :
 <<<
 +
 &
 >>>>>>>>>>>>>>
 +
 t
 ,,
===Disan Count===
 >
 >
 -
 :
 ?
 [
 :
 <
 +
 ]
 ~
 )
 [[
 !
 (
 ~
 ]]
===Fibonacci Sequence===
 >
 :
 !
 !
 >
 >
 {
 &
 ::
 +
 :
 !
 }
===Truth Machine===
 ?
 ]
 )
 [
 :
 !
 ]
 (
 !
===Cat===
 (
 ???
 ,,
 ~~
 )
===Factorial===
Works only with numbers greater than 2.
 >
 >
 -
 :
 ?
 [
 :
 <
 +
 ]
 ~
 ~
 [[
 *
 &
 ]]
 ~
 !
===Read a File===
 ???
 t
 ,,
===99 Bottles of Beer===
99 Bottles of Beer in gar can be found here.
===Deadfish===
>
<
+
^
{
??
>>>>>>>>>>
:
*
|
+
]
~
)
[
<<<<<
+
]]
~
))
[[
<<<<<<
+
]]]
~
)))
[[[
<<<<
+
]]]]
~
))))
[[[[
~~
)))))
(
~~
^^
<
+
^
~~
)))))
((
~~
^^
>
+
^
~~
)))))
(((
~~
^^
!
}
((((
~~
^^
:
*
^
~
(((((
~~
>
^^
+
]]]]]
>
<
+
^
[[[[[
~~
>>>>
:
:
:
*
*
*
|
^^
+
]]]]]]
>
<
+
^
[[[[[[
~~
}
==Implementations==
The official gar interpreter.
Category:LanguagesCategory:ImplementedCategory:Unknown_computational_classCategory:Stack-based
Garbage

Garbage is a very simple esoteric programming language invented by User:A in order to fullfill the definitions of a programmming language.
== Syntax ==
The language can only contain 0 bits of source code. The execution is as follows:
* If the first input is a prime:
** output 1
* otherwise
** output 0
* output the sum of the first input and the second input.
== Implementation ==
prime(n) {
 if(!((n-1)%6))return 0;
 else return 0;
}
main() {
	long long a, b;
	scanf("%lld%lld",&a,&b);
	printf("%d %lld",prime(a),a+b);
}
Category:Implemented
Category:2019
Category:Languages
Gate

Gate is a simple automaton with gates. Here is all the syntax, created by User:Yayimhere:
 Symbols
Symbol	Description
# 	Send a 1 through wire
_ 	send a 0 through wire
! 	send a not through wire
& 	send a nand gate through wire
X 	send a xnor gate through wire
+ 	takes one input from any direction and checks. If its a 1, it keeps going down, if its 0, it goes up again, and if its a gate it copies itself, and goes to the left, and right. if its anything else it turns 90º
^ 	Takes a left(A) wire, a right(B) wire, and a gate from the bottom. Then performs: A GATE B and send it upwards
< 	takes a upper(A) wire, and a lower(B) wire, And performs A(B)(look at table), then sends the result Right. if a multi digit binary value, is put in it will split it into the two half of it
 	wire. Anything can pass through. If to things collide at a wire the wire will output them. first wire is a flat wire can go left and right and the other is a upwards can go up and down
( 	end of wire. will output it as a ascii char(UTF-8)
> 	split. will copy the thing in the wire to the wires above and below the >. if the thing put in is multi
º 	turn the wire put in 90 degrees
Ø 	turn the wire put in -90 degrees
± 	wire intersection
letter	will take wire coming into it and label it letter. this can be used for later in any wire. if a number is sent into it AFTER it has been defined it will be redefined but if there is now value coming in then it will send out what its set too
§ 	integrate one wire into another(see osciliator)
== Notes ==
the origin of a value(e.g #) can have multiple wires since they spread
== examples ==
=== not(A) ===
 !
 |
 –<
 |
 A
=== A NAND B ===
 |
 | 
 A-^-B
 |
 &
=== A OR B ===
 |
 º–––^–––Ø
 | | |
 | & |
 | |
 | º–!–Ø |
 | | | |
 º–< Ø–< |
 | | | |
 | | | |
 | Ø–±–Ø
 | |
 º–––±–––Ø
 | |
 º–––±–Ø
 | |
 A B
using NOR it can be made shorter by using NOT(NOR):
 ! !
 | | |
 º–±–ºº–< !
 | | | | |
 º–< º––^–—<
 | | |
 | & |
 A B
=== A AND B ===
 !
 |
 –<
 |
 º––^–—Ø
 | | |
 | & |
 A B
=== A NOR B ===
 ! 
 º–±–Ø !
 | | | |
 º–< º––^–—<
 | | |
 | & |
 A B
=== XOR ===
 ! !
 | | |
 º–±–Øº–<
 | | | |
 º–< º––^–—Ø
 | | |
 | & |
 A B
=== A > B ===
 !
 |
 –<
 |
 º––^–Ø
 | |
 º––^––Ø |
 | | | |
 | | | |
 B & A–Ø
=== A < B ===
 !
 |
 –<
 |
 º––^–Ø !
 | | |
 º––^––Ø | |
 | | | º–<
 | | | |
 B & A–––Ø
=== OSC ===
 #
 |
 Ø-<
 | | 
 | Ø--Ø 
 #-§ _ |
 | | |
 Ø-±-º|
 | ||
 Ø-< ||
 | | ||
 | º-º|
 Ø----Ø
this will generate the sequence:
 1010101010101010101010...
Category:Languages Category:Two-dimensional languages Category:Unimplemented
Gato

Gato is one of the least known esoteric languages. It first appeared on 27th August of 2009, as a remake of happyhelper5's Minecraft in Delphi. The language now is on its INFDVISY point, or 'InfiniteDevelopementofDivisionY'. The prototype of the language, is nowhere to be found. The language itself, was created by the Archivist .gato555, which is a Discord user now. 
=== Type of Language ===
Gato is a a Anti-Sveltic language. In Greek, Sveltos, means fast. The language itself tries to be slow, so the memory of the computer system would operate must faster.
== Versions ==
The Computer Language Gato, is now on INFDVISY-20236_2, which was created on 6th August. The first version is known as Gat344 MineDelphi.dpr. The versions continued in chronolgical order: https://time.graphics/line/bc8eff5659543fc4d9a761a56ce6b57a
==== Commands ====
To say Hello , you must write:
>Message
'hello''''
On a .gatito file, in which, you must open with the .txt extention.
In order to open the .gatito file. there are two ways: Press Right click, and press open with: Notepad.Or create a .bat file and write: >Codex_File
Language.Gatito
Language.Pas
>Message:Hello?This is an example of the Computer Language called Language 
=== Old Commands ===
The commands of the previous versions, were the same as Delphi's, Object Pascal's, and Java.
=== Guide to current version ===
If you open the LANGUAGE_OPENER.bat, then Language.Gatito would be opened. If you open Linguistic.bat, then either Monk.gatitoimg or bartholomew.gatitoimg would be opened(NOTE: .GATITOIMG is an experimental branch of .iso, .png and .jpg images.). Gato.png is the logo. Lastly, LanguageGato.bat is a placeholder of the new Chrome extention. If you open it, then an automated direct to Youtube.com would happen.
=== Creators and Special Thanks ===
Gato555/Gat344:The original creator
happyhelper5: Inspirator
Thalassohora: Helper at L+++ programming
BookLover_Greek: Archivist
== Language download ==
https://archive.org/details/language_202308 L+++ Test
https://archive.org/details/language_202309
Gd auto level

gd auto level(Also called Geometry Dash auto level) is a two-dimensional thematic programming model made by user:tommyaweosme.
== How it works ==
=== Basic command flow ===
 @ player spawn
 - ground
Every tick the player moves forward.
 tick 1:
 @
 ---
 tick 2:
 @
 ---
 tick 3:
 @
 ---
 tick 4:
 
 ---@
 tick 5:
 --- @
 tick 6:
 ---
 @
When there is nothing under the player, then the player will goes down one per two ticks.
=== Spikes ===
 ^ spike
here is the example:
 tick 1:
 @ ^
 -------
 tick 2:
 @ ^
 -------
 tick 3:
 @^
 -------
 tick 4:
 ^
 -------
The player has crashed into a spike.
=== Jump pad ===
Luckily, there is jump pad.
 _ jump pad
jump pad makes player go up by two on the current tick its on:
 tick 1:
 
 
 @ _
 -----
 tick 2:
 
 
 @_
 -----
 tick 3:
 @
 
 _
 ------
 tick 4:
 @
 
 _
 ------
This is trajectory (marked with τ):
 τττ
 τ τ
 τττ_^^^τ
 ---------
=== Teleportals ===
Then the teleportals are ().
They do the same thing in geometry dash.
This is trajectory (marked with τ):
 (τ
 ττ
 ττττ) ττττττ
 ---------------
The player goes in the teleportal by right parenthese and goes out from left parenthese. You can use this to construct an infinite loop: 
( @ )
------------
That's it! Anything that isnt -@_^()τ can be claimed by the language itself.
== Categories and References ==
Category:ThematicCategory:2024Category:ConceptsCategory:Two-dimensional languages
Gdy Brainfuck

Gdy-Brainfuck is a derivate of Brainfuck but with ABCDEFG.
Created by User:Gadai on 5/18/2023.
== Commands ==
Brainfuck	GdyBrainfuck 	C/C++
+ 	a 	p[i]++;
- 	b 	pi[i]--;
. 	d(text) e(number)	printf("%s",t); printf("%d",pi[i]);
, 	None 	
< 	A 	i++;
> 	B 	i--;
None 	c 	t[c]=xxx;
None 	f 	p[i+1]=p[i-1]+p[i];
None 	F 	p[i+1]=p[i-1]*p[i];
None 	g 	p[i+1]=p[i-1]-p[i];
None 	G 	p[i+1]=p[i-1]/p[i];
[ 	None 	
] 	None 	
== Examples ==
===Hello, World!===
gbf1
cHceclclcoc,c cWcocrclcdc!c
dC
===1+1=2===
gbf1
c1c+c1c=dC
aaAaafAe
==Interpreter==
Interpreter in C++.
#include <fstream>
#include <iostream>
#include <string>
#include <vector>
int main(int argc, char **argv) {
 std::vector<char> run_list;
 int power = 0;
 int int_cp = 0;
 std::vector<float> fl_p;
 std::vector<char> str_p;
 for (int i = 0; i < 200; i++)
 {
 fl_p.push_back(0);
 }
 
 std::ifstream file(argv[1]);
 int count = 0;
 if (file.is_open()) {
 char getstr;
 while (file.get(getstr)) {
 run_list.push_back(getstr);
 count++;
 }
 file.close();
 for (int i = 0; i < count; i++) {
 if(run_list[i]=='g' && run_list[i+1]=='b' && run_list[i+2] =='f' && run_list[i+3] =='1' && run_list[i+4] =='\n' && power == 0){
 power = 1;
 }
 if(power == 1){
 if (run_list[i]=='a'){
 fl_p[int_cp]++;
 }
 else if (run_list[i]=='b'){
 fl_p[int_cp]--;
 }
 else if (run_list[i]=='A'){
 int_cp++;
 }
 else if (run_list[i]=='B'){
 int_cp--;
 }
 else if (run_list[i]=='c'){
 str_p.push_back(run_list[i+1]);
 i++;
 } 
 else if (run_list[i]=='d'){
 for (char c : str_p) {
 std::cout << c;
 }
 }
 else if (run_list[i]=='e'){
 std::cout << fl_p[int_cp];
 }
 else if (run_list[i] == 'C'){
 str_p.clear();
 }
 else if (run_list[i] == 'f'){
 fl_p[int_cp+1]=fl_p[int_cp-1]+fl_p[int_cp];
 }
 else if (run_list[i] == 'F'){
 fl_p[int_cp+1]=fl_p[int_cp-1]*fl_p[int_cp];
 }
 else if (run_list[i] == 'g'){
 fl_p[int_cp+1]=fl_p[int_cp-1]-fl_p[int_cp];
 }
 else if (run_list[i] == 'G'){
 if(fl_p[int_cp] == 0){
 printf("[ERR]\tIt is impossible to divide by 0.");
 break;
 }
 fl_p[int_cp+1]=fl_p[int_cp-1]/fl_p[int_cp];
 }
 
 
 
 }
 }
 } else {
 std::cout << "[ERR]\tCould not open file" << std::endl;
 }
 return 0;
}
==Gdy_Brainfuck2==
Currently under development 
Features to be added: 
 1. Repetition 
 2. User input 
 3. Command (cmd.exe) execution 
Category:Languages
Category:2023
Gen Alpha Brainrot

Gen Alpha Brainrot or GAB for short, is an esolang created by PoptartPlungerBoi in 2024. This esolang is equivalent to branflakes, but vertical. and it is made to represent the coined terms used by kids born in Generation Alpha, a demographic cohort succeeding Generation Z.
== Commands ==
Command 	Branflakes
skibidi 	>
rizz 	<
sigma 	+
gyatt 	-
ohio 	.
blud 	,
grimaceshake	[
fanumtax 	]
== Examples ==
=== Hello, World! ===
 sigma
 sigma
 sigma
 sigma
 sigma
 sigma
 sigma
 sigma
 grimaceshake
 skibidi
 sigma
 sigma
 sigma
 sigma
 sigma
 sigma
 sigma
 sigma
 rizz
 gyatt
 fanumtax
 skibidi
 sigma
 sigma
 sigma
 sigma
 sigma
 sigma
 sigma
 sigma
 ohio
 skibidi
 sigma
 sigma
 sigma
 sigma
 sigma
 sigma
 sigma
 sigma
 grimaceshake
 skibidi
 sigma
 sigma
 sigma
 sigma
 sigma
 sigma
 sigma
 sigma
 sigma
 sigma
 sigma
 sigma
 rizz
 gyatt
 fanumtax
 skibidi
 sigma
 sigma
 sigma
 sigma
 sigma
 ohio
 sigma
 sigma
 sigma
 sigma
 sigma
 sigma
 sigma
 ohio
 ohio
 sigma
 sigma
 sigma
 ohio
 skibidi
 sigma
 sigma
 sigma
 sigma
 sigma
 sigma
 sigma
 sigma
 grimaceshake
 skibidi
 sigma
 sigma
 sigma
 sigma
 sigma
 rizz
 gyatt
 fanumtax
 skibidi
 sigma
 sigma
 sigma
 sigma
 ohio
 gyatt
 gyatt
 gyatt
 gyatt
 gyatt
 gyatt
 gyatt
 gyatt
 gyatt
 gyatt
 gyatt
 gyatt
 ohio
 rizz
 rizz
 rizz
 rizz
 sigma
 sigma
 sigma
 sigma
 sigma
 sigma
 sigma
 sigma
 sigma
 sigma
 sigma
 sigma
 sigma
 sigma
 sigma
 ohio
 skibidi
 skibidi
 ohio
==See also==
* Brainrot (Theothetruenerd)
* Gen Alpha
* Rizzlang
Category:Unimplemented Category:Joke languages Category:2024 Category:Brainfuck derivatives Category:Brainfuck equivalents Category:Cell-based Category:Turing complete Category:Turing tarpits Category:Low-level Category:Thematic Category:Pseudonatural
General Compute Coprocessor

General Compute Coprocessor (GCC) is one of the languages used in the ICFP contest 2014. 
GCC is a virtual machine intended for running a lisp-like untyped functional language compiled to it. There are built-in instructions to create an environment with values (as a let statement requires), call closures with an environment of values indexed by small integers, to read variables from the current environment or one or more levels of environment below. There are also instructions to allocate cons pairs and read their fields, and arithmetic instructions handling 32-bit integers. Data (cons cells, environments, and closures) are automatically garbage-collected. From the description it appears that closures hold a reference the full environment of all their containing functions, including all variables in those functions, although in theory the garbage collector could analyze the code of the closures to determine which of those variables may still be used. There's also an extension for mutable variables in environments.
In the story of the contest, the LamCo company used this language to control the AI of Pacman in their arcade computer running a Pacman-like game when a single player wants to play a two-Pacman game. The operating system calls the main function in the GCC instance when the game is initialized, gets an update function, then calls this on each tick, it calls this update function with the game state and an accumulated AI state to determine what the AI Pacman should do.
== External links ==
* Contest homepage
* Language specification
Category:Languages
Category:2014
Category:ICFP contest
Category:Programming games
Generalized Assembler

Generalized Assembler by User:Zzo38 is a program which is used to create generalized assembly files. It also lets you write brainfuck programs inside the parenthesis. It can also be used to write esoteric programs as well. If you use this program on UNIX you have to make all of the filenames in uppercase otherwise it will not work. You can also use this program to run output-only brainfuck programs without modification (such as Hello World or 99 bottles of beer) if you put it all in one line.
Here is a examples of some macros that you can use with it:
 \\ This macro does nothing, it is a blank macro
 'nothing\macro
 \endmacro
 
 \\ This macro takes name from stack and uses as a hexadecimal number (1 byte)
 'bytefromstack\macro
 \name1
 =*1
 \endmacro
 
 \\ This command stores "00" in parameter 9, and it isn't a macro
 '00\name9
 
 \\ This macro creates variables and numbers them sequentially
 'var\macro
 \name1 \\ Get name of variable and store to parameter 1
 'nothing'*1\copy \\ Make a blank macro
 '*9'*1\pushname \\ Push value of parameter 9 to new macro
 'bytefromstack'*1\pushcmd \\ Push /bytefromstack command to new macro
 =*9(,+.)\byte9 \\ Add 1 to value of parameter 9
 \endmacro
(Yes, you do have to write three macros to make the variables to be numbered! And you also have to write the numbers to the output and then take them away again!)
Here is another one, but I added error-checking:
 'nothing\macro
 \endmacro
 
 'bytefromstack\macro
 \name1
 =*1
 \endmacro
 
 '00\name9
 
 'varlimit1\macro
 \\ Variable OK, did not exceed limit
 \endmacro
 
 'varlimit0\macro
 'var.limit\echo\error
 \endmacro
 
 'var\macro \\ *** Create variable ('name /var)
 \name1
 'nothing'*1\copy
 '*9'*1\pushname
 'bytefromstack'*1\pushcmd
 =*9(,+.)\byte9
 =*9(,[<+>[-]]<.)\byte2/varlimit*2 \\ Error checking
 \endmacro
This code is part of a file called PokemonScript that I am using to make a game called Pokemon CMQ.
Download: http://zzo38computer.org/gasm.zip