nyuuzyou/wikis huggingface dataset:
Proprietary Esolang

Proprietary Esolang is an esolang invented by User:Hakerh400 in 2023.
== Overview ==
This esolang is an example of a language whose both specification and implementation are publicly available, but nobody except its creator can make any useful programs. The reason is because every program must be signed with Hakerh400's private RSA 2048-bit key.
The syntax is essentially the same as Python, except that at the end of each program a valid RSA signature of the program must appear. If the signature is valid, interpret the file as a Python program. Otherwise, throw an error.
== Examples ==
=== Hello, World! ===
 print('Hello, World!')
 #8065A25ADB01B6F05BB04F06C6B5C0625DD9E2620686BADB6CEC7890D7B3AF3E0C021AF8283E6F340BE131EEF83E3CC984362ECA962ADF1AF1D8226F35047522B7A021304F692C4E770F5F533068D3FAC8945D9BC159A9C26AD1347D085EC4B4187DD0D50BA40232593BC7ADA1EF6A3492CDE4A291D113F0525BF25F2D06EC58218DC6D3B1C11360030A27D35A80C3DCEBA3DF6B3C20D37AB81C8D5D177209A0EEAD85791B278CB1D1009F6A9F260B03AA0D64C0BA1F0AA48B654AC08DAE424DBCF32C45653334575D7DB0D5EC22A71D3F23D2703BC9F0F5F6B649D037425D983DFF9A5BC31406443AC11753E0EAF43D1EACF152EC33B568E002A245F061D290
=== Truth machine ===
 n = input()
 if n == '1':
 while 1:
 print(1)
 else:
 print(0)
 #7A93B53DCCC0F6FE8F62E874246AF0810EA24BD65041BFF767DB3FE00F6176CCD4B285DB89B9964F8FB8C90E7B1A100F998C3D2C619974057156DF7F04EF57C3EE33F3AD248E570CE5EB0DDD4523C1DDCB90E0AAAE4D11649C1D00C2B57C31EB38D40BA71DBD19573C7119A216FB4795B1939D50F8686EBBC113E964214AEB200D617734D3F7F4F87FC4D9BC2E7B739664A6BE40933B6E0CA707CF3B7DD687BD88FCCEB4F0F5E0459445AA09A0D76E496132129DC50BEC92C6A9BAAF6451FA170CB1D8D49E606571F0D750FB245520FBC8A2C05588C5DC539CCD1A77EC48BF9E6AADFCA56457279EC38E36DCDCA92079590AD2FFDE68B09F02A66C73E90B4324
== Implementation ==
Implementation in Python
Category:Languages
Category:2023
Category:Turing complete
Protogen/Better python interpreter

User:DifferentDance8 created a significantly improved version of the official Protogen interpreter called Pygen. It differs from the official Protogen interpreter in that it allows users to indirectly use the examples folder by simply launching the Python script.
== Bytogen View ==
A feature unique to Pygen is "Bytogen", which provides a way to view Protogen code without needing a hex editor. Instead of using the hexadecimal instructions, it displays the corresponding ASCII characters. The only exception is the byte 0x00, which is represented as "N" instead of "NULL". However, Bytogen cannot convert back to Protogen at this time, so it is currently read-only.
Category:Implementations
PrySigneToFry-complete

PrySigneToFry-complete is a concept proposed by PSTF.
== What Esolang can be PrySigneToFry-complete? ==
# This Esolang must be able to output "問天地好在" or "Hello, world!".
# This Esolang must be able to output User:PrySigneToFry/烂下攫用乴 constant by using loop.
# This Esolang must be able to do User:PrySigneToFry/烂下攫用乴 function.
# This Esolang must be able to input 2 integers and output their sum. Additional, to be more PrySigneToFry-complete, this Esolang must be able to do Disan Count.
# This Esolang must be able to output a descending sequence from 99 to 0 by using loop. Additional, to be more PrySigneToFry-complete, this Esolang must be able to do 99 bottles of beer.
# This Esolang must be able to judge that 6 is not equal to 5.
* Additional rules(if the Esolang follow these rules, it will be only PrySigneToFry-complete and Turing-complete)
*# This Esolang must be able to do Wolfram's rule-110.
*# This Esolang must be able to simulate a Conway's game of life.
*# This Esolang must be able to access the Internet.
*# This Esolang must be able to develop a software that used graphic.
== Isn't PrySigneToFry-complete is Turing-complete? ==
Not exactly. Turing-complete didn't need I/O, but PrySigneToFry-complete need.
And, Turing-complete didn't need an Esolang to calculate trigonometric functions, but PrySigneToFry-complete need.
== If an Esolang is PrySigneToFry complete, it will also what-complete? ==
# Turing-complete because of arithmetic, loop, judgement and jump, I/O.
# Plushie-complete because of I/O and variable-operation.
# Aweosme-complete because of loop, I/O.
Category:Concepts
Psychairefatback (Archive)

