nyuuzyou/wikis huggingface dataset:
Glanose

Gnalose
This is an esolang I made.
Example run:
 {>>>>&<<&| |i|s| |t|h|e| |a|n|s|w|e|r| |t|o| |e|v|e|r|y|t|h|i|n|g}+
This should output:
 4
 2
 i
 s 
 t
 h
 e
 a
 n
 s
 w
 e
 r
 t
 o
 e
 v
 e
 r
 y
 t
 h
 i
 n
 g
What the characters do:
{ allows code to run
} lets code run if it is inside the curly brackets
> adds one to the stack
< takes away one from the stack
| prints character coming after it
& prints length of stack
+ runs code
So that code could have been translated into:
 #include <iostream> using namespace std; int main(void) { int stack = 0; stack = 4; cout << stack; stack = 2; cout << stack; cout << ' \ni\ns\n \nt\nh\ne\n \na\ns\nw\ne\nr\n 
 \nt\no\n \ne\nv\ne\nr\ny\nt\nh\ni\nn\ng'; }
I didn't put it online, so you can't download it or find it anywhere, so just copy the following python code into a python interpreter or software and run it:
chars = []
mem = [0]
init = []
def code(txt):
 for i in range(len(txt)):
 if txt[i] == '>':
 mem[0] += 1
 chars.append(':' + str(mem[0]))
 elif txt[i] == '<':
 mem[0] -= 1
 chars.append(':' + str(mem[0]))
 elif txt[i] == '|':
 chars.append('"' + str(txt[i + 1]))
 elif txt[i] == '{':
 init.append('r')
 elif txt[i] == '}':
 init.append('c')
 elif txt[i] == '&':
 chars.append('"' + str(mem[0]))
 elif txt[i] == '+':
 if len(init) > 0:
 if init[0] == 'r':
 if init[len(init) - 1] == 'c':
 run()
def run():
 for i in range(len(mem)):
 mem.pop()
 mem.append(0)
 for i in range(len(chars)):
 if chars[i][0] == ':':
 mem[0] = int(chars[i][1:len(chars[i])])
 elif chars[i][0] == '"':
 print(chars[i][1])
while True:
 inpt = input()
 code(inpt)
Glassman

Glassman is an esoteric programming language made by cinnamony based on the song Mister Glassman.
==Commands==
 Let's paint a picture
This starts the script.
 So nervously he looks around
This asks for input.
 In front of fans rappin' fast
This outputs the cell at memory pointer in ASCII.
 A few years later when now it's prom season
This moves the memory pointer right.
 You're in class
This moves the memory pointer left.
 And he's always in his head thinking too far ahead
This increments the cell at memory pointer
 Don't be shy kid, make your own fate
This decrements the cell at memory pointer.
 Even if you think you're bullet proof
This acts like BF's opening [ bracket.
 I am glass and so are you
This acts like BF's closing ] bracket.
 They're calling her
This prints the text infront.
 Woppity wop
This ends the script, just like it ends the song.
==Examples==
===Cat===
An infinitely repeating cat program, which terminates on a null character input, is presented:
 Let's paint a picture
 And he's always in his head thinking too far ahead
 Even if you think you're bullet proof
 So nervously he looks around
 In front of fans rappin' fast
 I am glass and so are you
 Woppity wop
===Hello World===
 Let's paint a picture
 They're calling her Hello, world!
 Woppity wop
===Truth-machine===
This program implements a truth-machine:
 Let's paint a picture
 So nervously he looks around
 A few years later when now it's prom season
 And he's always in his head thinking too far ahead
 And he's always in his head thinking too far ahead
 And he's always in his head thinking too far ahead
 And he's always in his head thinking too far ahead
 And he's always in his head thinking too far ahead
 And he's always in his head thinking too far ahead
 And he's always in his head thinking too far ahead
 And he's always in his head thinking too far ahead
 Even if you think you're bullet proof
 A few years later when now it's prom season
 And he's always in his head thinking too far ahead
 And he's always in his head thinking too far ahead
 And he's always in his head thinking too far ahead
 And he's always in his head thinking too far ahead
 And he's always in his head thinking too far ahead
 And he's always in his head thinking too far ahead
 Even if you think you're bullet proof
 You're in class
 You're in class
 Don't be shy kid, make your own fate
 A few years later when now it's prom season
 A few years later when now it's prom season
 Don't be shy kid, make your own fate
 I am glass and so are you
 You're in class
 Don't be shy kid, make your own fate
 I am glass and so are you
 You're in class
 Even if you think you're bullet proof
 They're calling her 1
 I am glass and so are you
 They're calling her 0
 Woppity wop
