nyuuzyou/wikis huggingface dataset:
1argasm

1argasm is an Assembly-like language created by Zero in June of 2018. The main restriction is that all commands can only take one argument.
==Overview==
here's an asm, command-whitespace-argument.
commands take only 1 argument.
this is the result of the last command.
about puts something in this.
==main vocabulary==
 f: [f] - define function f
 f call a previously defined function f
 ? about - assigns value to "this"
 $ store - assigns value to variable name
 ^ return - ends function and returns value
 @ argument - returns the function argument
 # this - returns the value in "this"
 < less than - skip next command unless this < value
 > greater than - skip next command unless this > value
 = equals - skip next command unless this = value
Beyond that, you'd create the vocabulary that suits your needs. Boring, isn't it?
==1-char names version==
 [fib]
 ? @
 < 3
 ^ 1
 ? @
 - 1
 fib #
 $ z
 ? @
 - 2
 fib #
 + z
 ^ #
==verbose ini file style version==
 [fib]
 about: argument
 if less than: 3
 return: 1
 about: argument
 decrement: 1
 fib: this
 store as: z
 about: argument
 decrement: 2
 fib: this
 increment: z
 return: this
==loose the whitespace so it looks like hell version==
 fib:?@<3^1?@-1fib#$z?@-2fib#+z^#
 
Category:2018
Category:Languages
1line

1line is a joke programming language worked on by DockedChutoy (talk) in the year 2022. It was made to be terrible.
== Commands ==
=== Types ===
In 1line, there are 3 types:
==== Strings ====
Strings are marked by being surrounded by minuses, like this:
 -Hi-
String can be also joined:
 -The-+-Thing-
==== Numbers ====
Numbers can be made in this fashion:
 |123|
Number operations can be stored as well:
 |21+21|
==== Booleans ====
Booleans cannot be used by the user, and are instead used in conditionals, which will be explained further.
=== Printing ===
The command write{} is used to print stuff to screen, like this:
 write{-Test-}
 write{|42|}
=== Variables ===
Variables are can be created using the var{} command this way:
 var{x-Yes-}write{x}
(Remember that programs are to be written in ONE line, just like in the name)
The above example creates a variable called x, stores the value Yes in it, and then prints it.
Also, a variable can be declared inside a command:
 write{var{x|876|}}
And finally, you can change a variable:
 var{x-AB-}write{x}var{x+-CD-}write{x}
=== Input ===
Input can be recieved and stored using the command expect{}:
 expect{-x-}write{x}
If there is already something in the variable the input is assigned to, then the input is joined to the variable (Note that expecting the wrong type is an error):
 var{x-This is a-}expect{-x-}write{x}
One can also make it so that a string or a number is joined to the recieved input:
 expect{-x-+-yes-}
Joining two different types results in a error.
== Examples ==
=== Hello World ===
 write{-Hello World-}
=== Cat ===
 write{expect{-x-}}
Category:Languages
Category:2022
Category:Joke languages
1quad

1quad is an esolang based on Conway's Game of Life created by User:Yayimhere. it may seem random but it was made such that 1 was a quad
== syntax ==
a program is made up of a single unary number where the unary symbol is .. to add a decimal behind it you seperate the decimal part with a =
== semantics ==
now we have a unary number. lets call it n. now do this process to turn the program into conway's game of life:
* set a variable P to abs(\frac{1}{n})+(55385795187-n)
* the area(called the rectangle) for the GoL pattern is n\times (5+n) by (n2) \times (n4)
* fit the binary of P into the rectangle(not caring about what goes outside the rectangle) where 1 is a live cell and 0 is a dead cell, and if there aren't enough digits we repeat the binary until there is. we ignore the decimal if there is any
* run the GoL program
so the program:
 .
returns this GoL layout:
and:
 ..
becomes the layout:
 
Category:Languages Category:Cell-based Category:Unknown computational class Category:Low-level Category:2024
1͏͢