This page is an archive of the page for Psychairefatback, a language which I thought was cool and should be archived but that was removed by its creator. Here is the page as it appeared 21:58, 28 November 2019:
Psychairefatback is an esoteric programming language, currently a work in progress, created by User:ashtons. Created without any real purpose or theme, with its name reflecting that, Psychairefatback works with a theoretically infinite (but practically finite) code layer, and a finite data layer. Data is manipulated 1 bit at a time. The data layer is structured as a 2 dimensional grid of 16 by 16 cells, with each cell representing a single bit. In the interpreter's memory view, each cell is shown as either Red or Green dependent on whether the contained bit is False or True.
Psychairefatback has 16 instructions, and words in <Angle Brackets> represent arguments. They are as follows:
* set = Set Bit
* clr = Clear Bit
* mov = Move <Direction>
* otc = Output to Console as ASCII Character
* oti = Output to Console as Integer
* ifc = Input from Console as ASCII Character
* ifi = Input from Console as Integer
* cmp = Compare <Direction>
* beq = Branch to <Line> if Equal
* bne = Branch to <Line> if Not Equal
* blt = Branch to <Line> if Less Than
* bgt = Branch to <Line> if Greater Than
* jmp = Jump to <Line>
* jsb = Jump to <Subroutine>
* ret = Return from Subroutine
* end = End Program
Note that, for the input and output commands, a Character is 8-bits (or 8 memory cells) and an Integer is 16-bits (or 16 memory cells). The character or integer starts at the currently accessed bit.
If the "end" instruction is not present in a program, the program will loop until it is forcefully closed by the user, the interpreter, or the operating system.
Category:Languages
Psyche

Psyche is a marriage of the SKI combinator calculus with Freudian theories of the human mind.
== Components ==
Psyche expressions are combinations of three combinators:
* The id combinator is equivalent to I, the identity combinator in SKI.
* The superego combinator is the S combinator in SKI.
* The ego combinator is the K combinator in SKI.
== Syntax ==
Not yet decided.
Category:Languages
Category:Turing complete
Category:No IO
Category:Functional paradigm
Category:2020
Category:Unimplemented
Psychopaths

Psychopaths is a subset of Python by User:None1, it is created because User:Quito0567 said that "only psychopaths use print()" in his language ErrorFull. However, this language only allows you to use print(), which is what a psychopath does.
==Examples==
===Hello World===
 print("Hello World!")
======
 print(4,end="")
Category:Esoteric subsetCategory:2023
Pth

Pth is a dedicated declarative path-finding language invented by User:A created in order to make path-finding challenges on CGCC very trivial.
==Example program==
In Pth the indexing operation has a higher priority than other operators.
# For each item in the input
i-1& # The transition may be decrement the number
i+1 # Or Increment the number.
# Rules:
i>9 i←9.\ # If the item at i is larger than 9, set that item to 0;
i<0 i←9.\ # If the item at i is less than 0, set that item to 9;
!t<10³ # The time must be less than 1000 steps.
# Main procedure:
# Find the path of
α ñ β # Input 1 transitioned to input 2
# that makes the time the least.
Condensed:
i-1&i+1
i>9 i←0.i<0 i←9.!t<10³
αñβ
Condensed:
iω&iζ
iεi←0.iΌi←9.!t<χ³
αñβ
* &: Return the index that the current position is in.
Category:Languages
Category:2019
Punc

