nyuuzyou/wikis huggingface dataset:
Base2e15text

Base2e15text is designed by PSTF.
== Brief introduction ==
It is Text but encoded by This tool.
The extension of Base2e15text is *.b2e15t or *.txt.
== Examples ==
=== Hello, world! ===
壼늿䉥监灅繻紌
=== 99 bottles of beers ===
췒㒇僙脐텵侒䀐뱤䦉뻩芙䩃㡁仒츖幡둏玼䭘槖죈洋뫳耸䛕蕲罹㜾㼙㒎挝삩蠀
仫흟쏐멨羾䙍籪堕柌쑜啉䶬凐律䫍姛㶸屔慀翻葂䤋萲冚汤忒뤜
䌉蒚嵬䎕핯횾힒䔘㤶芍헫䫯蜥吸㱵穬瀲㸍䏣뻧포宼蛐㧭펕풘渖슃항嫩꾆亴
렽쁆粧쁮롬䃿職油犖䮆䣒뉥璠洱햽첝쁎㙭岅䡌螅榏叭䯿꿙匡䍫蘖썒
炴呙恴䦀稜毉민疯랜琩㭌櫗芉횝肌宴좇쳟쭣揸乍宱㻄衇仜룆䱙廞솯埁퇥
䈻쑩蔟찛볫澶쥢䢒䖧홟坏竲퀑䃅휎뵀혶䶃癖뭴䍮녰氥
뺳汁焣䬬늴둷抐螪돳縞남簎䉹昻褁沞䬻텓煎擿䊏죓根䖌䨍瓆됡処풐뤳뷝
禺뤃㭹왎䈉厺녝緌䵡愭뜵筵㔨畘哞䭲瀩曐兄祸쎰칡蒡䐻抔팛㹻罇
퇵䶯嵷꺁픟쓼묌䘒帻㠱뫈曈佾쓊绋쭖巫䍋㴘맊뭖쾷㪷뵇폂媒嚗埴憩榈䒥䲮㮦䄃퉩嵎㙀
=== Fizzbuzz ===
藋瓐䓐嶼係륙捤쌲䳢훨㓭저忰汞䢼埔䄥빛뒺䓳䴸筫䦭뚣슈
줖烒䁻産㜱폛橍姇㮉䛲湊虈흋큣텇쾭떙콧买䚲䈔莃
䍗泋뵞몝뼮쏾棑䆫멷挰촏棁䎒웨䆂빖䣯湵籔兆퐯솢縠왔㕠
=== XKCD Random Number ===
今
== IDE ==
The only IDE is This.
== Categories ==
Category:Joke languages
Category:2024
Category:Implemented
Category:Total
Category:Unusable for programming
Category: Languages
Base64

Base64 lang is a simple esolang made by User:1048576.
We have 1 register val with default 0, and a sequence of length 512(start is a_0).
A command is two characters(12 bits when decoding in Base64 encoding):
[control(3bits)] [addr(9bits)]
(A is short for a_(addr in binary))
 Control
control	meaning
000 	val <- A
001 	A <- val
010 	A <- !(A and val)
011 	if val, then jump to before A-th command running
100 	Halt
101 	input a bit from stdin, then save it in A
=== Examples ===
Cat program:
 0180g000o0
Explanation:
when it writes in binary, it looks at follows:
000 000000001 # Set val to 0
001 000000000 # Set a_0 to val(0)
010 000000000 # Set a_0 to (a_0 and val), which is 1
000 000000000 # set val to a_0(1)
011 000000000 # jump to before the first command running, so it is a cat program.
Category:Languages
Category:Low-level
Base64 Text

