nyuuzyou/wikis huggingface dataset:
Fromage

Fromage is an esoteric programming language with ten instructions, all of which operate only on single bits. The name comes from FReakish Outright Mad languAGE.
==Implementation==
This C implementation, originally titled fromage.c, was taken from http://esoteric.sange.fi, the website with the backup of Fromage. It is likely this is a valid implementation, but it's also good to check if this isn't the case.
#include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
int main(int g,char**h){int c;char*i,j,*b;FILE*w;ptrdiff_t a,d,e,f,k,l,o,p,s,t,u
,v,x,y;for(i=b=NULL,c=e=f=k=l=o=s=u=x=0,w=--g?fopen(h[1],"r"):stdin;c-EOF;){x<l?
(c=i[x]):(i=realloc(i,++l),i[l-1]=c=getc(w)),c-EOF&&(p=k+!(c-'(')-!(c-')'),v=u+!
(c-'}')-!(c-'{'),a=f-!(c-']'),y=c==';',(t=s+!(c-'>')-!(c-'<'))/8<o||(b=realloc(b
,++o),b[o-1]=0),d=!(b[t/8]&(j=1<<7-t%8)),c-'['||(y+=d,++a),d^=c!=':',u?(p=a=y=0)
:k?(v=a=y=0):e?(f=(a?a<0:y)?(e=0):a,v=p=0):(e=!!y),x+=(u=v*=v>0)?-1:(k=p*=p>0)?1
:e||(t==8&d?putchar(*b):t==9&d?*b=getchar():(b[t/8]=b[t/8]&~j|d*j),s=t,1));}g&&
fclose(w),exit(0);}
==Commands==
The ten operator symbols are:
Symbol 	Description
parentheses 	SKIP always
braces 	LOOP forever
brackets semicolons	IF this bit ELSE
less greater signs 	DECREMENT INCREMENT pointer
colons 	TOGGLE bit
The Pointer points to a single bit.
Storing in bit eight writes a character from bits zero to seven.
Storing in bit nine reads a character in bits zero to seven.
==Examples==
These examples are to see how the language is and could contain errors
===Hello, world!===
>:>>>:>>>>:<<<<<<H
:>>:>:>>:>:<<<<e
:>>>:>::<<ll
:>:>:<<<<<<<o
:>>>:>:>:>:>:<<<<<<<blank
:>>:>>:>:>:>:<<<<<w
:>:>>>>:<<<<<o
:>:>:>>:>:<<<<<r
:>:>:>:>>:<<<<l
:>>>>:<<<<<<<d
:>:>>:>:>:>>:return
===Cat program===
>>>>>>>>{>:<<[<[<[<[<[<[<[<[(]>]>]>]>]>]>]>]>:})
==See also==
* Smallfuck
* Boolfuck
==External resources==
* Backup of Fromage website
* The part of the backup with the implementation
Category:Languages
Category:Implemented
Category:2000
FrontFlip

