nyuuzyou/wikis huggingface dataset:
(1) Grace sent you a message

(1) Grace sent you a message is a Turing-complete brainfuck derivative which is based on linear bounded automata.
== Overview ==
Input is an ASCII string and the output is a single bit.
Source code consists of two identical structures. Each structure starts with two positive numbers and then a brainfuck program follows. For example:
 2 3
 ,[+.,]
 
 11 5
 >+<-[.[-.],]
Each of the two structures represents a linear bounded automaton. Let the first number be x and the second be y, the memory size of the brainfuck program in that structure is equal to x+yn, where n is the size of the input (not the actual input, but internal input, it is explained in the next paragraph).
There is an internal state, which is an ASCII string. The internal state in initially empty (zero-length string). First, interpreter picks one of the two brainfuck programs and executes it, providing the internal state as its input. When (if) the brainfuck program halts, the output of that program is the new internal state. The interpreter then picks the same or the other program, executes it with the current state and sets its output as the new state.
If there is a sequence that leads to the actual user input (internal state becomes the user input), then interpreter outputs 1 and halts. If there is no such sequence, interpreter either does not halt, or outputs 0 and halts.
== Computational class ==
A TM can be encoded as a string (states, current state, memory, data pointer). LBA can simulate a single TM step. Therefore, iteratively applying an LBA to a TM state can simulate its computation. Since a TM can determine whether an LBA halts, we can write a Grace program that takes a TM and expected output as the input (we encode it somehow) and prints 1 iff the TM halts producing the expected output, prints 0 iff the TM halts producing some other output and loops forever iff the TM does not halt.
== Interpreters ==
Unimplemented.
Category:Languages
Category:Turing_complete
Category:Brainfuck_derivatives
Category:Unimplemented
Category:2020
(?!)

(?!) constitutes a programming language invented by the user User:MadMax which operates on an accumulator or register of a scalar non-negative integer capacity, the sole effective purpose of the same amounts to the output of characters.
==Commands==
3 Simple Commands:
Command 	Effect
? 	Increment the accumulator by one.
! 	Output the character whose ASCII code corresponds to the accumulator value.
(commands)	Loop to multiply numbers. Homologated commands include ? and loop nestings.
(!) 	Reset the accumulator to its default state of zero.
==Syntax==
The following Extended Backus-Naur Form (ENBF) treatise shall administer further formality to the syntactical exposition:
 program := { command , whitespaces } ;
 command := incrementCommand | outputCommand | loopCommand | resetCommand ;
 loopCommand := "(" , loopBody , ")" ;
 loopBody := { incrementCommand | loopCommand } ;
 incrementCommand := "?" ;
 outputCommand := "!" ;
 resetCommand := "(!)" ;
 whitespaces := { whitespace } ;
 whitespace := " " | "\t" | "\n" ;
==Examples==
===HELLO WORLD!===
This program displays the message “HELLO WORLD!”:
 ???????(??????????)??!(!) ?????????????(?????)????!(!) ???????????????(?????)?!(!) ???????????????(?????)?!(!) ???????????????(?????)????!(!) ??????????(???)??!(!) ?????????????????(?????)??!(!) ???????????????(?????)????!(!) ??????????(????????)??!(!) ???????????????(?????)?!(!) ?????????????(?????)???!(!) ??????????(???)???!(!)
==Interpreter==
* Common Lisp implementation of the (?!) programming language.
Category:Languages
Category:2019
Category:Output only
Category:Implemented
(Macro\\c)

(macro\\c) is a language where everything is a macro.
==Syntax==
(macroname\argument1\arg2\...\argx\code)defines a macro, code part can contain balanced parens.
When macronman is encounterd, code is executed, [arg] access an arfunemt.
There's a stack which stores strings. when a macro with args are executed, appropriate numbers of args are popped, LAST ARGUMENT IS POPPED FIRST.
anything that's not a macro name or$...$ push them ob the stack. (12$12$ pushes 1, 2, 12 ibnto the stack)
e.g.ab(1\a\b\[a](2\[b]))122 does push a, then define a macro called 2 which pushes b, then push b twice.
: output the TOS, ; inputs a character and push.
==Examples==
===duplicate the TOS===
 (d\x\$[x]$$[x]$)