==Interpreter==
* Common Lisp implementation of the Glassman programming language.
Category:ThematicCategory:2023Category:LanguagesCategory:Brainfuck derivativesCategory:Turing completeCategory:Implemented
Glitch

Glitch is a bytebeat language, used in the Glitch algorithmic synthesizer, for generating music. Its syntax is semi-compatible with other bytebeat languages (through the byte() function). The language internals are floating point numbers, which can be passed through composed functions. Like most bytebeat languages, code consists of an expression that is evaluated every timestep; the input is an unsigned integer representing how many ticks the program has run for, and the output signal is played as a sound (where the number represents the position of a speaker diaphragm). While Glitch offers low-level bitwise operations, it can be considered a high level language (in comparison to its peers), sporting such functions as: sine, conversion of musical notes to Hz frequencies, and random number generation.
==External Links==
* Site
* Github documentation
==See Also==
* StackBeat
Category:2016Category:LanguagesCategory:Declarative paradigmCategory:ImplementedCategory:High-level
Globglogabgalab

Globglogabgalab is a joke esolang created by cinnamony based on a meme.
==Commands==
I am the Globglogabgalab. is what begins the script.
The is a print command.
You put wabble after a letter to print that letter if it is after The.
Shwabble dabble glibble glabble schribble shwap glab moves the pointer left.
Dibble dabble shribble shrabble glibbi-glap shwap moves the pointer right.
I am the yeast of thoughts and minds outputs memory cell at pointer in ASCII.
Simply delicious asks for input and saves it to memory cell at pointer.
I'm full of increments or decrements the counter.
When using I'm full of, you have to end it with kind, shwibbly increments the memory cell at pointer, and liber decrements the memory cell at pointer.
Ooh, ha ha ha, mmm, splendid and Ohm, ha ha ha ha act like BF'S square brackets.
==Examples==
===Cat===
 I am the Globglogabgalab.
 I'm full of shwibbly kind.
 Ooh, ha ha, mmm, splendid
 Simply delicious
 I am the yeast of thoughts and minds
 Ohm, ha ha ha ha
===Hello World===
 I am the Globglogabgalab.
 The Hwabble ewabble lwabble lwabble owabble Wwabble owabble rwabble lwabble dwabble
===Kiwiscript===
 I am the Globglogabgalab.
 The kwabble iwabble wwabble iwabble
==Turing-completeness proof==
 You already know what this is
BF	GL
< 	Shwabble dabble glibble glabble schribble shwap glab
> 	Dibble dabble shribble shrabble glibbi-glap shwap
. 	I am the yeast of thoughts and minds
, 	Simply delicious
+ 	I'm full of shwibbly kind
- 	I'm full of liber kind
[ 	Ooh, ha ha ha, mmm, splendid
] 	Ohm, ha ha ha ha
==Comments==
 stop looking at my clipboard
Uh... we're not, User:Cinnamony.
Category:LanguagesCategory:2023Category:Joke languagesCategory:Turing_complete
Gluck

Gluck is a successor to Clart, designed by User:PolySaken to be used for a Virtual Machine (VM). There are a few major differences from the original Clart rules, most notably Gluck requires any implementation to have proper error reporting and includes a ByteCode specification for "compiling" Gluck into a format which can be executed much more efficiently than a direct interpretation, like the original Clart Interpreter written in Python. 
Gluck is as yet unimplemented.
GlyphCode

= GlyphCode =
== Overview ==
GlyphCode is an esoteric programming language that uses an array of unique glyphs to perform operations. The complexity of the glyphs makes deciphering the code a challenge, ensuring a mind-bending coding experience.
== Basic Commands ==
* ☀ (U+2600) - Start the program
* ☽ (U+263D) - Print command
* ✶ (U+2736) - Addition
* ✂ (U+2702) - Subtraction
* ➡ (U+27A1) - Move to the next position
* ⬅ (U+2B05) - Move to the previous position
* ⬆ (U+2B06) - Increment the value at the current position
* ⬇ (U+2B07) - Decrement the value at the current position
* ❄ (U+2744) - Input a value
* ❌ (U+274C) - Output the value at the current position
* ☯ (U+262F) - Begin a loop (continues until the value at the current position is zero)
* ☮ (U+262E) - End a loop
== Example Programs ==
=== Hello World ===
 
