nyuuzyou/wikis huggingface dataset:
Jail system is Turing-complete

Let's assume there are infinite people (there aren't really, but that doesn't matter), and there is one judge.
The judge can go from interviewing different people at a time, so > and < are down.
Since Brainfuck's system only needs two possible symbols per spot on tape to be Turing-complete, the jail system also has two symbols. Innocent and guilty.
(Everyone starts out innocent.)
Therefore, + and - are down as well.
The judge can use a "judgement process" depending on which people are innocent and which ones are guilty.
This means the brackets [] are also down.
Therefore, the jail system is Turing-complete. (The system, not in practice)
Category:ProofsCategory:2024
Jail system makes no sense

As everyone knows:
# There is at least one person who has not commited a crime and gone to jail.
# There is at least one person who has commited a crime and gone to jail.
# If someone has also commited a crime, they go to jail.
Lets say person A is in variable A, person B is in variable B, person C is in variable C, the jail is in the variable J, and the crime is in the variable D.
A has not done D, so A≠D
B has done D, so B=D
C has done D, so C=D
N=D=J
A≠J
B=D
C=D
D=B
D=C
D=C=B
C=B
Lets say person B was 0, and person C was 1. This would mean that 0=1. Now release everyone from jail or 0=1.
Category:2023Category:Proofs
Jannis Harder

Jannis Harder is the author of some esoteric languages he created many years ago:
* axo (2004)
* YABALL (Jun, 2005)
* Subskin (Sep, 2005) a OISC variant with an extreme short (148 bytes of code) Ruby implementation.
* Rhotor (Jan, 2006) a lazy evaluating functional language that utilizes pattern matching.
And he wrote some implementations for other esoteric languages:
* obi2, a nicely shaped Brainfuck interpreter written in Ruby. (Jul, 2005)
* bf2a, a Brainfuck to C converter which does many optimizations (gcc fails on too long programs), again written in Ruby. (Jul, 2005)
* bfx, a short (177 bytes of code) Brainfuck interpreter written in Ruby. (Not online yet) (Sep, 2005)
==See also==
* User:jix Jannis Harder's user page.
==External resources==
Jannis Harder's homepage
Category: People
Janus

Janus is a high level reversible programming language created by Christopher Lutz and Howard Derby [1] as part of a class they taught. It was later discovered and developed further by Yokohama, Gluck et. al [2]. Any program written in it can be run forwards or backwards. A compiler from Janus to PISA was described in [3].
== Example ==
 procedure init(int n, stack list)
 local int q=0
 
 n += 4
 q+=9 push(list,q)
 q+=7 push(list,q)
 q+=1 push(list,q)
 q+=5 push(list,q)
 
 delocal int q=0
 
 procedure makeidperm(int n, stack perm)
 local int i=0
 local int z=0
 
 from i=0
 do skip
 loop push(perm,z)
 perm[i] += i
 i += 1
 until i=n
 i -= n
 
 delocal int z=0
 delocal int i=0
 
 procedure sort(int n, stack list, stack perm)
 local int i=0
 local int j=0
 
 from i = 0
 do skip
 loop j += n-2
 from j = n-2
 do skip
 loop if list[j] > list[j+1]
 then list[j] <=> list[j+1]
 perm[j] <=> perm[j+1]
 else skip
 fi perm[j] > perm[j+1]
 j -= 1
 until j = i-1
 j -= i-1
 i += 1
 until i = n-1
 i -= n-1
 
 delocal int j=0
 delocal int i=0
 
 procedure main(int n, stack list, stack perm)
 call init(n,list)
 call makeidperm(n,perm)
 call sort(n,list,perm)