===eval the TOS===
 (e\x\[x])
===Hello, World!===
 !dlroW ,olleH:::::::::::::
===cat===
 (c\;:c)c
===Truth-machine===
 (e\x\[x])(0\$0$:)(1\$1$:1);e
Category:2024Category:Unknown computational classCategory:Unimplemented
(P™TM™)™

(P™TM™)™ or (PowerPoint™ Turing Machine™)™ is an esoteric programming language created by Tom Wildenhain, which runs completely in Microsoft PowerPoint. It uses punch cards for the programming and requires manual clicking of the mouse to step trough the program. It is basically infinitely expandable, and seems to be fully Turing-complete, as it can basically be run as binary, and could support every program that can be created on a traditional binary computer. Expanding the interpreter can be hard, as it requires expanding every aspect of the punch card, which run over a tape, which can also be expanded infinitely. 
==Trademarks==
* Microsoft PowerPoint™ is a trademark of Microsoft Corporation.
* Turing Machine™ is a trademark of Alan Turing.
* (P™TM™)™ and (PowerPoint™ Turing Machine™)™ are trademarks of Tom Wildenhain. 
==External resources==
* Tom Wildenhains presentation on (P™TM™)™
* Tom Wildenhains expandable (P™TM™)™ interpreter (.PPTX)
Category:Languages Category:Implemented Category:Turing complete
(WHATEVER WE NAME IT)

(WHATEVER WE NAME IT) is an esoteric programming language where the commands are just names of other esolangs
== commands ==
this is just a merge of brainfuck and befunge (multiple cells and stacks, multiple stacks)
 brainfuck move 1 stack
 befunge move -1 stack
 thue print top of stack as tanscii
 slashalash or /// pop top
 HQ9+ add/multiply/swap/rotate3c top 2 of stack
 deadfish subtract/divide/modulo/rotate3cc top 2 of stack b-a b/a
 pbrain rotate operation wheel right
 cbrain rotate operatio wheel left
 piet input
 poetic [
 shakespeare ]
 brainfork duplicate top
 n bits, n bytes befunge n except it works with multidigit
 FALSE add 0 to top of stack (n bits, n bytes doesnt work on 0)
 (WHATEVER WE NAME IT) terminate program
== computational class ==
turingcomplete
if it isnt, here are some extra names
 chef
 ook!
 FALSE
 SMETANA
 malbolge
 ALPACA
 viktor's amazing 4-bit processor
Category:Languages Category:2024 Category:Unimplemented Category:Stack-based Category:Turing complete
( )

[ ] (pronounced praces or /pʰreɪsəs/) is a very simple and very stupid esolang made by User:Yayimhere
== how it works ==
[] will swap the chars in and outside the braces.(so [A]B become [B]A. if there is a space before the braces it will append whats in the braces to whats outside the braces(so [A]B becomes [A]AB). if there is a space before and after some braces it will create whats called a link. it will link with the nearest other pair of brackets. what linking does is that everything that happens to one of the braces happens to the other as well. if there is a symbol to the left and right of the braces it will link with nearest braces with spaces around them. it will then replace every instances of whats in the braces surrounded by symbols with whats in the the braces with spaces around them. linked braces with $ inside will print the contents of what its linked to and a newline. the program halts when it cant apply any more rules. the rules are applied from left to right. $ is applied every time the rules are applied but it does not itself count as a rule. chained linking is allowed and linking between elements on different lines will not happen
== examples ==
hello, world!:
 [$] [hello world] 
Looping counter:
 [$] [ [*]*] 
or
 A[*)]A [* ] 
 [$] [*)] 
 A[* ]A [**)] 
the first one has a [*] at the start but is shorter. the second one does not
ALL SPACES ARE MANDATORY
Category:Languages
Category:String-rewriting paradigm
Category:Object-oriented paradigm
Category:Pattern-based
Category:Low-level
Category:Self-modifying
Category:Imperative paradigm
Category:Output only
Category:Unimplemented
(a)