Base64 Text is a programming language created by Mihai Popa. It's like Text, but it's in Base64.
== A short description ==
All Base64 Text programs output their source code, thus ALL programs are quines.
There are a HUGE AMOUNT of interpreters for Base64 Text, like Notepad, WordPad, "type" command on Windows, "cat" command on Linux, etc...
The file extensions for Base64 Text programs are .b64 and .txt, and some other extensions and even no extension at all!
== Examples ==
=== Hello, world! ===
SGVsbG8sIHdvcmxkIQ
=== XKCD Random Number ===
WEtDRCByYW5kb20gbnVtYmVyIGlzOiA0
=== FizzBuzz ===
MQ0KMg0KRml6eg0KNA0KQnV6eg0KRml6eg0KNw0KOA0KRml6eg0KQnV6eg0KMTENCkZpenoNCjEzDQoxNA0KRml6ekJ1enoNCjE2DQoxNw0KRml6eg0KMTkNCkJ1enoNCkZpenoNCjIyDQoyMw0KRml6eg0KQnV6eg0KMjYNCkZpenoNCjI4DQoyOQ0KRml6ekJ1enoNCjMxDQozMg0KRml6eg0KMzQNCkJ1enoNCkZpenoNCjM3DQozOA0KRml6eg0KQnV6eg0KNDENCkZpenoNCjQzDQo0NA0KRml6ekJ1enoNCjQ2DQo0Nw0KRml6eg0KNDkNCkJ1enoNCkZpenoNCjUyDQo1Mw0KRml6eg0KQnV6eg0KNTYNCkZpenoNCjU4DQo1OQ0KRml6ekJ1enoNCjYxDQo2Mg0KRml6eg0KNjQNCkJ1enoNCkZpenoNCjY3DQo2OA0KRml6eg0KQnV6eg0KNzENCkZpenoNCjczDQo3NA0KRml6ekJ1enoNCjc2DQo3Nw0KRml6eg0KNzkNCkJ1enoNCkZpenoNCjgyDQo4Mw0KRml6eg0KQnV6eg0KODYNCkZpenoNCjg4DQo4OQ0KRml6ekJ1enoNCjkxDQo5Mg0KRml6eg0KOTQNCkJ1enoNCkZpenoNCjk3DQo5OA0KRml6eg0KQnV6eg
== Development environments ==
The most common IDE for Base64 Text is Notepad, and is on Windows. It's powerful, and it can compile and run the program as you type it!
Category:Joke languages
Category:2024
Category:Implemented
Category:Total
Category:Unusable for programming
Category: Languages
Baselang

This esolang looks like it could get some changes, huh?
==Commands==
 print() - Prints something. No one knows what.
 input - Does nothing. Until user do something.
 x - No one knows.
 eval() - Do something, in CPU.
Category:LanguagesCategory:Joke languagesCategory:Baselang familyCategory:Unknown yearCategory: Unusable for programmingCategory:Unknown computational class
Bash: foo: No such file or directory

bash: foo: No such file or directory or hsaB is a joke language made by User:Marina. It imitates a common bash error when the file or command in an instruction is not found.
==Commands==
There are no/infinite commands as any instruction is valid and it prints:
 bash: [command]: No such file or directory
==Interpreter==
===Python===
 print('\n'.join([f'bash: {i}: No such file or directory' for i in __import__('sys').stdin.read().split('\n')]))
===C===
The program implements a REPL, and uses the insecure function gets to read the program.
#include<stdio.h>
char _[1000000];int main(){while(!feof(stdin)){printf("$ ");gets(_);printf("bash: %s: No such file or directory\n",_);}}
===Batch===
@echo off
:bad
set /p x=$ 
echo Bash: %x%: No such file or directory
goto bad
==See also==
* 'xxx' is not recognized as an internal or external command, operable program or batch file. is an esolang like this one, but imitates a common Windows command prompt error.
* foo : The term 'foo' is not recognized as the name of a cmdlet, function, script file, or operable program. Check the spelling of the name, or if a path was included, verify that the path is correct and try again. is another similar esolang that imitates a common Powershell error.
* Bad command or file name, another similar esolang.
* Filename "xxx" doesn't seem to be a valid filename. Please check if the filename your trying to execute written correctly, ft. Fiction
Category:Languages
Category:Joke languages
Category:Unusable for programming
Category:Output only
Category:Total
Category:2023
Category:Implemented
Basic

