nyuuzyou/wikis huggingface dataset:
0x42

0x42 is an esolang by User:None1 and inspired by HQ9+B and +.
The author named it 0x42 because the name "B" is already taken by another esolang.
==Command==
It has only one command: B, which reads input and interpret it as brainfuck. It is forwards compatible with HQ9+B. It is also ℒ-complete.
==Examples==
===brainfuck interpreter===
 B
Category:Languages
Category:Joke languages
Category:Unusable for programming
Category:Unimplemented
0x80070050

0x80070050 or sorry this file exists(which is what this error code is for...for the file existing) is a esolang created by User:Yayimhere inspired by An Odd Rewriting System spesefically the part in the TC proof where it uses a spesific format to represent a CA. it really just annoys you
== memory ==
there are 3 memory things:
* a a string that cannot be changed
* b just another a
* the string which is what is modified
== syntax ==
there are these commands:
* ⟨xyz⟩ define rule that xyz -> a and zyx -> b in the string
* ⟪x∧y⟫ define a and b to x and y. its only legal once in the program(idea by User:ais523)
* ⦑x⦒ define rule xa -> b and x -> xb in the string
* ❮x❯ set the string to x. must be on first line
* ‹x› x is a comment
* ₫ print the string with a newline
* ¤ print the string without a newline
* ◎ apply all the rules defined(kinda like censor in STIYALFICL) in order from their definitons
* ⇔ reset all rules
each command must be on different lines and i applied top to bottom. the program loops until no replacements applies. all rules defined will not get redefined if ran again
== examples ==
Hello, world!:
 ❮Hello, world!❯
 ₫
Looping counter:
 ❮*❯
 ⟪?∧*⟫
 ₫
 ⦑*⦒
 ◎
(the ? is just anything thats not in the string ever)
this shows that 0x80070050 is more power full than a Linear bounded automaton
Category:Languages Category:String-rewriting paradigm Category:Unknown computational class Category:Output only Category:Unimplemented Category:Low-level
1

1 (a.k.a one) is an esolang by User:None1, it has a stack that contains nonnegative integers of any size.
==Commands==
Command 	Meaning
* 	Pop a,b,c, if c mod 4 is 0, push b+a, if c mod 4 is 1, push b-a, if c mod 4 is 2, push b*a, otherwise push b mod a
, 	Pop a, if a mod 4 is 0, pop a number and output as character, if a mod 4 is 1, pop a number and output as decimal, if a mod 4 is 2, read a character from user input and push its ASCII, otherwise read an integer from user input and push it
_ 	Push a random number between 0 and 255 onto the stack
1 	Push 1 onto the stack
[x] 	While top of stack isn't zero, do x (like the bracket in BF).
Other characters	Push corresponding ASCII value onto the stack
Note: EOF returns 0, if a subtraction will result in a negative value, push 0 instead, if an empty stack is popped, return a random number between 0 and 255, modulo by 0 returns 0
==Examples==
===Hello World===
This only works in common1.
 H111*,e111*,l111*,l111*,o111*, 111*,W111*,o111*,r111*,l111*,d111*,!111*,
Shorter one:
 Hd,ed,ld,ld,od,1-1*d, d,Wd,od,rd,ld,dd,!d,
===Cat Program===
 111*11*,[111*,111*11*,]
===Random decimal number between 0 and 255===
 1,
===A+B Problem===
 111*111*111*11*1*,111*111*11*1*,*1,
===Random bit===
 111*111*11*1*111*11*_*1,
