nyuuzyou/wikis huggingface dataset:
J

J is a very simple esolang made for no reason at all. It was invented by User:Yayimhere
J logo.png|The logo of J
=== Syntax ===
J stores memory in variables. Variables are created like this:
 * A B
Where A is the name and B is the string. There are 5 operators:
* J Will take the input string and will “pop” the start of the string and “push” it to the front(so using this operator on the string AB it will become BA and using it on the string YUYT it will become UYTY)
* λ will go through the string and will then if it encounters a * it will replace the next char with a *
* Π Go through the string and replace each char with its corresponding digit in pi
* F Add a * To the end if the string
* P Print the inputted string to STDIN
To pass a string ti any if these function:
 F*U
This will pass the string U to the function F. To do it with a variable:
 F*U:
To pass the result back ti the function until the firs char in the string is a * you add a \ To the end. And last but not least to create a function:
 X$Y(…)
This will create the function Y with input X and will do the code in the brackets but with every X replaced with function input. Brackets can also be used to group an expression. Also if the program is looping it will check each line if theres something that will not evaluate to the same as before
=== examples ===
Hello world:
 P*Hello, world!
Category:String-rewriting paradigmCategory:LanguagesCategory:UnimplementedCategory:Unknown computational class
J--

J-- is basically a non-OOP version of Java. It is compiled into Java code and is run like a normal Java program, though you can not create new classes. There are plenty of classes available for you to use, including integers, strings, and every other Java class. J-- automatically imports: java.lang.*, java.util.*, java.math.*. It was made in July, 2015, by User:Phase.
== Keywords ==
All J-- code is put into a class called J. There are various keywords that are changed into real Java code:
* main -> public static void main(String[]a)
* fn -> public static
* str -> String
* dub -> double
* fpn -> float
* vd -> void
* echo -> System.out.println
* ^^ -> !=
* nw -> new
* map -> HashMap
== Built in functions ==
Here's a copy of some built in functions:
 add("public static int fac(int n){int f=1;for(int i=1;i<=n;i++){f*=i;}return f;}"); //factorial function
 add("public static final double GR = (1+Math.sqrt(5))/2;") //golden ratio used for other functions
 add("public static int fibo(int n){" +
 "return (Math.pow(GR,n) - Math.pow(-GR, -n))/Math.sqrt(5);}"); //get nth fibonacci number
== Examples ==
=== Hello World ===
main{echo("Hello World");}
=== Cat ===
main{ echo(input()); }
=== Fibonacci sequence ===
main{
 for(int i=0;i<10;i++){
 echo(fibo(i));
 }
}
=== Factorial ===
main{
 echo(factorial(5));
}
== External resources ==
* Current Compiler
Category:Languages Category:Implemented Category:Turing complete
J-bot

