nyuuzyou/wikis huggingface dataset:
+*-

+*- (say "add star minus") is an esolang very close to a Minsky machine, it is created by User:None1.
==Commands==
It had two unbounded accumulators named and , both set to zero at start of program.
Command	Meaning
 	Increment
 	Swap and .
 	If is 0, jump to the start of program, otherwise, decrement .
==Examples==
===Infinite loop===
 -
==Turing completeness==
Though the language is very close to a minsky machine, the author is not good enough at computational theory to prove whether it is Turing complete or not.
==See Also==
*UBLANG
*Brainpocalypse
==External resources==
* Python interpreter with an undocumented debugging command.
Category:Languages
Category:2023
Category:No IO
Category:Unknown computational class
Category:Implemented
++

++, or ?++ is C++, but the letter "c" is banned. If one is found, the compiler will say that a "bad letter" is found, and fail to compile.
== Examples ==
=== Infinite loop ===
 int main() {
 while (1) {
 }
 }
== Implementation ==
I don't have much time, so I don't implement this with code. However, it is simple to make a Bash program to detect the 'c's beforepassing it to the c++ compiler.
Category:Joke languages
Category:2021
Category:Languages
Category:Implemented
+++

made by Fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff (talk) 02:45, 25 September 2024 (UTC)
 Caption text
Command 	What it do?
+[increment]	accumulator += increment
++ 	accumulator++
! 	print accumulator
? 	input accumulator
!$ 	print accumulator as char
?$ 	input accumulator as char
[number] 	accumulator = number
$ 	clear input buffer
+? 	add user input
'#' is a comment character
== Programs ==
=== Hello, World! ===
 72 !$ 101 !$ +7 !$ !$ +3 !$ 44 !$ 32 !$ 87 !$ 111 !$ 114 !$ 108 !$ +-8 !$ 33 !$
=== A+B Problem ===
 ? +? !
=== Numerical Cat ===
 ? !
=== One Time Cat ===
 ?$ !$ $
== + compiled into +++ ==
def convert(c): return(c.count("+")*"++ ")
=== Interpreter ===
def plus(code,a=0,ib=[]):
 def isInt(x):
 try: int(x); return True
 except: return False
 for i in code.split(' '):
 if i == "": pass;
 elif i == '+?':
 if isInt(query := input()): a += int(query)
 else: print('Invalid Number');return
 elif i[0] == '+':
 if i == '++': a+=1
 elif isInt(i[1:]): a+=int(i[1:])
 else: print(f'Invalid command: {i}'); return
 elif isInt(i): a=int(i)
 elif i == '?':
 INP = input()
 if isInt(INP): a=int(INP)
 else: print(f'Invalid Input'); return
 elif i == '?$':
 if ib == []: ib+=list(input())
 else: a = ord(ib.pop(0))
 elif i == '!': print(a)
 elif i == '$': ib = []
 elif i == '!$':
 if a >= 0: print(end=chr(a))
 else: print(f'Invalid Character'); return
 elif i == '#': break
 else: print(f'Invalid command: {i}'); return
 return (a,ib)
def shell():
 a=0;ib=[]
 while (code:=input('>>> '))!='END':
 if code == or code.isspace(): continue
 F = plus(code,a,ib)
 if F==None:return
 a = F[0]; ib = F[1]
 print()
shell()
Category:Languages Category:2024 Category:Implemented Category:Total Category:Unusable for programming
++===