1͏͢ is an esoteric programming language made for the purpose of designing adventure games, made by User:AmNow.
1͏͢ is based off of decision shrubs.
== Commands ==
=== Switch - Case and Jumps ===
Switch Cases and Jumps are the ONLY way to do control flow.
 Syntax:
 𝌡 [case name]_[cnd]→
 [body]
 ⩀ [cnd]→
 [body]
 ⊭→
 [body]
Node Representation:
 A
 /|\
 B C D
Jumps:
 ⏧←[case name]
Node Representation:
 A<--\
 \ |
 B-/
=== Variables ===
To declare a variable:
 [variable name]≦[value]
=== Commands ===
Command	What it does 	Example 	Notes
⊞],) 	Addition 	⊞]2,1) 	Can be used for concatenation.
⊟],) 	Subtraction 	⊟]2,1) 	
⊠],) 	Multiplication	⊠]2,1) 	
⌹],) 	Division 	⌹]2,1) 	Division by 0 is undefined behavior.
⤝ 	Input 	inp≦⤝ 	
p]) 	Output 	p]inp) 	
=],) 	Equality 	=]inp,1)	
<],) 	Less Than 	<]1,2) 	
>],) 	Greater Than 	>]2,1) 	
≠],) 	Inequality 	≠]7,8) 	
== Programs ==
=== Truth Machine ===
 INP≦⤝
 𝌡 A_=]INP,1)→
 p]INP)
 ⏧←A
 ⊭→
 p]0)
==See also==
* Decision shrub
Category:Languages Category:Unimplemented
1⅞ bytes :3

1⅞ bytes :3 is a esolang based off of 3 bytes :v).
== interpreters ==
brainfuck (with one charecter of input)
 ,+++.
Python
 p=0;c=""
 while True:
 try:print(chr(ord(c[p])+3),end="");p+=1
 except IndexError:break
== print "a" ==
 ^
note this only works on certain interpreters.
other interpreters may use this instead:
 �
or whatever this is:
 ï¿¾
== print start of heading ==
 ~
== XKCD Random Number ==
 1
== Hello, World! with fullwidth space ==
 Ebiil⿽Tloia
== print ￬ ==
 ￩
==Hello world!==
 Ebiil\x1dTloia
Category:Languages Category:Joke languages Category:Unusable for programming Category:Total Category:Implemented Category:2024
2-ill

2-ill is designed by User:Zzo38, to be something like 2L but a bit different.
The memory is a tape (similar to Brainfuck) infinite on both directions and starts all zero, each cell can be only value 0 or 1, no other values are possible.
The commands are:
* $ indicates start position of program, going east. If hit, it has no effect.
* @ turns program pointer clockwise if value at pointer is 1, or counter-clockwise if is 0.
* # has different effects depending on direction of program pointer:
** North = output bit at tape pointer, skip 2 program cells
** South = input bit, store at tape pointer, skip 2 program cells
** West = move tape pointer 1 space backwards, skip 2 program cells
** East = toggle bit at tape pointer and then move tape pointer 1 space forwards, skip 2 program cells
* Anything else does nothing and can be used for comments.
Program stops when program pointer falls off the edge of the world.
==Examples==
A bitwise cat program which records the inverse of each bit along the tape:
 '------'
 '@ @ @'
 ' @@ '
 '@#$ @ '
 ' # '
 ' '
 ' @ @ '
 ' @@@ '
 '@ @'
 '------'
A plain old bitwise cat program:
 @@@
 @$@
 | 
 # 
 | 
 @?@
 @@@
Writes alternating 0's and 1's to the tape:
 @ @
 
 @# @
 @ #@
 @@
 @$# @
 @# @
Idiom for ending up on a known cell (one left of the current cell, at label A) after writing an unknown value to the current cell:
 @@
 $ @
 #
 
 @@
 A #@#@ @
 @ @
 @@ @@
==Implementations==
2-ill is implemented in yoob.
Category:Languages
Category:Implemented
Category:2007
Category:Two-dimensional languages
2.+-