FrontFlip is a version of BackFlip with two new commands 
== new commands ==
there are two new commands:
command	description
[ 	copy it and the comand right to it in pointer direction and turn 90 degrees clockwise
^ 	delete below command(includes NOP's)
Category:Unimplemented
Category:Languages
Category:Low-level
Category:Two-dimensional languages
Category:Unknown computational class
Category:No IO
Category:Reversible computing
Category:2024
Category:Self-modifying
Category:Total
Frums

Frums is a slightly modified version of Smurf invented by User:A.
==Syntax==
 " pushes the string, surrounded by " s and may contain newlines, " and \ escaped by \, onto the stack. 
 "ok""\"\n\\" 
 The example pushes "ok" onto the stack and pushes another onto the stack a string consisting of " , a newline and \ . 
 + combines 2 strings at the stack top. The string pushed first appears first in the resulting string. 
 i inputs a string and pushes it onto the stack.
 o outputs the string at the stack top.
 h replaces the string at the stack top with its first char.
 t replaces the string at the stack top with the rest of the characters except for the first char.
 q places " s at the start and end of the stack top string.
 p pops 2 strings from the stack and sets the first string specified variable to the the second string. 
 g pops a variable name from the stack and pushes the variable's value onto the stack. 
Category:Languages
Category:Golfing language
Category:Stack-based
Category:2018
Frédéric van der Plancke

Frédéric van der Plancke is the author of a few esoteric programming languages:
* BFM, an extension of Brainfuck with (higher-order) macros
* Brainffft, a LISP-inspired variant of Brainfuck
* Pandora, inspired by INTERCAL
He contributes to this wiki as User:Daycam.
Category: People
Fscratch

Fscratch is a language made by herohamp in a website called Scratch.
== Example programs ==
Print infinite ones (Not a truth machine)
 c1,e1,o,g7,
Pi Calculator (by NitroCipher)
 c1,e3,c3,e2,c4,e3,c5,e4,c6,ep3,mp4,mp5,c7,e4,dp6,c1,o,ap7,c3,a2,c4,a2,c5,a2,c6,ep3,mp4,mp5,c7,e4,dp6,c1,o,sp7,c3,a2,c4,a2,c5,a2,g23,
Fibonacci sequence (by NitroCipher)
 c2,e1,c1,o,ap2,c2,o,ap1,g6,
== Item data type ==
This language works with a data type I call "item", which can store a string or a number.
So if a item variable has the value of 65 (the ASCII value that represents A), it's not the same as A.
The max number that an Item can store depends on the implementation.
A math operation with an Item is normal, except that you cant do 12 + h, you can only do math operations with numbers, same to detecting if something is greater than another or not.
== Essentials ==
This language has the following rules:
* Every instruction should end with a "," even the last one.
* The memory is 128 items long.
*There is a pointer pointing to a item in the memory, with that pointer you will modify the memory.
*Every instruction is 1 character long.
*To write an instruction, you use the following syntax: [instruction][paramether],Example: c5,
== Instructions ==
Instruction	Description
c 	Changes the pointer to the paramether
e 	Sets the item of memory pointed by the pointer to the paramether
g 	Goto the character specified by the paramether
f 	Goto the character specified by the paramether IF the item pointed by the pointer is not zero
a 	Adds paramether to the item pointed by the pointer
s 	Substracts the item pointed by the pointer to by the paramether
m 	Multiplies paramether to the item pointed by the pointer
d 	Divides the item pointed by the pointer by the paramether
o 	Will print the item pointed by the pointer, if its a number it will print that number
== Notes ==
You can put a p at the right of an instruction, like this:
 ep5,
If you put a p it will tell to the interpreter, that the parameter put, its a pointer to a memory location, and it will use that location instead of the number put in the parameter. It's basically indirect addressing.
=== Example ===
Your memory is this:
 5, 3, 4, 3
and you do:
 cp2,
It will set the pointer to 3 (the second item in the memory)
=== Another example ===
Your memory is this:
 4, 3, 7, o, 6
and you do:
 c1,ep5,
It will set the item 1 of the memory, to the fifth item in memory (6)
== External resources ==
Reference and Interpreter
Category:Languages
Category:Implemented
Category:2018
Fuck

Fuck is a language designed by Josef N Patoprsty (User:Josefnpat) in March 2012.
The purpose of Fuck (capital F) is to provide a programming language to insult people, but still allow the recipient to decipher what you're really trying to say.
==Commands==
Command 	Description
fuck <raw> 	Initializes <raw> as a variable.
fucking <var> <raw> 	Sets <var> to <raw>, which can be a number or string.
fucked <var:1> <var:2> 	If <var:1> and <var:2> are numbers, <var:1> += <var:2>, otherwise, <var:1>=concat(<var:1>, " ", <var:2>).
unfucking <var> 	Store input from keyboard into <var>.
unfucked <var> 	Print <var> to stdout.
motherfuck <raw> 	Initializes <raw> as a label.
motherfucking <label> 	Jump to <label>.
motherfucked <var> <label>	Jump to <label> if <var> evaluates to true.
==Computational class==
Since you can add or subtract from variables, test for 0, and do arbitrary jumps, it is easy to implement a Minsky machine in Fuck, so it is Turing-complete.
==External resources==
*Fuck at GitHub, including full documentation, implementation, and examples
Category:Languages
Category:2012
Category:Turing complete
Category:Low-level
Fuck4

Fuck4 is four command esoteric language.
Fuck4 machine by default has 8 half-bytes 0-127, but this is not strict. In any case memory is finite and looped, this why only one-way pointer shift is required.
==Commands==
Fuck4 has four commands: f,u,c,k.
* f : increases current byte (brainfuck equivalent: +)
* u : starts loop if current byte not null (brainfuck equivalent: [)
* c : increases pointer position (brainfuck equivalent: >)
* k : ends loop if current byte is null (brainfuck equivalent: ])
+,[,>,] operators can be used instead of f,u,c,k
==Stdin/out:==
* input: after leaving second memory cell which is set to 2, first memory cell receives input
* output: after leaving second memory cell which is set to 1, first memory cell is printed out
Second cell automatically clears on each pass.
==Hello, world!==
 ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffcfccccc
 ccfffffffffffffffffffffffffffffcfcccccccfffffffcfccccccccfcccccccfffcfcccccccuf
 kffffffffffffffffffffffffffffffffffffffffffffcfcccccccufkffffffffffffffffffffff
 ffffffffffcfcccccccffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
 fffffffffffffffffffffffffffcfcccccccufkffffffffffffffffffffffffffffffffffffffff
 fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffcfcccccc
 cfffcfcccccccufkfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
 fffffffffffffffffffffffffffffffffffffffffffffcfcccccccufkffffffffffffffffffffff
 ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc
 fcccccccufkfffffffffffffffffffffffffffffffffcfc
====Fuck4 to C translator on Python:====
 # http://bfe.host.org/fuck4.html
 # fuck4 to C translator code in Python
 from sys import argv
 if argv.__len__()==1:
 print("usage: "+argv[0]+" input.fuck [out.c] [memsize] [bytecap]")
 print("default memsize is 8, default bytecap is 127")
 else:
 input = argv[1]
 output = input+".c" 
 MEMSIZE = 8
 BYTECAP = 127
 if argv.__len__()==3:
 output = argv[2]
 if argv.__len__()==4:
 MEMSIZE = int(argv[3])
 if argv.__len__()==5:
 BYTECAP = int(argv[4]) 
 r = open(input,'r')
 w = open(output,'w')
 if BYTECAP>255:
 BYTECAP=255
 if BYTECAP<1:
 BYTECAP=1
 if MEMSIZE<8:
 MEMSIZE=8
 w.write(" unsigned int p = 0, memsize = "+str(MEMSIZE)+"; char mem["+str(MEMSIZE)+"]; int main() { \n");
 code = r.read()
 r.close()
 p = 0
 sbv = 0
 for x in code:
 if x=="f" or x=="+":
 w.write(" if (mem[p] == "+str(BYTECAP)+") { mem[p] = 0; } else { ++mem[p]; } \n")
 if p==1:
 if sbv==BYTECAP:
 sbv=0
 else:
 sbv+=1 
 if x=="u" or x=="[":
 w.write(" while(mem[p]) { \n");
 if x=="c" or x==">": 
 if p==MEMSIZE-1:
 p=0
 else:
 p+=1
 if p==2 and sbv==1:
 w.write(" if (mem[1]==1) putchar(mem[0]); mem[1]=0; \n") 
 sbv=0
 if p==2 and sbv==2:
 w.write(" if (mem[1]==2) mem[0] = getchar(); mem[1]=0; \n") 
 sbv=0
 w.write(" if (p == "+str(MEMSIZE)+"-1) { p = 0; } else { p++; } \n")
 if x=="k" or x=="]":
 w.write(" } \n")
 w.write(" } //\n\n")
 w.close()
==External resources==
* fuck4 homepage with Python-based translator to C
Category:Brainfuck_derivatives
Category:Languages
FuckBrain

==Creator and Name==
FuckBrain is a language that adds spacetime travel to brainfuck that was written by User:Esolang1. The language Timefuck is very similar to FuckBrain, but FuckBrain allows to run more than one characters while traveling spacetime. The name symbolizes the spacetime traveling feature of the language. (E1-0002)
==Instructions==
 > Moves the pointer right
 < Moves the pointer left
 + Adds 1 to current cell
 - Subtracts 1 from current cell
 . Prints the current cell value as an ASCII character
 , Gets an ASCII character and saves it to current cell
 [ Jump to the matching ] if current cell is 0
 ] Jump to the matching [ if current cell is not 0
 # A marker for the start of spacetime travel
 ( Run commands up to matching } in the spacetime of matching ! (First {...} is matched with first !, and on)
 ) A marker for the end of spacetime travel
==I/O==
The commands . and , allow ASCII character I/O, same as brainfuck.
==Memory Structure and Code Structure==
While memory structure is identical to brainfuck, the code structure is a little bit different when spacetime travel is used. The following example code demonstrates the code flow of spacetime travel mechanism.
 A#B#(C)(D)E
This code will run A, B in order, and then run C in the spacetime of the first #. Then, D will run in the spacetime of the second #. After two spacetime travels, E will run and terminate the program.
Because the (...) command is not a loop, the following code is legal.
 A#[B(]C)
This code will first run A, and then enter a loop. Then, after B is executed for the first time, the code ]C will run as in the spacetime of #. This means that the program closed a loop before entering it. How these kinds of program will run is completely up to the compiler (as of now).
==Examples==
===How FuckBrain simulates the grandfather paradox===
==Interpreters or Compilers==
Unfortunately, there are no interpreters built for this language now. If there was an interpreter, it will use more memory than most other brainfuck derivatives, since the spacetime of every single command in the code has to be saved.
Category:Joke languages Category:Languages Category:Cell-based Category:Unimplemented Category:Unusable for programming Category:Unknown computational class
FuckBrainfuck

