nyuuzyou/wikis huggingface dataset:
V (FMota)

V is an esoteric programming language made by Francisco Mota circa 2007. It is called V after the sequence of instructions \/.
=What is it?=
A V program is a series of instructions to a machine (called the operator) that operates on a sum-tree. A sum-tree is a binary tree of infinite height (both up and down). It is composed, obligatorily, of three parts: the root node which has a value, a left subtree that is also a sum-tree, and a right subtree that is also a sum-tree. The value of the root node is the sum of the value of the root nodes of its subtrees (that is, if the left-subtree's root node has the value x, and the right-subtree's root node has the value y, then our root node has the value x+y).
There are 7 instructions:
\	The operator moves to the right subtree.
/	If the current tree is a left subtree, the operator ascends to its parent. Otherwise, it mirrors the sum-tree, and then ascends to the parent. Mirroring means that every left subtree swapped places with its corresponding right subtree (the values stay the same, they just switch places).
>	Decreases the left subtree's value by 1, and increases the right subtree's value by 1, preserving the root node value. To decrease a sub-tree's value by 1 is to decrease its right subtree's value by 1. Sort of similarly, to increase a sub-tree's value by 1 is to increase its left subtree's value by 1.
[	If the root node value is zero, jumps forward to the matching ].
]	If the root node value is not zero, jumps back to the matching [.
.	Outputs the value of the root node as an ascii character.
,	Inputs a character, stores it as the root node value. The difference between the root node's current value and the new value is added to the left subtree, and so on propagating the left subtrees. If the EOF is reached, the root node value is set to 0.
An input file can consist of any characters, but only instructions are considered (like Brainfuck).
This sounds really complicated and convoluted. But this is an esoteric programming language, so get used to it.
=Computational Class=
V is Turing Complete, as you can convert a Brainfuck program into a working V program (if it respects the I/O ways of V). Simply transform the Brainfuck instructions into V instructions like so:
 > \
 < /\/
 + >
 - \/>\/
 [ \[/\/
 ] \]/\/
 . \./\/
 , \,/\/
Several optimizations could be made in this translation. For example, converting two instructions at a time:
 -- \/>>\/
 .- \./>\/
 ., \.,/\/
 [. \[./\/
are a few simple optimizations.
==External resources==
*Implementation in Haskell
Category:Languages
Category:Turing complete
Category:Implemented
Category:Brainfuck derivatives
Category:2007
Vague

:This article is detailed enough and does not need to be expanded. Please help us by adding some more implementations.
Vague is an esolang designed by a user.
== Instruction Set ==
?	?
+	Add
-	Decrement
!	Print
>	Right
<	Left
&	NAND
=	Push
_	Pop
.	End
0	Zero
*	Discouraged
2	2D
1	1D
t	True
f	False
(	Start
)	End (
== Examples ==
=== Run code ===
=0!
This program prints something to somewhere you can see.
=== False ===
 f
V⊇O
==Implementations==
===Python 3===
* Vague/AnimaLibera - the only standards-compliant implementation of Vague
* Vague/IFcoltransG - the only standards-compliant implementation of Vague
* Vague/Quintopia - the only standards-compliant implementation of Vague
* Vague/OliveIsAWord - the only standards-compliant implementation of Vague
===Javascript===
* https://github.com/VilgotanL/Esolang-implementations/blob/master/js/vague/intetrpeter%2Cjs.sj.js - the only standards-compliant implementation of Vague
===Java===
* JVauge - the only standards-compliant implementation of Vague
Implementations of Vague in even more languages are wanted. Please add more. All implementations must precisely follow the specification above!
Category:Languages Category:Implemented Category:Unknown computational class Category:Turing complete
Vague/AnimaLibera

An implementation of Vague by User:AnimaLibera. This may be considered a reference implementation because no other implementations are correct.
 """
 The only standards-compliant implementation of Vague
 
 Final version 1
 """
 
 from sys import argv, exit
 from random import randint
 
 if len(argv) <= 1:
 print("usage: python3 vague.py sourcefilename optionalbinarynumber")
 exit(-8)
 
 s = [] if len(argv) < 3 else [c == "1" for c in argv[2]]
 c = open(argv[1]).read().replace("\t", " ").split("\n")
 x, y = 0, 0
 v = [1, 0]
 d = 1 # number of D
 p = 0 # number of (
 
 while True:
 try:
 k = c[y][x]
 except:
 break
 
 try:
 if k.isspace():
 pass
 elif k == "+": # Add
 s.append(bool(int(s.pop()) + int(s.pop())))
 elif k == "-": # Decrement
 if s[-1] == 0:
 raise Exception("there are no numbers below 0")
 s[-1] -= 1
 elif k == "!": # Print
 print(int(s[-1]))
 elif k == ">": # Right
 if d == 1 or (d == 2 and p > 0):
 v[0] = 1
 else:	
 v = [-v[1], +v[0]]
 elif k == "<": # Left
 if d == 1 or (d == 2 and p > 0):
 v[0] = -1
 else:	
 v = [+v[1], -v[0]]
 elif k == "&": # NAND
 s.append(not (s.pop() and s.pop()))
 elif k == "=": # Push
 if s:
 s.append(s[-1])
 elif k == "_": # Pop
 s.pop()
 elif k == ".": # End
 break
 elif k == "0": # Zero
 s = list((False,))
 elif k == "*": # Discouraged
 if randint(0 + d + p + y, 8 + x + v[0]) == 0:
 raise Exception("deliberate use of discouraged instruction")
 else:
 s.append(bool(int(s.pop()) * int(s.pop())))
 elif k == "1": # 1D
 d = 1
 if v[0] == 0:
 v = list((1, 0))
 elif k == "2": # 2D
 if p == 0:
 d = 2
 if abs(v[0]) + abs(v[1]) != 1:
 v = list((1, 0))
 elif k == "t": # True
 s.append(True)
 elif k == "f": # False
 s.append(False)
 elif k == "(": # Start
 p += 1
 elif k == ")": # End (
 p -= 1
 if p < 0:
 raise Exception("no `(` to end when `)` used")
 elif k == "u":
 pass
 else:
 pass
 except:
 p -= 1
 if p < 0:
 raise Exception("no `(` to end when error")
 
 if d == 1 or (d == 2 and p > 0):
 x += v[0] if v[0] != 0 else 1
 if x >= len(c[y]):
 x, y = 0, y+1
 elif x < 0:
 y -= 1
 x = len(c[y])-1
 else:
 x, y = x+v[0], y+v[1]
 
 if s:
 print("".join([str(int(v)) for v in s]))
Category:Implementations
Vague/OliveIsAWord

An implementation of Vague by User:OliveIsAWord. This may be considered a reference implementation because no other implementations are correct.
 #!/user/bin/python
 """
 The only implementation of Vague.
 Note that this implementation of Vague (the only one) has implementation
 defined by modules `stack` and `unsafe`, which may or may not be installed
 """
 
 VERSION = '1.0.0'
 
 def main():
 """Vague."""
 from sys import argv, exit
 if (argc := len(argv)) != 2:
 print(f'Error: expected 1 argument, found {argc - 1}', file=sys.stderr)
 print(f'Usage: {argv[0]} FILEPATH', file=sys.stderr)
 exit(-8)
 with open(argv[1]) as f:
 execute(f.read())
 
 def execute(program):
 """Runs."""
 import stack, unsafe
 for c in program:
 if c == '+': print('Add')
 if c == '-': print('Decrement')
 if c == '!': print('Print')
 if c == '>': print('Right')
 if c == '<': print('Left')
 if c == '&': print('NAND')
 if c == '=': print('Push')
 if c == '_': print('Pop')
 if c == '.': print('End')
 if c == '0': print('Zero')
 if c == '*':
 # Safety: None
 with unsafe('ERROR: discourage overflow'):
 stack.DISCOURAGED
 if c == '2': print('2D')
 if c == '1': print('1D')
 if c == 't': print('True')
 if c == 'f':
 stack += false
 if c == '(': print('Start')
 if c == ')': print('End (')
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 """ """
 g=globals()
 import contextlib as c,sys,random as r
 class s:
 g['false']=False
 def g(g,_):return g
 __iadd__,__getattr__=g,g
 class d:
 def find_module(*_):return d()
 def load_module(_,f):sys.modules[f]=s()if len(f)%2 else u
 @c.contextmanager
 def u(u):
 try:
 for e in r.sample(list(g.keys()),len(g)//2):g[e]=g.copy()
 except:print(u)
 finally:yield
 sys.meta_path.insert(0,d())
 if __name__=='__main__':main()
Category:Implementations
Vandalang

== Vandalang ==
Vandalang is the best language to ever be created. No one knows how it worked, who made it, or when it was destroyed, however the only interpreter was on a floppy disk that was thrown in a bonfire.
== Satire ==
this is quite obviously satire. ill put something here eventually
== Testing ==
For the time being, I'm using this to test my bot. The remaining will be used to reach testing character requirements.
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
Vandevelo

Vandevelo is an input-only esolang by User:PythonshellDebugwindow.
==Values==
The only values in Vandevelo are nil and not nil.
==Statements==
Each line has zero or one statements.
Command 	Meaning
var -> value 	Set the variable var to value (lazy evaluation, evaluated again on each access)
var -!> value	Set the variable var to not value (e.g., (nil) if value == (not nil) else (not nil)) (lazy evaluation, evaluated again on each access)
var ~> value 	Set the variable var to value (strict evaluation, evaluated immediately)
var ~!> value	Set the variable var to not value (e.g., (nil) if value == (not nil) else (not nil)) (strict evaluation, evaluated immediately)
x :: y 	JavaScript (x) && (y); (e.g., short-circuit if; nil is falsy and not nil is truthy)
==Expressions==
Usable within statements.
Expression	Result
var? 	The variable var (error if undefined)
x == y 	Not nil if x == y else nil
x != y 	Nil if x == y else not nil
==Comments==
Comments last until end-of-line, and are denoted by --, e.g. 2? -> 2? --Infinite loop.
==Conventions==
Variable names have to match the regex [A-Za-z0-9_&*$]+, but conventions are to number them starting with 0 incrementing by 1.
==Special variables==
Nil contains nil, and Inp returns user input when accessed (nil if input in {ε, 0, space} else not nil).
==Truth-machine==
 0 -!> Nil?
 1 -> Inp? == 0?
 2 -> 2?
 1? :: 2?
Category:Languages Category:2020 Category:Unimplemented Category:Unknown computational class Category:Usability unknown
Var=Bar

Var=Bar is an esoteric programming language by User:A, and is made up entirely of variables. Each line is just a case-sensitive variable name, followed by =, and then the variable's case-sensitive value.
The variable names can be anything including special names, and the values can be anything as well, and can also be special values:
1N 	prints the variable's value.
0UT 	inputs a value for the variable to take. Be careful: that 0 is zero.
+(add)-(subtract)	do math. For example:
 x=4
 J=x - 2
sets x as value 4 and J as value 2 (4-2). Also:
 f=n
 p=o
 s=f + p
sets f as value n(Any value without 0-9 is a string), p as value o, and s as value no (word math only works with +).
x=condition 	starts a while loop named x with the given condition.
x=STOP 	signifies the end of while loop called x.
Conditions have three parts, two compared values referenced by their names and a comparison.
They only use 3 instructions, which can be:
> 	is greater than
< 	is less than
==	equal to
==Example==
===Truth-machine===
 v=1N
 v=0UT
 x=v==1
 v=0UT
 x=STOP
===Cat Program===
Below follows the implementation of an infinitely repeating cat program:
 infiniteLoop = 1 == 1
 input = 1N
 input = 0UT
 infiniteLoop = STOP
==Interpreter==
* Common Lisp implementation of the Var=Bar programming language.
Category:Languages
Category:Turing complete
Category:Implemented
VarStack

VarStack is an esolang by User:ChuckEsoteric08 where all variables are 1-character stacks.
==Specification==
Commands look like this:
 X;Y;Z
Declare label X, execute command Y and jump to label Z. If you are trying to access non-existing label, stack element, or stack itself then program will halt.
@X:Y 	Create new stack called X with initial element(s) Y
$X:Y 	Push X to stack Y.
!X 	Pop element from stack X and discard it
"X 	Output X
'X 	Output stack X
?X 	Ask for input and push it to stack X
#X=Y:Z	If top of the stack X is equal to Y jump to label Z
!X=Y:Z	If top of the stack X is not equal to Y jump to label Z
%X=Y:Z	If top of the stack X is equal top of the stack Y jump to label Z
~X 	Swap top two elements in stack X
&X 	Reverse stack X
^X 	Move top of the stack X to the bottom
==Examples==
===Hello, World!===
hello;"Hello, World!;halt
===Truth-machine===
 start;@X:0;input
 input;?X;if
 if;#X=0:print0;print1
 print1;"1;print1
 print0;"0;halt
===Bitwise Cyclic Tag interpreter===
You should input program by character. Then input @ and input data. After you inputed data input @ again.
 initprogram;@code:0;initprogramfinish
 initprogramfinish;!code;initdata
 initdata;@data:0;initdatafinish
 initdatafinish;!data;inputcode
 inputcode1;?code;inputcode2
 inputcode2;#code=@:inputcode3;inputcode1
 inputcode3;!code;inputcode4
 inputcode4;&code;inputdata1
 inputdata1;?data;inputdata2
 inputdata2;#data=@:inputdata3;inputdata1
 inputdata3;!data;inputdata4
 inputdata4;&data;interpet
 interpret;#code=0:remove;if1
 remove;!data;move
 if1;#data=1;nextinstruction;move
 nextinstruction;^code;reverse
 reverse;&data;enq
 enq;#code=0:enq0;enq1
 enq0;$0:data;endenq
 enq1;$1:data;endenq
 endenq;&data;interpret
 move;^code;interpret
Category:Languages Category:Turing complete Category:Unimplemented Category:Stack-based
Variambda

This is another esolang by islptng.
The title, is a mixture of "Variable" and "lambda".</br>
The only thing you can do in this esolang is define a variambda.
==Syntax==
Line to define a variambda:
 name(arguments)return_value=initial_value
if (arguments) return_value is not present, it acts as a constant.
if =initial_value is not present, it will be zero when initialized.
Lists are also supported:
 name[index](arguments)return_value=initial_value
How to call a variambda:
 name # returns its value in the variable part
 name(arguments) # returns its result in lambda part and set its variable part to the returned value
Variambdas that is already defined, initializes as 0:
 in_num() : gets a number from stdin
 in_chr() : gets a character from stdin and return its ASCII value
 out_num(n) : prints n in number and returns n
 out_chr(n) : prints n in character (ASCII) and returns n
 sub(a,b) : return a - b
 what(a,b) : if a > 0, return b, else return a
 sum(args) : returns the sum of args
Define a variambda called "fuck": when program starts, it will execute fuck().
Every program without definition of "fuck()" does nothing.
==Examples==
Infinite loop:
 fuck()fuck()=0
Truth machine:
 const49 = 49
 repeat1()sum(out_chr(const49),repeat1())
 fuck()out_chr(what(in_num(),repeat1()))
A+B problem:
 fuck()out_num(sum(in_num(),in_num()))
Category:Languages Category:Unimplemented Category:2024 Category:Unknown computational class
Varnand

Varnand is an esoteric programming language created by User:DoggyDogWhirl. Its name is a combination of "var", an abbreviation of "variable", and "nand", as in the NAND operation.
The purpose of Varnand was to create a language where the only operation is the logical NAND. However, with only hexadecimal literals, it is impossible to create values above 15 (or below 240 if using an 8-bit NAND), making printing letters impossible, so there is also a rotation operation.
==Commands==
Varnand uses Polish notation. All commands return their value. Varnand does not have a way to loop, and thus is not Turing-complete.
Command 	Description
! _ _ 	Logical NAND
% _ _ 	Rotates first value left by second value of bits
O _ 	Outputs value as a number
P _ 	Prints character with given value
I 	Inputs one character
[0-9][A-F]	Hexadecimal value 0-15
[a-z] 	All variables, initialized to 0
= _ _ 	Set variable (first argument) to value
All other symbols are considered comments (although "U" is the only vowel available).
==Example programs==
===2===
Outputs "2".
 O2
===Cat program===
One-time cat program:
 PI
===Hello, world!===
Uses (A NAND A) NAND (B NAND B) as logical OR.
 P!!%44%44!88
 P!!%64%64!55
 =lPP!!%64%64!CC
 =mP!!%64%64!FF
 P!!%24%24!CC
 P%24
 P!!%74%74!77
 Pm
 P!!%74%74!22
 Pl
 P!!%64%64!44
 P!!%24%24!11
Newlines are not necessary and do not affect code.
===Adder===
Adds the values of two inputted characters (mod 256), and outputs that value's character.
 =xI=yI
 =o0
 =n!00
 =c0
 =a!n!1x=b!n!1y
 =d!ab=e!!da!db
 =f!ce=g!!fc!fe=o!!oo!gg
 =h!df=c%h1
 =a!n!2x=b!n!2y
 =d!ab=e!!da!db
 =f!ce=g!!fc!fe=o!!oo!gg
 =h!df=c%h1
 =a!n!4x=b!n!4y
 =d!ab=e!!da!db
 =f!ce=g!!fc!fe=o!!oo!gg
 =h!df=c%h1
 =a!n!8x=b!n!8y
 =d!ab=e!!da!db
 =f!ce=g!!fc!fe=o!!oo!gg
 =h!df=c%h1
 =a!n!%14x=b!n!%14y
 =d!ab=e!!da!db
 =f!ce=g!!fc!fe=o!!oo!gg
 =h!df=c%h1
 =a!n!%24x=b!n!%24y
 =d!ab=e!!da!db
 =f!ce=g!!fc!fe=o!!oo!gg
 =h!df=c%h1
 =a!n!%44x=b!n!%44y
 =d!ab=e!!da!db
 =f!ce=g!!fc!fe=o!!oo!gg
 =h!df=c%h1
 =a!n!%84x=b!n!%84y
 =d!ab=e!!da!db
 =f!ce=g!!fc!fe=o!!oo!gg
 =h!df=c%h1
 Po
==Implementation==
Implementation in Python
Category:Languages Category:Implemented
Varnand/Python Implementation

An implementation of Varnand written in Python 3.
 import sys
 
 code="""code goes here"""
 
 vardict=dict(zip("abcdefghijklmnopqrstuvwxyz",[0]*26))
 pnt=-1
 
 def vareval(n): #evals int, hex string digit, var
 if isinstance(n,int):
 return n
 if n in "0123456789ABCDEF":
 return int(n,16)
 if n in vardict:
 return vardict[n]
 
 def nand(x,y): #!
 x=vareval(x)
 y=vareval(y)
 return 255-(x&y)
 
 def redefine(strvar,newnum): #=
 assert strvar in "abcdefghijklmnopqrstuvwxyz","Attempted to redefine non-variable"
 newnum=vareval(newnum)
 vardict[strvar]=newnum
 return newnum
 
 def rotate(num,rot): #%
 num=vareval(num)
 t=2**(8-rot%8)
 return (num%t)*int(256/t)+num//t
 
 def oprint(num): #O
 num=vareval(num)
 print(num,end="")
 return num
 
 def pprint(num): #P
 num=vareval(num)
 print(chr(num),end="")
 return num
 
 def func():
 global pnt
 pnt+=1
 if code[pnt]=="!":
 return nand(func(),func())
 elif code[pnt]=="=":
 return redefine(func(),func())
 elif code[pnt]=="%":
 return rotate(func(),func())
 elif code[pnt]=="O":
 return oprint(func())
 elif code[pnt]=="P":
 return pprint(func())
 elif code[pnt]=="I":
 return ord(sys.stdin.read(1)) #I
 elif code[pnt] in "0123456789ABCDEF":
 return int(code[pnt],16)
 elif code[pnt] in "abcdefghijklmnopqrstuvwxyz":
 return code[pnt]
 else:
 if pnt<len(code)-1:
 return func() #comments
 
 while pnt<len(code)-1:
 func()
Category:Implementations
Velik

velik is an IRC bot maintained by User:Nakilon. It was created in 2021-05. It is resident on the libera/##nakilon and some other IRC channels. It can execute RASEL language (spec v1, i.e. supports $) code. It also responds to some other commands such as querying Esolang Wiki, Wikipedia, Wolfram Alpha, encode/decode Morse code -- use \help to see all the commands.
 11:16:48 <nakilon> \rasel "!dlroW ,olleH">:?@,Gj
 11:16:49 <velik> output: Hello, World!, exit code: 0
 11:17:04 <nakilon> \rasel -stdin|1 2 3|& .& .& .@
 11:17:05 <velik> output: 1 2 3 , exit code: 0
 10:09:08 <nakilon> \rasel -stdin|10|-multiline|1&$:?v:1-3\$/1\| >$11\/.@
 10:09:09 <velik> output: 3628800 , exit code: 0
 16:35:06 <nakilon> \wiki rasel
 16:35:07 <velik> RASEL (Random Access Stack Esoteric Language) is a fungeoid esoteric programming language. The main goals of making another fungeoid were: https://esolangs.org/wiki/RASEL
 16:35:12 <nakilon> \wiki velik
 16:35:13 <velik> velik is an IRC bot maintained by User:Nakilon. It was created in 2021-05. It is resident on the libera/#esolangs channel. It can execute RASEL language code and also responds to some other commands (use \help to see all of them). https://esolangs.org/wiki/Velik
 16:36:25 <nakilon> \wp linux
 16:36:26 <velik> (see also: Linux kernel) Linux -- family of Unix-like operating systems that use the Linux kernel and are open source https://en.wikipedia.org/wiki/Linux
 09:14:18 <nakilon> \wp VPCLMULQDQ
 09:14:20 <velik> AVX-512 are 512-bit extensions to the 256-bit Advanced Vector Extensions SIMD instructions for ...
 20:48:35 <nakilon> \wp-fi esolang
 20:48:36 <velik> Esoteerinen ohjelmointikieli tai esolang on ohjelmointikieli, ...
 14:40:31 <nakilon> \wa x^3 - 4x^2 + 6x - 24 = 0
 14:40:33 <velik> Real solution: x = 4 | Complex solutions: x = -i sqrt(6), x = i sqrt(6) | Alternate forms: (x - 4) (x^2 + 6) = 0, (x - 4/3)^3 + 2/3 (x - 4/3) - 560/27 = 0
 12:53:52 <nakilon> \morse hello world
 12:53:53 <velik> .... . .-.. .-.. --- / .-- --- .-. .-.. -..
 12:54:16 <nakilon> \demorse .... . .-.. .-.. --- / .-- --- .-. .-.. -..
 12:54:18 <velik> HELLO WORLD
 12:54:27 <nakilon> \demorse ru .... . .-.. .-.. --- / .-- --- .-. .-.. -..
 12:54:28 <velik> ХЕЛЛО ВОРЛД
Apart from commands starting with a backslash, velik also reacts to ping and one particular syntax anywhere inside IRC lines: [[Any search keywords]]
 13:35:01 <nakilon> I'm lazy to provide the full URL for [[velik]] so velik will do it for me
 13:35:02 <velik> https://esolangs.org/wiki/Velik
Also it can just talk if you ask:
 16:04:21 <nakilon> velik don't do drugs
 16:04:32 <velik> a bit address
* bot source code
* rasel command remote executor source code
Category:People
Velocityfuck

==Creator and Name==
Velocityfuck is an esoteric language created by User:Esolang1. The difference from brainfuck is that the pointer can gain velocity, and it will move even when another instruction is being executed. (E1-0003)
==Code==
As written, the pointer can gain velocity. The initial velocity is set to 0, and then when '<' or '>' is executed, the velocity will increase or decrease. On each instruction execution, the pointer will move velocity amount of times to the right, and then execute the instruction.
===Instructions===
 > Increment the pointer velocity
 < Decrement the pointer velocity
 + Increment the memory cell at the pointer
 - Decrement the memory cell at the pointer
 . Output the character signified by the cell at the pointer
 , Input a character and store it in the cell at the pointer
 [ Jump past the matching ']' if the cell at the pointer is 0
 ] Jump back to the matching '[' if the cell at the pointer is nonzero
 ~ No operation, used for moving the pointer without changing anything else
==I/O==
The '.', ',' instructions work same as in brainfuck.
==Examples==
===Behavior===
 >+>->+
The memory and the pointer velocity will change according to the following when the code is executed. Pointer velocity is denoted with pv.
 > | pv = 1, mem = 000000000000...
 | ^
 + | pv = 1, mem = 010000000000...
 | ^
 > | pv = 2, mem = 010000000000...
 | ^
 - | pv = 2, mem = 010000000000...
 | ^
 > | pv = 3, mem = 010000000000...
 | ^
 + | pv = 3, mem = 010000000100...
 ^
Category:2022
Category:Languages
Category:Cell-based
Category:Brainfuck derivatives
Category:Turing complete
VenetianScript

:Not to be confused with the Venetian language.
VenetianScript or VS for short, is a music-based esolang created by PoptartPlungerBoi in 2024. The esolang uses MIDI drums as code. 
== History ==
In 2024, PoptartPlungerBoi thought of a musical esolang but using drums as code. This was made after the esolang 100px|frameless|link=Nice also made by PoptartPlungerBoi as another non-textual esolang.
=== Etymology ===
The esolang's name is a combination of both JavaScript and Canadian breakcore musician Aaron Funk, also known by his stage name, Venetian Snares.
== Commands ==
VS 	Description
Kick, Kick, Snare 	Start script
1 Ride 	Print
2 Ride 	Input
3 Ride 	If
4 Ride 	Compute*
Crash 	Store variable
High Tom 	More than
Middle Tom 	Equal
Low Tom 	Less than
Ride, Drum Stick, Quarter rest, *string*, Quarter rest, *string*, Low Tom	Repeat for
Any rest 	Seperate code
Kick 	0 in binary
Snare 	1 in binary
Hi-Hat 	Linefeed
Kick, Ride, Snare, Snare 	Stop this part of script (do NOT use to end script, should be used for 3 Ride/Hi-Hat as an example)
Kick, Ride, Snare 	End Script
The Amen break 	Destroys your speakers
To make a program, any MIDI editor can be used. The MIDI file should have the BPM of 135. (danielx.net's Composer web app is good for making MIDI files as code.) Any Unicode character (in binary) can be used in the code.
*Since any Unicode character can be used, it includes math symbols simple and complex. Thus making VenetianScript technically Turing-complete.
== Programs ==
===Hello, World!===
===Truth-machine===
===Cat===
== See also ==
* Velato
* Yet Another Musical Esolang
Category:Non-textual Category:2024 Category:Unimplemented Category:Turing complete