nyuuzyou/wikis huggingface dataset:
Self-modifying Puzzlang

Self-modifying Puzzlang is a variation on Puzzlang. You could shorten the name to S-m Puzzlang, this variation is invented by User:Zzo38.
The program code does not wrap around and it is read from left to right on each line. Each symbol can be a digit 0 to 9 or any other symbol. A non-digit is no operation. A digit will be either on or off depending on the other state of the program (see below).
If a symbol is on, the operation depends on how many symbols are on adjacent (in the Moore neighborhood), from zero to eight. The numbers 1 to 8 correspond to brainfuck codes, 0 does something else, as described below. The corresponding codes are:
 12345678
 +>[<.-,]
Operation is then in the order of bytes in the program file; left to right on first line, and then second line and so on. The loop points is according to the current meaning of the symbols in the program, meaning the position of loops can be changed. In some cases it can lead to executing mismatched brackets; the program is terminated in such case if trying to do [ when cell is currently zero or if trying to do ] when cell is currently nonzero; other cases are allow to execute mismatched brackets acting like no operation and the program can continue.
Each cell on the tape can store a number 00 to 99, and it wraps. A symbol is on iff the current cell on the tape includes that digit either the tens place or ones place or both.
Input/output is by bits so the number on the tape will be either 0 or 1 when doing input (or 99 for EOF), and output uses even numbers to 0 bit and odd numbers to 1 bit, EOF is only when the program ends).
The command 0 adjacent on cells means a self-modifying command. It changes the digit in the current position of the code to the value at the current cell modulo ten.
Example:
 111 22333 111
 0 0 01 0 0 22 31 234567891 111
 000011 0 0 220330 0 0 0 1111
 9 7 77 7 7 2 3 3 0 0 0000000
Category:Languages
Category:2009
Category:Self-modifying
Category:Cell-based
Self-modifying esolang

Self-modifying esolang is the title created by User:ResU in 2021.
==Commands==
===insert.command(insert.command(x,3),2)===
Inserts the command insert.command(x) at line 2, which inserts the command x at line 3.
===append.string(x,defaultVariable)===
Appends x to the end of defaultVariable. defaultVariable is the default variable.
===goto.line(defaultVariable)===
Goes to the defaultVariableth line.
===if.(condition).happens { }===
Does everything between the brackets if a condition happens.
===store.(expression).to.(defaultVariable)===
Equivalent of defaultVariable=expression.
==="text"===
Prints the text. If the text is a variable, print the variable.
===a====
Initializes a. Every variable can be initialized except for defaultVariable.
===ask.for.input(defaultVariable)===
Asks for input and stores it to defaultVariable.
===define.function(name.of.function, parameters)===
Defines a function with the name name.of.function.
==Hello, world!==
"Hello, world!"
==Quine==
define.function(a, b) {
"b"b")"
}
a("define.function(a, b) {
"b"b")"
}")
==Infinite loops==
goto.line(1)
goto.line(3)
if.(1=1).happens {
goto.line(1)
}
==Truth machine==
a=
ask.for.input(a)
if.(a=0).happens {
"0"}
if.(a=1).happens {
"1"
goto.line(4)}
==Fibonacci sequence==
C is the number of Fibonacci numbers to print.
a= b= c= d=
store.(1).to.(a) store.(1).to.(b) store(100).to.(c) store(2).to.(d)
"a" "b"
if.(b<=a).happens {
store(a+b).to.(b) store(b).to.(a) "b" store(d+1).to.(d)
goto.line(4)}
==Interpreters==
No interpreters yet.
Category:Unimplemented
Category:2021
Category:Languages
Category:Self-modifying
Self-repeat

Program by Unicodes
= Overview =
This program gets a number from the user, let's say X, and prints X, X times
 I/O
Input	Output
0 	""
1 	"1"
2 	"22"
5 	"55555"
10 	"10101010101010101010"
= Examples =
== Python ==
 x = int(input())
 print(str(x)*x)
== Lua ==
 x = io.read()
 io.write(string.rep(tostring(x),x))
Self-replicating marbles