(a) is an esoteric number system, loosely based off of roman numerals.
== How it works ==
The character "a" represents one.
Brackets like this "()" take the power of two of whatevers in it. "(a)", this numbering systems title, means two.
The subtraction system works kinda like roman numerals.
Also, numbers look like they are screaming. So that's something.
== Numbers 1-20 ==
 a
 aa
 aaa
 aaaa
 aaaaa
 aaaaaa
 a(aaa)
 (aaa)
 (aaa)a
 (aaa)aa
 (aaa)aaa
 (aaa)aaaa
 aaa(aaaa)
 aa(aaaa)
 a(aaaa)
 (aaaa)
 (aaaa)a
 (aaaa)aa
 (aaaa)aaa
 (aaaa)aaaa
== Allergic variant ==
The character "b" means the same thing as a, but the program is allergic to these sequences:
 aa
 bab
 bbb
 bba
 b)a
 b)b
 a)a
The character "c" means the same thing as a, but can only be used like this:
 bbcb
If the program runs into any of these allergic sequences, it "gets sick" and the program outputs "Very high fever. Cannot go to work today"
Enjoy suffering trying to make things in this one.
=== Numbers 1-10 in allergic variant ===
 a
 ab
 aba
 bbcb
 bbcba
 abbcba
 a(aba)
 (aba)
 (aba)a
 (aba)ab
(ch34t) c0d3

(ch34t) c0d3 is an esolang created by User:Yayimhere. its 2d and has only 4 commands. kinda? well see concept. the commands are:
 >v
 ^<
which are code pointer arrows which changes its direction. its starts going left in lower right corner. memory is a stack holding unbounded strings. spaces are NOP's. the program extends infenitily to the right and up
== concept ==
the concept was that a sequence commands are the actual commands
== commands ==
they all have length 7. we dont care about NOP's. ? denotes that it can be anything. if a pop is applied with no element to pop program gives an error
sequence of arrows	what it does
^x>>?< 	push x(single command) to stack
^^^>^^> 	pop the two top values of stack and append the first popped to second popped and push result
>v<^^<< 	push a newline
^^?>v<^ 	pop top of stack and insert it at command pointer, with the middle of that string in both 2d directions and skip the code pointer out of the strings border in pointer direction
^^^^>v? 	pop top of stack
??^^>xv 	the same as >v<^^<< ^^^>^^> ^^^>^^> ^x>>?< ^x>>?< ^^^>^^>
everything is a NOP. so now normal arrows can be done, where x is where it enters:
 > :
 x
 x>>>>>>>
 x
 < : 
 x
 <<<<<<<x 
 x
 ^ :
 ^
 ^
 ^
 ^
 ^
 ^
 ^
 x^x
 x
 v :
 x
 xvx
 v
 v
 v
 v
 v
 v
==Computational class==
If change the structure of the program so that stack would not be empty while pop command is executed, the language is clearly Turing-complete, as the language is extension of Nopfunge Solid, with exception that program is infinite in the in the up, but not down, we can (probably) also use stack elements as registers. also if you make spaces be 7*7 of spaces, and arrows be the equals given above inserted into these 7*7 spaces its just normal arrows
Category:Languages Category:2024 Category:Unimplemented Category:Two-dimensional languages Category:Stack-based Category:Turing complete
(script())

(script()) is a esolang created by User:Ractangle. This language based on JavaScript
== Commands ==
Command 	Meaning
break 	Terminates the loop.
throw [any type] 	Puts the following string into a stack.
!case! if [condition]:/orif/isn't	Condition commands.
try 	Used for the loop command.
catch 	Outputs the highest string in the stack.
let <type> [name] {[value]} 	Creates/Edits a variable.
func is [name]{args}(...) 	Makes a function.
loop [condition](...) 	Makes a loop of a code. It repeats until the condition is true.
prompt 	Makes a prompt, the input is then pushed into the stack.
== Examples ==
=== Hello World ===
throw 'Hello World'
catch
=== Truth-machine ===
<pre class="rectwrap">
let int i {prompt}
case if {i=0}(throw '0'|catch)
case isn't (loop 1 (throw '1'|catch))
Category:LanguagesCategory:2024Category:Stack-based
)

) is an esoteric programming language made by User:AmNow.
== Commands ==
 )|<functions>) - Declare a new class, named the next character after the ). The rest should be functions. There are 2 classes named # and ⫵, which can’t be
 modified. They are used for storing integers and strings respectively.
 ]|args|body]- Declare a new function, named the next character after the ] ⩤ is the main function.
 }condition|body{ - Makes a while loop.
 “condition|body’ - Makes an if statement.
 _condition^true-body^false-body_ - Makes an if-else statement.
 [var]:<class|args> - Declares/Changes a variable to class with args(if necessary)
 €[var]€ - References Variable.
 »<Val/Var>,<Operator>,<Val/Var>« - Does math.
 O’<Val/var>’ - Output.
 I’[var]’ - Input into var. 
 ~ - Comment
 §’<Val>’ Return.
 @‘<function>\<args>’ Calls function with args.
== Programs ==
=== Truth Machine ===
 ]⩤|| ~ Starts main function.
 i:<#|0> ~ Sets variable i to 0.
 I’€i€’ ~ Inputs variable i
 }»1,==,€i€| ~ Starts while loop
 O’1’ ~ Output 1.
 { ~ End while loop
 O’0’ ~ Output 0.
 §’0’
 ]
