nyuuzyou/wikis huggingface dataset:
Byte Syze

Byte Syze is a very simple programming language devised by User:Smjg. Source code takes the form of a binary file.
In it, every instruction, value or memory address is a byte in syze. Moreover, there is no distinction between code space and data space.
The 256-byte memory space is initialised to the program code; if the program is shorter than 256 bytes then the remainder of the memory space is initialised to zero. A program may not be longer than 256 bytes.
There are also four registers: data register (DR), address register (AR), instruction register (IR) (program counter) and switch register (SR), also each a single byte and initialised to zero.
Execution consists of repeatedly reading the byte pointed to by the IR, incrementing the IR, and then executing the read instruction, until byte 255 is read as an instruction and executed.
== Instructions ==
Instruction(ASCII)	Mnemonicname	Description
< 	Load 	Copies the value at the memory address indexed by AR into DR.
> 	Store 	Copies the value from DR into the memory address indexed by AR.
* 	Point 	Swaps the values contained in DR and AR.
! 	Jump 	Swaps the values contained in AR and IR.
\ 	Switch 	Swaps the values contained in DR and SR.
+ 	Add 	Adds together the value in DR and the value at the memory address indexed by AR. Stores the result in DR.
- 	Subtract 	Subtracts the value at the memory address indexed by AR from the value in DR. Stores the result in DR.
( 	Input 	Receives a byte from the standard input and stores it in DR. If EOF of the standard input is reached, DR will receive the value 0.
) 	Output 	Writes the byte stored in DR to the standard output.
? 	Conditional 	If the value contained in DR is 0, increments IR by 1.
anything else 	Nop 	
== Computational class ==
The memory model restricts the number of possible program states to no more than 22080 (the actual number is probably much less than this). As such, Byte Syze cannot be Turing complete. At best, it is a finite-state automaton.
== External link ==
* The Byte Syze Programming Language
Category:Languages
Category:Cell-based
Category:Finite state automata
Category:Non-textual
Category:Low-level
Category:Self-modifying
Category:2007
Category:Implemented
Byter

Byter is a language for training brains. Byter consists of 11 instructions that are intended to move the instruction pointer on a 16 × 16 matrix and for outputting the characters which are associated with each cell. On an output operation the ascii character associated with the specific cell is printed out. The correct ascii value is determined by the position of the cell: It starts with zero in the top left corner of the matrix, and is increased from left to right. So the first two lines for example of the playfield have the following values associated with the cells:
 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 ...