FuckBrainfuck (or FBF) is a programming language that compiles directly to Brainfuck. The FBF compiler is written in Lua so that it runs on Windows and Linux and is released under the terms of the GNU/GPL v3 license.
==External resources==
* Home of the FuckBrainfuck programming language
* GitHub repository
* Official site of the Lua programming language
Category:Compilers
Category:High-level
Category:Languages
Category:Brainfuck
Category:Implemented
FuckPutin

FuckPutin is stack based esoteric programming language invented in 2022 by user PoetLuchnik.
Stack - 65536 cells.
Cell - 32 bit integer.
Two stacks (A and B).
Program is a sequence of digits and notes.
Each digit it is offset for operation-accumulator.
Operation-accumulator can be from 0 to 9.
After offset operation-accumulator, program interpret operation-accumulator.
At the beginning operation-accumulator is zero.
== Operations ==
operation-accumulator value	operation description
0 	A.pop()
1 	A.push(1)
2 	A.push(A.pop() + A.pop())
3 	A.push(~(A.pop() | A.pop()))
4 	A.push(A.pop() >> 1)
5 	A.push(B.pop())
6 	B.push(A.peek())
7 	tmp = B.pop(); if A.pop() != 0 then go to tmp
8 	output(A.pop())
9 	A.push(input())
== Examples ==
=== print A ===
 1597497497497497497916