2.+- is a variation of Deadfish, marked a divergent naming of the commands, as well as the contingency for defining aliases for characters.
==Commands==
It has the following commands:
Command	Result 	Deadfish equivalent	Notes
2 	Square the accumulator 	s 	 
. 	Print the accumulator as a character	o 	2.+- prints the character associated with the accumulator as its code, whereas Deadfish outputs the accumulator in its verbatim numeric form.
+ 	Increment the accumulator 	i 	 
- 	Decrement the accumulator 	d 	 
= 	Create an alias for another command 	None 	 
==Examples==
An approximate Deadfish implementation can be realized by the alias command =. Please note that 2.+- diverges from Deadfish by printing the character associated with the accumulator, not the numeric value itself.
 s=2
 o=.
 i=+
 d=-
 Then, you can insert any Deadfish code here.
===Hello world using the Deadfish interpreter===
The following program emulates a Deadfish “Hello, World!” program by utilizing the alias definition, producing “Hello world”:
 s=2o=.i=+d=-iisiiiisiiiiiiiioiiiiiiiiiiiiiiiiiiiiiiiiiiiiioiiiiiiiooiiiodddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddodddddddddddddddddddddsddoddddddddoiiioddddddoddddddddo
===Hello world===
This program prints “Hello world” utilizing the instruction set inherent to 2.+-:
 ++2++++2++++++++.+++++++++++++++++++++++++++++.+++++++..+++.-------------------------------------------------------------------------------.---------------------2--.--------.+++.------.--------.
==Interpreter==
* Common Lisp implementation of the 2.+- programming language.
Category:Languages
Category:Finite state automata
Category:Joke languages
Category:2018
Category:Unusable for programming
Category:Output only
Category:Implemented
Category:Program forms
Category:Total
200

It is his 200th esolang, and it is again, like his 100th esolang 100BF, a brainfuck equivalent.
==Commands==
 200 BF
 202 +
 020 -
 220 ,
 022 .
 222 [
 000 ]
 200 >
 002 <
==Examples==
===Hello, World!===
202202202202202202202202222200202202202202202202202202002020000200202202202202202202202202022200202202202202202202202202222200202202202202202202202202202202202202002020000200202202202202202022202202202202202202202022022202202202022200202202202202202202202202222200202202202202202002020000200202202202202022020020020020020020020020020020020020022002002002002202202202202202202202202202202202202202202202022200200022202202202022020020020020020020022020020020020020020020020022200200202022
===Cat Program===
 202222220022000
Category:Languages
Category:Brainfuck equivalents
Category:Turing complete
Category:2024
Category:Unimplemented
2002-12-14

2002-12-14 is an upcoming esolang by User:Yes that is based on the oldest freenode #esoteric irc log he could find on logs.esolangs.org
=== Current Iteration ===
There are 6 variables.
<fizzies>
<fizzie>
<navigator>
<calamari>
<lament>
<lameAFK>
However, only 3 are avalible, as in the log, fizzie and lament does not make an apperance, by that I mean not send messages, and lameAFK is just lament's nickname.
Format for instruction:
-!- var has joined Define if it is <fizzies>, <navigator>, or <calamari>
-!- var has left ("parting message") Delete (parting message is not required)
-!- var has changed nickname to ("nick") NOP (this does nothing)
hr:min:sec Message/Commands Command format
=== Commands ===
Commands are based on how many "words" are in a message.
 Caption text