Basic is a pseudonatural esolang by Mihai Popa. It transpiles to BASIC!
All commands must start with "This program", like "This program prints". Some words are exceptions.
== Commands and words ==
 Basic command list
Basic 	BASIC 	Meaning
This program prints [text] 	PRINT [text] 	Prints [text]
This program gives user input to [var] 	INPUT [var] 	Gives user input to a variable
This program makes a if clause [condition] 	IF [condition] 	Makes a IF clause
This program sets a variable, named [var] to [value]	LET [var] = [value]	Sets a variable to a value
equals / to 	= 	Equals (IF) / To (LET)
greater than / is greater than 	> 	Is greater than
less than / is less than 	< 	Is less than
This program jumps to line 10 	GOTO 10 	Jumps to line 10
This program makes a else if clause [condition] 	ELSEIF [condition] 	Makes a ELSE IF clause
This program makes a else clause 	ELSE 	Makes a ELSE clause
This program ends the if clause 	END IF 	Ends the IF clause
This program halts 	END 	Ends the actual program
then 	THEN 	Then
This program remarks the line: 	REM 	Marks a single line comment
This program remarks the line (shorter): 	' 	Marks a single line comment
More commands can be done with the translator! Also on Pastebin! (updated later)
== Examples ==
=== Hello, world! ===
This program prints "Hello, world!"
=== XKCD Random Number ===
This program prints 4
=== Cat ===
This program gives user input to cat
This program prints cat
=== Truth Machine ===
10 This program remarks the line: Truth Machine (in Basic)
20 This program gives user input to truth
30 This program makes a if clause x is 0 then
40 This program prints 0
50 This program makes a else if clause x is 1 then
60 This program prints 1
70 This program jumps to line 60
80 This program ends the if clause
== Implementer ==
Yes sure! Lingojam!
Here's the link: Basic to BASIC Translator
It also does the reverse (BASIC to Basic)
Category:Languages
Category:High-level
Category:2024
Category:Pseudonatural
Category:Implemented
Basic Input/Output Commands

Basic Input/Output Commands is an esoteric assembly code-like programming language that simply uses device input/output.
Instruction 	Details 	Examples
@s num 	
Changes the set of switches in the RAM represented by s to the binary representation of n.
The maximum number of n depends on the bitsize. For example, if the bitsize is 8, the maximum number of n is 255, and if the bitsize is 16, the maximum number of n is 65536.	
* @0 65
* @1 b01000001 // using binary representation
* @2 x41 // using hexadecimal representation
* read id:sect @s
* read id:@sref #@s
* read id:sect:subsect @s
* read id:@sref:@ssref #@s	Reads a value from a section by number in the device with the specified ID and stores it at memory position s. @s uses a value from memory (see "@s ...") 	
* read 14:1 @3
* read @4:35:@5 #@6
:(see the standard device reference for more examples)
* write id:sect n1 n2 n3 …
* write id:@sref @s1 @s2 @s3 …
* write id:sect:subsect n1 n2 n3 …
* write id:@sref:@ssref @s1 @s2 @s3 …	
Writes a value or set of values to a section by number in the device with the specified ID. 	
* write 16:9 98 12 52 43 54
* write @7:12 13 @8 23 94 @9
:(see the standard device reference for more examples)
* clear id
* clear id:sect
* clear id:sect:subsect	
Replaces all subsections in the specified section of the specified device identifier with 0. If the top-level section is cleared, a reset signal is sent to the device 	
* clear 11
* clear 12:43
* qio qid n1 n2 n3 … @s
* qio @qds @s1 @s2 @s3 … #@s	Sends n1, n2, n3, etc. to the quick input/output device with the specified identifier, waits for the device to process the input, then sets the set of switches represented by s to the output (mainly for quick conditional processing or mathematics)	
* qio 13 82 84 21 @10
* qio 12 @11 89 43 25 @12 @13 @14 #@15
:(see the standard device reference for more examples)
if @s instruction	Executes instruction if the set of switches represented by s is not 0 	
qrl 	Short for "Quick Reload" - jumps to the beginning of the program 	
frl 	Short for "Full Reload" - clears the memory cells that the program used and jumps to the beginning of the program 	
Category:Languages
Category:Unknown year
Category:Unknown computational class
Category:Low-level
Category:Unimplemented
Basic Programming

