nyuuzyou/wikis huggingface dataset:
VeriBasic

VeriBasic is a programming language, inspired by Verilog and PHP.
== Example ==
 // Connect two positive logic signals to AND-gate to LED Diode via basic wire
 <?veribasic
 $andGate = new AndGate(VCC,VCC);
 $ledDiode = new LEDDiode();
 $wir000 = new BasicWire($andGate,$ledDiode);
 turnOn();
 lookAt($ledDiode);
 ?>
Outputs true or an image of a red lightning LED diode.
Category:Languages Category:2018 Category:Object-oriented paradigm
Version

Version is an esoteric programming language based on the concept of ignorance-spaces, created by Chris Pressey in 2001.
A Version program consists of a series of instructions; when the final instruction is executed, control returns to the first instruction. Each instruction has a label. An ignorance-space is a regular expression; instructions whose labels match this regular expression will not be executed.
==External resources==
* 
Category: Languages
Category: High-level
Category: Implemented
Category: 2001
Version2

Version2 is a extension of Version invented by User:Zzo38 and with a few extra commands:
* (out) STORELAST = Set to "TRUE" to store last_var when used (default is "TRUE")
* (out) LASTVAR = Set name of last variable used
* (out) NEXTLINE = Set text on next line of the program
* (in) COUNTIGNORE = Counts number of lines ignored since the last executed line
* (in) PREVLINE = Text on previous line of the program
* (func) LASTVAR x = Return name of last variable followed by x
* (func) CHR x = ASCII character numbered x
* (func) ORD x = ASCII number of first character of x
== External resources ==
* Version2 interpreter in Perl
Category:Languages Category:Implemented
Vertical

Vertical is an esoteric programming language made to be unreadable by User:Deppong that uses only vertical characters, and has a single stack as well 
as a single register.
==Language overview==
The code is interpreted very similarly to Brainfuck in that it only accepts Vertical acceptable characters and ignores all other characters int the .vrt file. Vertical uses a single stack, and a single register to process the follow commands:
Command	Function
l 	Push register to the stack
I 	Pop from stack
1 	Increment register
| 	Decrement register
) 	Reset register (to zero)
[ 	Increment top value of stack
] 	Decrement top value of stack
T 	Swap the top 2 values of the stack
/ 	Start of loop
\ 	Jump to corresponding loop start while the value at the top of the stack is not zero
! 	Print the top value of the stack as ASCII char
( 	Save input of one char to the register
==Examples==
===Hello World!===
Hello World in vertical:
11111 11111l)
1111 1111l)
/
 1111
 ]
\
1l)TI
11111 11111l)
/
 11111 11111
 ]
\
lTI
1111 1111l
111 111l
|||l
||||||||||||||||||||||||l)
1111 1111l)
/
 1111
 ]
\
l)TI
11111 11111l)
/
 11111 11111
 ]