++=== is a register-based OISC with no branching. The name is a concatenation of ++, ==, and =, describing the singular instruction (if (*A++ == *B) *A = *C;).
== Specification ==
Memory in ++=== consists of indefinitely many registers containing non-negative integers initialized at 0, though only finitely many can be used in the program.
Programs consist of commands, each naming three distinct registers A, B, and C. The command, when executed, first increments A. After incrementing, if A is equal to B, A is set to C. It is undefined behavior if A, B and C are not distinct. At the end of the program, the program restarts at the first command.
No explicit halting condition or I/O extension is currently defined.
=== Syntax ===
If syntax is required, registers are named by strings containing no whitespace. Commands are specified as <register name><whitespace><register name><whitespace><register name>, and are separated by whitespace. Incomplete commands may only appear at the end and are ignored. For readability, non-empty alphanumeric register names, spaces within commands, and newlines separating commands are recommended, however programs consisting of (for example) only zero-width spaces, zero-width non-joiners, and zero-width joiners are also valid.
Category:Languages Category:OISC Category:2025
++Brainfuck

=Commands=
Command	Description
> 	Move the pointer to the right.
< 	Move the pointer to the left.
+ 	Increment the memory cell under the pointer.
- 	Decrement the memory cell under the pointer.
. 	Output the character signified by the cell at the pointer.
, 	Input a character and store it in the cell at the pointer.
: 	If the cell under the pointer is 0, read the next command.
; 	If the cell under the pointer is not 0, read the next command.
) 	Jump forward to the next (.
( 	Jump backward to the previous ).
0 	If the last ; is not true, read the next command.
1 	If the last : is not true, read the next command.
} 	If the current byte is 0, jump over the next command.
{ 	If the current byte is not 0, jump over the next command.
=Examples=
== Cat program ==
This cat program repeats infinitely.
 ;),.(
== Truth-machine ==
The following is a commented version of a truth-machine implementation.
 INPUT
 ,
 
 SET THE TEST CELL TO MINUS 48 TO LATER INCREMENT IT TO GREATER OR EQUAL ZERO
 >>
 ------------------------------------------------
 
 BACK TO INPUT
 <<
 
 SKIP ON FIRST ENTRANCE
 :
 )
 TO COPY CELL
 >
 BUILD COPY CELL
 +
 REPLACE THIS TEXT WITH A DOT TO TRACE THE COPY CELL INCREMENTATION
 >
 COMPUTE TEST CELL
 +
 BACK TO INPUT CELL
 <<
 -
 REPEAT UNTIL THE INPUT CELL IS ZERO
 THE COPY CELL WILL THE EQUAL THE ORIGINAL USER INPUT
 THE TEST CELL WILL CONTAIN A NUMBER EQUAL TO OR GREATER THAN ZERO FOR SIMULATING A CONDITIONAL
 ;
 (
 
 TO TEST CELL
 >>
 IF THE TEST CELL IS ZERO THE FOLLOWING LOOP WILL BE SKIPPED
 :
 SKIPPING IS REALIZED IF THE TEST CELL EQUALS ZERO
 )
 TO COPY CELL
 <
 PRINT COPY CELL
 .
 TO TEST CELL
 >
 (
 
 THIS SECTION IS ONLY REACHED IF INPUT IS ZERO AND PRINTS THE COPY CELL ONCE
 <
 .
A rendition with comments culled is reduced to the following:
 ,>>------------------------------------------------<<:)>+>+<<-;(>>:)<.>(<.
=Interpreter=
* Common Lisp implementation of the ++Brainfuck programming language.
Category:Languages
Category:Brainfuck derivatives
Category:Implemented
++C

++C (alternatively called PostC) is a C++ based esoteric programming language created by User:Yee haw in 2022. The premise of ++C is using postfix notation with the traditional C++ syntax.
== Syntax ==
In ++C, all C++ identifiers are classified as either operators or operands. As such, all C++ programs can be restructured to be valid ++C programs. Here is an example of a simple Hello World program:
 "Hello World!" cout <<;
In this case, the stream insertion operator takes it's lvalue, a string literal, and hands it to the C++ output stream. The order of an operator's operands does matter in ++C.
Operators can be either unary or binary. Unary operators take a single operand off of the stack and push a single value back onto the stack.
Just like in mathematical postfix notation, each operator returns a certain value. For some binary operators, it's uncertain whether the lvalue or rvalue should be returned, such as in the case of the stream insertion operator. In those cases, the lvalue will be ignored and the rvalue will always be returned.
In most other cases, such as in the case of the addition operator, the order of the operands doesn't matter and there's only one valid return value.
++C is a stack-based language, meaning that all operands are held on a large stack and are sequentially pushed on and popped off. The semicolon at the end of each line resets this stack, so that each line has a clean stack to use.
=== Notable Differences From C++ ===
Many expressions that would usually be invalid in C++ are valid in ++C. 
For instance, the following code is illegal in C++:
 cout << string a = "Hi" << endl;
But in ++C, the same line can be written legally as follows:
 endl a string "Hi" = cout << <<;
This is thanks to the extra control ++C gives the user in terms of control over operator precedence. In ++C, no such thing as operator precedence exists; lines are just executed from left to right.
Unlike C++, ++C requires spaces between operands, as there are no operators to separate them.
In C++, the following line does not require any spaces:
 cout<<"hi"<<endl;
The same line written in ++C would require a space between the endl, cout, and "hi".
== Examples ==
Hello World:
 "Hello World" cout <<;
A simple calculator program:
 {
 "Enter two integers: " cout <<;
 x int y int cin >> >>;
 "What operation would you like to perform? (+, -, +, /) " cout <<;
 operator string cin >>;
 {
 sum int x y + =;
 endl sum "\nTheir sum is " cout << << <<;
 } (operator "+" ==) if;
 {
 difference int x y - =;
 endl difference "\nTheir difference is " cout << << <<;
 } (operator "-" ==) if;
 {
 product int x y * =;
 endl product "\nTheir product is " cout << << <<;
 } (operator "*" ==) if;
 {
 quotient double x y / =;
 endl quotient "\nTheir quotient is " cout << << <<;
 } (operator "/" ==) if;
 "Would you like to run the program again? (y/n) " cout <<;
 input string;
 break (input "N" == input "n" == ||) if;
 } true while;
Category:Languages Category:2022
++brainfuck++

++brainfuck++ - joke language, written by User:Maximngy 27.05.2016.
That is an updated version of Brainfuck.
That is a juxtaposition of the ++brainfuck++ and Brainfuck commands:
BrainFuck	++BrainFuck++	Command
> 	> 	Move the pointer to the right
< 	< 	Move the pointer to the left
+ 	+ 	Increment the memory cell under the pointer
- 	- 	Decrement the memory cell under the pointer
. 	. 	Output the character signified by the cell at the pointer
, 	, 	Input a character and store it in the cell at the pointer
[ 	{ 	Jump past the matching ] or } if the cell under the pointer is 0
] 	} 	Jump back to the matching [ or { if the cell under the pointer is nonzero
none 	c 	Copies the current memory cell value to the temporary variable
none 	p 	Pastes the temporary variable's value into the current memory cell
none 	o 	Sets the current memory cell to 0
none 	e 	Exits from interpreter
none 	n 	Outputs the current memory cell's value as a number
none 	r 	Generates a random number from 1 to 1000 and stores it in the current memory cell
Examples:
++c>pn>p.
Output:
2
�
And this:
rcn>p-.
For example (random) output this:
509
Ǽ
And this cool program (for example):
rc+>p++>p+++{<.n}
Write that:
|124
{123
z122
This implements the Hello, world! program:
 ++++++++{>++++{>++>+++>+++>+<<<<-}>+>+>->>+{<}<-}>>.>---.+++++++..+++.>>.<-.<.+++.------.--------.>>+.>++.
The following demonstrates an infinitely repeating cat program:
 ,.{,.}
The truth-machine can be designed in this fashion:
 ,>++++++++++++++++++++++++++++++++++++++++++++++++{<->-}<{n}n
Thanks for reading me =3
==Interpreter==
* Common Lisp implementation of the ++brainfuck++ programming language.
* C++ implementation of the ++brainfuck++ programming language but with all values in range (0-255).
Category:Languages
Category:Brainfuck derivatives
Category:2016
++Ↄ

++Ↄ is basically C++ but every program must be written in one line and in reverse order.
A standard-compliant ++Ↄ preprocessor needs to split the source code into lines by whitespace characters and then reverse the line order.
== Programs ==
Here is a Hello World program written in ++Ↄ:
 } std::cout<<"Hello,\x20World!\n"; main(){ int #include<iostream>
And this is what the Hello World program should look like after preprocessing:
 #include<iostream>
 int main()
 {
 std::cout<<"Hello, World!\n";
 return 0;
 }
== Implementations ==
Here is a simple ++Ↄ preprocessor written in C++:
 #include <iostream>
 #include <fstream>
 #include <sstream>
 #include <string>
 
 std::string preprocess(auto &&is, std::string _code = {}, std::string _res = {}) {
 std::istringstream iss{ (std::getline(is, _code), std::move(_code)) };
 while (iss >> _code) _res = _code + "\n" + _res;
 return _res;
 }
 
 int main(int argc, char *argv[]) {
 if (argc >= 4) std::cout << "Usage: " << argv[0] << " [input file] [output file]\n";
 else if (argc == 3) std::ofstream(argv[2]) << preprocess(std::ifstream(argv[1]));
 else if (argc == 2) std::cout << preprocess(std::ifstream(argv[1]));
 else std::cout << "Enter ++Ↄ source code:\n" << preprocess(std::cin);
 }
Category:Languages
Category:2024
+-"quote

This is basically the same as "quote, but with recursion.
==Commands==
This is basically the same as "quote, but with 2 new commands
* -: intepret the stored string as +-"quote with sanme stored string
* +: halt
==Examples==
===Truth machine===
 te"qeq"eq"o-"-
(+ for 0, - for 1)
===Infinite loop===
 e"-"-
===Infinite output Hello, World!===
 e"q"Hqello, World!q"-"-
Category:Languages Category:Joke languages Category:Unusable for programming
+-)

+-) is a minimalistic esolang invented by User:None1 and inspired by brainfuck.
==Memory==
There is a tape with three cells, each cell contains an unbounded signed integer. There is also a pointer that wraps around.
==Commands==
In +-), there are three commands, both + and - matches ).
* +: Increment current cell unless the previous instruction executed is its matching ), then jump to the matching ) if the current cell is zero or the next character is ).
* -: Decrement current cell unless the previous instruction executed is its matching ), then move the pointer to the right, then jump to the matching ) if the current cell is zero or the next character is ).
* ): Jump to the matching + (or -) if current cell is nonzero and the previous character is ).
==Computational class==
It is Turing complete because it can be translated from 3 cell Brainfuck (without I/O) easily. Proof is below (BF stands for 3 cell Brainfuck in the proof for convenience):
===+===
+ in BF can simply be translated to +) in BF.
===> and <===
We notice that -) in +-) is the same as -> in BF, so > is equivalent to +->, which is +)-) in +-).
Because the pointer wraps around, now that we get the translation of >, we can simply translate < by repeating > twice, that is:
 +)-)+)-)