==Dialects==
1 has many dialects, the one shown above is the most common dialect known as Common1. coding in Common1 is very painful, but other dialects of 1 make it more painful!
===Advanced1===
Advanced1 removes literals, when it encounters other characters, it simple raises a syntax error.
===Pure1===
Pure1 is Advanced1, but it removes random, when an empty stack is popped, it raises a syntax error.
===Dead1===
Dead1 is very different from the other dialects, it minimizes Pure1 down to 4 instructions, so it is equivalent to Pure1 but almost completely unusable for programming (because programming in it will be too painful). If you try programming in Dead1, you will feel like you are dead. None of the examples programs here works in Dead1.
====Execution====
There are 4 commands: , , , and , the commands except work the same in Pure1.
The command works like this: Pop a value x, if x mod 8 is less than 4, execute the command in Pure1, but do not pop c, use x mod 4 instead of c. Otherwise execute in Pure1, but do not pop a, use x mod 4 instead of a.
==External resources==
* Official interpreter in Python, supports all dialects
==See also==
* 1/Constants
Category:Languages
Category:Stack-based
Category:Push-down automata
Category:2023
Category:Implemented
1+/Minimalization

:
This page contains attempts on minimizing the number of 1+ instructions, similar to BF instruction minimalization. We also use the same restrictions that is, there exists a simple translation from X to 1+ and from 1+ to X. A secondary goal is to golf the sum of the number of commands in the submission to which each 1+ command translates for every number of instructions.
If you're to add a submission try your best to explain it.
== Minimalization ==
=== Combining + and * (Reduced 1 instruction) ===
Starting with combining + and *. Let's add an & instruction that can do both addition and multiplication:
intermediate 1+
------------------
& +*
Since a + 0 = a and a * 1 = a it's easy to disable both addition and multiplication:
1+ intermediate
------------------
+ //1\\&
* 111&1<&
=== Combine Harvester (Reduced 2 instructions) ===
Now throw " into the mix. Combine it with the & instruction:
CH intermediate
------------------
@ &"
Disabling " is not as trivial since you need to decrease the length of stack and you can't use @ since it gives you another pair of identical items to get rid of. The only choice is <:
intermediate CH
------------------
& @111@1<<^@
" 1111@1<<@
=== The Lyxal command (Reduced 3 instructions) ===
The Lyxal command, L, is the 1+ equivalent of the BitChanger command, and it combines \ with ^.
Lyxal CH
------------------
L \^
CH Lyxal
------------------
\ L/L
^ /L 
== Properties ==
These are the properties that a 1+ minimalization language must have.
=== Property I ===
There exists an instruction that increases the length of the stack and an instruction that decreases it that does not affect I/O.
If you only have instructions that increases the length of the stack you'll get stuck on translating 1 and " and if you only have decreasers then you cannot do any of +*<.
== Notes ==
Category:Examples
1+/Programs

This page provide links to most, if not all, 1+ programs ever written, excluding the example programs on the 1+ page.
== CGCC ==
From oldest to newest.
Shortest infinite loop producing no output User:A & User:TwilightSparkle
Simple cat program User:TwilightSparkle
Test if two numbers are equal User:TwilightSparkle
"Hello, World!" User:Jo King
Internal Truth Machine User:TwilightSparkle
Implement a Truth-Machine User:TwilightSparkle
Draw an ASCII-art rainbow User:TwilightSparkle 
!I!n!s!e!r!t! !n!b!e!t!w!e!e!n! User:TwilightSparkle
Raise integer x to power x, without exponentiation built-ins User:TwilightSparkle
== Others ==
User:TwilightSparkle's twtxt.net blog contains some 1+ programs.
Category:Examples
1+/Snippets