j-bot is an IRC bot that evaluates the APL-like J programming language. j-bot could be found in the #jsoftware and #esolangs IRC channel on the Libera network under the nick j-bot . 
J-bot is hosted by Firefly. J-bot runs the software called jevalbot, which was originally written by User:b_jonas. (This doesn't include the J interpreter, which was written mostly by Roger Hui.) Its source code is found at https://github.com/FireyFly/jevalbot and http://www.math.bme.hu/~ambrus/pu/jevalbot.tgz , and is currently unmaintained. At least four different people have ran instances of jevalbot in history, and of those, j-bot was active most recently. (There were at least two other bots that evaluated the J language: IJX, and buubot versions 2 and 3.) https://code.jsoftware.com/wiki/Community/IRC#bots has some very obsolete description of the bot.
J-bot can be invoked with the [  shortcut, or using its full name followed by a space followed by a command name followed by a colon followed by optional arguments. The actual syntax is rather arcane and arbitrary, and b_jonas is sorry for it. J-bot can also be invoked in private message, where it takes a slightly different arcane syntax. Unlike most bots, j-bot can give several lines of output for one command, so you should be careful to avoid spamming channels when you use it.
Category:APL-like
Category:People
J.A.V.A.

J.A.V.A. or Just Another Verbose Annoyance is a WIP joke language by Tailcalled. It is an object disoriented language.
== Classes ==
Everything in J.A.V.A. is about classes. If you want to create a class, you have to get a class factory, which you can get from a class factory provider. The only implementation of that is ClassFactoryProviderSingleton, which contains a static singleton instance. This is how you create a simple class in J.A.V.A:
 ClassFactory factory = ClassFactoryProviderSingleton.getSingleton().getFactory(ClassFactoryProvider.CLASS);
 factory.setName("Hello, World!");
 MethodFactory methods = factory.createMethodFactory();;
 Method main = methods.createMethod("main");;;
 StatementBuilder statements = main.createStatementBuilder();;;;
 Statement statement0 = statements.createStatement(0);;;;;
 ExpressionBuilder expressions = statement0.getExpressionBuilder();;;;;;
 Expression helloWorldString = expressions.stringLiteral("Hello, World!").build();;;;;;;
 Expression printHelloWorld = expressions.clear().call("println").on(helloWorldString).build();;;;;;;;
 statement0.set(printHelloWorld).ignoreResult().save();;;;;;;;;
 Statement statement1 = statements.createStatement(1);;;;;;;;;;
 expressions = statement1.getExpressionBuilder();;;;;;;;;;;
 Expression return = expressions.return().from().method().with(expressions.nullLiteral.build());;;;;;;;;;;;
 statement1.set(return).ignoreResult().save();;;;;;;;;;;;;
 statements.updateStatement(0).set(statement0).save();;;;;;;;;;;;;;
 statements.updateStatement(1).set(statement1).save();;;;;;;;;;;;;;;
 main.updateStatements.set(statements).save();;;;;;;;;;;;;;;;
 factory.addMethod(main);;;;;;;;;;;;;;;;;
 factory.build().main();;;;;;;;;;;;;;;;;;
This program prints 'Hello world'. Some might say it's over-engineering, but we say that it's very maintainable, unlike the haskell equivalent:
 main = print "Hello world"
== Semicolons ==
The number of semicolons after statement n must be n.
Category:Languages Category:Joke languages
JBFM7L

JBFM7L - "Jitejix, But For Masohists 7th Level".
Almost the same concept of Jitejix,
but some things got even weirder
and there are less operations.
Now almost everything is based on linking.
Name thought up by R3D#9999 (Discord).
Extensions: .jm7l, .j7, none.
===Concept===
Only 256 cells, wrap around.
Cell values 0-255, wrap around.
At beginning: all cells with the value of their index:
[0,1,2,3,4,5,...254,255].
There is stack = 0, acts like a cell.
Can access stdout, not stdin.
===Instructions===
By "pointing" I mean the cell, which index is the value of current cell.
Command	Action
+ 	increase, but increases the pointed cell
- 	the same with decrease
& 	swap the value of current cell with pointed one
/ 	add value of current cell to stack
\ 	copy value from stack to cell
* 	multiply stack with pointed cell and store the result in current cell
% 	restore the original value of current cell
? 	proof boolean of current cell and skip to next : if false
# 	proof boolean of stack
! 	print char
> 	move so much to the right as the value in stack
< 	same to left
@ 	move to pointed cell
~ 	decrease stack
$ 	jump to last ? or #
 
All other chars are ignored completely.
===Hello World===
"Hello World!\n" - example written in JBFM7L:
 +//\/\//*@>>!
 *@~~ ~~ ~~ ~>!
 >~~ ~>!!
 >+!
 \/\/\/\/\@!
 ~~ ~~>~>!
 ~~ ~>!
 +++@!
 %-----@@!
 ~~<*!
 **#~$://\@+!
 ~\/\/\/\~ ~~>>!
===Interpreter===
Currently an interpreter available for my language, written in python.
To use it, do:
 $ python3 JBFM7L.py <filename>
==External links==
* Github page
Category:Cell-based
Category:Output only
Category:Implemented
Category:Languages
JC-0715

== JC-0715 ==
JC-0715 is designed by Allen123456hello,which inspired from 大香蕉
== Commands ==
 Convertion
This 	brainfuck
Just 	>
mod 	<
it. 	+
Why 	-
T3 	.
must 	,
use 	[
Lucas???	]
==Examples==
===Cat program===
must it.
use
 Why T3 must it.
Lucas???
JCLN

JCLN (Jump Conditionally to a LiNe) is an OISC instruction invented by User:A.
==Syntax==
Programs are executed in a sequential order by default. 
The basic syntax of the command is to jump to a specific line if a line specified is the "current line".
-1 is a special line: it matches with all of the lines.
===To unconditionally jump to a line:===
jcln -1, line
#For example, to jump to line 5, you type:
jcln -1, 5
===To conditionally jump to a line:===
jcln 1, 5
#If the current line number is 1, jump to line 5.
==Examples==
===Odd-Numbered Lines Jumper===
This program skips any even-numbered lines, visiting merely that at the positions one (1), three (3), and five (5):
 jcln 1, 3
 jcln 2, 0
 jcln 3, 5
 jcln 4, 0
==Interpreter==
* Common Lisp implementation of the JCLN programming language.
Category:Languages
Category:Finite state automata
Category:Implemented
Category:Low-level
Category:OISC
JIT

JIT is a OISC made by User:Robotosaurus6502 somewhere in early November 2024, JIT's one instruction is "Jump If and Toggle". JIT toggles single bits, The bit it toggles is determined by the first argument, And it jumps to the location determined by the second argument if the result was false, Else it just continues to the next instruction.
You can write code in memory and jump to memory, So this is Self modifying.
This is based off "Turing tumble" so it's probably turing complete but I'm not sure.
== Example programs: ==
Sorry there's only one, I'm too lazy to make more.
 0 32 0 32
This program starts at 32, And will toggle bit 0 zero on and off forever.
(God dammit I can't pull my self to write a whole page)
Category:Low-level
Category:No IO
Category:OISC
Category:2024
Category:Self-modifying
Category:Unimplemented
Category:Unknown computational class
JR

JR is a Deadfish variant with more commands.
==Syntax==
Commands are made up of one character. Just type the symbol.
Data is stored in an 8-cell array. Use the < and > commands to change cells.
Line breaks and spaces can be used to format code.
==Commands==
There are 10 commands recognized by JR:
Command	Function 	Deadfish command
[ 	Decrements the current cell. 	d
] 	Increments the current cell. 	i
; 	Squares the current cell. 	s
. 	Prints the current cell numerically.	o
, 	Prints the current cell as ASCII. 	 
@ 	Resets the current cell to 0. 	 
! 	Prints the source of your program. 	 
~ 	Clears the console. 	 
< 	Moves the cell pointer to the left. 	 
> 	Moves the cell pointer to the right.	 
==Sample programs==
===Hello World===
 ]]];[;]]]]]]]],
 @]];]]];[[[[[
 >]]];];],]]]]]]],,]]],
 <,[[[[[[[[[[[[,
 >>]]];]];[[,
 <,]]],[[[[[[,
 @]]];];,
 <],
===Quine===
 !
==Interpreter==
A simple interpreter written in Ruby in the style of a Trivial brainfuck substitution.
 #!/usr/bin/ruby
 s=ARGF.read;eval 'm=Hash.new(p=0);'+s.gsub(/./,
 '[' => 'm[p]-=1;',
 ']' => 'm[p]+=1;',
 ';' => 'm[p]*=m[p];',
 '.' => 'print m[p].to_s;',
 ',' => 'putc m[p];',
 '@' => 'm[p]=0;',
 '~' => 'print "\033[2J\033[H";',
 '>' => 'p+=1;',
 '<' => 'p-=1;',
 '!' => 'print s;',
 )
==External resources==
Online JR Interpreter (written by Ethan, the author of the language)
Common Lisp implementation of the JR programming language.
Category: Languages
category: Joke languages
category: 2018
category: Implemented
category: Output only
JSFlak

by User:I am islptng
This esolang's purpose is to confuse JS programmers. File extention is . js note that space!
The esolang, inspired by Brain-Flak, uses 6 commands, same as JSFuck.
However, the syntax is completely different.
==Syntax==
This esolang uses 3 stacks, call them X,Y and Z.
Nilads:
 () pops a value from active stack and return it.
 [] pops a value from active stack and return negated it.
Monads:
 (a) Push a into active stack and return it.
 [a] Repeat executing a until the top of active stack equal or less than zero. Returns the top value negated.
Tools:
 ! toggles active stack (Default is X, !a to be Y, !!a to be Z). A single ! returns 1.
 + connects 2 commands, returns their sum.
No-connections between 2 commands:
 a() prints the value a returns in ASCII.
 a[] prints in number.
 +() inputs char and returns its ASCII.
 +[] inputs number and return it.
==Examples==
===A+B problem===
 (+[])+(+[])+(()+())+()[]
==Interpreter==
Try it online!
JSInstruction

JSInstruction is an esoteric programming language written by User:Dominicentek. The language has only one built in instruction and you can add more by including JavaScript code.
== Information ==
As previously said, there is only one built in instruction. define and the text after it is used to define a JavaScript file containing the instructions and its code.
=== Functions ===
program.set(string, value) - Sets/adds a variable
program.get(string) - Gets a variable and returns it. undefined if the variable is not defined.
program.gotoLine(number) - Goes to a line number
program.print(string) - Prints out a message to console
program.println(string) - Prints out a message to console with a new line
program.input() - Asks user for input, returns a string containing the input
program.exit() - Exits the program
Value passed into the set function is converted into a string, then to a number (if it can).
program object is only defined in the functions. If accessed from outside of any functions, it returns undefined
console object is always undefined
=== How to define instructions ===
Instructions are defined as functions of the same name, with parameters being the instruction's parameter. A parameter can either be a string or a number. With constant string being surrounded by double quotes (") and constant numbers being the numbers themselves. Strings can not surrounded by double quotes (") are treated as normal strings also, space terminates them. Parameters of the function that are not defined in the instructions are null.
== Examples ==
=== Hello, World ===
define instructions.js
print "Hello, World!"
instructions.js:
function print(message) {
 program.print(message)
}
=== truth-machine ===
define instructions.js
input x
if_is x 0 6
print 1
goto 4
print 0
instructions.js:
function input(variable) {
 program.set(variable, program.input())
}
function if_is(variable, value, lineNum) {
 if (program.get(variable) == value) program.gotoLine(lineNum)
}
function print(message) {
 program.print(message)
}
function goto(lineNum) {
 program.gotoLine(lineNum)
}
=== Calculator ===
define instructions.js
input x
input operation
input y
math x operation y
print x
instructions.js:
function input(variable) {
 program.set(variable, program.input())
}
function math(x, op, y) {
 var left = program.get(x)
 var right = program.get(y)
 if (op == "+") program.set(x, left + right)
 if (op == "-") program.set(x, left - right)
 if (op == "*") program.set(x, left * right)
 if (op == "/") program.set(x, left / right)
 if (op == "%") program.set(x, left % right)
}
function print(value) {
 program.print("" + program.get(value))
}
== Interpreter ==
Download
Category:Implemented
Category:2021
Category:Languages
JSMeth

JSMeth is a JavaScript implementation of brainfuck. The commands are the same, but they're expressed as JS methods.
==Syntax==
The syntax is simple. The language only includes a Tape object, with the following methods, all of which return the Tape itself upon calls.
Method 	Result
.moveLeft() 	Moves the tape pointer to the next cell.
.moveRight()	Moves the tape pointer to the previous cell.
.inc() 	Increments the value of the cell by 1.
.dec() 	Decrements the value of the cell.
.loop(f) 	Executes the function f while the value of the current cell isn't 0.
.out() 	Outputs the value of the current cell.
.in() 	Accepts one byte of input and stores it to the current cell.
==Example==
===Adder===
The adder in BF is ,>,<[->+<]>.. The equivalent JSMeth code is Tape.in().moveRight().in().moveLeft().loop(function(){this.dec().moveRight().inc().moveLeft();}).moveRight().out();
===Hello World===
The HW program in BF is ++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>->>+[<]<-]>>.>---.+++++++..+++.>>.<-.<.+++.------.--------.>>+.>++..
In JSMeth, it's 
 Tape.inc().inc().inc().inc().inc().inc().inc().inc().loop(function(){this.moveRight().inc().inc().inc().inc().loop(function(){this.moveRight().inc().inc().moveRight().inc().inc().inc().moveRight().inc().inc().inc().moveRight().inc().moveLeft().moveLeft().moveLeft().moveLeft().dec();}).moveRight().inc().moveRight().inc().moveRight().dec().moveRight().moveRight().inc().loop(function(){this.moveLeft();}).moveLeft().dec();}).moveRight().moveRight().out().moveRight().dec().dec().dec().out().inc().inc().inc().inc().inc().inc().inc().out().out().inc().inc().inc().out().moveRight().moveRight().out().moveLeft().dec().out().moveLeft().out().inc().inc().inc().out().dec().dec().dec().dec().dec().dec().out().dec().dec().dec().dec().dec().dec().dec().dec().out().moveRight().moveRight().inc().out().moveRight().inc().inc().out();
==Real JavaScript implementation==
This is a real implementation of a Tape object constructor in JavaScript for browsers:
var Tape = function() {
	this.tape = [0];
	this.index = 0;
};
Tape.prototype.inc = function() {
	this.tape[this.index]++;
	return this;
};
Tape.prototype.dec = function() {
	this.tape[this.index]--;
	return this;
};
Tape.prototype.moveLeft = function() {
	this.index++;
	if (!this.tape[this.index]) this.tape[this.index] = 0;
	return this;
};
Tape.prototype.moveRight = function() {
	this.index--;
	if (!this.tape[this.index]) this.tape[this.index] = 0;
	return this;
};
Tape.prototype.out = function() {
	console.log(this.tape[this.index]);
	return this;
};
Tape.prototype.in = function() {
	this.tape[this.index] = prompt();
	return this;
};
Tape.prototype.loop = function(f) {
	while (this.tape[this.index] != 0)
		f.call(this);
	return this;
};
Category:Languages Category:2020 Category:Turing complete Category:Brainfuck derivatives Category:Brainfuck equivalents Category:Cell-based
JUMP

JUMP is a three command programming language by User:EzoLang with binary I/O. Commands are GOTO x, IF x THEN GOTO y ELSE GOTO z and OUTPUT x. If a program jumps to a non-existing destination the program stops.
== Syntax ==
 0 OUTPUT 0 IF 1 THEN GOTO 4 ELSE GOTO 1
 1 OUTPUT 1 IF 0 THEN GOTO 0 ELSE GOTO 2
 2 IF 1 THEN GOTO 1 ELSE GOTO 3
 3 GOTO 0
The possible line forms are
 line number IF 1 or 0 THEN GOTO line number ELSE GOTO line number
or
 line number OUTPUT 1 or 0 IF 1 or 0 THEN GOTO line number ELSE GOTO line number
or
 line number GOTO line number
or
 line number OUTPUT 1 or 0 GOTO line number
IF x THEN GOTO y ELSE GOTO z means: if input is x then jump to y, if it isn't jump to z. OUTPUT x outputs the 1 bit binary number x. GOTO x means jump to x.
== Binary form ==
 0 OUTPUT 0 IF 1 THEN GOTO 2 ELSE GOTO 1
 1 IF 0 THEN GOTO 0 ELSE GOTO 2
 2 OUTPUT 1 GOTO 0
becomes
 1011010100100000000110001100
which can be divided into four blocks (because 2 bits is the minimum binary number length to store numbers 0-2. The last block is this time 0001100).
 1011010
 1001000
 0000011
 0001100
Every block can be divided into five pieces
 A B C D E
 1 01 10 1 0
 1 00 10 0 0
 0 00 00 1 1
 0 00 11 0 0
D is 1 if the line used OUTPUT. E is the number to output. A is 0 if the line used GOTO and 1 if it used IF THEN GOTO ELSE GOTO. B is the destination if input is 0 or if A is 0. C is the destination if input is 1. If A is 0 and C is all ones program halts.
== Examples ==
=== CAT ===
 0 IF 0 THEN GOTO 1 ELSE GOTO 2
 1 OUTPUT 0 GOTO 0
 2 OUTPUT 1 GOTO 0
In binary form
 1011000000001000000110001100
=== 2 Bit counter ===
 0 OUTPUT 0 GOTO 1
 1 OUTPUT 0 GOTO 2
 2 OUTPUT 0 GOTO 3
 3 OUTPUT 1 GOTO 4
 4 OUTPUT 1 GOTO 5
 5 OUTPUT 0 GOTO 6
 6 OUTPUT 1 GOTO 7
 7 OUTPUT 1 GOTO 0
In binary form
 000100010001000010001100010010000011010100011011000010011100011000000011
=== Truth-machine ===
 0 IF 0 THEN GOTO 2 ELSE GOTO 1
 1 OUTPUT 1 GOTO 1
 2 OUTPUT 0 GOTO 3
In binary form
 110010000100110110010
== Computational class ==
JUMP is not turing complete. Every JUMP program can be translated to a DFA.
== Implementations ==
Implementation by User:Oshaboy - https://github.com/oshaboy/JUMP-Interpreter
Category:LanguagesCategory:ImplementedCategory:2009Category:Finite state automata
JUSTIF

Justif & Recursion (or simply JUSTIF) is an esoteric programming language created by Gerson Kurz, where control flow is limited to if-else statements and recursion.
==Examples==
===Hello, world!===
~1?.0=_,.$="Hello, World",=2:~2?.1!.0?>.1!.0,._+1,=2:0:0
===Fibonacci sequence===
This program outputs the first 10 numbers of the sequence.
~1?.2=$,.0=1,.3=$,=2:~_?+._=10?!.0,.1=.$,._+.3,.0=.$,.$=.1,.2+$,
=_:0:_
===atoi function===
~1?.2="1182",
.0=_,.1=$,=3,
!.$:~2?.3=.$!
.0,*.$=47?+.3
=58:0:~3?=2?.
$-48,.1*10,.$
+.3,.0+1,=3:0
:I AM JUSTIF_
==External resources==
* Official page: Justif and Recursion at p-nand-q
Category:Languages
Category:Implemented
Category:2001
Ja

ja is an esoteric programming language created by User:A. 
Twin language: Aj
== Instructions ==
Instruction	Description
j 	jump to cell numbered as the current cell and jump to the cell-th code command.
a 	add current cell by 1
== Example (Infinite Loop)(Set array to 1111111...) ==
 aj
== Computational class ==
 a = +
 j = < or > or [ or ]
This suggests that there *might* be enough power for Turing-completeness by emulating brainfuck or some variation of it.
However, because the translation depends on what values are in the cells, there remains quite a bit of work to show that you can
achieve an arbitrary effect at an arbitrary point.
Category:Languages
Category:2018
Category:Low-level
Category:Brainfuck derivatives
Category:Cell-based
Jackass

Jackass is a stack-based language made by User:Phase. The way it operates is inspired by Brainfuck, but the syntax is pure hexadecimal.
== Syntax ==
A program is split up into different hexadecimal commands separated by spaces.
01 02 02
Pushes 2 to the stack and pops it off. 
== Operation List ==
The operations are in the order I thought of them in, so they're completely out of order and are meant to be that way. This list is not complete by any means, I will be adding more once I recharge my computer.
Operation	Description
01 	push the next value to the stack
02 	pop the top of the stack off
03 	swap the top two values on the stack
04 	move the third value on the stack to the top
05 	pop the top of the stack, go to that line in the program
06 	clone the top of the stack
07 	add the top two values on the stack and push the result
08 	subtract the top two values on the stack and push the result
09 	multiply the top two values on the stack and push the result
0a 	divide the top two values on the stack and push the result
0b 	mod the top two values on the stack and push the result
0c 	print the top of the stack as a number
0d 	print the top of the stack as a character
0e 	push input from stdin as a number
0f 	push input from stdin as a string (splitting it up into characters and pushing the value of each one)
==Examples==
===Cat program===
An infinitely repeating numeric cat program shall be demonstrated:
 0e 0c 01 00 05
===Hello, World!===
This program prints “Hello, World!”:
 01 48 0d 02
 01 65 0d 02
 01 6C 0d 02
 01 6C 0d 02
 01 6F 0d 02
 01 2C 0d 02
 01 20 0d 02
 01 57 0d 02
 01 6F 0d 02
 01 72 0d 02
 01 6C 0d 02
 01 64 0d 02
 01 21 0d 02
===Truth-machine===
A truth-machine in this language follows:
 0e 0c 01 0c 09 03 02 01 0d 08 03 02 03 02 05
== Interpreter ==
Untested Interpreter based on spec at time of writing. Care to write a Hello World?
Common Lisp implementation of the Jackass programming language.
Category:Languages
Category:2015
Category:Implemented
Category:Low-level
Category:Stack-based