===-===
- is equivalent to -><. Because -) in +-) is the same as -> in BF, - can be translated to -)+)-)+)-).
===[ and ]===
When not before a ), + in +-) is the same as +[ in BF, so [, the same as -+[><, can be translated to -)+)-)+)-)++)-)+)-)+)-).
] can be translated to ).
Note: >< is a placeholder that does nothing to force the loop to be nonempty. If the >< doesn't exist, empty loops ([]) won't work, because it will be translated to -)+)-)+)-)+), which will do nothing because the last ) is right before a +.
 The whole translation table
BF	+-)
+ 	+)
- 	-)+)-)+)-)
> 	+)-)
< 	+)-)+)-)
[ 	-)+)-)+)-)++)-)+)-)+)-)
] 	)
==Examples==
===Calcuate 65===
 +)+)+)+)+)+)+)+)-)+)-)+)-)++)-)+)-)+)-)+)-)+)+)+)+)+)+)+)+)+)-)+)-)-)+)-)+)-))+)-)+)
Translated from brainfuck ++++++++[>++++++++<-]>+, which sets the second cell to 65.
==External resources==
* Original interpreter in Python
Category:Languages
Category:Turing complete
Category:2024
Category:No IO
Category:Turing tarpits
Category:Implemented
Category:Cell-based
+-.%*