Self-replicating marbles is an esolang by User:Joaozin003, which as the name says, uses self-replcating marbles.
== Concepts ==
A program is divided into a 2D grid of what we'll call sections. These sections then contain a 2D grid of instructions.
Sections can be blanked out, even if it doesn't make sense:
 > > v
 
 ^ <
Additionally, sections don't need to be exactly rectangular and they don't connect diagonally, so
 ex
 a
 mple
would be two separate sections.
A marble is your main way of storing data. It stores a bit and can go over instructions, executing them.
The interesting part is that if a marble reaches the end of a section, it will go to the next and replicate itself to all instructions of that section.
If a marble reaches the edge of a program, it gets removed.
== Execution ==
When the program is started, a marble with a 0 is placed at the top-left instruction of the top-left section, with the top winning if a tiebreaker is needed:
 m
 ar
 b
 le
In this case, the marble will land on the m.
Then, the marble will roll to the right.
The program ends when no marbles exist.
== Commands ==
Instruction 	Description
>, v, < and ^	Make the marble on top roll in the direction the arrow points
? 	Delete the marble on top if it holds a 0
i 	Input a bit into the marble
o 	Output the marble's bit
  	Separate sections
Anything else	No-op. Avoid using it as it makes your code impure (all interpreters must have a flag --PURE that errors if a no-op is present)
There is one command not mentioned here, and that is when 2 or more marbles collide. If that happens, then they will merge into a single marble with the combined NAND of all of the marbles.
This requires the marbles to be above an arrow or get deleted by ? (not guaranteed!), otherwise this error occurs:
 Runtime error: The marbles unexpectedly collided on a flat piece of track. (*waits until the heat death of the universe*)
== Clarifications ==
What happens when you do this?
 > >
 XXX
Well, the > will make the marble go to the second >, so no, this is not a section jump and will not replicate the marble.
== Examples ==
=== Cat program ===
 > i o
 < <
Pretty easy to understand.
=== Truth machine ===
 i > o ? >
 < <
Also pretty easy to understand.
=== NAND ===
 > i o
 i >
NANDs both inputs and outputs the result.
=== Snippets ===
A list of snippets can be found here.
Category:2024 Category:Languages Category:Two-dimensional languages Category:Unimplemented
Self2

like Self but better
== Reverse ==
 Reverse prints the code but reversed,
 aka the "Reverse" program would result in "Reverse",
 because it reverses the order of the code
== R(a command) ==
 Runs the thing it does,
 example "RSelf" would run "Self" because "Self" prints "Self",
 but it would not be infinite
 other example is "RReverse Self",
 which would run "Self RReverse",
 then "RReverse Self"...
 which would be an infinite loop,
 which would print "Self" forever
== Interpreter ==
 #python
 def Self2(code):
SelfModify

SelfModify is a programming language that uses Self-Modification to do something.
= Everything =
== Commands ==
 A#*#B - turns into #B*#A
 <C> - doesn't run C until not surrounded by <>, Note: C is multilettered.
 %#A - turns into #%
 Note: The program runs left to right, using the previous state of the program, then the new state of the program is the result
Self 2

Self 2 is a programming language where if you type two "Self"s, it prints two "Self"s
== Quine ==
 Self Self
== Interpreter ==
 program = input()
 selfcounter = 0
 for item in program.split(" "):
 if item == "self":
 selfcounter+=1
 else:
 raise NameError("you can only type self, not "+item)
 if selfcounter == 2:
 print("self self")
 selfcounter = 0
==See also==
* Self
* Self but with loops
Category:Languages Category:Unusable for programming Category:Joke languages Category:Total Category:Output only Category:2024 Category:Implemented
Self but with loops

self has loops now
== commands ==
 self now prints the thing before it and itself, Ex: haha self would print haha self
 loop loops the code behind it the number after it, Ex: haha self loop 5 would print haha self haha self haha self haha self haha self
 cloop loops the code after it till the cend the amount behind it, Ex: 2 cloop self cend would print cloop self cloop self
 cend ends cloops, no example because cloops gives it
== infinite loop ==
 haha self loop -1
== Interpreter ==
 no
==See also==
* Self
* Self 2
Category:Languages Category:Unusable for programming Category:Joke languages Category:Output only Category:2024 Category:Unimplemented
Self destruct

