nyuuzyou/wikis huggingface dataset:
Usage:Looping counter

Usage:Looping counter is an esoteric programming language based on looping counters invented by User:A.
==Syntax==
A Usage:Looping counter program consists of registers. A register can only preserve an eighth of a byte(i.e. one base-4 digit), and all commands consist of also an eighth of a byte. The virtual machine halts when all of the registers are 0.
// This does not work in this language. These are just non-comments merely for documenting the language.
1 2 + 1 // Create a register (i.e. register #1). When its zero-trigger is activated, increment register 2 by 1.
2 1 + 1 // Create a register (i.e. register #2). When its zero-trigger is activated, increment register 1 by 1.
In every looping counter program, register pairs are executed, and the pairs are simply every possible 2-register combination in a list of registers.
In every register pair, if the number of executions of a pair is even, decrement the register in the left of the memory and increment the register in the right of the memory until one of them is already zero. Then, their 0-triggers are triggered. If the number of executions of a pair is odd, then vice versa.
The first example is an infinite loop. This is the process of executing this program:
Assume that register 1 is 5, and register 2 is 4.
 5 4
-> 0 9 <- 0-trigger!
-> 0 10
-> 10 0 <- 0-trigger!
-> 11 0
...
== Bytecode ==
The bytecode for this language is simple:
+ = 00
- = 01 This is vise versa of +.
* = 02 This command is a placeholder for a 0-trigger.
. = 03 This command is for debugging; it outputs all of the registers.
Integer-constant = corresponding constant
Category:Languages
Category:2019
Category:Unimplemented
Category:No IO
Use of AI in esoteric languages

AI is used in some esoteric languages. Some esoteric languages are invented by AI, while other esolangs are so difficult to read or write that an AI has to be used to create their example programs.
==Esoteric languages invented by AI==
* GPTLang
* MoonScript
* AI-Generated Esolang
* AIGenLang
* BittyLang
* TinyF
Also see others at :Category:Generated by AI
==Esolang programs generated by AI==
* The first Hello World program in Malbolge was generated by a beam search algorithm in Lisp.
* Using Artificial Intelligence to Write Self-Modifying/Improving Programs is an article about generating brainfuck programs using a genetic algorithm in C#.
* Hello World program in BittyLang
==Esolang interpreters generated by AI==
* Brainfuck Python interpreter (ChatGPT)
* BittyLang official interpreter
* COPY WITH @ offical interpriter
==Other AI-related esolangs==
* Descriptive Program
* Horribly translated versions of other languages
Category:Concepts
Useful!

