nyuuzyou/wikis huggingface dataset:
LogicF---

LogicF--- is brainfuck minus all logic, devised by User:PythonshellDebugwindow.
==Commands==
Command	Meaning
+ 	Has a 2% chance to increment a random cell, a 67% chance to throw a KeyError because you pressed the wrong key when you hit 'enter' instead of 'delete', and a 31% chance to return false
- 	Renames your program '(value of all cells concatenated together).lf' and decrements all cells by 123
> 	Deletes half of your applications and then sends all your passwords to 100 random people
< 	Removes the character before this character, then moves execution back to that deleted character's previous position, but if that deleted character isn't at that position anymore, it will loop forever until it is
[ 	Executes the brainfuck [ instruction, then the Python code int(input("Enter your name: ")), then a quine in JavaScript for function _
] 	Sets the current cell to NaN, which in LogicF--- is a valid value for an unsigned 8-bit integer, then executes the brainfuck ] instruction
. 	Prints out the name, size, and contents of every file and folder on your computer, and somewhere in there it also prints out the value of the current cell as a base-22 integer (it might be hard to find if you have a lot of files/folders)
, 	Asks for user input, but the user says no
E 	Executes the program 'e.lf' as either a LogicF--- program or a Line Feed program randomly
All other characters are treated as comments, and any unmatched square brackets raise a TypeError.
==Examples==
===Quine (ignoring the [ and ] and assuming the user inputs 0)===
 [int(input("Enter your name: ")) 0
 (function _(){return`(${_})()`})()]
its not really a quine
===Infinite loop===
 X<
X can be any character.
Category:Languages Category:2020 Category:Unimplemented Category:Brainfuck derivatives Category:Unusable for programming Category:Joke languages Category:Cell-based Category:Nondeterministic
LogicGate

==Logic Gate==
This language is inspired by logic gates, by using simple alphabet you could make a program.
It is designed as a way for manual encryption, which kinda failed
All you can do in this language is to make a program with logic gates, sounds difficult and indeed it is.
===Startup===
First, make a logic gate file.
The file extension should be lgeso
also you need the runner
===Runner===
The code for the runner is here
Also most of the stuff is at the GitHub.
To use it, import the python file LogicGate.py in your python script, or just run the LogicGate.py
Remember for the run function, only the filename argument is needed.
The run function will return an exit code if you are using the run function, and outputs of the file will be printed(binary to ascii, and logical binary if enabled)
The compile function does the otherwise, it doesn’t return anything but it can write code into lgeso file.
===syntax===
For syntax it is very straight forward.
It process each character in each line as each command
For gates with multiple inputs (such as or, and) type like other syntax, the quota for the gate will automatically be processed.
No linking between words, unless the syntax in the middle is invalid
====Basic gates(gates that doesn’t require includes):====
A (and gate): the next 2 results will be accepted as inputs. If both inputs are 1, output is 1, else 0
O (or gate): the next 2 results will be accepted as inputs. If one of the inputs are 1, output is 1, else 0
N (not gate): the next 1 result will be accepted as inputs. If the input is 1, output is 0, else 0
1 and 0 (True and False): NO result will be accepted as inputs. They are the results, self explanatory
====special syntax====
There are 2 special syntax
—-- (three hyphens): new word, used for the ascii output separating the binary for ascii translation
### (three hashes): comment the entire line
For any of the special syntax, they are not being interpreted as special syntax unless the entire syntax appears.
They can be anywhere in a line, and that line will act like what the syntax shows (if the special syntax appears in the same line, they will be scanned and processed according to here)
==examples==
This is a hello world in LogicGate
1 
0 
0 
1 
0 
0 
0 
---
1 
1 
0 
0 
1 
0 
1 
---
1 
1 
0 
1 
1 
0 
0 
---
1 
1 
0 
1 
1 
0 
0 
---
1 
1 
0 
1 
1 
1 
1 
---
1 
0 
0 
0 
0 
0 
---
1 
0 
1 
0 
1 
1 
1 
---
1 
1 
0 
1 
1 
1 
1 
---
1 
1 
1 
0 
0 
1 
0 
---
1 
1 
0 
1 
1 
0 
0 
---
1 
1 
0 
0 
1 
0 
0 
---
1 
0 
0 
0 
0 
1 
==Sources==
GitHub: 
Current source code(working in progress): 
Category:Languages Category:Works-in-Progress
Logic Gates

