nyuuzyou/wikis huggingface dataset:
VALGOL

VALGOL is a joke language created by John Unger Zussman, and is one of the lesser known programming languages. It was described in the Info World article as follows:
:(With special thanks to Dan and Betsy "Moon Unit" Pfau) - From its modest beginnings in southern California's San Fernando Valley, VALGOL is enjoying a dramatic surge of popularity across the industry.
:VALGOL commands include REALLY, LIKE, WELL and Y$KNOW. Variables are assigned with the =LIKE and =TOTALLY operators. Other operators include the "CALIFORNIA BOOLEANS", FERSURE, and NOWAY. Repetitions of code are handled in FOR-SURE loops. Here is a sample VALGOL program:
 14 LIKE, Y$KNOW (I MEAN) START
 %% IF
 PI A =LIKE BITCHEN AND
 01 B =LIKE TUBULAR AND
 9 C =LIKE GRODY**MAX
 4K (FERSURE)**2
 18 THEN
 4I FOR I=LIKE 1 TO OH MAYBE 100
 86 DO WAH + (DITTY**2)
 9 BARF(I) =TOTALLY GROSS(OUT)
 -17 SURE
 1F LIKE BAG THIS PROGRAM
 ? REALLY
 $$ LIKE TOTALLY (Y*KNOW)
:VALGOL is characterized by its unfriendly error messages. For example, when the user makes a syntax error, the interpreter displays the message, GAG ME WITH A SPOON! 
There is an "implementation" over at Cat's Eye.
Category:Joke languages Category:Languages Category:Implemented Category:Pseudonatural Category:Thematic
VBF