Punc is an esoteric programming language(a LISP derivative) that uses English punctuation as-is. It was inspired by ~English, but it looks forward to simplifying its syntax.
==Syntax(lists of punctuations)==
punctuation 	meaning 	Usage
. 	Ends a statement 	I love Polish food.
, 	Separator; frequently used with the colon.	I know Polish, Russian, and English. See other examples on the bottom.
: 	Declare a list. 	I know the following languages: Polish, Russian, and English.
[...] or (...)	Indicates a comment 	They [most of them British] have been released.
"..." 	Quote a text 	"Help," he cried.
===Another example for the comma===
World English, the best place to study English, has very concise tutorials.
==Syntax==
===How to declare a list===
LISP:(a b (c) d) 
Punc:The contents of anonymous is:a, b, c, and d.
===(quote a)===
LISP:(quote a)
Punc:"a"
In order to nest quotes, the user can switch between " and '.
===(atom a)===
LISP:(atom a)
Punc:whether a is an atom
===(eq a b)===
LISP:(eq a b)
Punc:whether a is equal to b
===(car a)===
LISP:(car a)
Punc:the first item of a
===(cdr a)===
LISP:(cdr a)
Punc:the rest of the items of a
===(cons x y)===
LISP:(cons x y)
Punc:the result of appending x and y
===(cond ( ... ) ...( ... ))===
LISP:(cond ( ... ) ...( ... ))
Punc:if (...) is true, then return ... and skip the rest of the ifs.
Category:2019
Category:Languages
Category:Implemented
Punctuation

== Overview ==
punctuation is an esolang composed of only punctuation on the keyboard. It does not yet have a compiler. The purpose is for Hello World to be as annoying as possible.
== Hello World ==
Code is below. vv
 [0] << -------; #Initialize [0] with 64.#
 
 [0] < ----; #Add 8 to [0].#
 
 [1] << -------;
 
 [1] < ------;
 
 [1] < ---;
 
 [1] < -;
 
 [2] << --------;
 
 [2] < ------;
 
 [2] < -----;
 
 [2] < ---;
 
 [3] << [2]; #Set [3] to [2]. They are both "l"s.#
 
 [4] << -------;
 
 [4] < ------;
 
 [4] < ----;
 
 [4] < ---;
 
 [4] < --;
 
 [4] < -;
 
 [5] << -------;
 
 [5] < ----;
 
 [5] < ---;
 
 [6] << ------;
 
 [7] << -------;
 
 [7] < -----;
 
 [7] < ---;
 
 [7] < --;
 
 [7] < -;
 
 [8] << [4];
 
 [9] << -------;
 
 [9] < ------;
 
 [9] < -----;
 
 [9] < --;
 
 [10] << [2];
 
 [11] << -------;
 
 [11] < ------;
 
 [11] < ---;
 
 [12] << ------;
 
 [12] < -;
 
 [0] >; #Outputs byte [0] to std#
 
 [1] >;
 
 [2] >;
 
 [3] >;
 
 [4] >;
 
 [5] >;
 
 [6] >;
 
 [7] >;
 
 [8] >;
 
 [9] >;
 
 [10] >;
 
 [11] >;
 
 [12] >;
Category:Languages
Punktuation

Punktuation is a 2d programming language, that uses every punctuation symbol. The logo is the shortest program
=Symbols=
 