== References ==
* [1] Janus: a time-reversible language (1986) - The creation of Janus in a Letter from Christopher Lutz to Rolf Landauer.
* JANUS: A TIME-REVERSIBLE LANGUAGE - HTML version of the same letter. 
* [3] Clean Translation of an Imperative Reversible Programming Language (Axelsen 2011) - Details the compiler from Janus to PISA. 
* [2] A reversible programming language and its invertible self-interpreter - Tetsuo Yokoyama and 	Robert Glück. - Defines the term Reversibly-Turing Complete and proves that Janus is including a self interpreter.
== External resources ==
* Program Inversion and Reversible Computation - Modern Janus interpreter in Javascript by Claus Skou Nielsen and Michael Budde.
* An article about Janus on Wikipedia.
Category:Languages Category:High-level Category:Reversible computing Category:Implemented Category:Before 1993
Japt

Japt is a language designed for code-golfing.
== Overview ==
Japt is a compiled language, or specifically, transpiled. Many functions have been shortened to a single letter, and there's no need for the dot before or the left-paren after. Input and output are implicit. See the online interpreter for more documentation.
== I/O ==
=== Input methods ===
Input is automatically parsed as numbers, strings, and arrays, then stored in various variables.
Name	Value
N 	Array of inputs
U 	First input
V 	Second input
W 	Third input
X 	Fourth input
Y 	Fifth input
Z 	Sixth input
 
=== Output methods ===
The last evaluated expression (separated by semicolons) is automatically sent to the output. You can also output by using the functions Oo and Op (the latter prints a trailing newline).
== Compilers / Interpreters ==
* Online interpreter with docs
Category:Golfing language Category:Turing complete Category:Implemented Category:2015 Category:Languages
JarJarScript

JarJarScript is an esoteric language where the only way to write code is through the Star Wars character, Jar Jar Binks', grammar. It is currently being made by the beginning programmer,OdinSmodin (talk) 22:50, 28 October 2018 (UTC)OdinSmodin.
Category:Languages Category:Unimplemented Category:Thematic Category:Pseudonatural Category:Unknown computational class Category:Usability unknown
Jasp

Everyone knows that object-oriented programming is superior to the list-oriented programming of the Lisp family, and that JSON is superior to S-Expressions. Introducing Jasp, a language that lets you program in a Scheme-like dialect using nothing but JSON!
==Syntax==
Symbol definition 	
{
 "operator": "define",
 "name": <string>,
 "value": <expr>
}
Mutation 	
{
 "operator": "set!",
 "name": <string>,
 "value": <expr>
}
Reference 	
If "x" is defined in the current environment,
"$x" returns the value,
whereas "x" is just a string.
The dollar sign is not necessary if the referenced symbol is in the operator position.
Branching 	
{
 "operator:" "if",
 "predicate": <expr> ,
 "then": <expr>,
 "else": <expr>
}
Sequencing 	Jasp interprets naked arrays as sequences of instructions, like (begin) in Scheme.
[
 { "operator": "set!", "name": "x", "value": 2 },
 { "operator": "display", "arguments" [ "$x" ] },
 "$x" // returns the value of "x" from the sequence
]
Quotation 	
{
 "operator": "quote",
 "value": <expr>
}
Abstraction 	
{
 "operator": "lambda",
 "arguments": [ "string", "string", ... ]
 "body": <expr> // (can be an array, interpreted as a sequence)
}
Function application	
{
 "operator": "foo",
 "arguments": [ 1, 2, 3 ]
}
Reflection 	
{
 "operator": "eval",
 "code": <quoted-expr>
}
==Example==
Here is a simple program to calculate the factorial of 100 and display it:
 [
 {
 "operator": "define",
 "name": "fact",
 "value": {
 "operator": "lambda",
 "arguments": [ "n" ],
 "body": {
 "operator": "if",
 "predicate": { "operator": "=", "arguments": [ "$n", 0 ] },
 "then": 1,
 "else": {
 "operator": "*",
 "arguments": [
 "$n",
 {
 "operator": "fact",
 "arguments": [
 {
 "operator": "-",
 "arguments": [ "$n", 1 ]
 }
 ]
 }
 ]
 }
 }
 }
 },
 
 {
 "operator": "display",
 "arguments": [
 {
 "operator": "fact",
 "arguments": [ 100 ]
 }
 ]
 }
 ]
==External resources==
*Jasp implementation
Category:Languages Category:Implemented
Jav