This programming language uses self destruction to do stuff
== Self destruct ==
 the two letters on the side of a symbol is lowercase
 aDb - destructs itself and a and b, aka turn those into E
 aT - if a is U or B, turn into D
 E - turns into S
 Sb - turn b into S and S into b, if b is not P or B
 aP - if a is S, turn into B
 aB - if a is not S, turn into P
 aW - if a is U or B, turn into U, else turn into W
 aO - if a is U or B, stop program
 _ - do nothing
== Cool thing ==
 D_____PWWWWWT_PO
Selfermodif

there is some commands
== commands ==
 x, replaces itself with the code after it ending at X reversed, aka x123X would turn into 321123X
 X, for the x command, it does the same thing but with the thing reversed
 y, replaces itself with the recently replaced reversed, aka x123Xy would turn into 321123X123
 z, reverses one step of replacing, aka x123Xz would turn into x123Xz
 w, turns into the last command ran, note also ran at the same time, with the pair and the code in it,
 aka x123Xw would turn into 321123X321123X
 the commands are ran in order from left to right
 anything that weren't this is a comment, the letters xyzw were chosen because they are commonly not used,
 other than y
== program that is cool ==
 xyzyzXwxwwwwwwwwwwwwwwwwwwwwwwwwwXzzzzzyy
Selfie

Selfie is language by User:ChuckEsoteric08 inspired by Muriel
==Specification==
At the start of the program variables are set to 0. Unlike Muriel after executing subprogram it would go back to the program
.X. 	Output X
,X'Y, 	Set variable X to Y
!X! 	Execute X as Selfie program
(X'Y'Z)	Execute Z as Selfie program if variable X is not Y
==Arguments==
X+Y	Return X + Y
X-Y	Return X - Y
X*Y	Return X * Y
X/Y	Return X / Y
=X=	Return value of variable X
? 	Return user input
~ 	Return currently running program's source code
==Examples==
===Hello, World!===
 .Hello, World!.
===Infinite loop===
 !~!
===Truth machine===
 ,loop'.!=loop=!,,a'?',.=a=(a'0'=loop=)
===Use of ~===
In the program:
 .a!.a,x'~,!
variable x would be .a,x'~,, not .a!.a,x'~,!
==Computational class==
Selfie is Turing-complete because it is possible to translate PMMN without "else" blocks to it.
inc(x):
 ,x'=x=+1,
dec(x):
 ,x'=x=-1,
if(dec(x)) {...}:
 (=x='0'...)
while(dec(x)) {...} and loop is named y:
 ,y'(x'0'...!=y=!),!=y=!
Category:Languages Category:Turing complete Category:Turing tarpits
Selfmodi

selfmodi is a self-modifying esolang derived from brainfuck by user:tommyaweosme
== commands ==
 0 nop
 1 increment next number
 2 decrement next number
 3 | (flip)
 4 . (out)
 5 , (inp)
 6 [ (while0)
 7 ] (while0)
 8 > (next)
 9 < (prev)
 A-Z()
 script definition end
 a-z use script
== script definition ==
 A(34)
 4a4aa
prints
 01101
== asciification ==
groups of 8 can be turned into ascii using 3333 (or four repeats of 24 or 12) right after the eighth bit has been printed
 4244424444424424242424
prints
 a
instead of
 01100001
because we asciified it
== lethrough ==
 ;
is the lethrough character.
if current bit is 1, it lets commands after it until : be done, and gone through. otherwise, they get skipped.
== order ==
 0123456789abcdefghijklmnopqrstuvwxyz;:
this is for the increment and decrement commands (also it only uses letters that are defined)
== truth machine (example) ==
 54:[4];00
Semeler