How many "words"	Description
1 	Execute the next message as Chicken code, in the sense that every word repersents "chicken"
2 	Execute the next message if variable = 0 otherwise, skip it
3 	Set variable to variable + 1
4 	Set variable to variable - 1
5 	Get (value in variable) bytes from input and store each character as an individual ascii value onto the Chicken stack
6 	Output variable as ascii character
7 	Get input and output value of input
8+ 	Set the variable to current value of variable + (words on current line)
=== Examples ===
One Line Chicken Interpeter
01:01:00 -!- fizzies has joined
01:01:01 <fizzies> chicken
01:01:02 <fizzies> {Put line of chicken code here}
One time Cat program
12:34:56 -!- navigator has joined
12:34:57 <navigator> hey is anyone online right now ??
Hello World
12:00:00 -!- print has joined
12:01:00 <print> Hello, I am setting the variable to 72 (H). - . . . . . . . . . - . . . . . . . . . - . . . . . . . . . - . . . . . . . . . - . . . . . . . . . - . . . . . . . . . - . Done!
12:01:30 <print> Let's print the character for you!
12:02:00 <print> Setting to 85 (e) . . . - . . . . Done!
12:02:30 <print> Let's print the character for you!
12:03:00 <print> If I sent this message, variable is m...
12:03:10 <print> 1, 2, 3, there!
12:03:40 <print> We'll print the character two times.
12:03:50 <print> We'll print the character two times.
12:05:00 <print> Variable is m.
12:05:01 <print> Variable is n.
12:05:02 <print> There we go!
12:05:32 <print> Let's print the character for you!
You can continue, User:Yes.
=== Errors ===
NO USER Invalid var
NO -!- Invalid -!-
NO WORD MSG "Message" has no words
T.I.J.H.S.T.I.M.E. This Is Just Here So There Is More Errors
NO NAME ERROR Unknown error
NO COMPLETE LINE Incomplete line (eg., 12:00:00 <fizz )
NO MESSAGE TIME No timespamp (eg., <fizzies> buzzies)
The NO MESSAGE TIME error was made by Europe2048 (talk).
Category:Languages Category:Thematic Category:Turing complete Category:Stack-based
2014

2014 is an esoteric programming language created by User:AndoDaan on 31 December 2014. During the year 2014, any 2014 program will print "Hello, world!". In subsequent years (and, presumably, years before 2014, although it will never be possible to tell), 2014 programs do nothing. (This means that, like with several other esoteric programming languages, all 2014 programs are equivalent.)
The language's announcement, at 20:09 UTC on 31 December 2014, kicked off a race to make some use of the language before the end of the year (and this wiki article was written in a similar hurry, even though there is no particular reason for the article to be written in 2014). The first known implementation (on the IRC bot HackEgo) was announced at 20:30 UTC on 31 December 2014, meaning that this language will only have been usable for around 3 and a half hours, and by the time you read this, has probably forever faded into uselessness.
== Implementation ==
=== JavaScript Interpreter ===
"use strict";
const server="129.6.15.30"; // Currently a NIST server; change this to the address of the "2014 server" if it exists.
const net=require("net");
let d=Buffer.allocUnsafe(0);
net.connect(37,server).on("data",x=>{
 d=Buffer.concat([d,x]);
 if(d.length>=4) {
 if(new Date((d.readUInt32BE(0)-2208988800)*1000).getFullYear()==2014) {
 console.log("Hello, world!");
 process.exit(0);
 } else {
 console.error("");
 process.exit(1);
 }
 }
}).on("error",()=>{
 console.error("Error communicating with 2014 server.");
 process.exit(2);
}).on("end",()=>{
 console.error("Failed to receive four bytes of data from server.");
 process.exit(2);
});
==See Also==
* 2015
* 2017
* 2023
* 2024
Category:LanguagesCategory:2014Category:ImplementedCategory:Unusable for programmingCategory:Output onlyCategory:Total
2015

2015 is the successor to 2014. The language was invented by a person seconds before they exploded in a fireball. It works similarly to 2014, except it works in 2015 too.
==See also==
* 2014
* 2017
Category:Languages
Category:2019
Category:Joke languages
Category:Unimplemented
Category:Total
Category:Unusable for programming
Category:Output only
2017