☀⬆⬆⬆⬆⬆⬆⬆⬆⬆⬆☯⬅⬅⬅⬅⬅⬅⬅⬅⬅⬅⬅❌➡⬆⬆⬆⬆⬆➡❌➡⬆⬆⬆⬆⬆⬆⬆⬆⬆⬆⬆⬆❌➡⬆⬆➡❌⬆➡❌➡❌⬅⬅⬅❌➡⬆⬆❌➡❌➡⬆⬆⬆⬆⬆❌
 
=== Addition with Input ===
 
❄➡⬆➡❄⬆⬆➡❌
 
=== Looping ===
 
➡⬆☯❄❌☮
 
GlyphCode invites you to decipher and master the intricate dance of glyphs and commands. Are you ready to embrace the weird and wonderful world of GlyphCode? CodePhantom (talk)
Category:Languages
Glypho

Glypho is an esoteric programming language based on symbol independence. It was created by Brian Thompson in September 2005. Each instruction is composed of a string of 4 symbols which may be any value, and the language determines which instruction is executed based on the set of symbols in the string.
Glypho operates on a single stack which has the ability of rotating its elements around - pushing the top element onto the bottom of the stack, and pushing the bottom element onto the top of the stack - allowing for random access of the entire stack in O(n) time where n is the number of elements on the stack.
The instruction reference is given here. For each instruction, the characters abcd represent the symbols composing each instruction. a refers to the first unique symbol, b refers to the second unique symbol, etc.
 aaaa ..... n NOP - no operation; do nothing
 aaab ..... i Input - push input onto top of stack
 aaba ..... > Rot - pops top stack element and pushes to bottom of stack
 aabb ..... \ Swap - swaps top two stack elements
 aabc ..... 1 Push - pushes a 1 onto the top of stack (creates new element)
 abaa ..... < RRot - pops bottom element and pushes to top of stack
 abab ..... d Dup - Duplicates top stack element
 abac ..... + Add - pops top two elements and pushes their sum
 abba ..... [ L-brace - skip to matching ] if top stack element is 0
 abbb ..... o Output - pops and outputs top stack element
 abbc ..... * Multiply - pops top two elements and pushes their product
 abca ..... e Execute - Pops four elements and interprets them as an instruction
 abcb ..... - Negate - pops value from stack, pushes -(value)
 abcc ..... ! Pop - pops and discards top stack element
 abcd ..... ] R-brace - skip back to matching [
Glypho is based on Udage and the quest for symbol-independent programming languages.
==Turing completeness proof==
By simple conversion from brainfuck. For infinite tape to right stack must have unlimited depth. 
Command	Glypho short form
Start 	111-+
> 	< [ > 11-+ 11-+ > ] <
< 	>>
+ 	1 +
- 	1 -+
. 	d o
, 	! i
[ 	[
] 	]
==External resources==
* Java Glypho interpreter - Runs both normal Glypho code and shorthand notation.
* Jix's Glypho implementation in Ruby (Not up to date with the current spec)
* Glypho in the Esoteric File Archive
Category:Languages
Category:Turing complete
Category:Turing tarpits 
Category:Low-level
Category:Stack-based
Category:Implemented
Category:Pattern-based
Category:2005
GoDDS - Graph of Distributed Data Structures

This page does not contain the documentation, it can be found on the GitHub repository, here.
Code snippets: link.
The grammar written in ANTLRv4: link.
=== FizzBuzz implementation ===
 #CELLS_COUNT 6
 #CELLS_GRAPH
 011101
 010110
 001110
 100010
 000000
 100000
 #END
 #INPUT 100
 #INPUT_CELLS 0
 #CELL 0 Counter
 READ_BUS
 //COPY
 SWAP
 
 LABEL main
 ADD 1
 //PRINTNL R0 0
 WRITE_CELL CheckFizz
 WRITE_CELL CheckBuzz
 SWAP
 WRITE_CELL AdditionalMemory
 READ_CELL Printer
 IFEZ print_number
 LABEL continue
 READ_CELL AdditionalMemory
 SWAP
 SUB R1
 IFEZ $
 ADD R1
 JUMP main
 
 LABEL print_number
 SWAP
 PRINTNL R0 0
 SWAP
 JUMP continue
 
 TERMINATE
 #END
 
 #CELL 1 CheckFizz %Daemon
 READ_CELL Counter
 
 JUMP Helpers@check_divisibility_by_three
 IFEZ set_true
 SET R0 0
 
 LABEL send_to_printer
 WRITE_CELL Printer
 
 JUMP ^
 
 LABEL set_true
 SET R0 2
 JUMP send_to_printer 
 #END
 
 #CELL 2 CheckBuzz %Daemon
 READ_CELL Counter
 
 JUMP Helpers@check_divisibility_by_five
 IFEZ set_true
 SET R0 0
 
 LABEL send_to_printer
 WRITE_CELL Printer
 
 JUMP ^
 
 LABEL set_true
 SET R0 1
 JUMP send_to_printer 
 #END
 
 #CELL 3 Printer %Daemon
 READ_CELL CheckFizz
 SWAP
 READ_CELL CheckBuzz
 ADD R1
 
 SUB 3
 IFEZ Helpers@print_fizz
 IFEZ Helpers@print_buzz
 IFEZ Helpers@print_newline
 ADD 3
 
 SUB 2
 IFEZ Helpers@print_fizz
 IFEZ Helpers@print_newline
 ADD 2
 
 SUB 1
 IFEZ Helpers@print_buzz
 IFEZ Helpers@print_newline
 ADD 1
 
 WRITE_CELL Counter // call print_number if needed
 JUMP ^
 #END
 
 #CELL 4 Helpers %Inactive
 // this cell is just a labels holder
 
 LABEL check_divisibility_by_three
 MOD 3
 IFEZ set_true
 EXIT
 
 LABEL check_divisibility_by_five
 MOD 5
 IFEZ set_true
 EXIT
 
 LABEL set_true
 SET R0 0
 EXIT
 
 LABEL set_false
 SET R0 -1
 EXIT
 
 LABEL print_fizz
 PRINT Fizz 0
 EXIT
 
 LABEL print_buzz
 PRINT Buzz 0
 EXIT
 
 LABEL print_newline
 PRINTNL 0
 #END
 
 #CELL 5 AdditionalMemory %Daemon
 READ_CELL Counter
 WRITE_CELL Counter
 JUMP ^
 #END
 #END_ALL
Category:Turing complete Category:Implemented Category:2023
Goatoo

Goatoo is an esoteric programming language created by User:DynCoder in May 2021. It is especially made for people who hate the goto command. The official interpreter is written in python and published on github under a GPLv3 license.
==Language Overview==
The language uses 2 different memory systems: a stack, containing ascii codes (up to 255), and a cell system, containing booleans.
Goatoo has 23 commands:
Command	Description
:X 	Go to line X
=X 	Check if the ascii value of letter X is equal to the number at the top of the stack, and save the result to the cell at the pointer
~X 	Check if the number X is equal to the number at the top of the stack and save the result to the cell at the pointer
! 	Invert the state of the cell at the pointer (True <-> False)
> 	Move the pointer right
< 	Move the pointer left
? 	Skip the next line if the cell at the pointer contains False
] 	Output the symbol of which the ascii value is equal to the number on top of the stack
[ 	Get a symbol as input and save it's ascii value to the top of the stack
} 	Output the number on top of the stack
{ 	Get a number as input and save it to the top of the stack
|X 	Save the ascii value of symbol X to the top of the stack
(X 	Save number X to the top of the stack
+ 	Pop the top two numbers on the stack, add them up, and save the result to the top of the stack
- 	Pop the top two numbers on the stack, subtract the lower number from the top number, and save the result to the top of the stack
* 	Pop the top two numbers on the stack, multiply them, and save the result to the top of the stack
/ 	Pop the top two numbers on the stack, divide the top number by the lower number, and save the result to the top of the stack
% 	Pop the top two numbers on the stack, divide the top number by the lower number, and save the remainder to the top of the stack
\ 	Swap the top two items on the stack
& 	Copy the top value on the stack
^ 	Pop the top item on the stack
; 	End the program
# 	Comment (skips the line)
The program always has to end with ;, otherwise it will cause an exception, this however also terminates the program.
Category:LanguagesCategory:2021Category:Low-levelCategory:ImplementedCategory:Stack-basedCategory:Cell-based
GodScript

God Script is a computer language based on religions created by Digerati. The commands are:
==Commands==
*Create: Create a variable (person or element of nature)
*Believe: Makes a variable believe something
*Ritual: Makes something happen once certain conditions are fulfilled
*Ethic: Sets boundaries for what a variable can do
*(Vedas/Tao Tu Ching/Wu-Ching/Torah/Gospels/Qur'ran/Adi Granth): Declare the code
*(Jesus/Mohammed/Zoroaster/Buddha/Confucious/Lao-Tzu/Baha'u'llah): State the code declaration AND all vars refer to
*/[...]: Declares a command not in God Script
*"...": Comment
NOTE: All GOD scripts start with
 run syntax.GOD; <prophet> state declaration <text>
==Example==
 run syntax.GOD; Lao-Tzu state declaration Tao Tu Ching
 Create Man.element=Exist
 Create Adam.person=Exist
 Create Eve.person=Exist
 Create Evil.Element=Null
 Believe Adam=Mohammed
 Believe Eve=Buddha
 /[If Evil.Element = Exist (
 Adam Create Original_Sin.element=Exist
 ) Else (
 Create Original_Sin.element=Null
 "therefore:"
 Create Evil.Element = Null
 /[goto line= run syntax.God; Lao-Tzu state declaration Tao Tu Ching (1)]
 )]
Category:Thematic
Category:Languages
Gofe

Gofe is a golfing language. It is invented by User:None1, but anyone who would like to contribute can contribute it.
==Data Storage==
It has a stack, queue, tape and deque and a register, they contain floating point values of any size.
==Commands==
+ - < > the same as brainfuck
, input register as decimal
? input register as character
! output register as character
. output register as decimal
[CODE] while the register is not zero, do CODE.
(CODE) while the register is zero, do CODE.
{CODE} do CODE forever.
$(CODE1)(CODE2) if the register is not 0, do CODE1, otherwise CODE2.
$[CODE] if the register is not zero, do CODE.
${CODE} if the register is zero, do CODE.
s d D t q Stands for the stack top, deque front, deque back, tape pointer and queue front respectively.
& Push the register value to the corresponding data structure (for the tape, set pointer value instead of push).
# Pop the register value from the corresponding data structure (for the tape, set register instead of pop).
@ Pop from the corresponding data structure (for the tape, set register instead of pop) and discard it.
; Set the register value to the corresponding data structure, but do not discard it.
A Add the register value by the corresponding data structure.
S Subtract the register value by the corresponding data structure.
M Multiply the register value by the corresponding data structure.
G Divide the register value by the corresponding data structure.
P Power the register value by the corresponding data structure.
Q Mod the register value by the corresponding data structure.
L Set the register value to log(10, register value).
R Set the register to a random value within [0,1).
F Set the register to integer part of it.
"<string>" Output <string>
'<string>' Output <string> and a line feed.
/x/ set register to x.
0-9 set register to corresponding one digit number.
EOF returns 0 in all input.
==Examples==
===Hello World===
 "Hello World!"
===Cat Program===
 {?!}
====Alternative that terminates on EOF====
 ![?!]
===A+B Problem===
,&s,As.
===99 bottles of beer===
+/99/[.St"bottle"${"s"}" 
 of beer on the wall, "At.St"bottle"${"s"}' of beer.'"Take one down and pass it around, "$(.St"bottle"${"s"}At)("no bottles")' of beer on the wall.']'No bottles of beer on the wall, no bottles of beerGo to the store and buy some more, 99 bottles of beer on the wall.'
===Infinite counter===
 {+.''}
===Powers of 2===
 ++1{.Mt}
===Fibonacci===
 >+<{#t.>At>&t<}
This program exausts infinite memory over time.
===Truth Machine===
 ,.[.]
===Dice===
 6&sRMs+FAt.
===Factorial===
 ,&t1&s[#sMt-&s#t].
===Project Euler problem 16===
/1000/&t/10/&q/2/Pt[&sQq>At<#sGqF]>#t.
==Implementation==
Though it is a golfing language, it is currently unimplemented. If you have an implementation, you can put it here.
Category:Languages
Category:Golfing language
Category:Turing complete
Category:Cell-based
Category:Stack-based
Category:Queue-based
Category:Deque-based
Category:2023
Category:Unimplemented
Goldfish/Implementation

:
Goldfish implementation in C++ by User:Fergusq.
#include <iostream>
#include <fstream>
#include <string>
#include <cstdlib>
using namespace std;
const int SIZE = 10000;
const int HALF = SIZE/2;
int vars[SIZE];
string funcs[SIZE];
int runFunction(int n, int p);
int main(int argc, char * argv[]) {
	if (argc != 2) {
		cerr << "usage: goldfish <file>" << endl;
		return 1;
	}
	ifstream in(argv[1]);
	if (in.is_open()) while (!in.eof()) {
		int n;
		string code;
		char chr;
		in >> n;
		chr = in.get();
		while (chr != '\n' && chr != '\r' && !in.eof()) {
			if (!isspace(chr)) code += chr;
			chr = in.get();
		}
		if (code.length()) {
			funcs[HALF+n] = code;
		}
	} else {
		cerr << "io error" << endl;
		return 1;
	}
	runFunction(0, 0);
	return 0;
}
/**
 * Runs a function
 */
int runFunction(int n, int p) {
	int &v = vars[HALF+n];
	string code = funcs[HALF+n];
	int i = 0;
	while (code[i]) {
		switch (code[i++]) {
		case 'i':
			v++;
			break;
		case 'I':
			p++;
			break;
		case 'd':
			v--;
			break;
		case 'D':
			p--;
			break;
		case 's':
			v *= v;
			break;
		case 'S':
			p *= p;
			break;
		case 'n':
			v=0;
			break;
		case 'N':
			p=0;
			break;
		case 'c':
			v = runFunction(v, p);
			break;
		case 'C':
			v = runFunction(p, v);
			break;
		case 'x':
		case 'X':
			{ int tmp = p; p = v; v = tmp; }break;
		case 'm':
			funcs[HALF+p] = funcs[HALF+v];
			break;
		case 'M':
			funcs[HALF+v] = funcs[HALF+p];
			break;
		case 'o':
			cout << (char)v; cout.flush();
			break;
		case 'O':
			cout << (char)p; cout.flush();
			break;
		case 'r':
			cin >> (char&)v;
			break;
		case 'R':
			cin >> (char&)p;
		break;
		case 'h':
		case 'H':
			exit(0);
			break;
		}
	}
	return v;
}
Category:Implementations
Golf

Golf is basically the space-optimization of programs for sport - who can write the shortest program that does X in programming language Y?
The term probably attained coinage from Perl Golf. Prior to this, the activity was sometimes referred to as cramming or code-bumming (although the latter does not necessarily refer to space optimization).
Although there were some early informal contests to write small Befunge programs, the favourite esoteric programming language in which to play Golf is probably Brainfuck, in which Golf tournaments are irregularly held.
Several esolangs can be considered to have come about by means of (non-competitive) Golf, with the task being "compile or interpret a programming language" and the programming language being assembly language (but with the result measured in bytes of machine language). These esolangs would be:
* False, with a compiler written in 1024 bytes of Motorola 68000 machine language
* Shelta, with a compiler written in 512 bytes of Intel 80286 machine language
* Brainfuck, with a compiler written in 240 bytes of Motorola 68000 machine language
* Barely, with an interpreter written in 59 bytes of Intel x86 machine language
* MinISCule, with an interpreter written in 36 bytes of Intel x86 machine language
* MiniMAX, with Intel 8086 machine language interpreters written in from 13 to 32 bytes (depending on what counts as cheating; all take input that contains nonprintable characters, some have no I/O, some have extensions that require inline x86 machine code in the MiniMAX program, and some require the MiniMAX program to be appended to the interpreter).
A more recent development is a genre of languages, "golfing languages" designed to allow programs to be written very tersely. These straddle the lines between practical and esoteric programming languages; they are typically much more usable than a typical esoteric language, and often cover very powerful concepts in order to make tasks shorter to express, but because the syntax is designed for terseness rather than readability the programs often look like esolang programs rather than practical programs. Additionally, programs written in golfing languages are typically much harder to modify once written than programs written in practical programming languages.
==See also==
* GolfScript
* Golf/Feature golf
* :Category:Golfing language for a list of golfing languages
==External resources==
* Code golf on Wikipedia
* Brainfuck Golf
* Code Golf site supporting some esoteric languages.
* GolfScript, a language designed for winning code golf competitions
* Code Golf and Coding Challenges Stack Exchange
Category:Concepts
Category:Program forms