+-.%* is an esoteric programming language created by User:3xcpy. It is (kind of) pretty similar to Brainfuck.
== Overview ==
Just like Brainfuck, +-.%* operates on a tape of memory cells. These cells can hold any value between (including) 0 and 255. When a value exceeds these bounds, it wraps around to the opposite end. There is a pointer pointing to the current cell on the tape. The instruction pointer is moved forward by 2 every time an instruction is executed, effectively skipping one character every time. The % command uses this for conditional flow control, as it can essentially switch between the two halves.
 Operators
Command	Description
+ 	Increase the value held by the current cell (the one the pointer points to) by 1
- 	Decrease the value held by the current cell by 1
> 	Move the pointer one cell to the right (increase the pointer)
< 	Move the pointer one cell to the left (decrease the pointer)
% 	Move execution forward by 1 character (instead of 2), if the current cell's value is 0
* 	Move execution back to the start of the file
. 	Print the current cell's value as an ASCII character
, 	Read a byte from stdin and put it into the current cell
== Notes ==
* This idea came to my mind when I was thinking about languages that have only one means of looping: going back to the start of the program. Probably the most famous example of this is Fractran. This kind of language needs some kind of state that carries through the boundary of resetting the instruction pointer. Also, they probably need some way to only go back to the start conditionally (actually, if I think about it, this is not necessary. But it seems like the most natural way to do flow control). I also liked the idea of only evaluating half of the commands (skipping one every time) and having a way to switch between these two. Now that I think about it, this was not really necessary for this language. I could've just added a conditional looping command that resets to the start if the current cell's value is 0. (Edit: That exists now: +.*) 3cxpy (talk)
== Examples ==
=== +-.%* ===
 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + . + + . + . - - - - - - - - - . + + + + + . - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - .
This prints +-.%* and a newline. (The spaces are necessary)
== Links ==
Example implementation
Category:Languages
Category:2024
Category:Implemented
Category:Turing complete
Category:Brainfuck derivatives
+.*

+.* is a Brainfuck derivative where the [ and ] commands are replaced with *, which moves execution back to the beginning of the program if the current cell's value is 0. It was created by User:3xcpy.
== Overview ==
 Instructions
Command	Description
> 	Move the tape head to the right (like in Brainfuck)
< 	Move the tape head to the left (like in Brainfuck)
+ 	Increment the value in the current cell by 1 (like in Brainfuck)
- 	Decrement the value in the current cell by 1 (like in Brainfuck)
* 	Move execution to the beginning of the program if the current cell's value is 0
. 	Print the current cell's value as an ASCII character (like in Brainfuck)
, 	Read a byte from stdin into the current cell (like in Brainfuck)
== Turing-completeness ==
+.* is Turing-complete, because Brainpocalypse can be compiled into it. +, <, and > can be compiled directly, and - can become *-.
== Notes ==
* I came up with this while making +-.%*, where I noticed that the * instruction could be used for flow control on its own, if it was conditional (kind of like Fractran). 3xcpy (talk)
* The title was originally meant to be a little program that would loop through all the ASCII codes and print them, over and over again. It later occurred to me that the program would not work like that because the * instruction is conditional. Oh well, now I have to live with the consequences of knowing I have made such a terrible mistake. 3xcpy (talk)
* This seems pretty fundamental and simple, so it is possible that somebody else has already made something like this. If so, please let me know on my discussion page or something. 3xcpy (talk)
Category:Languages Category:2024 Category:Brainfuck derivatives Category:Cell-based Category:Turing complete Category:Unimplemented Category:Low-level
+/-