:
This is horrible and I'm very sorry. -- A random PPCG user
This page provides common code snippets for easy 1+ programming (and golfing).
Any unused function name represents, uh, any unused valid function name. Some snippets involves control flow and is wrapped in a function definition to create a seperate line of execution, and prevent affecting the rest of the program.
== Easy ==
Very short and trivial snippets.
=== Push 0 ===
11+1<
=== Negate ===
1+1<
=== Truthify ===
Yeah, you can negate it twice, but this is much shorter:
1^<
=== Pop ===
Only works when there's more than one element on the stack.
"<*
==== Universal Pop ====
Works anywhere.
(Any unused function name|"<##)
=== Comparison ===
Less than: (This saves 1 byte compared to ^<1+1<.)
^1+^<
More than: (This saves 1 byte compared to <1+1<.)
1+^<
== Medium ==
Longer and harder to understand snippets. They involve stack manipulation.
=== Equality ===
"/^"\</<\*
=== Ternary ===
That is, returns a for a b 0 on the stack (stack top is on the right), and b for a b 1 on the stack.
"1+1</*^\*+
== Hard ==
Involves control flow. Some of these takes an afternoon to make.
=== Operations ===
==== Decrement ====
(Any unused function name|"1<11+1<^#1+^"/^"\^1+<#)
==== Subtraction ====
(Any unused function name|11+1<11+##1+^1+^11+#/"/^"/^\\<11+*1+\^#)
==== Square root ====
If the square root is not an integer, rounds to the nearest *larger* integer.
(Any unused function name|"1<11+1<^#1+^"/^"\^"*<#)
=== Control Flow ===
==== Do-while loop ====
Let's say your pseudo-code is:
do { code } while (!x)
Assuming x is already a boolean and not an integer. (Otherwise you need to convert it to boolean with 1^<.)
(Any unused function name|1##
 [code]
[push x]1+#)
==== While loop ====
Pseudo-code:
while (!x) { code }
Compiles to:
(Any unused function name|[push x]#
 [code]
[push x]#)
This was originally very, very bulky when it was first created.
==== If block ====
Pseudo-code:
if (!x) { code }
Compiles to this 1+ code:
(Any unused function name|[push x]#
 [code]
1#)
==== If-else block ====
Pseudo-code: (Please note code2 comes before code1.)
if (x) { code2 } else { code1 }
Compiles to this 1+ code:
(Any unused function name|[push x]#
 [code1]
11+#
 [code2]
11+#)
Sometimes this works, depending on your operation in code1 and code2:
(Any unused function name|11+[push x]#
 [code1]
#
 [code2]
#)
== Insane ==
== Obviously Medium-Graded ==
== Legendary ==
Snippets about Lyxal (User:JonoCode9374)
=== COME BACK LYXAL!!! ===
(|111+")(_|""+*"*+)+";1111++"( |"+"*+"++;)()1+( )()+"""**++;()"""+"**";^"(_);()"+*"*+;\;()++"""++*;;""1+"+"*+"+";1111++"""*"*+++"1+;;()"+*"*+;;()"+"**+"";;;
Category:Examples
1.1

1.1 is a Turing-complete esoteric programming language based on string replacement in a string data buffer, arbitrary control flow among states, but without self-modifying code. 
1.1 is given as an example that Donald Knuth gives for how one could define computability in a precise mathematical way in the bible The Art of Computer Programming, chapter 1.1. The book says that the language is essentially equivalent to the one given in the book A. A. Markov, The Theory of Algorithms (Trudy Mat. Inst. Akad. Nauk. 42 (1954), 1–376), later revised and enlarged by N. M. Nagorny (Moscow: Nauka (1984); English edition: Dordrecht: Kluwer, 1988). The example is present in both the second edition (1973) and the third edition (1997) of vol. 1. of the bible. The bible does not seem to refer to this example anywhere later, instead programs are presented in other languages, such as MIX (Knuth).
An 1.1 program is has a finite sequence of states, numbered consecutively, the first state being the initial state, and the last state a halt state. The program consists of a specification of four pieces of data for each of the states: a needle string, a replacement string, the next state in case of successful replacement, and the next state in case of failure. The input for running a program is a string, which becomes the initial value of the data buffer. In each execution step, the execution searches for the first occurrence of the needle string of the current state in the data buffer, and if found, replaces it with the replacement string. After that, the state is changed to one of the two next states given in the program for the current state, depending on whether the needle string was found or not found. If the execution enters the halt state, the program halts and the data buffer becomes the final output.
== Implementations ==
* Interpreter in Perl by User:Sxakalo
* Interpreter in Node.js by User:Hakerh400
== See also ==
* Thue
* Thupit
Category:Languages
Category:String-rewriting paradigm
Category:Turing complete
Category:Before 1993
Category:Implemented
10

10 has two valid chars, 1 and 0, whitespace like newline, space, and tab are also valid, all other chars are comments
== Syntax of program ==
 [x]+ in syntax is x happens 1 or more times
 [anything] in syntax means any of the other syntax things
 [x]? in syntax is x happens 0 or 1 times
 {x:y} in syntax puts y in x
 10 starts the program
 01 ends the program
 11 {name:[101]+} starts a function with name
 00 ends a function
 000 nop
 001 {var:[111]+} {val:[anything]} sets var to val
 010 {var:[111]+} refers to var as var
 011 {name:[101]+} runs name as function
 100 {val:[anything]} returns val
 101 {val:[anything]} outputs val
 110 {prompt:[anything]?} gets input with maybe prompt
 111 {val:[010]+} is a value
 0 {val:[anything]} 1 brackets around val
== 3 program ==
 10 start
 001 111 0 111 010 010 010 1 set oneoneone to tree
 101 010 111 output oneoneone
 01 end
Category:Languages
100BF

100BF is an oOo CODE inspired, brainfuck equivalent esolang by User:None1, it is named 100BF because he realized this is the 100th esolang he created.
100BF Uses characters 1, l, 0, O, so programs in 100BF will be very obfuscated.
==Commands==
==Examples==
These programs are obviously generated by Python because real 100BF programming will be too obfuscated and Python is the most convenient language I can use on my computer.
===Hello World===
100 100 100 100 100 100 100 100 lO0 1OO 100 100 100 100 lO0 1OO 100 100 1OO 100 100 100 1OO 100 100 100 1OO 100 1O0 1O0 1O0 1O0 10O lOO 1OO 100 1OO 100 1OO 10O 1OO 1OO 100 lO0 1O0 lOO 1O0 10O lOO 1OO 1OO l0O 1OO 10O 10O 10O l0O 100 100 100 100 100 100 100 l0O l0O 100 100 100 l0O 1OO 1OO l0O 1O0 10O l0O 1O0 l0O 100 100 100 l0O 10O 10O 10O 10O 10O 10O l0O 10O 10O 10O 10O 10O 10O 10O 10O l0O 1OO 1OO 100 l0O 1OO 100 100 l0O
===Cat Program===
 l00 lO0 l0O l00 lOO
===Truth Machine===
 1OO 1OO 1OO l00 l0O lO0 lO0 10O 1OO 100 1O0 1O0 100 1OO lOO 1OO 10O lOO 1O0 1O0 1O0 lO0 1O0 1O0 lOO 1OO lO0 l0O lOO
==Interpreter==
===Python===
import sys
def ahundred_bf(code):
 s1=[]
 s2=[]
 matches={}
 tape=[0]*1000000
 for i,j in enumerate(code):
 if j=='lO0':
 s1.append(i)
 if j=='lOO':
 m=s1.pop()
 matches[m]=i
 matches[i]=m
 cp=0
 p=0
 while cp<len(code):
 if code[cp]=='100':
 tape[p]=(tape[p]+1)%256
 if code[cp]=='10O':
 tape[p]=(tape[p]-1)%256
 if code[cp]=='l00':
 c=sys.stdin.read(1)
 tape[p]=(ord(c) if c else 0)%256
 if code[cp]=='l0O':
 print(chr(tape[p]),end=)
 if code[cp]=='1O0':
 p-=1
 if code[cp]=='1OO':
 p+=1
 if code[cp]=='lO0':
 if not tape[p]:
 cp=matches[cp]
 if code[cp]=='lOO':
 if tape[p]:
 cp=matches[cp]
 cp+=1
ahundred_bf(input().split())
Category:Languages
Category:2023
Category:Turing complete
Category:Brainfuck derivatives
Category:Brainfuck equivalents
10Brainfuck

==10Brainfuck==
10Brainfuck is going to be my first contribution as far as esolangs are concerned. First of all programs are actually going to be written in numbers 1 ~ 8. The codes are as follow:
* 1 gets translated into '>'
* 2 gets translated to '<'
* 3 becomes '+'
* 4 becomes '-'
* 5 goes to '.'
* 6 -> ','
* 7 -> '['
* and finally 8 becomes ']'
Here's a python program that translates 10Brainfuck into brainfuck (former), and vice versa (latter).
 code = input('Enter 10Brainfuck code: ')
 chars = {'1': '>', '2': '<', '3': '+', '4': '-', '5': '.', '6': ',', '7': '[', '8': ']'}
 for i in chars.keys():
 code = code.replace(i, chars[i])
 print(code)
 code = input('Enter Brainfuck code: ')
 chars = {'>': '1', '<': '2', '+': '3', '-': '4', '.': '5', ',': '6', '[': '7', ']': '8'}
 for i in chars.keys():
 code = code.replace(i, chars[i])
 print(code)
== Note ==
Isn't the same as Numberfuck??
Category:Languages
Category:Brainfuck_derivatives
Category:Cell-based
Category:Turing complete
Category:Turing tarpits
Category:Brainfuck_equivalents
10D Deadfish 7 with Time Travel and a Multiverse

10D Deadfish 7 with Time Travel and a Multiverse is a joke esolang created in 2023.
==Commands==
 i - increment current timeline's current universe's number
 I - increment every number
 d - decrement current timeline's current universe's number
 D - decrement every number
 s - square current timeline's current universe's number
 S - square every number
 r - square root current timeline's current universe's number
 R - square root every number
 y - round current timeline's current universe's number
 Y - round every number
 c - create timeline
 > - go to the next timeline
 < - go to the previous timeline
 [ - go to the next universe
 ] - go to the previous universe
 0 - donut
 o - output current timeline's current universe's number
 O - output every number
 u - output current timeline's current universe's ASCII
 U - output every ASCII
==Hello world==
 iiisdsiiiiiiiiuiiiiiiiiiiiiiiiiiiiiiiiiiiiiiuiiiiiiiuuiiiu
 ddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddduddddddddddddu
 dddddddddddddddddddddsddudddddddduiiiudddddduddddddddu
 dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddu
== donut ==
 0
Category:LanguagesCategory:Joke languagesCategory:Multi-dimensional languagesCategory:2023
10 1

10 1 is a trivial brainfuck substitution given by PSTF.
== Commands ==
 Command table
CMD	Mean
东 	+ in Brainfuck
方 	- in Brainfuck
巨 	> in Brainfuck
龙 	< in Brainfuck
正 	. in Brainfuck
在 	, in Brainfuck
崛 	[ in Brainfuck
起 	] in Brainfuck
== Example ==
=== Hello, World! ===
 东东东东东东东东东东崛巨东巨东东东巨东东东东东东东巨东东东东东东东东东东龙龙龙龙方起巨巨巨东东正巨东正东东东东东东东正正东东东正龙龙东东正巨东东东东东东东东东东东东东东东正巨正东东东正方方方方方方正方方方方方方方方正龙龙东正龙正
== Implementations ==
===Ecliptica=== 
 a compiler into brainfuck
 based on command table might be wrong
 >>1[?0(x)<'+'O<)?26041(>'-'O<)?24040(>'>'O<)?40857(>'<'O<)?27491(>'.'O<)?22312(>','O<)?23835(>'['O<)?36215(>']'O<)>>l]
== Categories ==
Category:Languages Category:Brainfuck derivatives Category:Brainfuck equivalents Category:Implemented Category:CJK Category:Pseudonatural Category:Turing complete Category:Turing tarpits Category:Cell-based Category:Low-level Category:2024
11

11 is an esolang made by User:DifferentDance8, approximately 2 days after christmas :P
I named it as such because 11 was the first number to not have an article here, and because 11 is a cool number (as such, EVERY SINGLE COMMAND is 11-themed in some way)
 Caption text
Commands 	What they do
Eleven 	Starts the program
11 	Adds 11 to the stack
OneOne 	Takes the first number on the stack
1One 	Prints the last element of the stack as an ASCII character
One1 	Reverses the last element of the stack
OneTwo-One 	Subtracts the last element of the stack by one
5Point5Times2	Multiplies the last element of the stack by two
nevelE 	Ends the program
== Examples ==
Good luck writing a program.
This program prints 'H'.
 Eleven115Point5Times25Point5Times2
 Point5Times25Point5Times25Point5Times2
 5Point5Times25Point5Times25Point5Times2
 5Point5Times25Point5Times25Point5Times2
 5Point5Times25Point5Times25Point5Times2
 5Point5Times25Point5Times25Point5Times2
 5Point5Times2nevelE
Category:Languages Category:2024
111

111 is a :/// derivative based on length-prefixed binary strings.
== Semantics ==
A program is a list of bits. A string consists of any number of 1 bits (including zero), followed by a 0, followed by as many bits as there were 1s. For example, 1110010 consists of the length (111 in unary, aka 3), a 0 bit to delimit the length and the contents, and then the bits 010, whereas 0 is the empty string. A substitution consists of two strings, the source and destination, concatenated together; for instance, 110001110101 (read as 11 0 00 111 0 101) is a substitution with the source 00 and the destination 101. Substitution proceeds as in ///. The only possible output is whether the program halts or not, though implementations are encouraged to print the program as it evolves.
The behaviour when there are not enough bits in the program to read in a complete string or substitution shall be defined by the first person who manages to actually write a program that computes something with any reasonable interpretation of that case, but halting as /// does is likely to be the cleanest option.
==External resources==
*JavaScript interpreter
Category:Languages
Category:2014
Category:Implemented
Category:Unknown computational class
Category:Self-modifying
Category:String-rewriting paradigm
11CORTLANG

11CORTLANG (the 11th language by Cortex) is a stack-based language made by Cortex using only the characters 0, 1, and newline. Also, the null program is a cat program, because of course it is.
== Syntax and commands ==
Commands are separated with newlines. If a line starts with 0, push the contents of the rest of the line on top of the stack. Otherwise, if the line starts with 1, do something depending on the table below (the syntax is 1[commandname]).
Command name 	What it does
0 	Nop.
1 	Pop the value on the top of the stack.
00 	Print the value on the top of the stack as an ASCII character. If the value is a decimal, round up
01 	Add the top two stack values.
10 	Subtract the top two stack values. (top - second from top)
11 	Multiply
000 	Divide (top / second from top)
001 	Get a number from user input
010, followed by anything	Take the part of the command that isn't the 010 at the start. Go forward that many lines.
Anything else 	Take the command name as a binary number (remove any zeroes at the start). Run the below command that many times.
== Examples ==
=== Hello, World! ===
0100001
01100100
01101100
01110010
01101111
01010111
0100000
0101100
01101111
01101100
01101100
01100101
01001000
1101
100
Compressed:
33 7
100 8
108 8
114 8
111 8
87 8
32 7
44 7
111 8
108 8
108 8
101 8
72 8
13 4
4 3
==External resources==
interpreted in python by User:Nmcassa changed 010 command and didn't implement the anything command to get a working model, I won't change the description by the OC incase anyone wants to make a true interpreter but from what I understand that hello world example wouldn't work because it doesn't move down the stack and just prints the top stack however many times. 
Category:Languages
Category:2019
Category:Stack-based
Category:Total
Category:Implemented