2017 is a programming language created by Zayne, loosely based off of 2014. It was announced in June 2017 and was made only to be used in the year 2017.
If the year isn't 2017, any 2017 program will error out with the error: To 2017 or Not to 2017? You decided Not to 2017. During 2017, any 2017 program it will output 2017 is da bomb. The language doesn't check system time, it eats up your bandwidth by going to a 2017 server to get the EXACT date and time.
==Implementation==
===JavaScript Interpreter===
"use strict";
const server="129.6.15.30"; // Currently a NIST server; change this to the address of the "2017 server" if it exists.
const net=require("net");
let d=Buffer.allocUnsafe(0);
net.connect(37,server).on("data",x=>{
 d=Buffer.concat([d,x]);
 if(d.length>=4) {
 if(new Date((d.readUInt32BE(0)-2208988800)*1000).getFullYear()==2017) {
 console.log("2017 is da bomb");
 process.exit(0);
 } else {
 console.error("To 2017 or Not to 2017? You decided Not to 2017.");
 process.exit(1);
 }
 }
}).on("error",()=>{
 console.error("Error communicating with 2017 server.");
 process.exit(2);
}).on("end",()=>{
 console.error("Failed to receive four bytes of data from server.");
 process.exit(2);
});
==See Also==
* 2014
* 2015
Category:LanguagesCategory:2017Category:Unusable for programmingCategory:Output onlyCategory:TotalCategory:Implemented
2023

In 2023 B. C. E., this esolang is the same as brainfuck, otherwise it deletes the program and the interpreter.
The esolang had faded into uselessness for quite a long time, even before the first computers, so it is never useful.
==Interpreters==
The first interpreter, in Python, is written in 2024:
import sys,datetime,os
def bf(code):
 s=[]
 matches={}
 tape=[0]*1000000
 for i,j in enumerate(code):
 if j=='[':
 s.append(i)
 if j==']':
 m=s.pop()
 matches[m]=i
 matches[i]=m
 cp=0
 p=0
 while cp<len(code):
 if code[cp]=='+':
 tape[p]=(tape[p]+1)%256
 if code[cp]=='-':
 tape[p]=(tape[p]-1)%256
 if code[cp]==',':
 c=sys.stdin.read(1)
 tape[p]=(ord(c) if c else 0)%256
 if code[cp]=='.':
 print(chr(tape[p]),end=)
 if code[cp]=='<':
 p-=1
 if code[cp]=='>':
 p+=1
 if code[cp]=='[':
 if not tape[p]:
 cp=matches[cp]
 if code[cp]==']':
 if tape[p]:
 cp=matches[cp]
 cp+=1
if datetime.date.today==-2023:
 bf(open(sys.argv[1]).read())
else:
 os.remove(sys.argv[0])
 os.remove(sys.argv[1])
Category:Languages
Category:Joke languages
Category:2023
Category:Unusable for programming
Category:Implemented
2025

2025 is an esoteric programming language designed by User:Tommyaweosme. It behaves exactly like Deadfish in 2025 AD, and doesn't work any other year.
== Interpreter ==
 from datetime import datetime
 yaya = datetime.now().year
 if yaya == 2025:
 num = 0
 while True:
 com = input()
 if com == "i":
 num += 1
 if com == "d":
 num -= 1
 if com == "s":
 num *= num
 if num == 256:
 num = 0
 if com == "o":
 print(num)
 else:
 while True:
 input()
Category:LanguagesCategory:Unusable for programmingCategory:Output only
2025!

2025! is an esolang made by User:Fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff. It only has one command, number, which time travels to January 1st of the year number. Comments may be included, surrounded in parentheses.
== Examples ==
=== Time travel to the year 3000 ===
 3000
=== Infinite Loop (Only works after 2025) ===
 2025
=== Null Program ===
 ()
Category:Languages Category:2025 Category:Joke languages Category:OISC
2050706

2050706 is an esoteric macro language created by User:sigurdwe. It is a high-level procedural language based on C. The goals of the language are zero grammar, zero compilation errors and a total focus on numerics.
== Code ==
2050706 code is translated to C by a simple program and then compiled as usual. The code consists only of the digits 0-9. A statement contains a variable number of digits, decided by the first digits of the statement itself. The code for the minimal output program is 50, which outputs the number 0 to screen. Being a totally numeric language, it can not produce any "Hello world" program. A bigger example is this two-statement program:
 3001505510
 5300
The program takes two parameteres, multiplies them them together, assigns the product to a variable and outputs the value of that variable.
== Features ==
The variables are stored in two-dimensional grids, one for integers and one for floats. These will expand when a variable of an index outside the grid is declared, as in Matlab and similar. Functions can be defined, and elementary mathematical functions manipulating floats are borrowed from C. Integer output to files and automatic import of a programs source into the integer variable grid makes a program able to manipulate its own source code.
== External resources ==
* The 2050706 source code 
Category:Languages
Category:High-level
Category:2008
Category:Implemented
24