+/- or IPD is a multi-threaded esoteric programming language created by User:.yazic in 2023 as an extension to +-.
= Syntax =
+/- consists of a single accumulator and a character string to handle input.
Command	Name 	Action
+ 	Increment 	Increments the accumulator.
- 	Decrement 	Decrements the accumulator.
[ 	Start loop	Jump past the matching ] if the accumulator is 0.
] 	End loop 	Jump back to the matching [ if the accumulator is non 0.
= 	Input 	If the string is empty await user input and put it into the string.
Pop the first character from the string and assign its value to the accumulator.
@ 	Echo 	Print the accumulator as ASCII character.
Broadcast the accumulator value.
/ 	Pipe 	Create a new instance of this program.
# 	Listen 	Listen for a broadcast then push its value to the end of the string.
note that the echo can come from any instance of any IPD program
All other characters are treated as comments and are ignored.
= Examples =
=== Cat ===
=[@=]
=== Fork bomb ===
//
Add more examples.
= Interpreters =
Add more interpreters.
Category:Languages
Category:2023
Category:Unimplemented
Category:Concurrent programming
+Output

+Output is exactly the same as -Output, however there is now an output command. Everything else is still the same, and all -Output programs are compatible with +Output. Read -Output for the basic idea.
The file extension is .poutput
== Implementation ==
In -Output, it was required the memory or codebox be shown at the end of execution or live update. In +Output, this is no longer required, as there is an output command and reading from the memory or source code is no longer a must.
== New instruction ==
op	Values popped	Description
o 	x 	Outputs x to the standard output.
That's it. There only needs to be one output command.
== Examples ==
=== Hello, world! ===
 "Hello, world!" o X
=== A + B problem & string concatenation ===
 i& i& + o X
Input numbers to add them, input strings to concatenate them, input different types to get an error.
=== Truth-machine ===
 in #v_0o X
 v1<
 >o^
=== Cat program ===
Loops until an empty string is provided.
 >i:#v_X
 ^ o <
=== Cat program 2 ===
This one is a one-time use.
 ioX
It's pretty simple.
=== Add or subtract ===
Type sub to subtract, anything else to add. Inputs are done in this order: num1, num2, operation (aka reverse Polish notation).
i&i&v
v <
>i"sub"=#v_+oX
 Xo+n<
=== Is greater than ===
Takes 2 inputs, and outputs whether the first is greater or less than the second. Inputting strings will use their length, so this doubles as a length comparator.
i&i&`#v_"Is less than or equal to"v
 >"Is greater than"oX Xo<
=== Number or string checker ===
Takes an input, and outputs whether it's a string or a number.
i&t#v_"Number">oX
 >"String" ^
=== Hi interpreter ===
 il"hi"*oX
=== Print a 10x10 grid of asterisks ===
 a"*"a*oaUo1n+:!#X_#
This is my code-golfed version. Check +Output#External resources
=== Reverse Polish Notation calculator ===
i" ".0r01j
>:!#v_&:t#v_m01j >~)+(01j>~)n+(01j>~)*(01j>~)/(
 >)oX >:"+"=#^_:"-"=#^_ :"*"=#^_:"/"=~^
Enter input as one string to be evaluated, like 3 5 + 6 2 - * 2 / and the program will print the answer.
=== Fixed Repeating Output ===
 i&"1"*o"0"oX
A nice one-liner. Input a number.
== Python implementation ==
I finally got around to making an interpreter for this language. It may be bad, but I don't care. It works.
== External resources ==
* Python implementation
* Code-golf stack exchange 10x10 grid of asterisk +Output answer
Category:Stack-based Category:Languages Category:Implemented