Here is the playfield with all it's associated ASCII characters ('.' when not printable or codepage dependent):
 ................
 ................
 !"#$%&'()*+,-./
 0123456789:;<=>?
 @ABCDEFGHIJKLMNO
 PQRSTUVWXYZ[\]^_
 `abcdefghijkmlno
 pqrstuvwxyz{|}~.
 ................
 ................
 ................
 ................
 ................
 ................
 ................
 ................
The trick is now to direct the instruction pointer to the wanted cell and print it out.
The main difficulty of the language is that the field is limited. This could make it impossible to find the same character twice, such as in the word "papa", so a cell containing the operators >, <, A, V is written an operator pointing in the opposite direction when executed. This allows write algorithms with branching. But it is also is a hidden problem, so you need to be carefully.
Byter has the following operators:
* 0 - move to the previous cell
* < - move the pointer left and fill the cell with operator >
* > - move the pointer to the right and fill the cell with operator <
* V - move the pointer down and fill the cell with operator A
* A - move the pointer up and fill the cell with operator V
* { - display the symbol of the cell and move left
* } - display the symbol of the cell and move right
* + - display the symbol of the cell and move upwards
* - - display the symbol of the cell and move down
* $ - display the symbol of the cell and move to the cell 0:0
* # - exit
==Hello, world!==
This program prints the words Hello, world!:
 >>>>>>>>>V00V00V
 0#00A00V<V00V0VV
 -+>>A00VV<<0$0V>
 V0AA<00V>V<<<<V0
 >>V0V<<<-<000V<0
 0AV0VV<<<0000V<0
 0A>V+}>>>>>>}<V-
 0A{>>>>-000000>V
 00A0000>>>>>>>>A
 V0A<<<<<<<<<<<<>
 V000000000000000
 V000000000000000
 V000000000000000
 V000000000000000
 V000000000000000
 >>>>>>>>>>>>V000
==External resources==
* Byter HOWTO (russian)
* Vim syntax highlight for Byter
* esco - universal interpreter of esoteric languages
* ByterIDE - special IDE and compiler for Byter
Category:Joke languages
Category:Unusable for programming
Category:Languages
Category:Output only
Category:Implemented
Category:High-level
B̶r̶a̶i̶n̶fuck

Brainfuck is a pretty good esolang, but you can't use it without a brain. This is a bad esolang, but you don't need a brain to use it.
==Introduction==
This is an esolang designed by User:None1, for unbrained people and non-humans, but people with brains can still use it quite easily.
==Execution==
This esolang has only one command, which is the increment command +.There is also only one 8 bit cell.
When the program runs, it runs all the + commands (other characters are ignored), and prints the resulting cell value as ASCII.
==Example Programs==
===Print A===
 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
==Interpreters==
Note that the Python interpreter outputs an extra line feed, if you don't want that, you can add ,end="" before the last ).
===C===
#include<stdio.h>
int main(){
 char c,x=0;
 . while((c=getchar())!=EOF){
 if(c=='+') ++x;
 }
 putchar(x);
 return 0;
}
===Python===
 print(chr(__import__("sys").stdin.read().count("+")%256))
===brainfuck===
 >>>>>>>>>>>>>>>,>[-]>[-]+++++++++++++++++++++++++++++++++<<----------[<[-]<[-]>>[<<+>>-]+>>[<<<<->+>>>-]<<<[>>>+<<<-]<[>>-<<[-]]>[-]<[-]>>[<+<+>>-]<[>+<-]<[>>>+<<<[-]]>>,----------]>.
The program is generated using BFFuck, which is a brainfuck code generator.
A much shorter one:
 >,[<++++++[->-------<]>-[->[-]+<]>[->-<]>+<<,]>>.
Inteprets the whole program.
===><>===
>i:01-=?v00.
v &0 r+1<
>:"+"=?!v&v
 ;o&v?:< 1
^ ~< &+<
A more optimized version:
 0&01. >&n; >&1+&01.
 >i:0(?^:"+"=?^
==See also==
* +
* brainfuck
* brainfuck
* B-H
Category:Languages
Category:Output only
Category:Unusable for programming
Category:Total
Category:Brainfuck derivatives
B̶r̶a̶i̶n̶f̶u̶c̶k̶

brainfuck, brainfuck are pretty good esolangs, and so is brainfuck. But you can't use any of them without fingers. Although this is a weird esolang, anything can use it.
==Introduction==
This esolang is created by User:None1, for people who do not have fingers and non-humans, but people with fingers can still use it quite easily.
Because it has to be usable without fingers, the esolang is out of the topic "brainfuck", and it is NOT derived from brainfuck.
==Usage==
To use this language, you don't need a brain, or a hippocampus, or a finger, you don't even have to be alive! All you need is nothing.
==Syntax==
There is no syntax, any program is valid and always prints out "Hello World!" (without quotes, with or without exclamation mark). This helps you print "Hello World!" without doing anything.
==Example Programs==
===Hello World!===
===Quine===
 Hello World!
It is certain that the quine can only be run by people with fingers, but can be printed by anything.
==Implementations==
There are already tons of implementations in the Esolang wiki itself, known as the Hello World programs. But if you want, here is a Python interpreter:
 print("Hello World!")
and an even shorter Python interpreter:
 import __hello__
and a C interpreter:
#include<stdio.h>
int main(){
 puts("Hello World!");
 return 0;
}
and infinite number of self interpreters (because any program is one), one of them is:
==See also==
* brainfuck
* brainfuck
* brainfuck
* Nope.
* Hello, golf!, the exact same thing.
Category:Languages
Category:Joke languages
Category:Unusable for programming
Category:Output only
Category:Total
Category:2023
Category:Implemented
Category:Nope. derivatives
Category:No-code esolang
C

C, while not always a serious language, is far from an esoteric one. It was created by Dennis Ritchie in 1972 and is a derivative of B. As a fast, old and compiled language, C is often used to implement esolangs. For example, bffsree, the fastest known non-JIT brainfuck interpreter, is written in C.
==See also==
* C++
* B sharp
* A Triple Sharp
Category:Before 1993 Category:Implemented Category:Turing complete Category:Flat-nested Category:Languages Category:High-level
C+

C+ is C++ but all functions are subtracted by 1 character and all numbers are subtracted by one. (It means, iostream is iostrea, 0 is -1.)
(Note: Characters that are changed still perform the same function.)
Specific character changes from C++:
 # is {
 > is ;
 ; is >
 < is =
 = is ~
 { is |
 } is ?
 " is ^^
These changes make it hard to program for people who know (very hard)C, C#, (very hard2) C++, C+-, C+=, C<x<C, C64, and C--.
Additionally, all C+ programs have to be 1 continuous line, or the program will fail, and must contain the declarative statement
 THATSCPLUSCODENONOTCPLUSPLUS
However, comments are completely exempt from this rule and can be placed anywhere.
Whitespace must be notated with ;;;whitespace;;;.
The file extension for C+ is .cpl.
==Examples==
===Hello, World!===
 THATSCPLUSCODENONOTCPLUSPLUSCPLUS{includ =iostrea; usin namespac st> in mai()|cou == ^^Hello World!^^ == en>retur -1>?
 @&&@This is a comment in C+
 ;;;whitespace;;;
 ;;;whitespace;;;
 @&&@
 This is an amazing
 multi line comment
 in C+
 @&&@
==History==
C+ was created by a programmer with ≈6.5 hours of sleep in a fit of nonconformity.
Category:Languages Category:Unimplemented Category:2015 Category:Joke languages
C++

C++, while not always a serious language, is far from an esoteric one. It was created by Bjarne Stroustrup in 1979 as an extension of C. It is object-oriented and typically compiled. It's often used to implement esolangs.
==See also==
* Wikipedia:C++
* C
* C%46UCK
Category:Before 1993Category:ImplementedCategory:Object-oriented paradigmCategory:Turing complete
Category:Flat-nested
Category:Languages Category:High-level
C+++

C+++ is basically C++ but with less abbreviations & it has new syntax added to make things slightly easier.
== Hello World ==
C++:
 int main()
 {
 printf("Hello, world!\n");
 return 0;
 }
C+++:
 integer new main()
 {
 println.format("Hello, world!");
 return 0;
 }
== Syntax Examples ==
In the hello world example, the 'int' is un-abbreviated, 'new' tells the C+++ that there is a new something, 'main' initiates a new main
Category:Languages
C++++

C++++ is more update from C++.
In C++++, you will have more possibility to program.
== Changes ==
The int will be a integer type has a range from -∞ to +∞.
Original int replaced by medium. 
Similarly, float will be a float type has a range from -∞ to +∞, original float replaced by single.
Although you are using a 32-bit compiler, it also supports __int128.
There is also a keyword combination to show __int128, it is long long long.
And char can be written as short short.
== Programs ==
=== Hello, world ===
 #include<stdc++++.h>
 using namespace std;
 int func main()
 {
 print("Hello, world!");
 return 0;
 }
=== A+B Problem ===
 #include<stdc++++.h>
 using namespace std;
 int var a, b, c;
 int func main()
 {
 input.format("%d%d", &a, &b);
 c=a+b;
 print.format("%d", c);
 return 0;
 }
=== 99 bottles of beers ===
 #include<stdc++++.h>
 using namespace std;
 c_string var unit="bottles";
 int func main()
 {
 for(medium var i=99;i>0;i--)
 {
 if(i==1)
 {
 unit="bottle";
 }
 else
 {
 unit="bottles";
 }
 print.format("%d %s of beer on the wall, %d %s of beer.\n", i, unit, i, unit);
 print.format("Take one down, pass it around, \n%d %s of beer on the wall.\n", i-1, unit);
 wait(1000);
 }
 print("No more bottles of beer on the wall, \nno more bottles of beer.\n");
 print("Go to the store and buy some more, 99 bottles of beer on the wall.");
 return 0;
 }
=== Bubble sort ===
#include<stdc++++.h>
using namespace std;
int list arr[]={};
void func bubble(int list nums[], int var n)
{
	for(int i=1;i<n;i++)
	{
		for(int j=0;j<n-i;j++)
		{
			if(nums[j]>nums[j+1])
			{
				swap(nums[j], nums[j+1]);
			}
		}
	}
	for(int i=0;i<n;i++)
	{
		printf("%d ", nums[i]);
	}
}
int main()
{
	int n;
	cin>>n;
	for(int i=0;i<n;i++)
	{
		cin>>arr[i];
	}
	bubble(arr, n);
	return 0;
}
Category:Languages Category:High-level Category:Unimplemented
C-

C- is a joke language created by John Unger Zussman, and is one of the lesser known programming languages. It was described in the Info World article as follows:
:This language was named for the grade received by its creator when he submitted it as a class project in a graduate programming class. C- is best described as a "Low-Level" programming language. In fact, the language generally requires more C- statements than machine-code statements to execute a given task. In this respect, it is very similar to COBOL.
It is not to be confused with wikipedia:C--, a real-world C-like programming language that was intended as a compiler's intermediate representation.
Category:Joke languages Category:Languages Category:Low-level
C-4

C-4 is a revolutionary programming language designed to bring self-destruction to a whole new level. Unlike traditional languages that merely execute code, C-4 goes a step further by ensuring that both itself and any program you attempt to run are promptly annihilated in the process.
=== Specifications ===
In C-4, every program, regardless of content, is considered valid. This uniqueness stems from its core functionality, where executing any program results in the immediate destruction of the C-4 interpreter along with the intended program.
=== Example Programs ===
Delete itself and the interpreter:
 anything can go here, even a blank file is valid
===Quine===
== Interpreters ==
The peculiar nature of C-4 poses a significant challenge to developing interpreters. Any attempt to test or build a C-4 interpreter inevitably leads to its own demise, reflecting the language's commitment to self-destructive behavior.
== Author's Note ==
This language was intended to be a satire of bland and unoriginal "joke" languages wherein the entire punchline is "this language can not physically exist", although I can clearly see how people might think that this is indeed a "bland and unoriginal "joke" languages wherein the entire punchline is 'this language can not physically exist'". :P
Category:2024 Category:Joke_languages Category:Unusable_for_programmingCategory:Languages
C-INTERCAL

C-INTERCAL is an INTERCAL implementation first released on 12 May 1990 by Eric S. Raymond. Although compatible with INTERCAL-72, it has extensions for things like computed COME FROM, computed ABSTAIN, Threaded INTERCAL, Backtracking INTERCAL, and a debugger and profiler. The implementation is written in and compiles programs to POSIX-compatible C. It also supports TriINTERCAL.
== External resources ==
* (stub) C-INTERCAL homepage
** Compiler download page (note that C-INTERCAL is also available as a Debian and Ubuntu package via sudo apt-get install intercal)
** C-INTERCAL documentation ()
* Due to the tendency of links to break, the C-INTERCAL repository (including the documentation) is mirrored at http://nethack4.org/media/intercal.git; this is not accessible via a web browser, but is accessible using git directly.
Category:Implementations
Category:Before 1993
C-Shop

C-Shop is an esolang created by User:None1, it has nothing to do with the non-esoteric language C# except that they have similar pronounciation.
==Syntax==
Every line in C-Shop can be one of these:
 Welcome to C-Shop
This must be the first line of the program.
 The big C costs $x
This must be the second line of the program.
X must be a decimal integer.
 The small c costs $y
This must be the third line of the program.
Y must be a decimal integer.
 Person X buys Y big C's and Z small c's
X is a positive decimal integer, while Y and Z just have to be non negative(can be 0), this will add the price of the C's to that person's total consume.
 Person X will pay for his order
Print the total consume of the person in ASCII.
 Ask price of the big C/small c
Read a char from standard input and replace the price of big C/small c with its ASCII.
==Example Programs==
===One Time Cat===
 Welcome to C-Shop
 The big C costs $0
 The small c costs $0
 Ask price of the small c
 Person 1 buys 0 big C's and 1 small c's
 Person 1 will pay for his order
Note that you cannot write an infinite cat program because C-Shop has no loop.
===Hello World===
 Welcome to C-Shop
 The big C costs $16
 The small c costs $1
 Person 1 buys 4 big C's and 8 small c's
 Person 1 will pay for his order
 Person 2 buys 6 big C's and 5 small c's
 Person 2 will pay for his order
 Person 3 buys 6 big C's and 12 small c's
 Person 3 will pay for his order
 Person 3 will pay for his order
 Person 4 buys 6 big C's and 15 small c's
 Person 4 will pay for his order
 Person 5 buys 2 big C's and 0 small c's
 Person 5 will pay for his order
 Person 6 buys 5 big C's and 7 small c's
 Person 6 will pay for his order
 Person 4 will pay for his order
 Person 7 buys 7 big C's and 2 small c's
 Person 7 will pay for his order
 Person 3 will pay for his order
 Person 8 buys 6 big C's and 4 small c's
 Person 8 will pay for his order
 Person 9 buys 2 big C's and 1 small c's
 Person 9 will pay for his order
==Interpreter==
* Common Lisp implementation of the C-Shop programming language.
==See also==
* Drive-In Window
Category:Languages
Category:Unusable for programming
Category:Thematic
Category:Pseudonatural
Category:Total
Category:Implemented
Category:2023
C2BF

C2BF is a partially implemented C compiler targetting Brainfuck, written by Gregor Richards. The source is available via SVN:
 svn co https://c2bf.svn.sourceforge.net/svnroot/brainfuck/c2bf/trunk c2bf
=Implementation=
Brainfuck's tape-based system is very different from the stack-and-heap view of a conventional computer. C is tailored to fit a stack-and-heap view, and so, a stack and heap are emulated in the tape. This is done by dividing the tape into repeating five-cell chunks. Each cell serves a different purpose:
 1) Stack
 2) Heap
 3) Stack location marker / top marker
 4) Walk
 5) Carry
The stack grows from the bottom up (unlike many computers). The stack and heap are addressable in the order they appear: That is, 0x00 is stack, 0x01 is heap. To rectify this situation, all pointer math in C is multiplied by 2. Since the pointer math is already assumed to be implicitly multiplied, this (while breaking the spec) shouldn't break much code.
The stack location marker is used to determine the current location in the stack, and whether the pointer is at the top of the stack. This is mostly necessary because of how functions are implemented.
==Functions==
The function style was suggested by calamari, and is used in his BFBASIC.
Basically, at the top of the stack, there are a number of reserved spaces, precisely equal to the number of functions. At the beginning of execution, a default one of these is set (the one referring to the main function). A loop checks which one is set and runs an appropriate block of code. That block of code conventionally ends by setting another one, thus causing that block to be "called." Finally, it leaves in the stack the address for the next block in the current function when calling another function. The function being called, in turn, reads this address and marks that block to be called.
Category:Compilers
Category:Implementations
Category:Brainfuck
Category:Flat-nested
C40

C40 is a language based on C, but each function is at most 40 bytes.
==Examples==
===Hello World===
 int main(){return!puts("Hello World!");}
===a+b===
 int f(){int x;scanf("%d",&x);return x;}
 void g(int x){printf("%d",x);}
 int main(){g(f()+f());return 0;}
==Background==
They suggest that functions should be small so this is what they'd get
C@

C@ (cat) is an esolang speedran by User:BoundedBeans. Let’s see how long it takes to write this exclusive specification. 
All characters of input are pushed onto the stack at the start of the program.
==Commands==
 : duplicate
 / swap
 $ discard
 . print
 Anything else: push to the stack.
==Examples==
===5-character text reverser===
 .....
===One character cat/Quine===
 .
This is normally a one character cat taking the last character, but if the input is ., this program is a quine. In fact, any program consisting of only dots is a quine if given only dots as the last (program length) characters of input.
===Two character cat===
 /..
===Bigger cats===
C@ cannot create any larger cats than two characters, though it can make text reversers, and it can make quines of any size.
===Text scrambler===
Will scramble the last 10 characters of text
 /../../../../../../../../../..
===Insert "CAT" into reversed text after every character===
Works with 10 characters.
 C.A.T..C.A.T..C.A.T..C.A.T..C.A.T..C.A.T..C.A.T..C.A.T..C.A.T..C.A.T..
===Hello world===
 H.e.l.l.o. .w.o.r.l.d.!.
Alternatively:
 !dlrow olleH............
==Use==
This may be a somewhat useful language for text-processing algorithms that:
* do not have any sort of randomness or conditionals
* do not have loops other than defined for loops
* process text in reverse and not in any other order
* process the last characters of input rather than the first
* process a defined number of characters
* have exactly one possible output for each possible input
* do not insert colons, forward slashes, dollar signs or periods anywhere
* only ever work with two characters at a time
==Implementation==
Implementation in Python (which I'm just learning, so forgive me if it's bad):
 program = "....." #<- insert program here
 
 stack = input("")
 output = ""
 
 for i in program:
 if i == ":":
 stack += stack[-1]
 elif i == "/":
 stack = stack[:-2] + stack[-1] + stack[-2]
 elif i == "$":
 stack = stack[:-1]
 elif i == ".":
 output += stack[-1]
 stack = stack[:-1]
 else:
 stack += i
 
 print(output) 
 
 #input command is here so that you can see the output when directly running the file through File Explorer
 #as soon as you press enter the program will end
 input("") 
Category:Languages
Category:Joke languages
Category:Unusable for programming
Category:Stack-based
Category:Implemented
Category:Total