24 is an esoteric programming language that only works if the last 2 digits of the current year are before or equal to 24. All it does is print "ham n eggs" if the year fits the previously talked about requirements.
==Scratch interpreter==
Screenshot 2023-06-19 145723.png|The interpreter
==Common Lisp implementation==
The following implementation in Common Lisp can be optionally driven by a user input or an automatic detection of the current year:
 (defun interpret-24 (&key (interactive-p NIL))
 "Launches the 24 interpreter, either evaluating the current year, or
 if INTERACTIVE-P is true, queries the standard input for a year to
 indagate."
 (declare (type boolean interactive-p))
 (let ((probed-year
 (if interactive-p
 (loop do
 (format T "~&Please enter a year: ")
 (finish-output)
 (let ((input (read-line NIL NIL "")))
 (declare (type string input))
 (clear-input)
 (handler-case
 (return (parse-integer input))
 (error () (format T "~&The input ~s is no valid year." input)))))
 (nth-value 5
 (get-decoded-time)))))
 (declare (type integer probed-year))
 (let ((year-as-string (format NIL "~a" probed-year)))
 (declare (type string year-as-string))
 (let ((last-two-year-digits
 (parse-integer
 (subseq year-as-string
 (max 0 (- (length year-as-string) 2))
 (length year-as-string)))))
 (declare (type (integer 0 99) last-two-year-digits))
 (when (<= last-two-year-digits 24)
 (format T "~&ham n eggs"))))))
==Python Implementation==
from datetime import *
year=datetime.now().year
if year%100<25:
 print('ham n eggs')
An alternative that allows the user to specify the year using the -a argument.
import sys
from datetime import *
year=datetime.now().year
if len(sys.argv)>1 and sys.argv[-1]=='-a':
 year=input('Enter year: ')
 if not year.isdigit():
 print('Invalid year')
 sys.exit(1)
if year%100<25:
 print('ham n eggs')
Category:LanguagesCategory:Joke languagesCategory:2023Category:Output onlyCategory:Implemented
Category:No-code esolang
2484345508

2484345508 is an esolang that is also a rickroll.
== commands ==
 Never starts line (unless its [])
 gonna ever +
 ever gonna -
 gonna no +- before <>.,cst
 xn repeats commands n times
 give you up >
 let you down <
 desert you .
 make you cry ,
 run around c clears cell at pointer
 spell a N s puts the ascii value of N to cell at pointer
 go spell a N t adds the ascii value of N to cell at pointer
 or placed between <>.,cst on same line, or +- after a <>.,cst
 We're no strangers to love [
 You know the rules and so do I ]
== ascii loop ==
 Never gonna ever
 We're no strangers to love
 Never gonna desert you
 Never gonna ever
 You know the rules and so do I
== hello world ==
 Never gonna spell a H or desert you
 Never gonna spell a e or desert you
 Never gonna spell a l or desert you
 Never gonna desert you
 Never gonna spell a o or desert you
 Never gonna spell a , or desert you
 Never gonna spell a or desert you
 Never gonna spell a W or desert you
 Never gonna spell a o or desert you
 Never gonna spell a r or desert you
 Never gonna spell a l or desert you
 Never gonna spell a d or desert you
 Never gonna spell a ! or desert you
== truth machine ==
 Never gonna make you cry
 We're no strangers to love
 Never ever gonna give you up x2
 Never gonna let you down
 Never gonna ever let you down
 You know the rules and so do I
 Never gonna give you up
 Never gonna spell a ,
 Never gonna give you up
 We're no strangers to love
 Never gonna let you down or desert you
 Never gonna give you up
 You know the rules and so do I
Category:Languages Category:Joke languages Category:Brainfuck derivatives Category:Pseudonatural Category:Cell-based Category:Turing complete Category:Unimplemented Category:2024