Description: push_1 dup add dup add dup add dup add dup add dup add push_1 add out
== C implementation ==
 #include<stdlib.h>
 #include<stdio.h>
 #include<stdint.h>
 
 FILE* fp = 0, * fi = 0, * fo = 0;
 
 struct stk {
 	long _[0x10000];
 	uint16_t i;
 } A = { .i = 0 }, B = { .i = 0 };
 
 long fp_len = 0;
 
 void push(struct stk* s, long d) {
 	s->_[(s->i)++] = d;
 }
 long poop(struct stk* s) {
 	return s->_[--(s->i)];
 }
 long peek(struct stk* s) {
 	return s->_[(s->i) - 1];
 }
 void jump() {
 	long t = poop(&B);
 	if (poop(&A)) fseek(fp, t % fp_len, SEEK_SET);
 }
 
 int main(int argc, char** argv) {
 	// open
 	if (argc > 1) fp = fopen(argv[1], "r");
 	if (fp == 0) return 1;
 	fseek(fp, 0, SEEK_END);
 	fp_len = ftell(fp);
 	fseek(fp, 0, SEEK_SET);
 	if (argc > 2) fi = fopen(argv[2], "r");
 	if (fi == 0) fi = stdin;
 	if (argc > 3) fo = fopen(argv[3], "w");
 	if (fo == 0) fo = stdout;
 	// run
 	uint8_t op = 0;
 	for (int c = fgetc(fp); c != EOF; c = fgetc(fp)) {
 		if ('0' > c || c > '9') continue; // ignore
 		op = (op + c - '0') % 10; // op += c (WARNING: NOT op = c)
 		switch (op)
 		{
 		case 0: poop(&A); break; // pop
 		case 1: push(&A, 1); break; // one
 		case 2: push(&A, poop(&A) + poop(&A)); break; // add
 		case 3: push(&A, ~(poop(&A) | poop(&A))); break; // nor
 		case 4: push(&A, poop(&A) >> 1); break; // shr
 		case 5: push(&A, poop(&B)); break; // bta
 		case 6: push(&B, peek(&A)); break; // atb
 		case 7: jump(); break; // jmp
 		case 8: fputc(poop(&A), fo); break; // put
 		case 9: push(&A, fgetc(fi)); break; // get
 		}
 	}
 	// close
 	fclose(fp);
 	if (fi != stdin) fclose(fi);
 	if (fo != stdout) fclose(fo);
 	return 0;
 }