A Logic Gate program is a program (or subprogram) that implements AND, OR, NOT, or others as boolean operations in some programming language. This is helpful in demonstrating that a programming language is capable of simulating a computer. All boolean operations (and the computers that run them) can described and combinations of these three logic gates connected in some arbitrarily complex circuit. Implementing this program does not prove a language is Turing-complete but it can provide evidence of Turing-completeness, and prove a language is usable.
==External resources==
* Wikipedia:Logic gate
Category: Program forms Category:Concepts
Logig

logig is a esolang made by Yayimhere when he realized that + and - can be used as 1 and 0 in logic gates. the name comes from a misspelling of logic when searching
== memory ==
memory is stored in a 2 line tape that extends infinitely to the left and right. the first line is filled with 0's with a single 1 in the middle. the other tape holds + and -. these plusses and minuses can be modified with you guessed itlogic gates(or "logig gates" as the gates in logig are called)
== syntax ==
the syntax of logig. it only has one of logig gates. all logig gates mentioned are on the second layer:
 Caption text
Header text	Header text
} 	move right on the tape
{ 	move to the left on the tape
& 	do a NAND on current cell and the cell on the left and store it into current cell
: 	run current cell of the second row on current cell in the first row. if the cell does not become 0 set it to -
, 	print current cell as a ascii char
$ 	print current cell as a number
0 	set current cell to user input
( and ) 	bf loop
== computational class ==
pretty sure you can simulate a MM and/or brainfuck but idk im to lazy to proove it
Category:Languages
Category:Object-oriented paradigm
Category:Cell-based
Category:Unknown computational class
Category:Low-level
Category:2024
Category:Unimplemented
Logique

Logique is an esoteric programming language developed by Ettore Marmo in 2014.
It is a low-level language based on simple binary logic where you can only use either NAND or NOR gates.
== Syntax Overview ==
=== Function Definition ===
Using only one of these two gates one can define all the other logical functions! In logique you can easily test this:
 NOT(x) = NAND(x, x)
 AND(x, y) = NOT(NAND(x, y))
and so on.
=== Datatypes ===
The only datatype in Logique are the two boolean values 0 and 1, they can be concatenated with the infix : or simply by juxtaposition. For instance
 0110110 == 0 : 1 : 1 : 0 : 1 : 1 : 0
You can also create functions that return a list of 0s and 1s
 REVERSE(x, y) = NOT(x) : NOT(y)
=== Function Call ===
Every function can accept as arguments only single binary values, meaning that functions like NOT(x) will only accept 0 or 1 and not any list of those. However functions with more than one argument can be called using a list of values.
 NAND(1, 0) == NAND(10)
 FUNC(1, 1, 0, 0) == FUNC(1, 100) == FUNC(11, 00) == FUNC(110, 0) == FUNC(1100)
this comes quite in handy when simulating numeric operations.
=== I/O and Utilities ===
Logique comes with the command out that prints whatever function is after it, and read(n) that reads an input in binary form long n digits (n is written in base 10 though). For instance:
 out NAND(read(2)) // Reads a 2-digit binary number
Also the function char(x) reads an 8-digit binary input and outputs the corresponding character
(NOTE: not fully implemented yet!)
The command table outputs the truth table for whatever function that comes after it.
 table NAND // outputs: 
 	x	y	NAND(x, y)
 	0	0	1
 	0	1	1 
 	1	0	1
 	1	1	0
== File Formats and Modules ==
Logique accepts two types of file format: .nand and .nor, in the first you start with the predefined function NAND, in the other with NOR. With the command import you can load all the function definitions and calls from another file, to avoid ambiguities the module imported must have the same file extension.
LolKek

LolKek is modified Brainfuck. It has 19 commands.
Commands:
 LolKek Brainfuck Pseudocode
 ======================================================================================================================
 +1 + mem[i]++;
 -1 - mem[i]--;
 < < i--;
 > > i++;
 [ [ while(mem[i] != 0) {
 ] ] }
 . . printf("%c", mem[i]);
 , , scanf("%c", &mem[i]);
 b none if(mem[i] > buffer) {mem[i] = 1;} else {mem[i] = 0;}
 = none if(mem[i] == buffer) {mem[i] = 1;} else {mem[i] = 0;}
 ! none mem[i] = !mem[i];
 a none mem[i] = mem[i] + buffer;
 s none mem[i] = mem[i] - buffer;
 ? none mem[i] = floor(random(0, 15));
 / , (don't "stop") ???
 \ none mem[i] = millis(); //the time in milliseconds since the program was started
 ~ none pause(100 * mem[i]);
 c none buffer = mem[i];
 p none mem[i] = buffer;
Category:Turing complete
Category:Brainfuck derivatives
Category:Languages
Category:2019
Category:Unimplemented
Category:Low-level
Lol waht i cant edit talk pages

lol waht i cant edit talk pages is an esolang made by user:tommyaweosme because of the admins of this very wiki.
== commands ==
 user:? - defines new variable called ?
 edit user talk:? to remove n messages - subtracts n from ?
 edit user talk:? to change n messages - adds n to ?
 JUST LET ME CHANGE n MESSAGES ON ? {code} - does code while ?=n
 im awesome tottaly but no ? - sets ? to input
 grr why u do this ? - outputs ? as ascii
 i hate u ? - outputs ? as number
 waht i got banned - ends program
n can be no to mean 0
1 messages is 1 message instead
=== Added commands by PSTF ===
 [String] --tommyaweosme 14:39, 7 January 2024 - Print [String] directly
== truth machine ==
 user:i
 im awesome tottaly but no i
 i hate u i
 JUST LET ME CHANGE 1 MESSAGE ON i {
 i hate u i
 }
 waht i got banned
== cat? (numbers instead of ascii characters) ==
 user:autocorrect
 im awesome tottaly but no autocorrect
 JUST LET ME CHANGE AUTOCORRECT MESSAGES ON AUTOCORRECT {
 i hate you autocorrect
 }
 waht i got banned
== A+B Problem(?) ==
User:用户1
User:用户2
im awesome tottaly but no 用户1
im awesome tottaly but no 用户2
User:用户3
edit user talk:用户3 to change 用户1 messages
edit user talk:用户3 to change 用户2 messages
i hate u 用户3
waht i got banned
=== Minified ===
user:A
user:B
im awesome tottaly but no A
im awesome tottaly but no B
edit user talk:A to change B messages
i hate u A
waht i got banned
== Output "A" ==
user:A
edit user talk:A to change 65 messages
grr why u do this A
waht i got banned
== Hello, world! ==
 Hello, world! --tommyaweosme 14:39, 7 January 2024
 waht i got banned
== Empty Program ==
 waht i got banned
==See also==
* Poetic LOLWICNETP
Category:Languages Category:2024 Category:Unimplemented Category:Pseudonatural
Long2

User:Hex96 made an esolang called Long
So here's an actual good version. By User:Yes
== Commands (this is worse quality than normal esolang lol) ==
The language's instruction set is exhausted by a twain of operations.
===ASCII Character Output===
In order to print an ASCII character, its character code must be employed in the following command:
PRINTTHEVALUEHEADEDAFTERTHISCOMMANDASACHARACTERFROMTHEAMERICANSTANDARDCODEFPRINFROMATIONEXCHANGEOHANDBYTHEWAYITSTHEEIGHTBITVERSIONNOTTHESEVENBITVERSION (ASCII code)
===brainfuck Interpreter===
A line of arbitrary brainfuck code may be interpreted using the command
INTERPETTHENEXTLINEASCODEFROMTHEESOTERICPROGRAMMINGLANGUAGEBRAINF**KBYEURBANMULERINIFORGOTWHICHYEARWITHATAPEOFTHIRTYTHOUSANDEIGHTBITCELLSALLINITIALLYSETTOZERO
(brainf**k code to interpret on the next line)
That's it.
== Examples ==
Output the character A, corresponding to the ASCII code 65:
PRINTTHEVALUEHEADEDAFTERTHISCOMMANDASACHARACTERFROMTHEAMERICANSTANDARDCODEFPRINFROMATIONEXCHANGEOHANDBYTHEWAYITSTHEEIGHTBITVERSIONNOTTHESEVENBITVERSION 65
The following program invokes the brainfuck interpreter in order to execute its Hello World! program:
 INTERPETTHENEXTLINEASCODEFROMTHEESOTERICPROGRAMMINGLANGUAGEBRAINF**KBYEURBANMULERINIFORGOTWHICHYEARWITHATAPEOFTHIRTYTHOUSANDEIGHTBITCELLSALLINITIALLYSETTOZERO
 ++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>->>+[<]<-]>>.>---.+++++++..+++.>>.<-.<.+++.------.--------.>>+.>++.
==Interpreter==
* Common Lisp implementation of the Long2 programming language.
Category:Languages
Category:Joke languages
Category:2022
LongDick

LongDick is a variant of Dick, made by the same person. Concept happened when someone complained to me about how there’s no control flow in Dick when I was talking about my language in the unofficial Esolang discord.
It is currently unimplemented, but please do make an interpreter! Now implemented!
== Control flow ==
Since Dick is an unusual language, we’re going to do something unusual here.
In conditionals, all other commands after the exclamation (and before the End Conditional statement) will be executed only if the condition is true.
Greater Than:
 LOOK! <dick1> IS BIGGER THAN <dick2>!
Lesser Than:
 LOOK! <dick1> IS SMALLER THAN <dick2>!
Equal:
 LOOK! <dick1> IS JUST LIKE <dick2>!
End Conditional:
 DICK JOKES ARE IMMATURE, SERIOUSLY
In Control Flow, we should also have loops. Therefore, loop!
Note that <condition> does not have the LOOK! Part at the front.
Loop:
 COCK GO FAST IF <condition>!
End Loop:
 ALRIGHT, STOP COCKING AROUND
== Variables ==
In normal Dick, you can name your variable whatever you want. Here in LongDick however, you have to name it using at least one of the following words, in no particular order, and non case-sensitive:
* Johnson
* Dick
* Cock
* Schlong
* Penis
* Dong
==See also==
* PenisScript
* Dick
Category:Languages
Category:Output only
Category:Thematic
Longplayer

Longplayer is a language loosely based on the music that bears its name. It implements a control flow scheme that the author believes to be entirely unique, based on multiple permutations of different command steps.
== Overview ==
Code is given in the form:
 <number of tiers> <instructions>
The instructions are executed by each tier simultaneously, as if they are multiple threads. Upon successfully executing the instructions a tier will begin the instructions again.
What makes this language interesting is that each tier takes a different length of time to execute: the second tier executes 2 instructions in the time it takes the first to execute 3, the third can do 2 instructions in the time it takes the first to do 5, and so on through all the primes. Thus the speeds are in the ratio 2:3:5:7... This is not quite how Longplayer music works, but I adapted it in an attempt to force the programmer to think in more interesting ways.
If two or more tiers would execute simultaneously, the tier with lowest number executes first. An instruction also produces different effects depending on what tier it is on, as described below.
== Instruction set ==
The instructions operate on an unbounded tape, heavily inspired by brainfuck. Each tier operates on the same tape. 
If there are n tiers in total, and the mth tier executes an instruction, take the first n primes apart from the mth prime. Let the product of these primes be p in the following table:
Instruction	Effect
+ 	Increment cell by p.
- 	Decrement cell by p.
< 	Move p cells left.
> 	Move p cells right.
. 	Output value in cell divided by p as character
, 	Input character, convert to number and store number times p
! 	Skip, see below.
? 	Skip if cell is 0, see below.
: 	Halt the program (there is no other way to do this)
* 	NOP
A skip will treat all instructions up to and including the next instruction on that tier as *. This takes effect across tiers: if one tier is executing a skip, instructions will be ignored until it is finished. This makes it possible to skip a skip, which makes conditional stuff easier (hopefully). Notice that lack of square brackets makes it impossible to skip multiple instructions without this functionality.
== Examples ==
=== Cat program ===
 1 ,?!:.
Some simple programs like this can be done on just one tier. Remember that the instructions automatically loop after executing.
=== Truth test ===
 1 ,.------------------------------------------------?!:++++++++++++++++++++++++++++++++++++++++++++++++!
Again, just one tier.
== Computational class ==
If someone finds a way to move the instruction pointer backwards, then you can translate BF to Longplayer, thus making it turing complete
Category:Languages Category:Cell-based Category:Unknown computational class
Look!

Look! is a sound-based esolang based on brainfuck by User:None1. Its name has nothing to do with the specification of the language.
==Commands==
 Commands
Note 	brainfuck
C or D#	+
D 	-
E or A#	,
F 	.
G or G#	>
A 	<
B or F#	[
C# 	]
If there were multiple tracks in the sound file, Look! picks the first one.
==Examples==
Remember that these programs here are only notes of the real program, for the real program (that will run correctly in the interpreter), please see the MIDI file link under each program.
===Hello World===
 C D# C C D# D# D# D# B G D# D# C D# F# G# C C G D# C C G C C C G# C A A A A D C# G# C G# D# G# D G G C B A C# A D C# G G F G D D D F C C D# D# C D# C F F C C D# F G# G F A D F A F C C D# F D D D D D D F D D D D D D D D F G# G D# F G D# D# F
The program as a MIDI file.
===Cat program===
 A# B F E C#
The program as a MIDI file.
===Truth Machine===
 G# G G A# F B F# D G C A A D# G C# G# D C# A A A F# A A C# G F# F C#
The program as a MIDI file.
===Nope. interpreter===
 C D# D# C C D# B G# C D# C D# C D# D# C C C C D# D# A D C# G F G# D# D# D# C C C D# D# C D# C F# G# C D# C D# C D# D# D# D# D# A D C# G D# F D# F D D D D D D D D D D D F G C D# D# D# C B G C D# D# D# C C C D# D# A D C# G# D# F
The program as a MIDI file.
======
 G# D# G D# G# C B G C F# D A C C C G# C# A A C# G F
The program as a MIDI file.
===brainfuck interpreter===
G G G C F# F# D C# G G# B D C# D# D# G# D# G# D# C D# C C D# C B A D# C C C G# G# D# C A D C# D# D# G# G C G D# G# D# D# D# C D# B G# D# C G D# D# C D# D# C A A D C# C G# G G A# A C D# F# F# G# B D G# G C# A B G G C# A A D C# A B A C# A C G G# F# G C# G# F# A D# G D B B A D# G D C# G# C# A F# F# B D C# A C# D# C A D F# A C C C C C D# C C C G F# A D G# D C# G# G C# G G# C# C# A A C# A C# A F# B A C# G# F# F# G# C# G G B G G C# D# B A A C# A F# A C# A C G G D C# G# F# G# C# D# B D G# G# C# A A A A B F# A A C# A B A C# D# A A F# D# G D# A A D B G# D D G# D# A A D B G# C A B G G D# A A D C# C# C# G# F# A D# G D C# A C# D# D# G G D D G B G# C# G G F# G# G C# C# A A B G G# C A F# F# A C# A C# G F# B A A C# A F# A C# D# B D A D# G G D F# A A D# G D# D# G# D F# A D G F# A A D# G# G# D C# C# C# A B G D# A D C# G# C# G B G C# G# C# G F# G G C# G G C# A A F# G G# C G# G D# G G# C# A A F# D G# G# G# G G# G G G C# A A B G F G G# G# G G G# G C# A A B G# D G# G# G G# G C# A A F# G# A# G G G C# A A F# G# C G C# A A F# D# A A C# A C#
The program as a MIDI file.
===Looping counter===
 D# B G G# B G C# C D# D# C C C C C D# D# D# C C C D# C D# C C D# D# C C D# C D# D# D# D# D# C C C C C C C C C C C D# B A C# G# B F G# C# C C C D# C D# D# D# C D# F D D D D D D D D D D A B A C# A C#
The program as a MIDI file.
==External resources==
* the GitHub repository of Look! with the official Python interpreter.
* A very ugly online interpreter/converter that supports interpreting and writing Look! programs and converting them into brainfuck.
== See also ==
* Sound
Category:Non-textual
Category:Languages
Category:Turing complete
Category:Brainfuck derivatives
Category:Brainfuck equivalents
Category:2023
Category:Implemented
LoopDeLoop

= LoopDeLoop =
== Overview ==
LoopDeLoop is an esoteric programming language centered around looping constructs. Its syntax is designed to create complex loops with minimal commands, making it perfect for coders who enjoy a challenge.
== Basic Commands ==
* `!start` - Begin the program
* `!echo` - Print command
* `!spin` - Start a loop
* `!twirl` - End a loop
* `!end` - End the program
== Example Programs ==
=== Hello World ===
 
!start
!echo "Hello, World!"
!end
 
=== Simple Loop ===
 
!start
!spin 3
 !echo "Looping!"
!twirl
!end
 
=== Nested Loop ===
 
!start
!spin 2
 !echo "Outer Loop"
 !spin 3
 !echo "Inner Loop"
 !twirl
!twirl
!end
 
LoopDeLoop challenges you to master the art of loops and create intricate patterns with code. CodePhantom (talk)
Loop without output

Loop without output is an extremely esoteric computer experiment conducted by User:Star651 in June of 2011. The experiment is esoteric, but it was conducted using a very mainstream programming language; JavaScript. Loop without output is as esoteric as the BF programming language, and, in a very strange way, was inspired by BF. The experiment's basic idea is self-explanitory; it is a loop (a for loop, to be specific) with no output, except outside the loop, when the counter variable is printed on the screen. The only practical use of this "virtual tape loop" is to be amazed at speed; loop without output has been known, on some machines, to do 2,000,000 iterations within 30 seconds, and it takes an hour or two for 1,000,000,000 iterations.
==More specifications and example code==
The initial JavaScript-based experiment takes a number, counts to that number (using a for loop), but produces absolutely no output for the iteration; the JavaScript loop curly braces are empty, except for maybe a space or newline. The code is placed in HTML script tags, so this esoteric looping device should run in script-enabled web browsers. The JavaScript sample code below (inside HTML script tags) has a variable named j representing the number it takes in; variable i is the counter variable. Variable j in the sample code is set to 500000 (five hundred thousand), but you can change it to whatever number you want, to see how the computer uses it. Be glad it's in JavaScript. You don't need to buy, or even download, any interpreters or compilers; there should be an interpreter right in the ol' Chrome, Firefox or Explorer.
----
<nowiki>
<html>
<head>
<title> Esoteric Loop Without Output Experiment </title>
</head>
<body>
<script>
for(i=1, j=500000; i<j; i++){
} </script>
<script>
document.write(i) </script>
</body>
</html>
</nowiki>
----
The document.write(i) can be replaced with alert(i) if you don't want your results displayed on a 98% blank page.
category:concepts