Semeler is a bunch of languages randomly mashed together. The goal is to make it possible for almost every program to run in Semeler, so that people can code in whatever format they'd like! 
== Intro continued ==
This language is described by a few algorithms.
If a feature is used in an algorithm it exists! So if someone put "pop the last element of a string" or even string.slice(84) as an algorithm step then bam, the functionality exists!
=== More very loose features ===
Every Function implicitly evaluates to (the result of the last step).
Which is similar to what Rust does...
fn add(a, b) {
 a + b
}
...here the function implicitly returns a + b
Steps are evaluated like this:
# Let be a step.
# If has substeps,
## If has a substep than ran and evaluated to something
### Return the last such substep
## Else
### This step doesn't evaluate to anything
# If that step returns or outputs or errors or logs , return 
# If that step is an , return the result of evaluating 
Some example expressions are variable declarations, variable assignments, mathematical expressions, and function calls.
If a step is a declaration or assignment, it's returns 
== Main ==
When running , the following function is run:
# Let be 0
# For every entry in the following table (in order from top to bottom)...
## Let be the regex in cell 1 of that entry
## If .slice() matches the 
### Let be that match
### Run the Function in cell 2
### Unless otherwise specified by the Function in cell 2...
#### Set to + .length
#### If is .length
##### Output the result of step 2.2.2
#### Else
##### Run step 2 again
# Increment 
# If is not .length
## Go to step 2
== The token table ==
 The token table 
Regex	Function
 	Output the result of the last expression
Semi-serious language list

__NOTOC__
:This list is currently incomplete, please help add on anything that belongs.
This is a third list that lists only "good" languages.
Languages added here must meet the following criteria:
* It's either Turing-complete, will be Turing-complete if memory constraints are removed, or nearly Turing-complete;
* It's not a joke language, a stub, or a work in progress;
* It's implemented and/or described on an external resource;
* It is original (not a derivative of any well-known existing language, unless it differs strongly and in a unique way).
However, that is not to discourage people from adding new languages here. if you add something that doesn't belong here, it will simply be removed by other people, with no other consequences.
Rules from the other two lists also apply here.
== Non-alphabetic ==
* +-)
* :///
* :)
* 0x29A
* 1+
* ><>
* 勿忘国耻
== A ==
* Aargh!
* Addition Automaton
* Advance The Wheel!
* Aheui
* ALPACA
* The Amnesiac From Minsk
== B ==
* Befunge
* Binary lambda calculus
* bitch
* Bitdeque
* Bitwise Cyclic Tag
* Black
* Blindfolded Arithmetic
* Bouncy Counters
* brainfuck
* Brainpocalypse II#Numerical version
* But Is It Art?
== C ==
* Chicken
* Come Here
== D ==
* DownRight
== E ==
* Emmental
* ETA
* evil
* Execode
== F ==
* FALSE
* FlipJump 
* Forte
* Fractran
* Funge-98
* Fysh
== G ==
* Game of Life
== H ==
== I ==
* I/D machine
* Imprecision
* Incident
* INTERCAL
* Iota
== J ==
== K ==
* Kayak
* Kipple
* Kawa
== L ==
* Langton's ant
* lenum
* LNUSP
== M ==
* Malbolge 
* match
* Muriel
== N ==
* Nine
* Nopfunge, special enough
== O ==
* Obscure
* ORK
== P ==
* Piet
* PROLAN/M
* Pxem
== Q ==
* Queue based
== R ==
* RAM0
* Recur
* Redcode
* Re:direction
== S ==
* Sclipting
* Shove
* Smurf
* Sreg
* Strelnokoff
* Subleq
== T ==
* Three Star Programmer
* Thue
* Tip
* Trampolines
== U ==
* Unary 
* Underload
* Unlambda
== V ==
* V++
* Von Neumann's 29-state cellular automaton
== W ==
* The Waterfall Model
* Whitespace
== X ==
== Y ==
* Ypsilax
== Z ==
== See also ==
* Esoteric programming language
* Language list
* Joke language list
SemiScript