Category:Low-level 
Category:Stack-based 
Category:Implemented 
Category:Languages
Category:2022
Category:Turing complete
Fuck 2red

Fuck 2red is an esolang created by user:tommyaweosme after he got banned on pixilart
== commands ==
commands are stacks of "fuck 2red" seperated by "Fuck 2red"
 1 +
 2 -
 3 >
 4 <
 5 .
 6 ,
 7 [
 8 ]
== cat ==
 fuck 2red fuck 2red fuck 2red fuck 2red fuck 2red fuck 2red Fuck 2red fuck 2red fuck 2red fuck 2red fuck 2red fuck 2red fuck 2red fuck 2red Fuck 2red fuck 2red fuck 2red fuck 2red fuck 2red fuck 2red Fuck 2red fuck 2red fuck 2red fuck 2red fuck 2red fuck 2red fuck 2red Fuck 2red fuck 2red fuck 2red fuck 2red fuck 2red fuck 2red fuck 2red fuck 2red fuck 2red
Fuck you!

Fuck you is an esolang created by User:None1, its only purpose is to fuck its user.
==Commands==
There is only one command: !, that prints Fuck you! with a line feed, other characters are NOPs.
==Exmaple Programs==
===Fucks the user===
 Fuck you!
====Alternative====
 !
=====???=====
 Ƒūčķ ƴŏū!
===Quine===
 Fuck you!
===Quine2===
 Fuck you!
 Fuck you!
===Quine3===
 Fuck you!
 Fuck you!
 Fuck you!
==Implementations==
The following is the official implementation of this esolang in brainfuck
Category:Languages, it interprets only the first line of input and is compiled using BFFuck and isn't very optimized.
>>>>>>>>>>>>>>>,----------[<<<+++++++++++++++++++++++>>[-]<[-]>>[<<+>>-]+<<<[>->+<<-]>>[<<+>>-]<[>>-<<[-]]<[-]>>[-]<[-]>>[<+<+>>-]<[>+<-]<[>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.[-]+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.[-]+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.[-]+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.[-]++++++++++++++++++++++++++++++++.[-]+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.[-]+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.[-]+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.[-]+++++++++++++++++++++++++++++++++.[-][-]++++++++++.[-]<[-]]>>,----------]
The BFFuck source code of this interpreter is at the wiki page of BFFuck.
Category:Joke languages
Category:Unusable for programming
Category:Output only
Category:Total
Category:Thematic
Category:Implemented
FuckbeEs