=== Factorial ===
 ]!|a|
 “»€a€,==,0«|§’1’’
 §’@‘!\»€a€,-,1«’’
 ]
Category:Languages Category:Unimplemented
):

): is Notf but it can modify its own interpreter.
== changes ==
there a single new command: (symbol;body). what this does is it makes symbol a command. what this command that has created does, is that it will execute the code body
== computational class ==
): is turing complete since it can simulate a Bitwise Cyclic Tag:
 (0;:2:\1e1e1+\1)
 (2;:2:\1e1|e+\1)
 (>;:2:e3^0)
 (<;:2:e3^2)
 (v;?2)
 D
 E
 >>7
this makes these commands:
 ): | BCT
 > <-> 10
 < <-> 11
 v <-> 0
you need to replace the E with the ): BCT code and the D with the datastring(replace each one in the datastring with 2). so the Collatz sequence program is:
 (0;:2:\1e1e1+\1)
 (2;:2:\1e1|e+\1)
 (>;:2:e3^0)
 (<;:2:e3^2)
 (v;?2)
 200
 ><>>><v<>>v<>><>><>>vvvv
 >>72
the number of times 200 is repeated is the collatz input
== see also ==
* Not
* Notf
Category:Languages Category:Functional paradigm Category:Stack-based Category:Turing complete Category:Low-level
*