Jav is a low level language made by BrickLikesCoding as a side project.
This was kind of made as a important language, like it was a actual attempt but I gave up so this is the result
----
Examples:
* The Hello World program is very similar to python / lua
 print 'Hello, World!'
* You can add comments like this:
 [ Hello, I am a comment! ]
* You can also save variables like this:
 var my_variable = 'Value'
although currently, you can't call them. (I'm working on it, though)
* You can call wait times like this:
 print 'Wait a second'
 wait 1000
 print 'Ok I waited a second'
------
You can run a online version here:
Repl.it interpeter
(Fork it!)
Category:Languages Category:Implemented Category:Unusable for programming Category:Total Category:Output only
Javagony

Javagony is an OOP programming language derived from Java. The only differences to Java are that following statements are not available in Javagony:
 for (){}
 if (){} //including else and else if
 while (){}
 do {} while ();
 switch(){}
 ?:
But everything else remains exactly the same as in the corresponding Java version. As the Loops - that Java users might be used to using - are not available, the primary instrument for looping is recursion. And one of the ways of anchoring recursions is using the
 try {} catch(){}
statement.
==History==
Java is known to be very unsuitable for code-golf as it is inherently verbose. To emphasize this feature, Javagony was created, in the spirit of "There is no problem so bad that you can't make it worse.". The name was first coined by the user flawr in PPCG.SE.
==Turing-completeness==
Javagony is Turing-complete; proof is at Javagony Turing-completeness proof.
==See also==
* Javagony Turing-completeness proof
* Javagony/Brainfuck Reduction
Category:Esoteric subset
Category:Languages
Category:High-level
Category:Implemented
Category:Object-oriented_paradigm
Category:Turing complete
Category:2015
Javagony/Brainfuck Reduction