fuckbeEs is exactly the same as Brainfuck except better
==Language overview==
fuckbeEs operates on an array of memory cells, also referred to as the tape, each initially set to zero. There is a pointer, initially pointing to the first memory cell. The commands are:
Command	Description
f 	Move the pointer to the right
u 	Move the pointer to the left
c 	Increment the memory cell under the pointer
k 	Decrement the memory cell under the pointer
b 	Output the character signified by the cell at the pointer
e 	Input a character and store it in the cell at the pointer
E 	Jump past the matching s if the cell under the pointer is 0
s 	Jump back to the matching E if the cell under the pointer is nonzero
All characters other than fuckbeEs should be considered comments and ignored. But, see extensions below.
==History==
fuckbeEs was created to show that there are too many brainfuck clones and that people should stop, please.
==Examples==
===Hello, World!===
 cEuEfkucEucccuEcccccccccccusEskEfsu
 kssccccccccccfsuuuuuukkkkbffcccbfkb
 bcccbfkbuuubffbcccbkkkkkkbukbffcbfb
==Implementation==
 #!/usr/bin/ruby
 eval 'm=Hash.new(p=0);'+ARGF.read.gsub(
 /./,
 'f' => 'p-=1;',
 'u' => 'p+=1;',
 'c' => 'm[p]+=1;',
 'k' => 'm[p]-=1;',
 'b' => 'putc m[p];',
 'e' => 'm[p]=STDIN.getbyte if !STDIN.eof;',
 'E' => '(',
 's' => ')while((m[p]&=255)!=0);')
Category:Languages
Category:Brainfuck equivalents
Category:Turing complete
Category:2016
Fucker

Fucker is an esolang invented by User:None1 and inspired by Fuck you!, but it fucks the programmer instead of the user.
==Syntax==
Fucker is basically APLWSI, but it compiles the program to brainfuck, in order to fuck the programmer, it outputs Fuck you! before compiling.
==Examples==
===APLWSI interpreter===
 Any text can go here.
===Quine (sort of)===
 Fuck you!
===Quine (At least translated)===
 操你妈!
==Compiler==
===Python===
You don't have to pass the source code as argument because this is a no-code esolang. Just pass the output file name.
import sys
f=sys.argv[-1]
print('Fuck you!')
open(f,'w').write()
Category:Languages
Category:Joke languages
Category:Unusable for programming
Category:2023
Category:Total
Category:Implemented
Category:No-code esolang
Fuckfuck

Fuckfuck (also known as f*ckf*ck), is a brainfuck variant, using profanity (optionally censored with asterisks, or any other characters if you wish) instead of brainfuck's one-character commands. The commands are case and white space insensitive. Also, C-style comments /* */ may be used. By appending an exclamation mark ('!') a command can be repeated, without the need to write the word again.
Fuckfuck command	Brainfuck command
fuck 	>
shag 	<
boob 	+
tits 	-
cock 	.
knob 	,
arse 	[
butt 	]
Please remember that, only the first and last letter of the word has to be correct, the second and third letter can be anything and it will still work. For example, you do not have to write "fuck" you could write "fork" or "fkfk" or "fpok" or "fsck" or "fcuk" instead if you want to, but "fine" or "f***" is no good.
==Hello World==
This is a very sanitised version of hello world.
 barb!!!!!!!!! able folk barb!!!!!! folk barb!!!!!!!!! folk
 barb!! folk barb sing!!! teas bait folk barb! cask folk barb cask
 barb!!!!!! cask! barb!! cask folk barb! cask sing! barb!!!!!!!!!!!!!!
 cask folk cask barb!! cask teas!!!!! cask teas!!!!!!! cask folk barb
 cask folk cask
==See also==
* Marinus' interpreter
==External resources==
* 
Category:Brainfuck equivalents
Category:Unknown year
Category:Languages
Fuckgoid

Fuckgoid is the fungoid with the smallest interpreter, by User:None1.
==Commands==
It is Befunge-98, but there are only 4 commands: which works the same. When the IP goes out of bounds, it wraps back.
An empty program is an infinite loop, characters that are not commands are NOPs.
==Examples==
===Infinite loop===
==Interpreters==
===brainfuck===
 +[]
It is easy to prove that this interpreter is always correct.
===Self interpreter===
 
===Infinite loop (esolang)===
Shorter than in bf.
 []
Category:Languages Category:Joke languages Category:No IO Category:2023 Category:Implemented Category:Two-dimensional languages