* is a very simple esoteric programming language, where the only commands consist of *, space, and + (if you can even count that one).
* * prints "Hello World".
* [SPACE]*[SPACE] ([SPACE] is the space character) prints a random number between 0 and 1 multiplied by an extremely big number. (In the Java interpreter, it's the biggest number possible in Java, 2,147,483,647.)
* *+* runs forever.
== Examples ==
=== Hello World ===
 *
=== Random Number Generator between 0 and 2,147,483,647 ===
 [Space]*[Space]
=== Infinite loop ===
 *+*
== Interpreters ==
=== Java ===
 import java.util.Scanner;
 
 public class Asterisk{
 
 public static void main(String[] args){
 
 Scanner in = new Scanner(System.in);
 System.out.println();
 String ast = in.nextLine();
 
 if(ast == "*") System.out.println("Hello World");
 else if(ast == " * ") System.out.println(Math.random() * Integer.MAX_VALUE);
 else if(ast == "*+*") recur();
 }
 public static void recur(){ recur(); }
 }
=== JavaScript ===
 var code=prompt();
 code === "*"?console.log("Hello World");
 code === " * "?console.log(Math.random() * Number.MAX_VALUE);
 code === "*+*"?while(true){}
User:Nomad was here. I made an improved version for browser:
const code = prompt();
while (code === '*+*' ? 1 : console.log(code === '*' ? "Hello World" : code === ' * ' ? Math.random() * Number.MAX_VALUE : ) || 0) {};
=== JavaScript (Node.js) ===
User:Nomad was here. I made a one-liner for Node.js:
// Save in a file, and call with 'node <filename> '
while (process.argv[2] === '*+*' ? 1 : console.log(process.argv[2] === '*' ? "Hello World" : process.argv[2] === ' * ' ? Math.random() * Number.MAX_VALUE : ) || 0) {};
=== Python 3 ===
 from random import random
 def ast():
 while True:
 cmd = input('*> ')
 if cmd == '*': print('Hello World')
 elif cmd == ' * ': print(random() * 2147483647)
 elif cmd == '*+*':
 while True: pass
=== C++ ===
~User:Earthrulerr GitHub Repo
// Author == earthrulerr
// A C++ implementation of *.
#include <iostream>
#include <string>
using namespace std;
int main() {
 string input;
 int loop2 = 0;
 int loop = 1;
 int random = rand();
 while (loop == 1) {
 getline(cin, input);
 if (input == "*") {
 cout << "Hello World";
 } else if (input == " * ") {
 cout << random;
 } else if (input == "*+*") {
 loop2 = 1;
 while (loop2 == 1) {}
 }
 }
} 
Category:Languages
Category:Implemented
Category:Unusable for programming
Category:Output only
Category:Finite state automata
Category:2015
***

*** (pronounced "Asterisks") is a language created by VCFever on October 31, 2014
==Example==
P*hello world*
P**bottles of beer on the wall * P***bottles of beer on the wall
~This is a comment
~The amount of asterisks leads to the amount of beer
~P prints things
~Asterisks also represent an "and"
An underscore represents a "print this and".
P**_Blah
Category:Languages Category:2014
*W

*W is an esoteric programming language created by John Colagioia.
==Programming in *W==
It has seven data primitive data types, intended to cover every expected necessity, and many unexpected ones.
*hole: A data type with only a single possible value, which may be used in place of a value of any other type.
*bits: An arbitrary-length bitstring.
*cplx: A complex number, i.e. the sum of a real part and an imaginary part. Takes the form (X + Yj), where X and Y are integers and j multiplied by j is -1. X and Y have an implementation defined range, with a minimum of {-32768 ... 32767}.
*sack: A mutable collection of elements with operations such as packing, unpacking, and checking with other data.
*dref: A pointer, or similar reference to a value of any data type.
*name: A name given to another value.
*chrs: A character string with an arbitrarily length.
Each program is split into sections, beginning with declarations of functions a.k.a. "Functions", then data type declarations a.k.a. "Stuff", then a sequence of statements a.k.a. "Text".
==External resources==
*Specification
Category:Languages
Category:Unknown year
Category:Unknown computational class
*bfuck

*bfuck is an esolang by User:ChuckEsoteric08 based on brainfuck
==Commands==
The tape has infinite amount of nonnegative unbounded integers
 +-,.[]
Are the same, <> are removed and there is additional command
 |
Which toggles between two states: in one of them commands function on the first cell, which is default one; and second one, in which the cell which is the cell which first cell points to, so if first cell value is 0 it will modify the first cell, if it is 1 it will modify second cell and ect.
==Examples==
Set second and third cells to 2 and 4, respectively, add them and store result in second cell
 +|++|+|++++[-|-|+|+|]
==Converting brainfuck to *bfuck==
 BF = *F
 Programm start = +
 + = |+|
 - = |-|
 > = +
 < = -
 [ = |[|
 ] = |]|
Category:Languages Category:Brainfuck derivatives Category:Turing complete Category:Turing tarpits Category:Cell-based
*python

*python (or it's python) is an esolang created by User:Ractangle where it's syntax is python but with major changes.
==Syntax==
Arguments:
Variable creation:
Function definition:
 :func func_name [arg1]|[arg2];
 *Commands here
 :end;
Conditional:
 :check a is 8;
 [Yes?]|[*Commands here]
 [No?]|[*Commands here]
Function call: or 
C's printf command... kinda:
Goto statement:
===Errors===
If you try to run a non existent function:
 Syntax not obeyed:funct doesn't exist
If the program doesn't end (A.K.A. EOF Error)
 File end:EOF reached
==Examples==
===Hello, world!===
 form[print[string[Hello, world\n]]];#H
===Truth-machine===
 :i,form[input[]];
 :func o;
 form[number[1]];#o
 :end;
 :check i is 0;
 [Yes?]|[form[number[0]];#H]
 [No?]|[#o]
===Cat program===
 :i,form[input[]];
 form[print[i]];#H
Category:Languages Category:High-level
Category:Turing complete
+

+ is HQ9+ with two differences: there are no "H", "Q", or "9" instructions, and all characters that are not + are explicitly ignored.
==Instructions==
Unlike some languages, + is relatively simple to learn, even for non-programmers. It has only one instruction, +, which increments the program's accumulator. All others are ignored.
==Examples==
Increment the accumulator once:
 +
Increment it five times:
 +++++
Wow, what a useful language!
==Computational class==
+ is a push-down automaton, as the + instruction simulates pushing to a stack. The initial state can also be a halt state, and the only state, and a + instruction can loop back to the initial/halt/only state, pushing a value to the stack as it does so.
==Interpreters==
===Perl===
60 bytes
 my$r=$ARGV[0];open my$z,'<',$r or die$!;my$c=()=<$z>=~/\+/g;
===XENBLN===
17 bytes, 12 characters
 $a0ŽIÍ=x„+äa
===Lua===
Reads program from given file name.
local args = {...}
local file = io.open(args[1],"r")
local counter = 0
while true do
	local nLine = file:lines()()
	if not nLine then
		break
	end
	if string.find(nLine,"+") then
		local _, count = string.gsub(nLine,"+","+")
		counter = counter + count
	end
end
file:close()
Shorter, less… stupid. Reads program from input.
local counter = 0
repeat
	local c = io.read(1)
	if c == '+' then counter = counter + 1 end
until not c
Even shorter. Requires input to terminate before execution starts. Entire program is stored in memory, so beware long programs.
local counter = #io.read("*a"):gsub("[^%+]","")
=== ><> ===
Reads code from input
>i:01-=?v00.
v &0r+1<
>:"+"=?!v&1v
^ ~;!?:<&+<
A second version
0&01.
>i:0(?;"+"=?v
^ &+1&<
=== Python 3 ===
 a = 0
 c = input()
 for char in c:
 a += 1 if char == "+" else 0
The one-liner:
 (a:=0,[a:=a+(_=='+')for _ in input()])
Shorter:
 input().count("+")
=== C++ ===
#include<bits/stdc++.h>
using namespace std;
int main()
{
	int i = 0;
	string s;
	getline(cin, s);
	for(int pstf = 0; pstf < s.length(); pstf++)
	{
		if(s[pstf] == '+') i++;
	}
	cout << i;
	return 0;
}
Category:Languages
Category:Joke languages
Category:Unusable for programming
Category:2016
Category:Total
Category:Implemented
Category:No IO
+!

+! (pronounced "Plus-bang") is a two-dimensional esoteric programming language by User:Fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff in 2024.
== Control flow ==
When an IP is created, it is given an ID, where the smaller IDs run first. When an IP hits the edge, it is destroyed. The program halts when all of the IPs are deleted.
The instruction pointer starts out at the top left corner with an ID of 0, facing right.
== Commands ==
Instruction	Name 	Description
+ 	Expand 	First, copy the program in a square shape. Then, split the current IP into two, with the clone turning 90 degrees. Finally turn this instruction into an !. The newly generated IP does not run any code this cycle.
! 	Signal 	Make every IP that is on the same X or Y coordinates face the same direction the current IP is facing. Then turn 90 degrees and replace this instruction with a +.
# 	Comment	Any line that starts with a # is removed, allowing for comments to exist. If the program encounters a #, nothing happens.
All instructions not mentioned above are no-ops.
== Input and output ==
+! doesn't have I/O functionality, but extensions can be used to introduce I/O.
 I/O Extensions
Instruction	Name 	Description
0~9 	Print Digit	Print the corresponding digit.
N 	Newline 	Print a newline.
? 	Interpret 	Input a character, then run it.
% 	Input 	Input an arrow/mirror and point in that direction.
C 	Clear 	Clear all the output. (An implementation is not required to introduce this command)
== Examples of commands ==
=== The + command ===
Let's say the program is
 +!
 !+
where the IP is at the bold, the program becomes
 !!+!
 !+!+
 +!+!
 !+!+
=== The ! command ===
Let's say the program is this (V) where the first IP is facing right and the other is facing down
 ! !+
 ++ !
The first IP points down and the other points right.
Category:Concurrent programming
Category:Unknown computational class
Category:Usability unknown
Category:Two-dimensional languages
Category:2024
Category:Languages
Category:Unimplemented
Category:Self-modifying