nyuuzyou/wikis huggingface dataset:
Minimalbf

Minimalbf is a esoteric programming language made by User:Yes in 2022. It is their fourth esolang they have made (and shared), it was inspired by brainfuck, and was made for the purpose of a language sharing properties with brainfuck, yet minimalistic limiting the language.
== Language Overview ==
Due to Minimalbf's minimalism, it is limited in multiple ways. It has 6 commands, and does not allow for any user input, causing programs output to always remain the same. Most regular brainfuck programs that do not require user input will likely function, however it is unclear if Minimalbf was intended for characters that are not valid commands to be fully ignored. If that is the case, most regular programs still won't produce the desired output due to the absence of loops, and the alternate method of switching cells Minimalbf uses, which also requires cells to be cleared (value reset to 0) to move back cells. Only programs that use solely the commands +-. will work cross Minimalbf and brainfuck.
== Commands ==
 Caption text
Command	Purpose
+ 	Increment
- 	Decrement
. 	Print ascii char
0 	Clear cell
/ 	If 0 then back 1 cell otherwise go forward 1 cell
? 	If 0 then skip next instruction
==Interpreter==
Written in Python 3.
code = input("> ")
tape = [0]
i = 0
while i < len(code):
 if code[i] == "+":
 tape[-1] += 1
 elif code[i] == "-":
 tape[-1] -= 1
 elif code[i] == ".":
 try:
 print(end=chr(tape[-1]))
 except ValueError:
 print("Error: The number", tape[-1], "cannot be converted to a character")
 break
 elif code[i] == "0":
 tape[-1] = 0
 elif code[i] == "/":
 if tape[-1] == 0:
 tape.pop()
 if len(tape) == 0:
 print("Error: Cell pointer is negative")
 break
 else:
 tape.append(0)
 elif code[i] == "?":
 if tape[-1] == 0:
 i += 1
 i += 1
== Examples ==
=== Hello, World! ===
This Hello World program was made by the designer himself!
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.0+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.0++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++..+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.0++++++++++++++++++++++++++++++++++++++++++++.0++++++++++++++++++++++++++++++++.0+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.0+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.+++.0++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.--------.0+++++++++++++++++++++++++++++++++.0
Category:Languages Category:Total Category:Cell-based Category:Output only Category:Implemented Category:2022 Category:Unusable for programming
Minimalist's Markup

Minimalist's Markup is the markup language used in The Minimalist's Web, which is what this page is actually about. It's designed to be extremely minimal, to the point of enraging anyone who tries to use it, while still being pretty straightforward. It is completely minimal, but still decent enough to use and even comes with support for stylesheets and scripting.
== Usage ==
To create a line of text in this markup, simply type it with the proper prefix:
 text:Hello, world!
You can put any sequence of Unicode characters in that line, but it all must be on one line. You cannot have more than one line like this. Newlines will be explained shortly. Note that there can be an unbounded number of spaces after the word "text" and before the colon, and they will be ignored. This actually is true of all tags, but there is the requirement that prefixes must be exactly the same length before the colon, including spaces.
If you wish to format text, you must format it character-by-character on another line. Text is formatted by starting a line with the name of the markup you wish to apply, followed by the same colon, then a series of letter "X"es and spaces denoting whether or not to mark up that line. If you wish to greet someone but you don't know their name, you could do something like:
 text :Hello, your name here!.
 italic: XXXX XXXX XXXX