Symbols	and where to use them
> 	move right
< 	move left
^ 	move up
v 	move down
+ 	add the top of the stack, to the second to the top
- 	subtract
* 	multiply
/ 	divide
% 	mod
. 	print ascii (will stop after there’s nothing left)
, 	print number
: 	start program
; 	end program
~ 	if the top of the stack is 0, move up, if not, move down, if 1, keep moving
| 	randomly move in a random direction randomly random
“ 	start, and end, string, and add the ascii number to stack
‘ 	start, and end, number sequence (example: ‘14 15’ as in coordinates)
@ 	goto coordinates (top and 2nd to top, in that order)
# 	add ascii top of stack to coordinates
$ 	add number top of stack of coordinates
& 	input (example: &’ to input numbers, &” to ascii)
_ 	call function (later down)
\ 	Rotate the stack clockwise if top is 1, if 0 the counterclockwise, else don’t to anything
` 	start comment
[ 	start loop
] 	go to [ if the top of the stack is not 0, if it is then keep going
( 	loop except while true
) 	end forever loop
{ 	subscript/function (can be multi line, like html tags)(also use like this: name{)
} 	stop the subscript (run like _name)
It automatically starts going right
=Examples=
Hello world:
:>”!drloW ,olleH”............;
(i hate apple for making it so that three periods make an ellipsis)
Multi line hello world:
 v <
 :>”!drloW ,olleH”$1 $13 v > ;
 . ~^
 >-^
Better hello world:
 v<<
 >.^;
 :”!drloW ,olleH”^
Randomly choose from two numbers in input:
 >,;
 :&'>|<
 >&',;
for example, the input:
 1 2
randomly outputs 1 or 2.
Truth Machine:
 ;
 ,
 :&’~(,)
 ;
Cat:
 v < v <
 ^<.
 ^<
 :>&" ^
Category:Languages
Category:2023
Category:Two-dimensional languages
Category:Stack-based
PureBrainz

PureBrainz was inspired by brainfuck and tries to keep the basis, the spirit, while implementing proper tools to make programs.
These tools include variables (anchor-points) in the memory-tape, multiple kinds of loops, that can either be hard-coded or depend on a memory cell, as well as functions that can take in pointer positions as arguments, and ternary operations (if/else), and finally, modules, which means you can create a package manager, and have libraries! You can too, import raw data from files.
Here is another explanation by the creator (hoping it doesn't break the rules of the wiki)
== Commands ==
Programming Concept 	brainfuck syntax 	PureBrainz Standard Syntax
Increment 	+ 	+
Decrement 	- 	-
Output 	. 	.
Input 	, 	,
Move to the left 	< 	<
Move to the right 	> 	>
While loop 	[...] 	[...]
Repeat an action N times (hardcoded) 	... ... ... ... ... 	5(...)
Repeat an action N times (variable) 	+++++[...-] 	$counter_variable(...)
Repeat an action i times (where i is the loop_index)	Keep count manually of the index 	%(...)
If cell != 0 	[... break out somehow] 	? {...}
If cell == 0 	temp0[-]+temp1[-]>[<...x>->]<< 	! {...}
Declare a Variable (set an Anchor) 	- Need to implement gliders etc. 	#variable_name
Overwrite a Variable (reset an Anchor) 	A true headache 	#variable_name
Go to an Anchor (Variable) 	+[->+]- (extremely limited) 	@variable_name
Declare a function 	Impossible 	#fun(*arg1*arg2*arg3){...}
Call a function 	Impossible 	:fun(*arg1*arg2*arg3)
Use current pointer as argument 	Impossible 	*here
Import a module 	Impossible 	~ModuleName|
Import raw data from a file 	Impossible 	~ModuleName|"
Hardcode a string 	++...>++++...>... 	"Hello World !"
Empty a cell 	[-] 	[-] or $(-) (better practise)
Addition (not destroying input) 	Need to copy cells to not destroy the input values	@c $(-) $a(+) $b(+) or use ~Math Module
== Modules ==
Multiple modules are also available to deal with different data types and problems, such as ~List, ~Math, ~Memory, ~Utils, ~Matrix, ~String, etc.
== Example Programs ==
=== Print Function ===
This print function stops when it hits a -1, the conventional end of any data structure.
It is included in ~Util
#print(*s){
 *s +[-.>+]-
}
Print (the memory values, not the char)
#print(*s){
 *s +[-48(+).48(-)>+]-
}
Print, with a space in between (for another separator, replace 32 with the ord of the character you want)
#print(*s*tmp){
 *tmp 32(+)
 *s +[-.#i*tmp.@i>+]-
 *tmp $(-)
}
=== Fibonacci sequence ===
0(+)>1(+)>
23(
 #c<#b<#a
 @c $a(+) $b(+)
 >
)
=== Powers of 2 ===
|~Math|
#base 2(+)
@12 #index +
@0 ><
11(#i @index+ @i > :pow(*base*index*here*11))
== Make PureBrainz Better ! ==
To get access to a python interpreter, or more info to create your own, please contact me !
Sinjoro (talk) 12:46, 14 April 2020 (UTC)
== External resources ==
* GitHub repo
Category:Languages
Category:Brainfuck derivatives
Category:Unimplemented
Category:2020
Pure BF

Pure BF is a completely functional joke programming language based on brainfuck.
== Details ==
Every first class value is a function of the type
 (Tape, World) -> (Tape, World)
A program technically doesn't have to be run after being compiled, as the language is purely functional, but the interpreter/compiler is encouraged to create an infinite tape, pair it with the world and apply the program to it, as that will make it possible to inspect the results of the code.
== Commands ==
Pure BF only has two commands:
 ab -- composes the functions a and b in the reverse of normal composition order.
 [a] -- creates the function that works like the identity function if the current cell is
 zero, and works like a[a] if it isn't.
== Built-in functions ==
Pure BF has 6 built-in functions that aren't the identity function:
 > -- copies the input tape, but with the head moved a single cell forwards.
 < -- copies the input tape, but with the head moved a single cell backwards.
 + -- copies the input tape, but with the current cell being 1 higher.
 - -- copies the input tape, but with the current cell being 1 lower.
 . -- copies the world, but with the output containing the value of the current cell.
 , -- copies the world and the input tape, but with one character moved from the input stream to
 the current cell.
Any other character is the identity function.
== Computational Class ==
Pure BF may seem equivalent to brainfuck. For example, here is a Pure BF function that converts any brainfuck program to a Pure BF program:
 ,[.,]
But while Pure BF may seem Turing-complete, it isn't. Pure BF is meta-Turing-complete in some sense, as it allows you to assemble Turing-complete programs, but a Pure BF program doesn't have loops. You might say that [a] is a loop, but it isn't. It creates a new function which loops, but that function cannot be executed in Pure BF. Pure BF is for that reason not very powerful.
== Implementation ==
* Implementation in Haskell
* Implementation in Python which errs on the side of the joke
* Implementation in Ocaml which doesn't execute the computed function
Category:Languages
Category:Joke languages
Category:Functional paradigm
Category:Brainfuck derivatives
Category:Implemented
Pure BF/Implementation in Ocaml

:
This Ocaml program defines the types world and tape, then the function:
:f : world * tape -> world * tape
that corresponds to the Pure BF program given as command line argument.
However, the function f is never applied. This implementation is for that reason not very powerful.
Note that functions . and , actually modify their input world, rather than a copy.
type world = { inp : in_channel; out : out_channel }
type tape = { back : char list; current : char; forth : char list }
let forwards (world, tape) =
 match tape.forth with
 | h :: t -> (world,
 { back = tape.current :: tape.back;
 current = h;
 forth = t })
 | [] -> (world,
 { back = tape.current :: tape.back;
 current = '\000';
 forth = [] })
let backwards (world, tape) =
 match tape.back with
 | h :: t -> (world,
 { back = t;
 current = h;
 forth = tape.current :: tape.forth })
 | [] -> (world,
 { back = [];
 current = '\000';
 forth = tape.current :: tape.forth })
let higher (world, tape) =
 let succ c = if c = '\255' then '\000' else Char.chr (succ (Char.code c))
 in let x = succ tape.current
 in (world, { back = tape.back; current = x; forth = tape.forth })
let lower (world, tape) =
 let pred c = if c = '\000' then '\255' else Char.chr (pred (Char.code c))
 in let x = pred tape.current
 in (world, { back = tape.back; current = x; forth = tape.forth })
let output (world, tape) =
 output_char world.out tape.current;
 (world, tape)
let input (world, tape) =
 let x = try input_char world.inp with
 | End_of_file -> '\000'
 in (world, { back = tape.back; current = x; forth = tape.forth })
let id (world, tape) = (world, tape)
let compose f g x = f (g x)
let rec loop f (world, tape) =
 if tape.current = '\000' then id (world, tape)
 else compose (loop f) f (world, tape)
let rec parse acc p =
 match p with
 | '[' :: p ->
 let (q, p) = parse id p in parse (compose (loop q) acc) p
 | ']' :: p -> (acc, p)
 | [] -> (acc, [])
 | '>' :: p -> parse (compose forwards acc) p
 | '<' :: p -> parse (compose backwards acc) p
 | '+' :: p -> parse (compose higher acc) p
 | '-' :: p -> parse (compose lower acc) p
 | '.' :: p -> parse (compose output acc) p
 | ',' :: p -> parse (compose input acc) p
 | _ :: p -> parse acc p
let str_to_list s =
 let l = ref [] in
 for k = String.length s - 1 downto 0 do
 l := s.[k] :: !l done;
 !l
let (f, _) = parse id (str_to_list Sys.argv.(1))
Category:Implementations
Push-down automaton

A push-down automaton (PDA) is a simple form of imaginary machine; essentially, it is a finite-state automaton hooked up to a unbounded stack onto which symbols can be pushed, and off of which symbols can subsequently be popped, in a last-in first-out order.
Push-down automata are more powerful than finite-state automata; for instance, the problem of recognizing that parentheses are correctly nested in a string can be solved by a PDA, but not by a FSA.
By the same token, there are certain strings which push-down automata are incapable of recognizing, such as anbncn (that is, a number of a's, followed by the same number of b's followed by the same number of c's.) This makes PDAs less powerful than Turing machines.
A push-down automaton can be deterministic or nondeterministic, and unlike for FSAs, these are not equivalent in power. Deterministic PDAs can recognize the so-called LR(1) languages, while nondeterministic ones can recognize any context-free language.
== See also ==
*A listing of esoteric languages on this site which have the same computational power as push-down automata.
Category: Computational models
PushDupAddSub

PushDupAddSub (PDAS) is an esolang by User:ChuckEsoteric08 inspired by Volatile.
==Commands==
 1 - push 1
 + - pop a and b, push a+b
 - - pop a and b, push b-a
 / - pop a and b, push b/a, pushing quotient followed by remainder
 : - duplicate
 [...] - while 0
==Computational class==
PDAS is Turing-complete because its behavior is capable of implementing the PMMN:
n should be prime number. P(n) would push n, when compiled to normal it uses 1, +, and :.
Initialisation:
 1
inc(n):
 : n-times, + n-times
dec(n):
 P(n)/:-+
while(n):
 :P(n)/[+ ... P(n)/]:-+
if(n):
 :P(n)/[+ ... 11+]:-+
==Examples==
===Addition and Subtraction===
This program demonstrates basic arithmetic operations by setting the top stack value to five, and subsequently decrementing it to four:
 11+1+1+1+::/+-
===Infinite Counter===
This program implements a counter which, commencing from zero, perpetually increments. During each loop iteration cycle's inchoation, the top stack element contains the current counter state.
 11:1/+-[+1+1:1/+-]
==Interpreter==
* Common Lisp implementation of the PushDupAddSub programming language.
Category:Languages Category:Turing complete Category:Turing tarpits Category:Stack-based Category:2023 Category:Implemented
Putlines

Putlines is a esolang that uses line selectors like "Run lines N to N" to loop
= Commands =
== Normal ==
=== Print ===
 print "hi"
 print "this is how"
 print "to do this"
=== Comments ===
 #this counts as a line btw
 #ok
=== Labels ===
 loop:
 print "this is used later"
=== Vars ===
 a = 10
 print a
 b = a*a
 print b
== Unnormal ==
=== Run lines N to N ===
 a = 10 #this is line 1
 a = a*a #this is line 2
 print a #this is line 3
 Runlines 2 to 4 #this is line 4
=== Swap lines N and N ===
 Swaplines 2 and 5
 print a
 a = a+1 #run second, caused by Swap line
 a = 10 #run first, caused by Swap line
 Swaplines 4 and 3
=== Set line N to C ===
 Setline 2 to { print "hello" }
 #replaced with print "hello"
=== Multi-Lines in Single-Lines ===
 print "hi"; print "hello" #hi then hello
 not:
 out = 1-a
 endnot:
 a = 1; Runlines not to endnot; output = out
= Examples =
== Loop ==
 #note 0/0=0
 a = 5
 loop:
 print a
 a = a - 1
 Runlines loop+(1-(a/a)) to 4+a/a
 print "Lift off!"
== Not ==
 input = 1
 output = 1-input
== And ==
 a = 1
 b = 1
 out = a*b
== Or ==
 #Use And and Not
 not:
 out = 1-a
 nnot:
 and:
 out = a*b
 nand:
 input1 = 1
 input2 = 0
 a = input1
 Runlines not to nnot
 not1 = out
 a = input2
 Runlines not to nnot
 not2 = out
 a = not1
 b = not2
 Runlines and to nand
 last = out
 a = last
 Runlines not to nnot
 output = out
Pwajnvlib

Pwajnvlib, compared to BF, is User:Cinnamony's mind compared to one of a neurotypical. He is diagnosed with autism but has gone undiagnosed for so much more.
==Commands==
 > moves pointer right
 < moves pointer right
 , orders pizza from little ceasers and ships it to one of your friends
 . prints a failed attempt at communicating the concept in the ASCII character of the cell at pointer
 + increments cell at pointer
 - decrements accumulator
 [ start of a forever loop
 ] end of a while loop
==Notes==
* Even though this would fit in the joke esoteric programming language category, it will not go there because it would be calling neurodiversity "a joke".
* This is not as weird-but-seemingly-normal as User:Cinnamony's mind compared to one of a neurotypical.
* User:Cinnamony was very scared of being judged or accused of "faking" while writing this article. (it took me the most courage i ever had to write this note and release it to the, very judging, public)
* User:Cinnamony has a lot of courage. He wastes it on this.
Category:LanguagesCategory:ThematicCategory:2023