VBF is a brainfuck derivative by VilgotanL with some extra instructions for control-flow.
== Instructions ==
New instructions compared to brainfuck:
( 	Begin if zero
!(	Begin if not zero
) 	End if
{ 	While zero
} 	End while zero
Single-line comments are also supported, with #.
== Examples ==
=== Cat program ===
Same as in brainfuck.
,[.,]
=== Infinite counter ===
Counts to infinity in base 10 starting with 1.
->>--<<[>---------(----------)++++++++++{>++(++>--
<)-----------(----------)++++++++++}++[-->++]--<+[
+++++++++++++++++++++++++++++++++++++++++++++++.--
----------------------------------------------<+]+
+++++++++.-----------]
The above program transpiled to brainfuck and minified:
->>>>--<<<<[>>---------[->+>>+<<<]>>>[-<<<+>>>]+<<[[-]>>-<<]>>[-<<<---------->>>
]<<<++++++++++[->+>>+<<<]>>>[-<<<+>>>]+<<[[-]>>-<<]>>[-<++[->+>>+<<<]>>>[-<<<+>>
>]+<<[[-]>>-<<]>>[-<<<++>>-->]<<<-----------[->+>>+<<<]>>>[-<<<+>>>]+<<[[-]>>-<<
]>>[-<<<---------->>>]<<<++++++++++[->+>>+<<<]>>>[-<<<+>>>]+<<[[-]>>-<<]>>]<<<++
[-->>++]--<<+[+++++++++++++++++++++++++++++++++++++++++++++++.------------------
------------------------------<<+]++++++++++.-----------]
== Transpilation table ==
Here is a table for transpiling VBF to brainfuck:
VBF	brainfuck
> 	>>
< 	<<
( 	[->+>>+<<<]>>>[-<<<+>>>]+<<[[-]>>-<<]>>[-<<<
!( 	[->+>>+<<<]>[-<+>]>>[[-]<<<
) 	>>>]<<<
{ 	[->+>>+<<<]>>>[-<<<+>>>]+<<[[-]>>-<<]>>[-<<<
} 	[->+>>+<<<]>>>[-<<<+>>>]+<<[[-]>>-<<]>>]<<<
All other instructions are the same.
== Computational Class ==
VBF is obviously Turing-complete since it is basically backwards-compatible with brainfuck.
== Implementations ==
Online Interpreter and Transpiler by the creator
Category:Languages
Category:Brainfuck_derivatives
Category:Turing_complete
Category:Cell-based
Category:2021
Category:Turing tarpits
Category:Implemented
VD3

VD3 is a simple programing language. It has only one command.
==Syntax and commands==
VD3 syntax is simply:
 variable<-X^Y^Z
X, Y and Z can be variables or signed, unbound integers.
Variables are as follows:
 VD3 variables
Variable	Meaning
A 	Data
B 	Data
C 	Data
PC 	Program counter
IN 	Input
OUT 	Output
 VD3 2.0 variables
Variable	Meaning
A 	Data
B 	Data
C 	Data
D 	Data
E 	Data
PC 	Program counter
IN 	Input
OUT 	Output
===VD3 expressions===
The following example shows how VD3 expressions work:
 W<-X^Y^Z
W is now X+Y+Z. In VD3 2.0 it can be too:
 ...W<-X^Y^Z
... means every empty command position after it (and before next ...) has same command.
===Simple adding===
 A<-1^1^0
A is now 2 (1+1+0).
===Using variables===
 A<-1^2^3
 B<-A^1^0
Now A is 6 (1+2+3) and B is 7 (A+1+0).
===I/O===
 OUT<-65^0^0
This program prints the ASCII character 65 (A).
 A<-IN^0^0
This program stores an ascii character from input in variable A.
===Jumping===
 PC<-2^0^0
 OUT<-65^0^0
 OUT<-66^0^0
This program prints only B. It skips the command in position 1 (OUT<-65^0^0). Command position numbering starts from 0.
===Halting===
 PC<-0^0^-1
 OUT<-65^0^0
This program halts and doesn't print A because jumping to negative positions stops the program.
===Jump if zero(VD3 2.0 only)===
 E<-5^0^0
 F<-PC^2^0
 PC<-7^IN^-48
 OUT<-66^0^0
 PC<-0^0^-1
 OUT<-65^0^0
 PC<-0^0^-1
 PC<-E^0^0
 ...PC<-F^0^0
This program ask input. If ascii code of input is 48('0') then jump to 7 and from 7 to 5(saved to E) and print A, if ascii code is greater than 48 jump to >7 and then jump to 3(saved to F) and print B.
==Examples==
===CAT===
 OUT<-IN^0^0
 PC<-0^0^0
==Computational class==
VD3 2.0 is Turing-complete. To show this, we will implement any 2-counter machine with instructions INC, DEC, and JZ. Let X be the position of the current command, and let L be the total number of commands excluding the postfix. Let R denote A or B, and let Z denote a jump destination position. Then, each instruction can be implemented:
INC(R):
 R<-R^1^0
DEC(R):
 R<-R^-1^0
JZ(R, Z):
 C<-X^0^0
 PC<-R^(L+1)^0
 PC<-Z^0^0
Postfix:
 PC<--1^0^0
 PC<-C^2^0
 ...PC<-C^3^0
The computational class of VD3 without VD3 2.0 features is unknown.
==External resources==
* Interpreter in Python 3
Category:Languages
Category:OISC
Category:2009
Category:Unusable for programming
Category:Turing complete
Category:Implemented
VENIAL

VENIAL (VErne's Novice International Algorithmic Language) is an alternate history BASIC or FOCAL, adapting IAL (ALGOL 58) to a time-shared, line-numbered system for the IBM 7090. The primary inspiration was the ACM-GAMM committee record, Preliminary Report: International Algebraic Language. FORTRAN II was a strong influence on VENIAL.
VENIAL is a work in progress of User:Jeffrey Henning.
The IBM 7090 had 36-bit word length, and this influenced the design of VENIAL.
==Symbols==
Symbol strings start with a letter and can be followed by any length of letters but only the first two letters differentiate the symbol (e.g., DESTINATION, DEST and DE all refer to the same variable or procedure). Only 702 symbols are permitted; 26 letters * (26 letters + null). The same symbol table is used for procedures and variables, so if a procedure is named DE then no variable can be named DE.
Math: +, -, * (multiplication), / (division), ^ (exponent)
Comparison: =, /= (not equal), >, >=, <=, <
==Statements==
Every line of a VENIAL program has its own line number. The VENIAL-59 system supported line numbers from 1 to 4095. A line may contain multiple statements, delimited by a semicolon.
Wherever a logic structure expects a single statement, a series of statements may be substituted, but they must be bracketed by BEGIN; END.
===Basic Statements===
1. Assignment statement.
The := symbol specifies assignment.
 10 PI := 3.14159
2. Go to statement.
The keyword GOTO specifies unconditional branching.
 90 GOTO 10
3. If statement.
The keyword IF evaluates an expression; if it is true, all subsequent statements on the line are executed.
 20 IF X>0; Z := Z/X
4. For statement.
Loops can be specified 
 10 FOR X := 1, 10; Y := Y + X
 20 FOR COUNTDOWN := 10, -1, 1; TYPE COUNTDOWN
5. Alternative statements.
Multi-part ifs can be specified.
 20 IFEITHER X<0; Y := -1; ORIF X=0; Y := 0; ORIF X>0; Y := 1
6. Do statement.
Calls a procedure.
 30 DO 100
7. Stop statement.
Ends execution
 4095 STOP
8. Return statement.
Returns execution from a procedure.?
 190 RETURN
9. Input statement.
Reads input from the teletype.
 10 READ ANSWER
10. Output statement.
Types output to the teletype.
 10 WRITE `WELCOME'
===Declarations===
1. Type declarations.
Unlike IAL, VENIAL does not require variables to be declared before they are used. All variables are floating-point numbers.
5. Comment declaration.
A comment begins with the word comment and may contain any symbols other than the semicolon.
 10 COMMENT A FIRST PROGRAM
 20 COMMENT BY JEFFREY HENNING; DO 100
6. Procedure declaration.
A procedure must be declared before it is used. A procedure name must be a valid variable name and may not otherwise be used as a variable.
 10 PROCEDURE COUNTDOWN; FOR COUNTDOWN := 10, -1, 1; TYPE COUNTDOWN
 10 PROCEDURE COUNTDOWN; BEGIN; FOR COUNTDOWN := 10, -1, 1; TYPE COUNTDOWN; TYPE `BLASTOFF!'; END
===Reserved Words===
*BEGIN
*DO
*END
*IF
*IFEITHER
*FOR
*GOTO
*ORIF
*PROCEDURE
*READ
*RETURN
*STOP
*WRITE
VERPNL

VERPNL stands for Vietnamese "Extendable" Reverse Polish Notation Language. The specific meaning of "Extendable" is not specified, but the language idea and name is created 6 months ago and now I'm creating the page.
It is a imperative stack-based language.
== Syntax ==
Every line is like this:
 [header] [code]
or
 [label]:
No you can't put labels and code on the same line (not if you use the original, you can make preprocessors to make writing code 200% easier)
===Comments===
Anything after a semicolon in a line will not be parsed.
===headers===
Headers must begin every non-label-line.
There is the standard header: #, it just executes the code after the header.
The conditional header: ?[label]. It excutes the code, pops a value, and if it is nonzero, it jumps to the label.
The subroutine header: @[label]. Like the conditional header, but you can return.</code>
Return header: R: Return from the subroutine header. The behaviour if there are no subroutines to return from is undefined.
There is no uncond jump header, unless you use preprocessors.
===Code after the header===
Here are the defined commands, as of V1.0. You're free to suggest extensions.
 Caption text
Command 	Function
dup drop pop swap over roll 	Runs the corresponding Forth Stack Word.
Any floating-point number 	Push the number on the stack
+ * 	Does addition or multiplication, popping 2 numbers on the stack and pushing a result.
- / 	Does negation or reciprocal. Modifies the top element of the stack. Try to / on 0 causes to print 99 bottles of beer.
and/or/xor/not 	Bitwise operators
print/putchar 	Pop the top element and print it as integer/character.
input/getchar 	Input a/an integer/character and push it(s ascii) to the stack.
Any string quote by double quote	Push the ASCII code corresponding to all characters of the entire string into the stack.
$ 	Reverse the stack.
someone pls help me do variables	...
==Variables==
(OPTIONAL EXTENSION)
Now all elements on the stack are strings. All numeral operators tries to convert any string into a number, unless the operator have a special string handling procedure.
In addition, storage is now not only a stack but a stack AND a dictionary (or map<string><string> if you use C++)
Additional Operators:
 ? Pops the string on top of stack, then pushes the value in the dictionary, with the key being the popped value.
 = Pops 2 values, set the value at key [first popped] to [second popped]. 
 R pops a string (a) and a string (b). Returns the (a)th character of (b).
 S pops a character (a), a index (b) and a string (c). Pushes (c) with the (b)th char changed to (a).
 L pop a string, pushes its length.
You could make variables, and arrays(if you try hard enough).
==Credits==
User:Xyzzy for the language idea and control structure and for the variables
User:PrySigneToFry for the output command, string operations and reversing stack
put your names here if you make a contribrution, do not delete my lines
VES++

VES++ has included the most common languages from west Europe (and for some random reason the Turkish language is also included). This way many people are able to understand a part of the code, yet (probably) not everything. In my opinion it is a fun way to get involved with other languages! 
Detailed description and specification and an implementation of the language can be found here.
==Symbols==
 Overview symbols
Type 	Word in this language	Language where it comes from
Plus operator 	mas 	Spanish
Minus operator 	eksi 	Turkish
Multiply operator 	vezes 	Portugese
Division operator 	dela 	Swedish
Assignment 	er 	Norwegian
If 	ef 	Icelandic
Else 	annars 	Icelandic
While 	aika 	Finnish
Equal operator 	lig 	Danish
Not equal operator 	unterschiedlich 	German
Terminate character (;)	fin 	French
Left parenthesis 	haakje_begin 	Dutch
Right parenthesis 	haakje_eind 	Dutch
Left bracet 	fa_inizio 	Italian
Right bracet 	fa_fine 	Italian
Print statement 	taispeain 	Irish
 Overview symbols
Symbol	Usage
$ 	Line starting with '$' are comment lines
# 	This character ends the print-statement
@ 	Every variable starts with an @
> 	Greater than
>= 	Greater than or equal to
< 	Smaller than
<= 	Smaller than or equal to
==Examples==
===Hello World===
Prints ASCII values.
 taispeain
 	72 fin
 	101 fin
 	108 fin
 	108 fin
 	111 fin
 	32 fin
 	87 fin
 	111 fin
 	114 fin
 	108 fin
 	100 fin
 #
===Truth-machine===
Replace <input> with your input.
 @the_program_input er <input> fin
 aika haajke_begin @the_program_input lig 1 haajke_end fa_inizio
 	taispeain
 		1 fin
 	#
 fa_fine
 taispeain
 	0 fin
 #
==External resources==
* An interpreter on GitHub
Category:Languages Category:Pseudonatural Category:2020 Category:Implemented Category:Turing complete
VGFJKDMLFJNDSJHGFYHJDZNYFBICHU,SBYFHDSR,JCBVFBDSJ;

VGFJKDMLFJNDSJHGFYHJDZNYFBICHU,SBYFHDSR,JCBVFBDSJ; is a web-accessing esoteric programming language.
==Commands==
 access()
This accesses a certain website.
==Cat==
 access(https://docs.new)
==Hello World==
 access(https://pastebin.com/vcraektC)
==Turing-completeness proof==
Of course it is! Just run this code:
 access(https://esolangpark.vercel.app/ide/brainfuck)
==Interpreters==
===Python===
from webbrowser import open as access
import sys
exec(sys.stdin.read())
Of course, it's possible to inject any Python code into this interpreter.
Category:Turing completeCategory:LanguagesCategory:2023Category:Usability unknownCategory:Implemented
VIOLET

VIOLET (Verbose Interactive Operating Language for Educational Terminals) is an interpreted programming language alleged to have been the custom onboard language developed for a 1980s educational computer, the Buttech CAI-1.
An interpreter for VIOLET written in Python is included as part of the BlueBox library, itself a graphics library for producing a basic retro terminal interface. 
==History==
According to the VIOLET and BlueBox documentation, VIOLET was created by a community college intern in a matter of days as a hasty replacement for rejected BASIC and PILOT proposals, and cobbled together from bits of other languages from FORTH to LISP.
==Basic Operation==
All VIOLET programs are composed of operator statements, which take arguments, and return their values to a built in value named &LAST. Each line can only contain one operator, save for the IFY/IFN operators, which may call a sub operator if they are successful. Variables are strictly typed, and their values can only be changed by the SET operator. Flow control is in the form of an IF/IFY/IFN operator set similar to PILOT C:/CY:/CN:, as well as a WHILE/WHEND loop, and the dreaded GOTO statement, here particularly problematic because line numbers aren't hard set but based on file position.
Because the VIOLET interactive editor can also handle arbitrary text files, the interpreter first checks any file sent to it for a PROGRAM START clause at the beginning, and a PROGRAM STOP clause at the end. 
==Sample Code==
Taken from the included samples in the repository:
 PROGRAM START
 IGNORE HELLO WORLD
 IGNORE
 PROMPT $ "WHAT IS YOUR NAME: "
 SET $NAME &LAST
 ADD "HELLO " $NAME "."
 PRINT &LAST
 PROGRAM STOP
 PROGRAM START
 IGNORE EXPONENT CALCULATOR
 IGNORE
 PRINT EXPONENT CALCULATOR
 PRINT PLEASE USE WHOLE NUMBERS ONLY
 PROMPT # "BASE: "
 SET #BASE &LAST
 PROMPT # "EXPONENT: "
 SET #EXP &LAST
 SET #TOTAL 1
 SET #X 0
 WHILE LESSER #X #EXP
 MULT #TOTAL #BASE
 SET #TOTAL &LAST
 ADD #X 1
 SET #X &LAST
 WHEND
 PRINT "YOUR TOTAL IS: " #TOTAL
 PROGRAM STOP
 PROGRAM START
 IGNORE FACTORIAL SOLVER
 IGNORE
 PRINT "FACTORIAL SOLVER"
 PRINT "PLEASE USE WHOLE NUMBERS"
 SET #RUN 1
 WHILE EQUALS #RUN 1
 PROMPT # "ENTER NUMBER: "
 SET #X &LAST
 SET #Y #X
 SET #TOTAL 1
 WHILE GREATER #Y 0
 MULT #TOTAL #Y
 SET #TOTAL &LAST
 SUB #Y 1
 SET #Y &LAST
 WHEND
 PRINT #X "! = " #TOTAL
 PROMPT $ "RUN AGAIN? "
 IF EQUALS &LAST "YES"
 IFY SET #RUN 1
 IFN SET #RUN 0
 WHEND
 PROGRAM STOP
==External resources==
*BlueBox - A graphics library for simulating the appearance of CAI-1 applications. Includes violet.py, a VIOLET interpreter in Python 2.7.
*The VIOLET Programming Language - The only known documentation for the VIOLET language. (Possibly still incomplete.)
Category:Languages Category:2014 Category:Implemented Category:High-level Category:Thematic
VL

VL is esolang loosely based on vim commands.
It consists of the following internal registers:
* value
* pointer
* index
* int
* pc
Where
value is the current value held (String, char or integer)
pointer is a pointer to one of 26 arrays (defaults to a at beginning of program)
index is the current index of the current array (defaults to 0 at beginning of program)
int is used for loops, repetition and comparisons
pc is the counter to the current instruction
Values in memory locations are initialised to 0.
Execution starts at the first character and reads instructions sequentially (unless moved by a jump).
== Examples ==
Hello word:
 iHello World!;W
Here, 'i' enters insert mode and any following characters up until an unescaped ';' are copied into value and the current memory location pointed at by pointer and index. Then 'W' writes out to stdout.
Output numbers 1 to 10:
 10(aW)
Here the number 10 sets the int register which is the number of times that the following instruction is performed. Instructions can be grouped using parenthesis so this program runs 'aW' 10 times.
'a' increments the current memory location's value (which is 0 by default at the beginning of the program) and sets the value register to the result. Again 'W' writes to stdout.
Fibonacci Sequence (stopping at 144):
$ fibonacci sequence up to 50th term $
aW}aW $ set initial two ones and position pointer on third $
'bi2; $ 'b holds nth term counter $
v`a2{y2}p $ set next number to previous $
{y}vy+p $ increment by value of the previous previous $
W'ba50!2k $ Write line and look until 'b is 50 $
anything between '$' pairs is ignored as a comment
'}' increases the index register. '{' decreases the index register.
'p' puts the current value register into the memory location currently being pointed at by pointer and index. 
'y' copies the current memory location value into the value register.
'v' copies the value register value into the int register so vy+ will add the current memory location to the previous memory location.
'k' moves execution up a line, so '2k' moves 2 lines.
'!' makes the following jump conditional. '!' performs jump if value register != int register so here 50 sets the int register and checks against the value of 'b, if they are not equal then the following jump activates. '?' is a similar conditional which checks if value register == int register
See full command list on the interpreter github repo readme:
==External resources==
VL interpreter written in Rust
VNL

VNL is designed by Steve Abel.
VNL = Python + C++ + My code.
== Commands ==
Not on display.
== Examples ==
=== Hello, world! ===
print("Hello, world!")
=== A+B ===
var a, b
input(a)
input(b)
var c = a + b
print(c)
=== Guessing Number ===
include <random> <*>
a = input(a, "Please Input how many life do you have(If you guessing wrong, your life will decrease by 1): ")
if a == :
 a = 10
a = int(a)
answer = randint(-50, 50)
while a > 0:
{
 b = input(b, "Please Input what number are you guessing: ")
 b = int(b)
 if b == answer:
 {
 print("That is it! Thanks for playing!")
 break
 }
 elif b > answer:
 {
 a -= 1
 printf("%d is too big! Try again(%d lifes left): ", b, a)
 }
 elif b < answer:
 {
 a -= 1
 printf("%d is too small! Try again(%d lifes left): ", b, a)
 }
}
== Categories ==
Category:Languages
VTL

VTL is an esoteric programming language created by user:David.werecat which loads code into modifiable memory and an extended section.
== Instructions ==
Each instruction is split into two parts, the OpCode and the Param. The OpCode is the first three bits of the instruction, and the Param is the other 5 bits. Code is executed in a 256 byte long segment. There is a pointer register that points into that segment. The current "value" is the instruction pointed to by the pointer register. If a second file is specified to the interpreter, it is loaded into the extended section. The extended section can be any size. When execution flow jumps to the extended section, the pointer register still indexes the code segment. When the execution reaches the end of the code segment or extended section, it loops back to the start. Possible OpCodes are as follows:
OpCode	Description
000 	Move the pointer register forward by Param
001 	Move the pointer register backward by Param
010 	Increment the value by Param
011 	Decrement the value by Param
100 	Jump forward Param+1 instructions if the value is 0
101 	Jump forward Param+1 instructions if the value is not 0
110 	Execute an extended instruction specified by Param
111 	Terminate the program with exit status Param
Extended Instructions are as follows:
Param	Description
00000	Clear the console
00001	Beep
00010	Set the value to random
00011	Read a character from the console into value
00100	Write a character from value to the console
00101	Push the value into stack 1
00110	Push the value into stack 2
00111	Pop the value from stack 1
01000	Pop the value from stack 2
01001	Set the value to the value pointed to by value
01010	Set the value to 0
01011	Binary not on value
01100	Jump to the extender grid
01101	Return from the extender grid
01110	Start executing instructions
01111	Stop executing instructions
1xxxx	Waits for 2^xxxx miliseconds
== External resources ==
* Visual Basic .NET interpreter and sample programs
Category:Languages
Category:2012
Category:Implemented
Category:Low-level
V (DJMcMayhem)

V is a 2D string-based golfing language designed by User:DJMcMayhem. It is an extension of the Vim text editor that provides many mappings to common vim-golf idioms, as well as providing new features not implemented in vim, such as compressed regular expressions, extended recording/macro abilities, new operators, and more convenient ways of taking input/output and running programs.
The official interpreter is found on Github, and an online interpreter is hosted at https://tio.run/nexus/v thanks to PPCG user/moderator Dennis.
Category:2016
Category:Golfing language
Category:Languages
Category:Implemented