Not to be confused with BASIC, Atari BASIC or batari BASIC
Basic Programming was a cartridge released in 1979 for the Atari 2600 by Warren Robinett that contained an interpreter for the (Non-Esoteric) programming language Basic. For those who know anything about the Atari 2600, this is a stupid idea. 
The entire machine only had 128 bytes of RAM. of which 65 are used for internal uses. Which gives you 63 bytes (called symbols) total for program storage, variables, the stack and the printout. 
The "Keyboard" was just a pair of 12 key keypads that connected to the 2 controller ports. Instead of typing in the tokens the tokens were printed on the keypads (a. la Sinclair Basic) in 4 colors and a modifier key called the "Shift Control Key" cycled between the colors.
The cartridge gave the user a full IDE that included a memory viewer, an output console and even a graphics output with 2 sprites. 
== Keywords ==
Operations: + - × ÷ ← Mod = < > 
Flow Control: If Then Else Goto
I/O: Print Clear Note(music) Key(input)
Sprite Control: Hor1 Ver1 Hor2 Ver2 Hit
== Examples ==
This is the PONG game that’s included in the manual (ball and paddle)
1 Hor 1!Hor 1+Key
2 Hor 2!Hor 2+8
3 Ver 2!Ver 2-3
4 If Hit Then Ver 2!99
,Note!7
5 Goto 1
This is the version without sound
1 Hor 2!Hor 2+Key
2 If Ver 1>90 Then
Ver 1!88
3 If Hit Then Ver 1!9
4 Ver 1!Ver 1+If
Ver 1 Mod 2 Then 8 Else
92
5 Hor 1!Hor 1+7
6 Goto 1
== External Links ==
Wikipedia Article
Manual Scan
Manual text in HTML
Category:Bounded-storage_machine
Category:Before_1993
Category:Implementations
Basilisk

Basilisk is an esoteric programming language created by User:Vriskanon. It consists of only one command, execute, which can execute any executable program in any language. However, as a cost for using such an easy programming language, one must first fight a giant snake to the death.
==Commands==
===Execute===
The execute command is the only command in basilisk. When run, it will execute a program on your computer with that name in any language. For example, to execute the file 'Hello_World.py', one would use the following code:
execute Hello_World.py
Once the code gets to that point, a giant snake (often a basilisk) will be summoned near your computer. To actually execute the code, you must fight the snake to the death. Only when it dies will the execute command work.
If there are many execute commands within a program, one must fight a snake for each execute. One cannot just fight one big one to run all of the executes.
The size of the snake will vary depending on the size of the file, but the snake will always be 'giant'.
==Sample programs==
===Hello, World!===
execute Hello_World.py
===Quine===
This code will execute a Text program (all of which are quines).
execute Quine.txt
Programs that execute Text files tend to produce the smallest snakes.
===Blue Screen the User===
 execute BSoD.tcesl
Program that execute the program written in User talk:/w/wiki/index.php/Talk:index.php/Main page will summon a strange thing(its size is 1000~3000 ft).
===Disan Count===
execute Disan_Count.bbl
This executes a program written in BubbleLang.
===Do nothing===
execute test.aplwsi
Program that execute the program written in APLWSI will do nothing, too.
===Nope.===
execute Nope.nope
Program that execute the program written in Nope. will summon a snake even just a bit bigger that Text.
==Computational class==
A Turing-machine interpreter can be written as:
execute UTM.py
(where UTM.py is the interpreter of the Universal Turing Machine.)
The computational class of this language solely depends on the strength of the user.
Category:Joke languages Category:Unimplemented Category:Languages Category:Turing complete
Battlethought