Useful! is a concept by User:Maxsteele2 for the most useless computer language ever created. Evidently, the name is sarcasm and should be ignored.
==Sample Programs==
===Hello World===
This is how a Hello World program would appear in Useful!:
 sdUH&^BGI*DEM,90fd,<*^)${CM*%M*(I()<BV#%m,z,.<(V%U<(_
There is no way to understand this, other than being a robot.
===Fibonacci===
This prints the first 42 Fibonacci numbers:
 gu$$YDGHn^mdmC$mc<?5m38R$%^ZpotAto7DIU(CFR%NB&(C#%B%(&#(&)C%N#NMX#X%NN(C#^B^bnnmy4&NB&*
Ack, now I have headache.
===Quine===
This outputs a quine:
 YGTgh^R$@CV*TNM*O@NM^*$NM*OLOLOLOLAZERggyTYR&nm7%&(V*)#V%M*
Obviously, this prints YGTgh^R$@CV*TNM*O@NM^*$NM*OLOLOLOLAZERggyTYR&nm7%&(V*)#V%M*.
===99 Bottles===
This outputs the 99 bottles of beer lyrics:
 sdgf*888ijrrddJsdfgasgfKOFF435nbkdgWho?
 dgfsdg5eleven1fdsgsggsg"blahfe346$%5
==Writing a Program==
===Any Program===
One way is to mash on keys randomly and pray that it gets desirable results. Another way is to be a machine and just know the result, although most prefer to remain a living being.
===Specific programs===
Just give it up, it's a 1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679 to 1 chance you'll ever do it. Hey, that's the first hundred digits of pi.
Category:Languages
Category:Joke languages
Useful brainfuck

Useful brainfuck is a brainfuck-derivative created by User:Evylah which aims to be useful. It still is brainfuck at its core, but adds a handful miscellaneous instructions to aid with programming.
== Additions ==
Along with new instructions, Useful brainfuck adds a new accumulator. This is just another cell, but can be accessed from anywhere in the program. The accumulator is a 8-bit wrapping number and initializes to 0.
Wrapping mode can be toggled with ' and is on by default. When off, each cell and the accumulator can hold any integer, not just numbers from 0-255.
== Instruction set ==
Input is taken in and stored mod 256 if wrapping mode is on.
=== Vanilla brainfuck ===
op 	description
> <	Select the cell one to the right or left.
+ - 	Increment and decrement the current cell by one.
[ 	Jump to the corresponding ] if the current cell is zero.
] 	Jump to the corresponding [ if the current cell is not zero.
, . 	Input and output the current cell as a Unicode character.
=== Useful brainfuck ===
op 	description
( 	Set the accumulator's value to the current cell.
) 	Set the current cell's value to the value of the accumulator.
0 	Set the accumulator to 0.
? 	Set the accumulator to a random number 0 through 255 inclusive.
{ }	Move the memory tape pointer left/right the accumulator's value times.
i d	Increment/decrement the accumulator by 1.
I D	Increment/decrement the accumulator by 10.
* /	Double and halve the accumulator, rounded to the nearest integer.
a 	Accumulator = Accumulator + Value of current cell
A 	Value of current cell = Value of current cell + Accumulator
; :	Input and output the current cell as a number.
' 	Toggles wrapping mode.
== Examples ==
=== A + B problem ===
Using accumulator:
 ;(;A:
No accumulator (also works with Brainfuck+2)
 ;>;<[>+<-]>:
===Truth-machine===
This program harnesses the numeric input and output facilities in order to realize a truth-machine:
 ;[:]:
===Looping counter===
The following implements a looping counter which first accepts the number of lines to print, and secondly expects the user to specify the symbol to output in lieu of the traditional asterisks (*):
 ';>>,>++++++++++<<<[i>)[>.<-]>>.<<<-]
== Turing-completeness ==
Since any brainfuck program can run in Useful brainfuck, Useful brainfuck is Turing-complete.
==Interpreter==
* Common Lisp implementation of the Useful brainfuck programming language.
Category:Languages Category:2024 Category:Cell-based Category:Brainfuck derivatives Category:Implemented
Useless

Useless is a useless programming language (unless you want to put the world in danger).
Commands:
 FAIL - Obsolete
 NOT - Discouraged
 NEVER - Illegal
 IDK - Undefined
 BOOM! - Dangerous to executing unit
 KABOOM! - Dangerous to world
 NO. - Halts
 QWAOZAPWQFUOA - Impossible to understand
 WUT? - Platform dependant
 WHERE? - Doesn't exist
 DONTUSEME(n) - Deprecated, will be replaced with DONTUSEME(n + 1) in 24 hours (relative to this post (00:09, 12 April 2011, GMT + 1)) - Note: n starts as 0, then 1, and so on - Will open n empty unclosable windows
 HOW? - Impossible to execute
 ILLEGAL - Not enough rights
 GODEXISTS - Proves that the program is crazy
 WINDOWS - Makes the program suck and popular - OPTIONAL
 NOOP - Does nothing at all
 INCLUDE-xxx - Will add a command with the name xxx (not the name "xxx", but something with the same name as what is written there) that has the same effect as a random command
 TURINGVSALONZO - Generate a random valid no-input BF program, execute it and interpret the output as a UTM, execute it and interpret the output as a lambda calculus program, execute it and throw away the result
== External resources ==
* Interpreters from Codegolf competition
Category:Languages
Category:Joke languages
Category:Uncomputable
Category:Unusable for programming
Category:Unimplemented
UserNo

UserNo is a propaganda esolang against User:Yes as a joke.
== Commands / User == 
It uses users that resemble Wikipedia users as commands seperated by spaces.
User:No - Increment Accumulator in positive (because i am positive)
User:Yes - Decrement Accumulator (because negative)
User:Zero - Print Accumulator as number (because number)
Any Other - Print as ascii
==Implementations==
C# interpreter by User:No
using System;
public class Program
{
 static int accumulator = 0;
 public static void Main(string[] args)
 {
 Console.WriteLine("What is your code?");
 string code = Console.ReadLine();
 string[] users = code.Split(" ");
 
 foreach (string s in users) {
 switch (s) {
 case "User:Yes":
 // ew bad
 accumulator--;
 break;
 case "User:No":
 // SO GOOD THIS IS POSITIVE INCREMENT BECAUSE OSITIVE
 accumulator++;
 break;
 case "User:Zero":
 //idk who user zero is but it will print as a number cause i need aw ay to do that
 Console.Write(accumulator + "");
 break;
 default:
 Console.Write((char) accumulator + "");
 break;
 }
 }
 }
}
Category:Languages
Category:2023
Category:Implemented
Category:Output_only
Category:Total
Category:Joke_languages
UserScript

UserScript is a Joke Language invented by User:A that outputs how long a CGCC submission is. (Inspired by this post.)
Apparently the language is simple: find the first and second matches of ```, and then output the length of the text between it. If there is no match, output the first consecutive matches of the length of the texts prepended with 4 spaces, with the spaces removed.
The output will then be checked against the header of the post prepended with ##; the last number in the header is the intended length. If they are not equal, this outputs a falsy value. Otherwise, this outputs a truthy value.
== Sample program ==
## Golfscript - 66 chars
 "placeholder text for userscript which counts chars ";
`xxd`: (use `xxd -r` to revert)
 0000000: 332c 7b3a 533b 2e7b 3438 2d22 5e70 285d 3,{:S;.{48-"^p(]
 0000010: 7025 d3c4 4ab1 7d4a b8dc 4469 ce41 2222 p%..J.}J..Di.A""
 0000020: f303 227b 6261 7365 7d2f 3330 2f53 3d33 .."{base}/30/S=3
 0000030: 2f3d 7b22 5f20 7c22 3d7d 257d 256e 407d /={"_ |"=}%}%n@}
 0000040: 2f3b /;
This follows most of the other answers in that there are no spaces between numbers and trailing spaces are kept in. A space between numbers can easily be added with `1+` before `{"_ |"=}%`. Packed into a base 3 number, and then as base 243 into a string.
This program scans for lines prepended with 4 spaces. It finds just one: "placeholder text for userscript which counts chars ";. Then, it removes the prepending 4 spaces and outputs its length, which is 66. It checks the number against the number in the header, and then outputs a truthy value.
Category:Joke languages
Category:Languages
Category:Unimplemented
Category:2019
Category:Unusable for programming
Category:Total
Category:Output only
Utopia Divine

Utopia Divine is a programming language for a post-quantum world. It is a programming language of desire, of hope, of beauty. It is a deeply personal programming language. I hope one day it may be seen by a better world.
The rest of this document has been encrypted with 4096-bit RSA. I have deleted the keypair.
https://archive.org/details/utopia-divine.zip.asc
Category:Languages Category:2024 Category:Quantum computing Category:Usability unknown Category:Unimplemented
UwU

UwU is a joke esoteric programming language designed by User: KiraRose.
It is exactly like Brainfuck but uses UwU faces making it a member of the TrivialBrainfuckSubstitution family of programming languages.
==Commands==
Brainfuck	UwU 	Description
> 	OwO 	Move the pointer to the right
< 	°w° 	Move the pointer to the left
UwU 	Increment the memory cell under the pointer	
QwQ 	Decrement the memory cell under the pointer	
. 	@w@ 	Output the character signified by the cell at the pointer
, 	>w< 	Input a character and store it in the cell at the pointer
[ 	~w~ 	Jump past the matching ¯w¯ if the cell under the pointer is 0
] 	¯w¯ 	Jump back to the matching ~w~
==Hewwo Wowwd! program==
UwU UwU UwU UwU UwU UwU UwU UwU ~w~ OwO UwU UwU UwU UwU 
~w~ OwO UwU UwU OwO UwU UwU UwU OwO UwU UwU UwU OwO UwU 
OwO UwU UwU UwU UwU °w° °w° °w° °w° °w° QwQ ¯w¯ OwO UwU
OwO UwU OwO QwQ OwO OwO QwQ OwO UwU ~w~ °w° ¯w¯ °w° QwQ
¯w¯ OwO OwO @w@ OwO QwQ QwQ QwQ @w@ OwO OwO OwO QwQ @w@
@w@ °w° °w° °w° UwU UwU UwU UwU UwU UwU UwU UwU UwU UwU
@w@ OwO OwO @w@ °w° QwQ @w@ °w° @w@ OwO OwO OwO @w@ @w@
°w° °w° °w° QwQ QwQ QwQ QwQ QwQ QwQ QwQ QwQ QwQ QwQ QwQ 
@w@ OwO OwO UwU @w@ OwO OwO UwU UwU @w@ 
==External resources==
* - GitHub
* - UwU-Intewpetew
Category:Brainfuck equivalents
Category:Cell-based
Category:Joke languages
Category:Turing complete
Category:Implemented
Category:Low-level
Category:2020
Category:Languages
UwU: A cute esolang

UwU is an esoteric programming language made by PhoenixHO. It is entirely based on UwU faces and UwU-fied english words. A fully functioning bytecode interpreter written in C++ can be found in the external resources.
=Language features/syntax=
==Variables and data-types==
UwU is a statically typed esolang that supports working with user-defined variables. It supports the following data-types:
* Numbers (integers and decimal numbers)
* Strings
* Characters
* Boolean
The syntax for defining a new variable is:
 uwu variable_name
without the need to specify the data-type of the variable. To initialize a variable:
 uwu variable_name := value
value can be any valid expression in UwU.
UwU supports global as well as local variables.
Local variables are variables that are declared within a block/scope (enclosed by [: and :]) and only accessible within that block.
===Expressions===
Bellow are some valid UwU expressions:
* number literals (hex currently not supported)
* character literals (enclosed by backticks `)
* string literals (enclosed by quotation marks ")
* boolean (twue or fawse)
* unary/binary operations
===Operators===
Binary operators:
* Addition +
* Subtraction -
* Multiplication *
* Division /
* Concatenation + (works with both character and string literals and the result is always a string)
* Equality =, != (works with strings too)
* Comparison <, <=, >, >=
* Assignent :=
Unary operators:
* Not !
* Negation -
Logical operators:
* awnd
* ow
==Comments==
UwU supports only multiple line comments. The syntax for them is as follows:
 {: This is a comment that will be entirely ignored :}
==Statements==
===If-statements===
The syntax for an if-statement in UwU is:
 ?w? condition [:
 {: code :}
 :]
And the syntax for an if..else statement is:
 ?w? condition [:
 {: will execute if 'condition' is true :}
 :] ewe [:
 {: will execute otherwise :}
 :]
condition can be any UwU valid expression. UwU treats any non-zero value as truthy, while 0 is falsy.
===Loops===
The syntax for a loop in UwU is:
 untiw condition [:
 {: will stop executing if 'condition' is true :}
 :]
===Print statements===
The syntax for printing an expression is:
 ouo expression >>
To print multiple expressions at once:
 ouo expression1, expression2, ... >>
The new line character in UwU is ~n, while ~t corresponds to the tab character.
So to print a new line or a tab:
 ouo ~n >>
or,
 ouo ~t >>
===Reading input===
Reading input is different for each data type. The syntax is:
 iwi type variable_name <<
type can be:
* -s for string literals
* -d for number literals
* -c for character literals
===Functions===
UwU supports both recursive and non-recursive functions.
To define a function:
 fwun function_name(parameter1, parameter2, ...) [:
 {: function body :}
 
 out return_value >>
 :]
Parameters and return values are optional.
=Examples=
===Hewwo Wowwd!===
 ouo "Hewwo Wowwd!" >>
===Twuth-machine===
 uwu input
 iwi-d input <<
 
 untiw input = 0 [:
 ouo 1, ~n >>
 iwi-d input <<
 :]
=External resources=
* UwU C++ Bytecode Interpreter
Category:Implemented
Category:Languages
Category:High-level
Category:2022
Uxntal

Uxntal is the programming language for the Uxn virtual machine. It is a stack-based concatenative assembly style language designed to be highly portable and lightweight.
It has been ported to many platforms and is well suited for creating and sharing graphical and audio tools and games. 
The reference implementation consists of only 150 line of C. 
=== Terminology ===
* Uxn is the name of the virtual CPU.
* Varvara is the virtual computer system consisting of input controllers, audio and video output, and other system devices which runs on Uxn.
* Uxntal is a human readable concatenative programming language used for assembling ROMs to run on a Uxn system. 
== Examples ==
Deadfish interpreter in Uxntal
== External resources ==
* Official site, Hundred Rabbits
* Uxntal reference manual
* Uxntal opcodes, hand gestures, and glyphs
* Uxn resources curated by Hundred Rabbits
Category:Languages Category:Stack-based Category:Implemented
V'ger

V'ger is an Matrioshka language created by User:Yayimhere inspired by V'ger (voyager 6) from the first startrek movie
== syntax/semantics ==
the program is made up of two parts. the voyager, and the universe:
 [voyager|universe]
the voyagers syntax is a index which is an index of the string(see later) which will delete everything up to index and add it to the voyagers memory and then the next universe is all the data left. if the index is not in the string the next universe will be the string added to itself the index will either be incremented by 1(if the char after the number is +) or decremented by 1(if the following char is -). and if theres also a $ then it would delete the first char of voyager string. the universe is just a string
Category:Languages Category:2024 Category:String-rewriting paradigm
V++

==Overview==
V++ is a small programming language made for fun. It is an interpreted, strongly-typed language. It has functions, advanced math and IO support.
V++ first appeared in 2016 in private tests. It was released for the public in November 2020.
==Documentation==
For documentation go to https://github.com/vpp-lang/vpp-source/wiki
==Code samples==
Hello world program
function main ()
command (0x0005,"Hello world!",null)
command (0x0006,null)
exit
end function
Adding two numbers
function main ()
define result as number = 0
vppmath :: add (result,5,7,null)
command (0x0004,"5+7=",null)
command (0x0004,result,null)
command (0x0006,null)
exit
end function
Write to file
function main ()
command (0x0012,"C:\test.txt","Hello from V++",null)
command (0x0006,null)
exit
end function
==External links==
* 
Category:Languages 
Category:Functional paradigm
Category:Object-oriented paradigm
Category:Turing complete 
Category:Implemented 
Category:2016
Category:Graphical Output
Category:High-level
V--

V-- is an interpreted high-level programming language created by Marcus Kaiser in 2007.
==Overview==
V-- is currently an interpreted language, using the "V-- Programming Language Interpreter 0.1", shortened "V-- PLI.1".
V--'s goal is to "encourage the free will of the programmer.", which is quite contradictory to a statement made in "The V-- Programming Language 0.1" (The official manual/language reference): "V-- is unforgiving. One little sidestep and it eats you alive".
According to the manual the language is very logical, yet "to understand V--, one must abandon all their earlier definitions of 'logic'".
==Variables and data types==
V-- uses (in version 0.2.1) four variables, &a, &b, &c and &d. The variables &a and &b are of "num" (integer) type, and &c and &d are of string type.
==Commands and syntax==
V-- command types and "command type operators". V-- has currently (in version 0.1) four command types:
 
* The string/print command (=)
* The variable command (&)
* The arithmetic command (#)
* The comment command (!)
Each command must be prefixed with it's command type operator:
 = Hello,World!
The above command demonstrates the famous "Hello World" program in V--. The string/print command type in V-- cannot contain spaces, therefore the program is somewhat modified.
The output being:
 'Hello,World!'
A V-- program demonstrating the declaration of 
variables and the string/print command type operator:
 &			! Declares the variable command type
 -> .		! Declares the num data type
 -> &a		! Declares the variable
 -> 12	! Assigns a value to the variable
 { .&a $ 12 }		! Output of the variable information
 
 = &a			! Prints the variable's contents
The above program can also be written like this:
 & . &a 12
 = &a
As source code interpretation probably will be implemented in version 0.4, the code could be written like the above one and then interpreted. V-- PLI.1 is very picky about spacing.
Arithmetic operations have to be prefixed with their "sub-command operator":
 # + 3 5
Gives the output:
 { 3 + 5 $ 8 }
==External resources==
*The official site of the V-- Programming Language 
Category:Languages
Category:High-level
Category:2007
V3i

V3i, an abbreviation for Variable 3 Input, is an esoteric programming language created by BowlingPizzaBall which has only three variables named x, y, and z.Despite this, the language is somewhat powerful, having stuff like a wait function and the support for infinite loops.
== Functions ==
Function	Definition 	Arguments/Examples
def 	Defines one of the 3 variables. 	def <x,y, or z> <varcontent>
var 	Calls one of the 3 variables. 	var <x,y, or z>
+ 	Adds 2 numbers. 	n+n
- 	Subtracts 2 numbers. 	n-n
* 	Gives the product of 2 numbers. 	n*n
/ 	Gives the quotient of 2 numbers. 	/
sqrt 	Gives the square root of a number. 	sqrt n
% 	Gives the mod of 2 numbers. 	n%n
= 	Checks if something is equal to something. Returns 1 if so, 0 if not. 	6=4 (returns 0)
> 	Checks if a number is greater than another. Returns 1 if so, 0 if not.	6>4 (returns 1)
< 	Checks if a number is less than another. Returns 1 if so, 0 if not. 	6<4 (returns 0)
print 	Prints something. 	print <"text"/number/variable>
if 	If statement. 	if <content> <condition> <content>
else 	Else statement. 	else <content>
loop 	Starts a loop. 	loop <timesToLoop> <contentToLoop>
iloop 	Starts an infinite loop. 	iloop <content to loop>
input 	Halts execution until an input is received from the user. 	None
wait 	Waits for n milliseconds. 	wait <ms>
# 	Comment function. 	# <comment> #
end 	Ends execution. (optional) 	None
== Examples ==
=== Hello World ===
print "Hello, World!";
=== Truth Machine ===
if input = 0;
print "0"; end;
else;
iloop print "1";
=== Cat ===
print input;
=== Fibonacci ===
def x 1;
def y 1;
print 0;
print 1;
print 1;
iloop; def x x+y; print x; def y y+x; print y;
=== 99 bottles of beer ===
def x 99;
loop 99;
if x = 1;
print "1 bottle of beer on the wall";
print "1 bottle of beer";
print "Take one down, pass it around";
print "No more bottles of beer on the wall";
else;
print x " bottles of beer on the wall";
print x " bottles of beer";
print "Take one down, pass it around";
def x x-1;
print x " bottles of beer on the wall";
=== Deadfish ===
def x 0; # Simulates the accumulator. #
def y ""; # Stores the current user input. #
iloop;
def y input;
if y = "o";
 print x;
else if y = "i";
 def x x+1;
else if y = "d";
 def x x-1;
else if y = "s";
 def x x*x;
else;
 print "Invalid command";
==Computational class==
Language is Turing complete by reduction from Infinite GotoStart with 3 registers.Program starts with:
 iloop;
+(x) becomes:
 def x x+1;
-(x) becomes:
 def x x-1;
=(x:y) becomes:
 def x y;
?(x=y>abc)xyz becomes:
 if x=y;
 abc;
 xyz;
 else;
 xyz;
== Interpreter ==
It will come soon, or at least when I fully understand python and its sys module.
* Common Lisp implementation of the V3i programming language.
Category:Languages
Category:Turing complete
Category:Implemented
Category:2022