SemiScript is an esolang using 4 different characters:
; : , .
These symbols aren't commands, but when strung together, result in an output.
For the interpreter, it simply translates SemiScript code into Node.JS code.
For an example, let's look at the hello world program.
===Some info===
If you use version 1.1, you can use comments anywhere (the tokenizer ignores characters that aren't in the SemiScript alphabet)
Use ":" as a command separator
Use "." to function as a new line
Use "," for a space
SemiScript uses SSCT (SemiScript Character Translator) text that inserts into the translation
===Use it===
=====Versions=====
Version 1.0
Version 1.1 not available :(
=====Text translator=====
Useful SSCT encode/decoder
==Cheat sheet==
=====Functions=====
; - output
;;;; - binary to decimal
;;;;;;;;;;;;;;;;;;;;; - input
;;;;;;;;;;;;;;;;;;;;;;;;; - random integer
;;;;;;;;;;;;;;;;;;;;;;;;;; - to string
;;;;;;;;;;;;;;;;;;;;;;;;;;; - to integer
=====Symbols=====
;;;;; - (
;;;;;; - )
;;;;;;; - [
;;;;;;;; - ]
;;;;;;;;; - {
;;;;;;;;;; - }
,, - =
,,, - !
,,,, - '
,,,,, - ,
=====Operations=====
;;;;;;;;;;; - addition
;;;;;;;;;;;; - subtraction
;;;;;;;;;;;;; - multiplication
;;;;;;;;;;;;;; - division
;;;;;;;;;;;;;;; - exponentiation
=====Comparing=====
;;;;;;;;;;;;;;;;;; - is equal to?
;;;;;;;;;;;;;;;;;;; - x less than y?
;;;;;;;;;;;;;;;;;;;; - x greater than y?
=====Keywords=====
;;;;;;;;;;;;;;;;;;;;;; - variable declaration
;;;;;;;;;;;;;;;;;;;;;;; - constant declaration
=====Loops=====
,; - if
,;; - else if
,;;; - else
,;;;; - for
,;;;;; - while
=====Other=====
,,,,,, - true
,,,,,,, - false
;; - 1
;;; - 0
Text translator in tools part
=Examples=
That cheat sheet is cool and all, but how can we actually use them?
Let's start with making the console say "Hello world":
=====Hello world=====
 ;
 ;;;;;
 ,,,,
 ,;.......:....:;..........:;..........:..........:,:...:..........:.....:;..........:;....:
 ,,,,
 ;;;;;;
So, basically, this is what it is doing:
# start display function
# start parenthesis
# start quotes
# ssct text saying "Hello world"
# end quotes
# end parenthesis
This outputs "Hello world".
Alternatively, if you don't like seeing what your code does, go for this:
 ;:;;;;;:,,,,:,;.......:....:;..........:;..........:..........:,:...:..........:.....:;..........:;....::,,,,:;;;;;;
This well, is the same thing but taking advantage of ":" to separate commands.
Category:Languages Category:Implemented Category:Turing complete
SemicolonHash

;# (SemicolonHash) is a programming language created by PPCG user caird coinheringaahing. It has only two commands: ; - add one to the accumulator, and # modulo the accumulator by 127, convert to ASCII character and output without a newline. After this, reset the accumulator to 0.
== Examples ==
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
 Output: ;#
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
 Output: !
== Interpreter ==
===Perl===
perl -043paF(?!^); -e '$_=/#/&&chr@F%127'
===Python===
 control = 0
 while True:
 code = input('>> ')
 for i in code:
 control = control + 1 if i == ';' else chr(control % 127)
 if i == '#':
 print(control)
 control = 0
== External resources ==
* Original codegolf question
* An online interpreter
Category:Languages Category:Implemented Category:Total Category:Output only Category:Unusable for programming
Semiconkéfalos

Semiconkéfalos is a portmanteau of "semicolon" and "enkéfalos" (brain). It is a variant of brainfuck created by User:TheCanon2, but the only valid symbols are the semicolon and Greek question mark.
==Commands==
Command	Unicode values 	Brainfuck equivalent
;;; 	U+003B U+003B U+003B	>
;;; 	U+003B U+003B U+037E	<
;;; 	U+003B U+037E U+003B	+
;;; 	U+003B U+037E U+037E	-
;;; 	U+037E U+003B U+003B	.
;;; 	U+037E U+003B U+037E	,
;;; 	U+037E U+037E U+003B	[
;;; 	U+037E U+037E U+037E	]
These commands behave exactly the same way as their brainfuck counterparts.
The only computational difference is that Semicónkefalos handles text in UTF-8. The only purpose of this was to allow for quines.
==Examples==
===Hello, World!===
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;
===Cat===
;;;;;;;;;;;;;;;
==Implementations==
The following is a Python script for converting brainfuck to Semiconkéfalos.
brainfuck = input('>prgm ')
semico = [""]
def text(bits): # Reduces the amount of lines used #
 for c in range(0, 3):
 if bits[c] == "0":
 semico.append(chr(59))
 else: semico.append(chr(894))
for i in range(0, len(brainfuck)): # Converts #
 if brainfuck[i] == "<":
 text("000")
 elif brainfuck[i] == ">":
 text("001")
 elif brainfuck[i] == "+":
 text("010")
 elif brainfuck[i] == "-":
 text("011")
 elif brainfuck[i] == ".":
 text("100")
 elif brainfuck[i] == ",":
 text("101")
 elif brainfuck[i] == "[":
 text("110")
 elif brainfuck[i] == "]":
 text("111")
 else:
 print("Invalid syntax.")
 break
semico = .join(semico)
print(semico)
The following program converts Semiconkéfalos to brainfuck.
replacements = {
 "\u003B\u003B\u003B": ">",
 "\u003B\u003B\u037E": "<",
 "\u003B\u037E\u003B": "+",
 "\u003B\u037E\u037E": "-",
 "\u037E\u003B\u003B": ".",
 "\u037E\u003B\u037E": ",",
 "\u037E\u037E\u003B": "[",
 "\u037E\u037E\u037E": "]"
}
program = input("Enter program: ")
for semiconkefalos, brainfuck in replacements.items():
 program = program.replace(semiconkefalos, brainfuck)
print(program)
Category:Languages
Category:Brainfuck equivalents
Category:2024
Category:Cell-based
Category:Brainfuck derivatives
Category:Turing complete
Category:Turing tarpits
Category:Low-level
Category:Implemented
Sep

Sep is an esolang created by islptng.
It is designed to be "even easier to learn than Waduzitdo while Turing-complete".
==Commands==
<nowiki>
>a a = input
<a print(a)
'x print a character
"x print a whole line of text
\x print the escaped character
#v break from loop with the depth v
+a register += a
-a register -= a
=a a = register if a is a variable name, register = a if a is number
{[v1]c1[v2]c2 ... [vn]cn[vd]}
 for i = v1 to vd, if v1 <= i < v2, execute c1. if v2 <= i < v3, execute c2, etc.
 if there is thing before v1, it will be treated as the step.
</nowiki>
==Computational class==
Turing Complete because it can simulate Minsky machines, but
SequenceScript

SequenceScript is invented by User:A.
==50+60(Save in [00])==
 00=32
 01=3C
 02=[00]
 03=[01]
 02+[03]
 00=[02]
 x=y
Set x(which is a place in the internal storage, x is a hex number) into y(represents a place of internal storage or a value, which is a hex number).
 x+y
Increment x(A place in the internal storage) by y
 x-y
Decrement x(A place in the internal storage) by y
 [X]
A place in the internal storage(same as the one in x=y)
==Add from 1 to 100(Save in #0)==
 00=00
 02=[00]
 03=[02]
 03=64:08
 02+[03]
 03+01
 00=00:04
 00=[02]
 x=y:z
If x(A place in the internal storage) equals y, jump to sequence numbered z.(z is hex)(The sequences start with 0)
==Computational Class==
It seems that it is Turing-complete, but it is actually not.
Using implementation of the Collatz function:
+ x+01(x can be [00], [01], or [02].)
- x-01
< and > does not produce code directly---it is just switching vars.
[ x=0:y
y is where the other bracket is.
] x=???:y
Obviously, it can't implement unequality.
Category:Languages
Sequential tag system

A sequential tag system is similar to a cyclic tag system, but where the production rules are given as an explicit, infinitely long list, rather than as a finitely long list that repeats.
Sequential tag systems are often the simplest way to prove a language Turing complete – if it accepts an infinitely long input program, as is the case for many cellular automata and some Turing machines. This definition of Turing-completeness is quite controversial, due to the introduction of infinity. However, because a cyclic tag program compiles into a sequential tag program that repeats indefinitely, then in many cases, this will lead to an infinitely repeating program in the language whose computational class is being examined, something that most (but not all) mathematicians will accept as a legitimate initialization. For more information on the status of infinitely long input programs, see Transfinite program.
Here are some implementations of sequential tag system:
* In brainfuck: (with some documentation )
* In Urn: 
* In Hollow: 
Category:Computational models