Battlethought simulates a battle between the programmer and their thoughts.
==History==
User:Cinnamony made this. Here is a quote from him:
 the mind is powerful. sometimes it gives you thoughts you dont want, and sometimes they go against you :(
He acknowledges the fact of the mind becoming powerful, and he acknowledges the fact that some people have unwanted thoughts. He then makes a programming language out of it.
==Thinking about something else==
You use think to think about something else. The perks last for 2 commands after the think command, and then you can't use it again for 5 commands.
===Perks===
You can use the non-protection commands, that don't protect the outside from the thoughts.
==Commands==
Use protect to protect the outside world from your thoughts. If you don't and use a non-protection command, the non-protection command doesn't work and it prints out "Your friend is going to get struck by lightning".
===Non-protection commands===
 print() - Prints something.
 [var] = [thing] - Sets a variable to something.
 input - Asks for user input.
 wait() - Waits an amount of seconds.
 TERMINATE - Terminates the script.
 kniht - Does something. Kinda vague, though.
There are no loops because these should only work for 2 commands after think. Using protect works after think, but it does nothing.
==Hello World==
 think
 print("Hello, World!")
 TERMINATE
==Cat==
 think
 b = input
 print(b)
==Palindrome==
 think
 kniht
Category:LanguagesCategory:2023
Bauberqueue/bauberqueue.py

Reference implementation for Bauberqueue in Python.
 import sys
 from collections import defaultdict
 
 def load(filename):
 try: 
 listing = defaultdict(list)
 with open(filename, "r") as openfile:
 for num,line in enumerate(openfile):
 listing[num+1] = map(ord,list(line.rstrip().decode('string_escape')))
 except IOError: print("File '%s' not found."%filename); sys.exit(1)
 return listing
 
 def get(data,id):
 if id==ord("1"):
 return 1
 if id in map(ord,"abi"):
 return data.__dict__[chr(id)]
 if id in map(ord,"ABI"):
 return data.listing[data.__dict__[chr(id+32)]].pop(0) if data.listing[data.__dict__[chr(id+32)]] else 0
 if id==ord("o"):
 return ord(sys.stdin.read(1)) #blocks and waits for an input if buffer empty, reads 1 byte
 try: id = chr(id)
 except ValueError: 
 try: id = unichr(id)
 except ValueError: id = str(id)
 raise ValueError(id + "is an invalid source argument in queue %d."%data.i)
 
 def put(data,id,val):
 if id in map(ord,"abi"):
 data.__dict__[chr(id)]=val
 elif id in map(ord,"ABI"):
 data.listing[data.__dict__[chr(id+32)]].append(val)
 elif id==ord("o"):
 try: sys.stdout.write(chr(val))
 except ValueError: 
 try: sys.stdout.write(unichr(val))
 except ValueError: pass
 else:
 try: id = chr(id)
 except ValueError: 
 try: id = unichr(id)
 except ValueError: id = str(id)
 raise ValueError(id + " is an invalid target argument in queue %d."%data.i)
 
 def run(data):
 while True:
 x,y,z=[data.listing[data.i].pop(0) if data.listing[data.i] else 0 for _ in range(3)]
 # print chr(x),chr(y),chr(z)
 # import pdb;pdb.set_trace()
 if (z==ord("o") or y==ord("o")) and x!=ord('='):
 raise ValueError('o used as source or target of non-assignment command at queue %d.'%data.i)
 if x==ord("="):
 put(data,y,get(data,z))
 elif x==ord("+"):
 put(data,y,get(data,y)+get(data,z))
 elif x==ord("-"):
 put(data,y,get(data,y)-get(data,z))
 elif x in map(ord,"abiABI"):
 count=get(data,z)
 seq = []
 src = get(data,y)
 tgt = get(data,x)
 for c in range(count):
 seq.append(data.listing[src].pop(0) if data.listing[src] else 0)
 data.listing[tgt].extend(seq*2)
 else:
 break
 data.listing[0]=[] #throw out the trash
 
 if __name__=="__main__":
 class Aubergine:
 def __init__(self, listing, a, b, i): 
 self.listing = listing
 self.a = a
 self.b = b
 self.i = i
 if len(sys.argv)<2:
 print "No filename to execute."
 else:
 listing = load(sys.argv[1])
 data = Aubergine(listing, 0, 0, 1)
 try:
 run(data)
 except Exception as e:
 print e.message
 for key in data.listing.keys():
 if key!=0:
 print key,map(chr,data.listing[key])
 print "a",data.a
 print "b",data.b
 print "i",data.i
Category:Implementations
Bayes Leaf

Bayes Leaf is a cell-based esoteric programming language created by Peter Berg in 2013. It utilizes random number rolling.
== Instructions ==
Command	Output
U 	Increments the current cell's value.
D 	Decrements the current cell's value.
Y 	Moves the cell pointer two places to the left if the current cell value is odd, and three places to the right if the current cell value is even.
Z 	Lifts up the cell pointer and places it on a random cell.
R 	Rolls a random number between 1 and 9.
Q 	Rolls a random number between 1 and 99.
R(X) 	Performs X — which can be any other command(s) — a random number of times between 1 and 9, then continues.
R(R(X))	Performs R(X) a random number of times between 1 and 9, then continues. R-command nesting can continue infinitely. Q can be substituted for R.
Fig 	Sets the current cell's value to the most recently rolled random number.
Bop 	If the current cell's value is zero, do nothing. If it is not zero, output the cell's value as an ASCII character.
Sn 	Fools the program into terminating.
Once initiated, a program loops until the Sun explodes, at which point it prints the front sprite of the Pokémon Bayleef from the Generation V Pokémon games, and then terminates. (An example sprite is available on Bulbagarden Archives.) If you use the Sn command and fool the program into thinking the Sun has exploded, it will do the same thing, but at a reduced speed of 16 pixels per second. Rest assured that when the Sun actually does explode, Bayleef will be printed very quickly.
=== FAQ ===
Q: How large and numerous are the cells in Bayes Leaf?
A: There are infinite cells, and each cell's value is unbounded.
Q: Is it mandatory to use that particular Bayleef sprite, or can a conforming implementation display a cropped version using the 256 colors provided by modern terminals?
A: The latter option is correct.
Q: But if the Sun explodes—
A: Hush, you.
Category:2013
Category:Languages
Category:Unimplemented
Category:Unknown computational class
Category:Low-level
Category:Cell-based
Bbblang

Bbblang is a Turing tarpit created by User:CreeperBomb. "Bbblang" is either pronounced as /'b::leıŋ/ or /'bbbleıŋ/, depending on which one turns out to be less intuitive for the general people. It takes place on a bidirectionally (up-down) infinite tape of cells and one pointer, each cell storing integers 0-3, inclusive. Only the parity (even/odd) of each cell is readable and writable to the user, but is readable and writable at all times. There are four commands, written in quaternary:
Value	Action
2 	Increments the pointed cell, wrapping back to 0 on overflow
1 	Moves the pointer up if the value of the pointed cell is less than 2, and down otherwise
3 	Goes immediately after matching 0 if the current cell is even
0 	Goes to matching 3
These are then concatenated and converted to base suboptimal to get the final code. Blank programs become 0 during this conversion.
Category:Languages
Bbtos

�BRING BACK THE OLD SANDBOX is a joke esolang developed with the goal of it being a "memorial language", but has failed at its goals, which was made by User:Tommyaweosme.
== Commands ==
 R prints "BRING BACK THE OLD SANDBOX"
Any other character else does nothing
== Quine ==
 BRING BACK THE OLD SANDBOX
==Interpreters==
Befunge-93:
>~:"R"-|
^ >0"XOBDNAS DLO EHT KCAB GNIRB">,:#v_$52*,
^ < ^ <
><>:
 i:"R"=?!;"XOBDNAS DLO EHT KCAB GNIRB"oooooooooooooooooooooooooo~
The text outputting is kinda cringe but I couldn't think of another way. Outputs "BRING BACK THE OLD SANDBOX" until it hits a character that's not R.
Python:
 print(''.join('BRING BACK THE OLD SANDBOX'if i=='R'else''for i in input()))
BASE:
 ASSIGN i TO USER
 WHILE TRUE:
 IF i IS R IF YES THEN
 PRINT BRING BACK THE OLD SANDBOX
！中文:
输入一串字符串。如果字符串中有R，就输出（R的出现次数）次“BRING BACK THE OLD SANDBOX”，否则啥也不做。
Category:Joke languages Category:Languages Category:Implemented Category:Output only Category:Total Category:Unusable for programming
Beatnik Extended

Beatnik Extended is two seperate Turing complete extensions of Beatnik created by User:ChuckEsoteric08
==Additions==
===Infinite Beatnik===
This version is only different from Beatnik by having unbounded non-negative integers instead of bytes on a stack. This version is Turing complete by reducing Minsky machine and other counter machines into it. Difficulty is that it can only access top two values on the stack to make, for example, interpreter of another esolang into it, Unlike the next one.
===Reversing Beatnik===
It adds additional opcode:
 18 - reverse the stack
The language is Turing complete because it is easy to translate brainfuck or even Turing machine itself into it
==Assembly notation==
To further simplify programming in them, there is additional Assembly-like notation for opcodes that is compatible with both of these and original Beatnik that would later be compiled into either of them:
 Op Cmd
 5 n psh n
 6 pop
 7 add
 8 inp
 9 out
 10 sub
 11 swp
 12 dup
 13 n fz n
 14 n fnz n
 15 n bz n
 16 n bnz n
 17 hlt
 18 rev (only RevBeatnik)
 none lbl: (declare lable for jumping)
Category:Languages Category:Turing complete Category:Unimplemented Category:Stack-based Category:2024 Category:Pseudonatural Category:Low-level
Beautiful day

Beautiful day is a functional and string-rewriting esolang.
== Overview ==
Source code consists of zero or more rules. Each rule ends with a semicolon and contains left-hand-side and right-hand-side separated by a hyphen. Syntax of rules are identical as in Golden sunrise, but instead of bits, any character can appear. However, characters \/#-.(); and whitespace characters must be escaped by prepending a backslash before each of them. On the left-hand-side, parentheses do not need to be escaped. Meaning of parentheses is identical as in Golden sunrise.
However, instead of being able to match exactly one rule in each step, this language matches all possible rules and for each match creates a new branch. It starts from an empty parentheses and keeps executing all branches in parallel. When no rule can be matched, that branch is deleted. When no parentheses are left, the string that remains is called a constructible string. Each program defines a set of constructible strings.
== I/O format ==
Input is a string (can contain any characters). Output is a single bit. If the input string is constructible by the program, the output bit is 1, otherwise the output bit is either 0 or the program does not halt.
== Examples ==
=== Output 1 iff the input consists of zero or more letters A ===
 # - (c);
 a - (b)(c);
 b - A;
 c - /;
 c - (a);
=== Output 1 iff the input is a palindrome that includes only letters A, B and C ===
 # - (palindrome);
 palindrome - /;
 palindrome - (letter);
 palindrome - (func(letter));
 func - .(palindrome).;
 letter - A;
 letter - B;
 letter - C;
== Interpreters ==
Interpreter
Category:Languages
Category:Turing_complete
Category:Implemented
Category:2020
Category:Functional paradigm
Category:String-rewriting paradigm