\
11111111111lTI
|||ll
|||||||l
|||||||||||||||||||||||||||||l)
!I!I!I!I!I!I!I!I!I!I!I!I!
Hello world without any formatting:
1111111111l)11111111l)/1111]\1l)TI1111111111l)/1111111111]\lTI11111111l111111l|||l||||||||||||||||||||||||l)11111111l)/1111]\l)TI1111111111l)/1111111111]\11111111111lTI|||ll|||||||l|||||||||||||||||||||||||||||l)!I!I!I!I!I!I!I!I!I!I!I!I!
===Cat===
(l!/(l!\
==External resources==
* C implementation and programs
Category:Languages
Category:Implemented
Category:Stack-based
Category:2020
Category:Turing tarpits
Vigil

Vigil is an esoteric programming language similar to Python, created by Bob Nystrom, aka munificent in 2013.
Its primary distinguishing feature is its supreme moral vigilance. Using swear and implore, functions may specify what they accept and return. Non-compliant functions are automatically deleted from the source file.
==External resources==
*Bob Nystrom's GitHub site
**Vigil repository
Category:2013
Category:Languages‏‎
Violation

Violation is inspired by Error which is inspired by ErrorFull which is inspired by ErrorFree. It is created by User:None1.
It outputs:
 Fuck!!!
And deletes the interpreter.
==Examples==
===Quine===
 Fuck!!!
==Violation+==
Violation+ is a variation of Violation where the interpreter is not deleted, allowing it to be a Nope. derivative.
===Examples===
====Quine====
 Fuck!!!
====Self Interpreter====
 Any text can go here.
====Self Interpreter 2====
 Fuck!!!
====Self Interpreter 3 (the shortest)====
==Interpreters==
The following interpreters are in Python.
===Violation===
import sys,os
print('Fuck!!!')
os.remove(sys.argv[0]) # Deletes the interpreter
===Violation+===
 print('Fuck!!!')
===See also===
* ErrorFull
* Error
Category:Languages
Category:Joke languages
Category:Unusable for programming
Category:Output only
Category:Total
Category:Unusable for programming
Category:Nope. derivatives
Category:No-code esolang
Visify

Visify is an assembly-like esolang by User:PythonshellDebugwindow that can be used to draw graphics.
==Syntax==
Visify code is made up of newline-separated commands grouped into blocks by headers. Code under a specific header executes at certain times. Headers start with an = equals sign, and commands use the syntax name arg1 arg2.
===Headers===
Header 	Called
=setup 	At the start of the program
=click 	When the mouse is clicked
=update	Every tick
===Commands===
arg1 denotes the first argument, and arg2 denotes the second one.
Command	Meaning
f 	Fill the pixel at (X,Y) = (arg1,arg2) (set it to black)
e 	Empty the pixel at (X,Y) = (arg1,arg2) (set it to white)
ve 	Set the variable arg1 to arg2
jf 	If arg1 doesn't evaluate to 0, then jump to the 1-indexed arg2th line
===Arguments===
Command arguments can take any of the following forms:
* Integer: a base-10 integer
* Variable: the first character is a $ dollars sign, and the rest of the argument is the variable to get (set with ve)
** Special variable: if the variable to get is x, return the mouse X, and if the variable to get is y return the mouse Y
* Logical negation: the first character is a ! exclamation mark, and the rest of the argument is parsed as usual and then logically negated (0 becomes 1, and all other integers become 0)
* Addition: the argument is split around the + plus sign, and all the split sections are parsed as usual and then added together
===Comments===
Comments last until end-of-line and are denoted by #, e.g. f $x $y #Fill the pixel under the mouse
==Examples==
===Truth-machine===
Instead of waiting for input from the keyboard, this Truth-machine waits for the mouse to be clicked and uses its X position as input, drawing an infinite line across the screen buffer if the X position is nonzero.
 =setup
 ve cx 0
 =click
 jf !$x 7
 f $cx 0
 ve cx $cx+1
===Basic painter===
Whenever the mouse is clicked, the pixel at the mouse's position gets filled in (but not erased after).
 =click
 f $x $y
==Computational class==
Visify is able to simulate a Minsky machine, as variables can be incremented and decremented and jumps are conditional.
==External resources==
* A Python interpreter on GitHub using Pygame
Category:Languages Category:2020 Category:Implemented Category:Low-level Category:Turing complete Category:Turing tarpits Category:No IO
Voclex

Voclex is esoteric, very functional based language. Here is all is functions.
==Examples==
===Hello, world!===
main{
rem($COM$ is comma, because comma symbol is special symbol);
outputln(Hello$COM$ world!)l
}
=== Truth-machine ===
one{
output(1);
one();
}
zero{
output(0);
stop();
}
main{
set(inp,input(> ));
if(=(get(inp),0),{
zero();
},{
if(=(get(inp),1),{
one();
},{});
});
==Docs==
Instruction 	Desc
output(str) 	output string to screen
outputln(str) 	output string to screen with line feed
rem(anytext) 	Comment
chr(ascii) 	Returns char by his ascii code
ord(abysymbol) 	Returns ascii code of char
strcat(str1,str2) 	Contactive strings
strcmp(str1,str2) 	Compare strings
strrev(str) 	Reverse str
strrep(str,what,to) 	Replace what to to in str
strlen(str) 	Returns string length
strtolow(str) 	Converts string to lower case
strtoup(str) 	Converts string to upper case
+(a,b) -(a,b) *(a,b) /(a,b) %(a,b) 	Math
=(a,b) !(a,b) !=(a,b) >=(a,b) <=(a,b) <(a,b) >(a,b)	Condtitional
if(cond,{true},{false}) 	Condtitional
ifNot(cond,{true},{false}) 	Condtitional
stop() 	Stop execution
set(var,val) 	Set variable
get(var) 	Returns variable value
inc(a) dec(a) 	Returns a+1 or a-1
Soon will added all commands.
== External resources ==
* http://alc.comuf.com/Voclex.zip (Implementation on Node.js)
Category:Languages
Category:Functional paradigm
Category:Unknown computational class
Category:Implemented
Category:2016
Voiced dental fricative

Voiced dental fricative or "ðis" is Schwa-derived language.
==Description==
Like in Schwa, it has two States:
*Voiceless(or θ)
*Voiced(or ð)
And 4 commands:
*t
*d
*h
*e
Commands do different things in each state(In start of proggram state is "Voiceless"). Here is table, which show what commands do in each state
Command	Voicless State 	Voiced State
t 	Get input and store it in accumulator 	Output accumulator
d 	Start a while loop, which ends when accumulator contain ð or θ	Start a while loop, which ends when accumulator contain ð or θ
h 	Switch State 	Switch State
e 	End while loop 	End while loop
==Examples==
===Cat===
 dththe
Explaination:
 d - Start While Loop
 t - Get input
 h - Switch State
 t - Output
 h - Switch State to make loop work
 e - Ends While Loop
==See Also==
*Schwa - similar language
Category:Languages Category:Finite state automata Category:Unimplemented
Void

Void is User:None1's first esolang (that isn't a dialect of an old esolang) invented in 2025.
==Types==
This esolang is an untyped one as it has only 1 type: void. Unlike the type with the same name in most practical languages, this type can not only store empty value but also store a lambda function. We'll use none to represent a void type that contains no value in the rest of the article.
==Features==
==Code==
Commands are separated by semicolons, like C and C++.
===Lambda functions===
A lambda function is defined like this, similar to that of C++:
 ([](arg1,arg2,...){code})
The brackets that wrap around the function are mandatory (unless it is in a return statement).
Of course, the type of the function itself, its arguments (if any) and its return value are all void.
====Named functions====
A named function is defined like this:
 [name](arg1,arg2,...){code}
===Return statements===
The return statement is like this:
 ->(statement);
The brackets are mandatory as well.
To return none, use this syntax:
 ->();
If a function doesn't have a return statement, it returns none.
===Conditional===
The conditional statement is like this:
 ?(statement){code}
If statement isn't none, code is done.
===Calling a function===
 (function)(arg1,arg2,...)
Again, the brackets are mandatory.
If there are not enough arguments, the remaining arguments are initialized with none. If there are too many, the excess arguments are stripped off.
===I/O===
There's no I/O.
==Computational class==
It is Turing complete because it can be translated from a 2-register Minsky machine.
We can use nested lambda functions for numbers, the level a function is nested represents its value, none is 0.
First, we can write the increment function and the decrement function:
 [inc](a){->([](){->(a);});}
 [dec](a){->((a)());}
Next, we can use recursion for jumps.
Finally, we can use the conditional statement for conditional jumps.
Category:Languages
Category:2025
Category:Unimplemented
Category:No IO
Category:Turing complete
Category:Functional paradigm
VoidLang

A stack-based language. It supports eval, user input, loops, and basic math.
It was designed by iovoid.
== Operators ==
* " starts and end pushing to stack
* ! prints the first element of stack, deleting it
* * multiply the two first elements of stack, deleting the originals
* / will divide the first element of stack with the second, deleting the originals
* + will add two first elements of stack, deleting the originals
* - will remove the first element of stack with the second, deleting the originals
* [ starts a loop
* ] ends a loop
* ~ breaks from a loop
* ? break if the first element of stack is 0
* # break if the length of stack is 1 or 0
* . pop first element of the stack
* % adds a random item to the stack, from 1 to 255
* $ push the length of the stack
* _ replace first item of stack with it converted to a string, if impossible return the original
* & eval the concatenation of all elements in the stack, replaces stack with output
* , take a line of input from stdin
* ; does nothing
* ^ push the program code to the stack
* | actually print the output (! is still needed)
* = end the program
== Computational class ==
VoidLang is an extended pushdown automaton with multiply and divide, but has no way of performing divisibility checking without destroying the counter since there is no instruction which takes an element of the stack and produces at least two elements based on it. Therefore, it is in the class of push-down automata.
== Examples ===
===== Hello, World! =====
 "Hello, World!"[#!]
What's done here? First, " opens the pushing of items to stack (H,e,l,l,o,...), later " closes it. Inside a loop, every item of the stack is printed until its empty.
===== Other Hello World!=====
 "89"*_!"ello World!/"[!#]
Here, the / is purposefully eaten by [!#] that will ignore the last character
===== REPL (Read-Eval-Print Loop) =====
 ,&[#!]$^&
Here, input is asked with , and then & evals it. Later a [!#] prints everything, like in Hello, World!.
===== Cat program =====
 ,[#!]$^&
^& will repeat the program by eval-ing itself
===== Cheating quine =====
 ^[#!]
== Implementations ==
* In Node.JS, by iovoid: https://gist.github.com/io4/c82798e6dfd918e37fe11f67283184a7
Category:Implemented
Category:Stack-based
Category:2016
Category:Push-down automata
Von Neumann's 29-state cellular automaton

Von Neumann's 29-state cellular automaton is a Cellular automaton published in 1966. 
The state of the automaton is a square grid filling the whole plane, in which each cell of the grid can have one of a set of 29 states. Each cell is considered to have four neighbors, the ones that are exactly 1 Manhattan distance from it. The state is updated at each clock cycle (generation), in which the state of each cell is replaced simultaneously. The state of the cell is determined by its state and the state of its four neighbors, through a rather complicated rule.
This cellular automaton was deliberately constructed by von Neumann as a Turing-tarpit. (To define it as Turing-complete, we need to restrict starting patterns as finite, but I don't know what finite means in this case.)
The automaton is described in the following book, which is credited as the inspiration for the whole line of research in Game of Life and other Cellular automaton.
von Neumann, J.; Burks, A. W. (1966) Theory of Self-Reproducing Automata (older pdf). No ISBN. WorldCat OCLC number: 7298386.
Category:Languages
Category:Before 1993
Category:Cell-based
Category:Turing complete
Category:Turing tarpits
Category:Two-dimensional languages
Category:Low-level
Category:Self-modifying
Category:Cellular automata
Vowels

vowels is a programming language that was designed by Matthew "mattmik" Mikolay in 2011. It was designed to explore alternative ways to pass data to command calls. Instead of using the traditional system of parameters and arguments, all data passed to a vowels command call comes from the number of vowels repeated in a particular call.
==Key Letters and Vowel Repetition==
Each vowels command contains a key letter, which is always the first vowel found in the command name that is not the last letter. By repeating this vowel in a command call, data is sent to the command. For example, the following command call instructs the interpreter to jump to line 12, as it contains twelve repetitions of the first vowel in the goto command:
gooooooooooooto
==Example Program==
The following vowels program prints out the message "Hello, World!":
: Point the target variable to Variable 1
point
: target = 72, then print as ASCII character (H)
assiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiign
charprint
: target = 101, then print as ASCII character (e)
assiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiign
charprint
: target = 108, then print as ASCII character (l)
assiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiign
charprint
: target = 108, then print as ASCII character (l)
assiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiign
charprint
: target = 111, then print as ASCII character (o)
assiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiign
charprint
: target = 44, then print as ASCII character (,)
assiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiign
charprint
: target = 32, then print as ASCII character ( )
assiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiign
charprint
: target = 119, then print as ASCII character (W)
assiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiign
charprint
: target = 111, then print as ASCII character (o)
assiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiign
charprint
: target = 114, then print as ASCII character (r)
assiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiign
charprint
: target = 108, then print as ASCII character (l)
assiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiign
charprint
: target = 100, then print as ASCII character (d)
assiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiign
charprint
: target = 33, then print as ASCII character (!)
assiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiign
charprint
==External resources==
* The Google Code homepage for vowels
Category:Languages
Vowels (2017)

Not to be confused with vowels (2011).
Vowels is an esoteric programming language created in 2017 by Ethan Howell. In a Vowels program, the only valid symbols are the upper and lowercase English vowels (including y) and all other symbols (including whitespace) are ignored. The full Vowels program specification and interpreter is available on GitHubVowels Interpreter on GitHub, link to interpreter and language specification..
==Sample Programs==
===HelloWorld.vw===
 ue
 yeouo
 euea
 euai
 euai
 euoa
 eaiu
 eaao
 eioo
 euoa
 euou
 euai
 euee
 eaai
 eeoe
 eeee
 y
===Cat.vw===
 ieeyyu
 uae
 iaeyyu
 uie
 o
 o
 y
==Computational class==
A Vowels program has access to two stacks on which the specification imposes no limit of size, instructions to move numbers around
and add and subtract them, and while loops which execute as long as a condition such as "not equal to zero" is true.
It should therefore be straightforward to reduce brainfuck to Vowels to show that Vowels is Turing-complete.
==References==
	
Category:Languages
Category:2017
Category:Stack-based
Category:Turing complete
Category:Implemented
Category:Thematic
Voxvy

The Voxvy IDE is an IDE conceptualized by User:PythonshellDebugwindow in November 2019.
==Languages included==
Voxvy includes the following languages:
* Python
* JavaScript
* Java
* C
* C++
* C#
* Brainfuck
It also includes the following "Voxvy originals":
* Stu
* HZOP
* RFN (Remote File Networking)
* DOML (Directionally Oriented Markup Language)
** Together with DOSS (Directionally Oriented Style Sheets) and either RFN or DOSL (Directionally Oriented Scripting Language)
Category:2019
Vrejvax

Vrejvax is a three- or five-instruction Boolfuck derivative designed by User:Nortaneous in 2008. An interpreter was written by User:Madk in 2010. There is an incomplete interpreter written in QuickBASIC available here. 
== Pronunciation ==
The name is represented in IPA as vɹeɪ̯vax. "Vrejvax" is a contraction of the Foolang phrase "vrejas vaxra", meaning "mind-fucker".
== Instructions ==
Instruction 	Description
Flip the current bit and increment the pointer.	
< 	Decrement the pointer.
? 	If the current bit is a 1, jump to the instruction located at the position given by the byte to the immediate right of the current bit; if that byte is zero, add 256 to the location of the byte after that and jump to the instruction given by that; if that byte is zero, add 256 again and get the next byte, and so on.
, 	Same as boolfuck.
. 	Same as boolfuck.
The , and . instructions are not required for Turing completeness, so they can be omitted.
== Example code ==
===Hello World===
 +<+++<++<++<<<<<.+<++<+++<++++<++<<<<<<<<.+<++<++<++<+++<++<++<<<<<<<<..+<++<++<++<++<++<+++
 <<<<<<<<.+<+++<++<+++++<<<<<<<<.+<+++++<++++<<<<<<<<.+<++<++++<<<<<.+<++<++<+++++<++<<<<<<<<
 .+<++<++<++++++<+<<<<<<<<.+<++<++<++<+++<++<++<+<<<<<<<<.+<+++<++<++<+++<++<<<<<<<<.
===Cat===
 ,.
== External resources ==
* Download interpreter by User:Madk
* http://nortaneous.freehostia.com/wiki/doku.php?id=vrejvax 
Category:Languages
Category:Turing tarpits
Category:Turing complete
Category:Low-level
Category:Cell-based
Category:Brainfuck derivatives
Category:Implemented
Category:2008
Vroom

Vroom is a three-dimensional esolanng based on the concept of pathfinding. Every vroom program is composed of one or more blocks of code. Code blocks are separated by an empty line. The program starts in the first block. The cursor starts in slot 1:1 (the top left) and then moves to 1:3 through the fastest way possible. However, it can only move on spaces. Each time the cursor moves, it will run the instruction written under it (so 1:1 run the instruction in 2:1 and 314:42 runs 315:42). Once it reach the end of the code block, it will go to the beginning of another block of code determined by the last value of the stack. If the stack is empty or the block doesn't exist, the program will stop. Since some IDEs replace 2 spaces with a tab, tabs are replaced by 4 spaces when the code is read.
==Commands==
Name 	Description
' ' 	Add the Unicode value of the next operation to the stack and skip the next operation
# 	Skip the next instruction
? 	If the last value of the stack is not 0, skip the next instruction
p 	Print the last value of the stack as a Unicode character
⌨ 	Push a value inputted by the user at the beginning of the stack (each character a value + the length of the input)
Pop the last 2 values of the stack, add them and push the result 	
Pop the last 2 values of the stack, substract them and push the result	
* 	Pop the last 2 values of the stack, multiply them and push the result
/ 	Pop the last 2 values of the stack, divide them and push the result
% 	Pop the last 2 values of the stack, modulo them and push the result
^ 	Pop the last 2 values of the stack, power them and push the result
¬ 	Pop the last value of the stack, push the opposite
> 	Push 0 to the stack if the last value is positive
< 	Push 0 to the stack if the last value is negative
→ 	Move every value in the stack to the right
← 	Move every value in the stack to the left
⇄ 	Swap the last 2 values of the stack
↩ 	Reverse the stack
0 	Pop the last value of the stack
2 	Duplicate the last value of the stack
§ 	Do nothing
Any other character will return an error if read by the interpreter, but they won't do anything if they aren't read.
==Examples==
===Hello, World!===
 | |
 ppppppp§ § |
 H | |
 e | p § |
 l | |
 l | p § |
 o | |
 , | p § |
 | |
 w | p § |
 o | |
 r | p §|
 l | |
 d |p |
 ! |
 §§§§|
This program pushes the Unicode value of each character of "Hello, World!" to the stack and prints them one at the time.
===Cat program===
 | |
 |2-0← |
 |
 !-⌨←>§|
 
 | |
 |2+←<0← |
 |
 ←0→p2←2→-|
This program takes an input from the user. If this input is not null, it enters the second block, where it loops and prints each character one at the time until the there's no value left in the stack.
===Truth machine===
 | |
 |§2+0← |
 |
 0 0⌨-⇄2+|
 
 | |
 |20← |
 |
 ←0 1←p|
 
 | |
 |§ |
 |
 0↩p|
This program takes an input from the user, checks if the input is 1, running the second block (which prints 1 indefinitely) if so, and going to the third block (which just prints a 0 once) if not.
Category:Languages
Category:2023
Category:Turing complete
Category:Multi-dimensional_languages
Category:Implemented