:
Javagony has already been proven turing complete by User:PythonshellDebugwindow, through the implementation of a brainfuck interpreter, however, it would be easy to prove it turing complete by simply reducing it TO brainfuck.
== Variables ==
Brainfuck can provide near infinite variable storage through the means of a pointer, Java (and javagony) has this capability through variables.
== Incremention / Decrementation ==
Simple enough, however, you can increment or decrement a variable with ++ or --
== Input ==
Input can be received as an ASCII byte through the Scanner class. One way to receive the bytes value might be:
Scanner scanner = new Scanner(System.in);
pointerVar = scanner.nextLine().toCharArray()[0];
However, this is not the best way to do it.
== Loops ==
Loops is the most restrictive thing about Javagony that could suggest it not being turing complete. Loops in brainfuck require a while loop, or similar, and to check if a value is non-zero. In Javagony, the most common way to replicate loops is through recursion. If your loop has too many steps, you will get a stack overflow error, however, this can just be caught. So, to create a loop, we can start with a function that calls itself, and a try catch.
public void loop() {
 try {
 loop();
 catch (StackOverflowException e) {
 loop();
 }
}
Now, we must check if a value is non-zero on each iteration. We can use the ArithmeticException for this, because it is called upon division by zero. Therefore, we can check if a number, divided by the pointer value is 0.
public void loop() {
 bool zero = false;
 try { double d = 7.0 / pointerVar } catch (ArithmeticException e) { zero = true; }
 if (zero) {
 return;
 }
 try {
 loop();
 catch (StackOverflowException e) {
 loop();
 }
}
This will divide 7, by the pointer var, and thus, if the value is 0, ArithmeicException will be called, where we will return the loop.
== See Also ==
* Javagony Turing-completeness proof
Category:Proofs
Javascular

Do you absolutely hate yourself? Do you wish Javascript was worse than it actually is? Well, fret not, this is Javascular, which makes you hate Javascript!
Javascular basically reverses all code.
==Program examples==
===Hello, World!===
 ;("!dlroW ,olleH")gol.elosnoc
===Sum of x+y is z===
 ;(z + " si y+x fo mus ehT")gol.elosnoc
 ;y + z = z rav
 ;2 = y rav
 ;1 = x rav
===5 is greater than 2===
 {
 ;("!2 naht retaerg si 5")gol.elosnoc
 } (2 < 5) fi
Category: joke languages Category: Languages
Jcram

JCram is a golfing language derived by Kamila Szewczyk from JavaScript. JavaScript code is compressed using a specialised neural network model, making JCram competitive with existing golfing languages like Jelly, Vyxal or 05AB1E.
== Examples ==
Determine the Egyptian fraction representation (EFR) of a number. 
⌽⌊≥⍸χⒷ⁸d⊤¤β⁷D⏧¤⍆ξτ⍯⍇¯⌷3⊑¹⍤L
Add two numbers (Lambda function):
σ⟄∆θ
Fibonacci numbers function:
π⍒⏧z⍳⍚s⍷
== External links ==
* Author's blog post describing the programming language.
Category:Languages
Category:Implemented
Category:Golfing language
Category:2024
Jeb

Jeb, pronounced /ʤev/ is an esolang created by User:Infinitehexagon with 14 instructions. This is his first esolang in months.
Category:2024Category:LanguagesCategory:Unimplemented
==Syntax==
Almost all instructions require at least one or two arguments. 
 je a
 ej a b
Only two instructions use three or more arguments, and that's bjej, beej, and bje . The bje instruction can have an infinite amount of instructions because its for statements.
 bjej a b c
===Operators===
 jjj NOT (!)
 jj =
 j ==
 eeee %
 eee >
 bbbb AND (&)
 bbb <
 bb /
 b *
For operators that dont exist such as >= or <= you combine them. Greater than or equal to would be (eee jj), less than or equal to would be (bbb jj) and not equal to would be (jjj jj).
==Instructions==
 Caption text
Command	Description 	Eqiuvalent 	Usage Example
ee 	increment a variable by a value. 	var += x 	ee var 15
eb 	create an array and give values to it. 	var = [] 	eb array [1, 2, 3]
ej 	set a variable to a value or an operation. leave second argument blank for declaring a variable.	var = x 	ej var 15
bj 	store user input into a given variable. 	 	bj var
je 	output the given variable. 	print(var) 	je var
be 	while statement is matched, initiate a loop. 	while x do{ 	be var jj 15
bee 	close a loop. 	} 	
bej 	create a function. 	function function() {	bej func { (code)...} bej
jeb 	start program. 	 	jeb (code)...
jje 	set a variable to a random value ranging from 1 to the number. 	random(1, n) 	jje var 6
bje 	if statement. performs code below if the statement is true. 	if var = x then... 	bje var (operator) x ... bje
beej 	set variable to the value in the index number of an array. 	var = array[index] 	beej var array 0
bjej 	append a value to an array. 	 	bjej
jeeb 	halt / end program. 	 	(code)... jeeb
==Programs==
===Hello World program===
 ej helloworld "Hello, World!"
 je helloworld
===Cat program===
 bj input
 je input 
===Count up to 100===
 ej count_up 0
 be count_up bbb jj 100
 ee count_up 1
 je count_up
 bee
===FizzBuzz program===
 ej fizzbuzz 100
 ej counter 0
 ej output "empty"
 eb text ["Fizz", "Buzz", "FizzBuzz"]
 be fizzbuzz eee counter
 ee counter 1
 bje counter eeee 3 jj 0
 beej output text 0 
 je output
 bje
 bje counter eeee 5 jj 0
 beej output text 1 
 je output
 bje
 bje counter eeee 3 b 5 jj 0
 beej output text 2 
 je output
 bje
 bje counter jjj eeee 3 bbbb eeee 5
 je counter
 bje
 bee
Jebscript

Jebscript (also known as "Jebscript!") Is a programming language based on former governor of Florida and presidential candidate in the 2016 election Jeb Bush.
Its file extensions are .je and .jeb
== Commands ==
jeb! jeb+: Adds one to the energy count variable. 
If energy count goes over 16 a randomly chosen error is printed since any number over 16 is too high energy for Jebscript(!).
jeb! jeb-: Removes one from the energy count variable. 
pleaseclap! : Outputs one word.
Any line that starts with guac! Is a comment.
== Hello World ==
"Hello World" In Jebscript is 
 pleaseclap! Hello
 pleaseclap! World
Jebscript's interpreter is written in Python 2. 
It can be found here
Jeffry Johnston

Jeffry Johnston is the author of several esoteric programming languages including:
* Numberix
* Bubble
* Esofunk
* Hanoi Love
* Spaghetti and Linguine
* BitChanger
* Barely and MinISCule
He is also the author of many interpreters and compilers for brainfuck (which he prefers to call "BF"), as well as BFBASIC, which compiles BASIC programs to BF, and BFASM, which assembles to BF.
==See also==
* User:Calamari and User:Calamari2 is Jeffry Johnston's user page on this wiki.
==External resources==
* calamari's Home Page
Category:People
Jellang

Jellang is an esolang made by emelchenko that is a derivative of deadfish.
The Commands are supposed to look like you are jellyfishing near bikini bottom.
== Commands ==
Catch!: Increments the Accumulator by 1.
Release!: Decrements the Accumulator by 1.
Square!: Squares the Accumulator.
Here is the amount of jellyfishes I got!: Prints out the Accumulator as a Number. (yes, the command is THAT long.)
Hello jellyfishes!: Prints out Hello World.
Category:2023 Category:Languages Category:Unusable for programming Category:Implemented Category:Thematic Category:Output only Category:Pseudonatural
Jello

jello is a two stack esolang by User:Yayimhere where the only control flow is skip, reverse and evaluate
== memory/script ==
as said before jello uses two stacks. jello has a pointer which points to the current stack. each stack can hold number and strings. the script is circular so if the IP goes out of bounds on the left edge it will in the same direction be at the right side(and the other way around).
== syntax ==
this is the syntax of jello:
 syntax
symbol	description
/ 	skip the following command
\ 	reverse the IP direction
) 	evaluate the top of the stack as code. if it causes an error it skips the following command
# 	NOP
~ 	negate the top of the stack
0-3 	push the base 4 number
( 	switch to the other stack
[ 	push the following char to the stack as a string
+ 	if the top two top values of the stack are numbers then pop the two numbers add them together and push the result. if they where strings then pop the two strings(A and B) and prepend A to B
] 	halt the program
{ 	pop the top of the current stack and push it to the other stack
} 	push EOF user input as a string
! 	pop the top of the stack. if its a string print the string as a string. if its a number print it as a number
? 	copy the top of the stack
the program will give an error if the wrong datatype is used, if there aren't enough elements on the stack
== examples ==
lololololol program:
 [l[o+/\#/?/#!/!#/#?/\
print lol forever. im not sure it works
== external recourses ==
* code golf stack exchange page holding the original idea for the lol program
Category:Languages Category:Stack-based
Jelly

Jelly is a golfing language by Dennis Mitchell inspired by the J programming language. It has a free online compiler on Try It Online. It comes with its own character set (of 256 characters) and character encoding, apparently unrelated to any previous encodings. 
==External resources==
* https://github.com/DennisMitchell/jelly
* Try It Online
* https://jellyballs.github.io/
Category:Languages
Category:Golfing language‏‎
Category:Functional paradigm‏‎
Category:Implemented
Category:APL-like
Jenl

Jenl is a language for those who are lazy to write complicated parsers, especially expression parsers, they've been known to be the pain.
Jenl's parsers are taking tokens and directly transform them to executable format.
Jenl's parsers do not require recursion and do not require complicated parsers (e.g. expression parsers).
Jenl's parsers must not backtrack nor have any ambiguities.
Jenl's parsers strings are raw, no escape sequences. 
Jenl should have only a single, more general way of doing things, even if its inefficient or hacky.
This language, is probably opposite of functional paradigm due to huge amount of mutations happening
Hello world in Jenl:
print(`Hello world`);
Square printer program in Jenl
def buffer = ``;
def width = 10;
def height = 10;
~repeat width as idx
 buffer += idx;
~quit
print(`Let's draw a rectangle`);
~repeat height as idx
 print(buffer);
~quit
Fib program in Jenl
def fib_iters = 40;
def a = 0;
def b = 1;
~repeat fib_iters as i
 def c = a;
 c += b;
 a = b;
 b = c;
~quit
print(a);
Even without conditional its possible, remember how we mentioned there must be always a single way to do anything. This program prints if age is over 18
def age = 19;
def is_adult = 0;
def adult = age;
adult += -17;
~repeat adult
 is_adult = 1;
~quit
print(`Is adult? 1: True, 0: False`);
printn(is_adult);
Nested loops are possible
~repeat 10 as i
 ~repeat 10 as j
 printn(i);
 ~quit
 print(``);
~quit
The linear grammar is very easy to implement.
Basics:
number: /-?[1234567890]+/g
string `Anything goes here`
only += and =
directives:
 directives start with ~ symbol and then parsed, to avoid being mistaken for something else
expressions: present only as a single atom (token, number, string, etc)
Syntax:
toplevel: ( def ";" | call ";" | atom ";" | dir | assign ";" ) *
dir: ~(atom)+
call: Ident "(" atom ")"
atom: Ident | Number | String
assign: Ident "+=" atom | Ident "=" atom
def: "def" Ident "=" atom
Proof of concept implementation (as bad as the language overall is): 
https://github.com/ishidex2/jenl-node/blob/master/test.jn
Jitejix

An esolang created for fun.
Pronounciated as [d zh i t e d zh i k s].
Inspired by Brainfuck.
Probably not turing complete, who knows.
The name was chosen while randomly typing letters.
Extensions: .jj, .j, 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===
Command	Action
+ 	increase, but increases twe two neighbour cells
- 	the same with decrease
& 	swap two neighbour cells
/ 	add value of current cell to stack
\ 	copy value from stack to cell
* 	multiplies values of neighbour cells
and adds to current cell
% 	restore original value of current cell
_ 	set cell to zero
? 	proof boolean of current cell and skip to next : if false
# 	proof boolean of stack
! 	print char
> 	move one cell right
< 	same to left
^ 	move so much to the right, as much the value is in stack
@ 	move to cell with index of current value
~ 	decrease stack
$ 	jump to last ? or #
 
All other chars are ignored completely.
===Hello World===
"Hello World!\n" - example written in jitejix that shows its functionality:
 >>>_*@*@>!
 ////^<<<!
 >>>>>>>!!
 >>>!
 _\!
 _+<%>++*@>>>>>>>!
 ^_\*@<%!
 ->!
 <<<<!
 <<<<<<<<!
 _\@>!
 _@>>>@>>!
Sure can be written shorter.
===Interpreter===
Currently an interpreter available for my language, written in python and javascript.
To use it, do:
 $ python3 jitejix.py <filename>
or
 $ node jitejix.js <filename>
==External links==
* Github page
Category:Cell-based
Category:Output only
Category:Implemented
Category:Languages
Category:Stack-based
Jive

jive is a golf esolang made by User: Ractangle
==Syntax==
Commands	Action 	
 	input. 	
 	if the symbol next to is	then convert tos into
 	interger 	
 	float 	
 	string 	
==Examples==
===Factorial===
 *`,!↓
====Implementations with automatic type conversion====
 *!↓
===Cat program===
 *↓
==Implementation==
Python implementation
Online implementation
Category:Languages
Category:2024
Category:Implemented
John Horton Conway

John Horton Conway (1937-2020) was a prolific mathematician, whose work spanned from the extremely serious (such as finite group theory) to the extremely recreational and what we here would call esoteric. Things he has made or investigated that may be of interest to our community include:
*Fractran
*Look-and-say sequences
*The Game of Life cellular automaton
*Surreal numbers and games
*Collatz functions
==External resources==
*John Horton Conway on Wikipedia.
Category:People
Joke Page

Joke Page is a pointless esolang by User:None1.
==Execution==
If the program is Joke, print Page.
If the program is Page, print Joke.
Otherwise, print .
==Examples==
===Quine===
 Nope.
===Nope. interpreter===
 anything except Joke and Page
===Output Joke===
 Page
===Iterating quine===
 Joke
and
 Page
Category:2023