Some prefixes cannot be used together. These prefixes are written with a common property and a dot at the beginning, indicating that they are mutually exclusive- such as dec.under and dec.through, which are both forms of text decoration. If there is a conflict between two formatting options, whichever comes last in the document takes precedence.
The complete supported list of line prefixes is:
* text: The body text of the markup
* italic: Italicize this character
* bold: Boldify this character
* dec.under: Underline this character
* dec.through: Draw a strikethrough through this character
* fg-col(#RRGGBB): Set the foreground to the indicated hex color
* bg-col(#RRGGBB): Set the background to the indicated hex color
* special: The current character is a special character, not a literal. An example of a character that becomes special is "/", which when declared as special becomes a newline.
== Stylesheets ==
:To be decided
== Scripting ==
Scripting in MinMU is done via a 32-bit brainfuck derivative. The file is marked up using the standard brainfuck commands (minus , and .), with the additional commands ^ and v. ^ goes to the above style option (wrapping to the last if this is the top) and v goes to the next (wrapping to the first if this was the last). The > and < instructions scroll on the tape as usual, but the "tape" used is actually the current style option, where each cell represents a character. When modifying the text line, it changes which character is used, while when modifying a style line, 0 means a space and nonzero means X.
System calls are also supported, triggered by the ! instruction, but are yet to be defined.
Category:Markup Languages
Minimized BF

Minimized BF is brainfuck with only 4 commands +>[], created by User:None1. Despite the fact that it has only 4 commands, it's still very powerful and almost Turing complete.
==Memory==
This esolang runs on a circular tape with 256 8-bit cells, overflow and underflow wraps around.
==Commands==
Minimized BF doesn't need the - command because 255 + commands is equivalent to one - command. It doesn't need the < command, because 255 > commands is equivalent to one < command.
===I/O===
Unlike brainfuck, this esolang has no commands for I/O, but it still has I/O. Before a program runs, the input is read from a file and into the tape clockwise as a C-Style string, starting from the pointer. After the program terminates, the tape starting from pointer's initial position clockwise as a C-Style string is written into the output file.
==Example Programs==
===Hello World (unoptimized)===
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>
++++++++++++++++++++++++++++++++>
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>
+++++++++++++++++++++++++++++++++>
===Cat Program===
===Truth Machine===
See the page Ruck for a Truth Machine in Minimized BF.
==Implementations==
The following Python script is an interpreter.
tape = [0]
for i in range(0, 256):
 tape.append(0)
pointer = 0
prgm = input('>mBF ')
init = input('>i ')
for i in range(0, len(init)):
 tape[i] = ord(init[i])
# Executes the program
loop_table = {}
loop_stack = []
for ip, inst in enumerate(prgm):
 if inst == "[":
 loop_stack.append(ip)
 elif inst == "]":
 loop_beginning_index = loop_stack.pop()
 loop_table[loop_beginning_index] = ip
 loop_table[ip] = loop_beginning_index
inst = 0
while inst < len(prgm):
 if prgm[inst] == "+":
 tape[pointer] += 1
 tape[pointer] %= 256
 elif prgm[inst] == ">":
 pointer += 1
 pointer %= 256
 elif prgm[inst] == "[":
 if not tape[pointer]:
 inst = loop_table[inst]
 elif prgm[inst] == "]":
 if tape[pointer]:
 inst = loop_table[inst]
 else: pass
 inst += 1
pointer = 0
while tape[pointer]:
 print(chr(tape[pointer]), end="")
 pointer += 1
Category:Languages
Category:Brainfuck derivatives
Category:2023
Category:Implemented
Category:Cell-based
Category:Low-level
Category:Finite state automata
Category:Non-interactive IO
Minimum

Minimum is a joke language by Ihope127 which is functional and has Unlambda-like syntax. Unlike Unlambda, a Minimum program defines a function which takes the two essential primitive functions, s and k (in that order), and uses them to construct something useful, instead of actually allowing s and k to be specified directly in the program. Though Minimum has an apply operator (Unlambda's `), it has no primitive combinators, therefore making it impossible to program in. The syntax:
 <program> ::= "`" <program> <program>
== Interpreter ==
As a functional language, it is especially suiting for an interpreter to be written in Haskell:
 {-# LANGUAGE OverloadedStrings #-}
 
 import Data.Attoparsec.ByteString
 import Data.Void
 import System.Exit (die)
 import qualified Data.ByteString as B
 
 data Program = App Program Program
 
 eval :: Program -> Void
 eval (App x y) = app (eval x) (eval y)
 where app = absurd
 
 parser :: Parser Program
 parser = string "`" *> (App <$> parser <*> parser)
 
 main :: IO ()
 main = do
 code <- B.getContents
 case parseOnly parser code of
 Left _ -> die "Invalid program."
 Right program -> absurd (eval program) (\x y z -> x z (y z)) const
Category:Joke languages
Category:Functional paradigm
Category:2006
Category:Unusable for programming
Category:No IO
Category:Implemented
Category:Languages
Minipy

Minipy is a golfing "language" created by Challenger5. It is Python, but with the following statements prepended to every program:
import sys as y
av = y.argv
if len(av) > 1:
 v1 = av[1]
 try:
 v2 = eval(v1)
 except SyntaxError: pass
import os
import re
import functools as ft
import string as st
import copy as cp
import random as rd
import math as m
ri = rd.randint
rt = lambda seq: seq[ri(0, len(seq)-1)]
N = None
_i = __import__
_b = __builtins__
_B = dir(_b)
ab = abs
al = all
an = any
bn = bin
c = chr
cx = complex
d = dict
dr = dir
em = enumerate
e = eval
x = exec
b = lambda x: lambda y: eval(x)
fm = lambda x,y: map(b(x),y)
ff = lambda x,y: filter(b(x),y)
fr = ft.reduce
fl = float
gtat = getattr
hsat = hasattr
dlat = delattr
stat = setattr
hx = hex
i = input
n = lambda *args: eval(input(*args))
sr = ""
t = int
l = len
ls = list
ot = oct
o = open
f = lambda s: o(s).read()
p = print
r = range
rp = repr
rvr = reversed
rnd = round
srt = sorted
s = str
sm = sum
v = vars
z = zip
def rf(s): # regex finder
 index = s.index("!")
 regex = re.compile(s[:index])
 search = s[index + 1 :]
 if search[0] == "!":
 return regex.findall(search[1:])
 else:
 return regex.findall(eval(search))
q = chr(34)
k = "\n"
def e(s):
 raise RuntimeError(s)
This shortens the names of functions, automatically imports modules, and creates some useful functions.
== Interpreter ==
Here is a (minimized) Python interpreter for Minipy. It assumes that the above statements are loaded into the file minipy.py stored in the current directory. It executes a file given as a command line argument.
from minipy import*;x(f(v1))
== Examples ==
Hello, World! program:
p("Hello, World!")
Quicksort:
def q(k):
 if l(k)<2:return k
 p=rt(k);return q(ff("y>p",k))+q(ff("y<=p",k))
Factorial:
p(m.factorial(v2))
Category:Languages
Category:Golfing language
Category:Turing complete
Category:Implemented
Category:2016
Minitable

: The title of this article is not correct because of technical limitations. The correct title is actually 
.''
 is an Esoteric programming language created by User:Buckets in 2022.
(Rings are the size of 6l cells per Ring.)
Commands	Instructions
^ 	Moves the pointer radially outward from the current ring m to the next ring m + 1. If it Is at the middle, it moves to ring 1 and sets the angular index = 0.
v 	Moves the pointer radially inward from the current ring n to the previous ring n – 1. If it Is at the middle, it does Noop.
/ 	It moves to the next cell in the ring.
\ 	it moves to the previous cell in the ring.
+ 	+ 1 in current cell.
- 	- 1 in Current Cell.
. 	Prints Current cell in ASCII.
$ 	Behaves like ^ if = 0, Behaves like v if = 1, Behaves like \ if = 2, Behaves like / if = 3.
# 	Behave like the opposite of the newest direction, Example: ^, # would Behave like v.
= 	Behave like the 90 Degrees of the newest direction, Example: ^, = would Behave like >.
"Hello, World!" Program:
 ++++++++++++++++++++++++++++++++++++++
 ++++++++++++++++++++++++++++++++++.+++
 ++++++++++++++++++++++++++.+++++++..++
 +.^+++++++++++++++++++++++++++++++++++
 +++++++++.^+++++++++++++++++++++++++++
 +++++.++++++++++++++++++++++++.+++.^++
 ++++++++++++++++++++++++++++++++++++++
 ++++++++++++++++++++++++++++++++++++++
 ++++++++++++++++++++++++++++++.^++++++
 ++++++++++++++++++++++++++++++++++++++
 ++++++++++++++++++++++++++++++++++++++
 ++++++++++++++++++.^++++++++++++++++++
 +++++++++++++++.
Category:Output only
Category:Languages
Category:Joke languages
Category:2022
Minks

Minks is a programming language based on a Minsky machine with two registers: the REGISTER and the register. Every instruction is preceded by a condition, which is a string of alphabetic characters. (Case is ignored here.) Conditions are like boolean variables: if they're set to True, the instruction will be executed; if False, it won't. Conditions start out as True.
Execution loops through the entire program until none of the conditions before any command is met (they're all False).
==Instructions==
Instruction 	Description
INC 	increment the REGISTER
inc 	increment the register
DEC condition	if the REGISTER contains zero, set condition to False; otherwise decrement the REGISTER and set condition to True
dec condition	same as DEC but with the register
OUT 	output the REGISTER modulo 256
out 	output the register modulo 256
INP 	take input and put it in the REGISTER
inp 	take input and put it in the register
==Example programs==
===Hello, World!===
The following program prints the word "HELLO", followed by a newline:
b INC b INC b INC b INC b INC b INC b INC b INC b INC b INC 
b INC b INC b INC b INC b INC b INC b INC b INC b INC b INC
b INC b INC b INC b INC b INC b INC b INC b INC b INC b INC
b INC b INC b INC b INC b INC b INC b INC b INC b INC b INC
b INC b INC b INC b INC b INC b INC b INC b INC b INC b INC
b INC b INC b INC b INC b INC b INC b INC b INC b INC b INC
b INC b INC b INC b INC b INC b INC b INC b INC b INC b INC
b INC b INC b OUT
b DEC c b DEC c b DEC c b OUT
b INC b INC b INC b INC b INC b INC b INC b OUT b OUT
b INC b INC b INC b OUT
b inc b inc b inc b inc b inc b inc b inc b inc b inc b inc b out
b dec b b dec b b dec b b dec b b dec b b dec b b dec b b dec b b dec b b dec b b dec b
===Cat program===
Assuming the instruction INP returns 0 on end of file.
 while INP
 while DEC while
 while INC
 while OUT
===Truth-machine===
a INP
a OUT
a DEC x a DEC x a DEC x a DEC x a DEC x a DEC x a DEC x a DEC x
a DEC x a DEC x a DEC x a DEC x a DEC x a DEC x a DEC x a DEC x
a DEC x a DEC x a DEC x a DEC x a DEC x a DEC x a DEC x a DEC x
a DEC x a DEC x a DEC x a DEC x a DEC x a DEC x a DEC x a DEC x
a DEC x a DEC x a DEC x a DEC x a DEC x a DEC x a DEC x a DEC x
a DEC x a DEC x a DEC x a DEC x a DEC x a DEC x a DEC x a DEC x
a DEC b
a DEC loop
a dec a
b INC b INC b INC b INC b INC b INC b INC b INC
b INC b INC b INC b INC b INC b INC b INC b INC
b INC b INC b INC b INC b INC b INC b INC b INC
b INC b INC b INC b INC b INC b INC b INC b INC
b INC b INC b INC b INC b INC b INC b INC b INC
b INC b INC b INC b INC b INC b INC b INC b INC b INC
b INC b DEC loop
b dec b
loop OUT
==Implementation==
An implementation in Ocaml by User:Koen is on the talk page.
Category:Languages
Category:Implemented
Category:2006
Category:Usability unknown
Category:Unknown computational class
Category:Low-level
Minreg the Cat

Minreg the Cat (short for "Minimal Regex: the Concatenative") is a variant of Regex,
created by the UOPL (Union of User:Olus2000, User:Pro465, and User:LyricLy) in 2024.
pro465 came up with the idea (concatenative regex) inspired by discussion about regex on the esolangs discord server.
And his laziness while implementing it led to it being minimal.
olus came up with most of the concatenative variations of regex commands 
(albeit with a little help from the rest).
lyricly provided constructive criticisms of every single iteration.
She also created the semantics of the final iteration of , (see below).
== Working == 
each instruction modifies a matcher, which is basically a tree which matches a specific set of strings according to its contents.
note the appending means adding the thing to the matcher tree's list of children, 
and popping means removing the last element of the list, which makes it effectively a stack.
Instruction 	Meaning
. 	appends a matcher that matches any character.
\ 	appends a matcher that matches the next character in the string and skips it.
, 	pops the last 2 children of the tree and appends a matcher that only matches if the first and the second child match in sequence.
 	pops the last 2 children of the tree and appends a matcher that matches if at least 1 of the children matches.
* 	pops the last child of the tree and appends a matcher that matches 0 or more of the child.
Any other character	appends a matcher that matches the character in question.
Once the expression is fully evaluated, it results in a matcher, 
which can be used to test if it matches with strings like normal Regex.
== Examples ==
ab and ab, both match only ab. 
ab| matches a and/or b. 
c* matches , c, cc, etc. 
ab* matches a, ab, abb, etc. 
ab,* matches , ab, abab, etc. 
ab,*cd|,* matches , abccd, ababcabdd, etc. 
== Implementation ==
in Rust: Minreg the Cat/minreg.rs
Category:2024
Category:Finite state automata
Category:Total
Category:Languages
Category:Implemented
Minreg the Cat/minreg.rs

use std::io::{self, Write};
fn main() {
 let mut lines = io::stdin().lines().map(Result::unwrap);
 let mut prompt = |s| {
 print!("{s}");
 io::stdout().flush().unwrap();
 lines.next()
 };
 let regex = prompt("Enter Minreg expression: ").expect("could not read regex from input");
 let tree = Tree::new(®ex);
 while let Some(line) = prompt("Enter string: ") {
 if tree.matches(&line) {
 println!("matched")
 } else {
 println!("did not match")
 }
 }
}
#[derive(Debug)]
enum Tree {
 Any, // .
 Or(Vec<Tree>), // |
 Kleene(Box<Tree>), // *
 Group(Vec<Tree>), // ,
 Literal(char),
}
impl Tree {
 fn new(regex: &str) -> Self {
 let mut stack = Vec::new();
 let mut iter = regex.chars();
 while let Some(x) = iter.next() {
 if !",.|\\*".contains(x) {
 stack.push(Tree::Literal(x));
 } else if x == '\\' {
 stack.push(Tree::Literal(
 iter.next().expect("why tf wud u put \\ @ da end??"),
 ));
 } else {
 if x == '.' {
 stack.push(Tree::Any);
 } else {
 let b = stack.pop().expect("empty stack");
 if x == '*' {
 stack.push(Tree::Kleene(Box::new(b)));
 continue;
 }
 let mut a = stack.pop().expect("empty stack");
 match x {
 '|' => match &mut a {
 Tree::Or(v) => v.push(b),
 _ => a = Tree::Or(vec![a, b]),
 },
 ',' => match &mut a {
 Tree::Group(v) => v.push(b),
 _ => a = Tree::Group(vec![a, b]),
 },
 _ => unreachable!(),
 }
 stack.push(a);
 }
 }
 }
 Tree::Group(stack)
 }
 fn matches(&self, s: &str) -> bool {
 let (b, idx) = self.matches_priv(s);
 b && s.len() == idx
 }
 fn matches_priv(&self, s: &str) -> (bool, usize) {
 let mut idx = 0;
 let fail = (false, 0);
 match self {
 Tree::Any => {
 if let Some(c) = s.chars().next() {
 (true, c.len_utf8())
 } else {
 fail
 }
 }
 Tree::Literal(c) => {
 if Some(*c) == s.chars().next() {
 (true, c.len_utf8())
 } else {
 fail
 }
 }
 Tree::Group(v) => {
 for m in v {
 if let (true, i) = m.matches_priv(&s[idx..]) {
 idx += i;
 } else {
 return fail;
 }
 }
 (true, idx)
 }
 Tree::Or(v) => {
 for m in v {
 if let (true, i) = m.matches_priv(s) {
 return (true, i);
 }
 }
 fail
 }
 Tree::Kleene(b) => {
 while let (true, i) = b.matches_priv(&s[idx..]) {
 idx += i;
 }
 (true, idx)
 }
 }
 }
}
Category:Implementations
Minscode

Minscode is a simple langauge based on the Minsky machine. It has 4 registers. A, B, and C are normal numeric registers, c is a conditional register.
== Instructions ==
Command	Description
+ 	Increment the current register.
- 	If the current register is greater than 0, decrement it and set the conditional register c to false. Otherwise, set c to true.
A 	Switch to register A. This is the default register.
B 	Switch to register B.
C 	Switch to register C.
! 	Negate the conditional register c.
(…) 	Run the code enclosed in the parentheses if the conditional register c is true.
{…} 	Run the code enclosed in the braces until the conditional register c is true.
, 	Output the value of the current register.
. 	Input a user-supplied number to the current register.
== Programs ==
Prints out the Fibonacci numbers. Note that the vertical bar separates the actual code, located to the left, from appertaining comments in the right column, the latter portion of which does not represent valid statements in the program.
 A, | Print F(0) = 0.
 B+, | Print F(1) = 1.
 { |
 A- |
 {-C+A} | Set C = A.
 B- |
 {-C+A+B} | Set C = A + B, while setting A = B.
 C, | Print C, which now equals F(n) = F(n-2) + F(n-1).
 - |
 {-B+C} | Reset C to zero, while setting B = C.
 A+- | Set conditional register c to false for infinite loop.
 } |
This program implements a truth-machine:
 .
 -
 {+,-}
 ,
==Interpreter==
* Common Lisp implementation of the Minscode programming language.
Category:2016
Category:Languages
Category:Implemented
Category:Unknown computational class