Doki!+

Not to be confused with Doki!.

Doki!+

Designed by	User:A random guy
Appeared in	2026
Memory system	variable-based
Computational class	Hypercomputer
Reference implementation	Unimplemented
Influenced by	Doki!, DDLC

Doki!+ is an extension of Doki! that is in the same Period in as it’s predecessor with all 114 of it's commands, but with modifications that allow it to break past Turing Completeness in already known ways, just made more customizable. Also made it be able to do some quantum shenanigans too, though I will do some research.

New Commands

Hypercomputational commands are in Monika's Act 3 section, so I do not need to specify what Act it is in. This programming language, counting every command, now has 125 commands, MC having 8 commands, Sayori having 14 commands, Yuri having 24 commands, Natsuki having 25 commands, and Monika having 54 commands.

Hypercomputational Commands

Monika

Command	Description
Act 3:Monika[JustMonika]Function, t, AppliestoAllLines (True/False)	Uses a function made by Yuri's [Define] command to determine how much time it will take for each iteration in a Loop/Infinite Loop to finish up. The [Define] command's Function has to be purely mathematical and have only 1 parameter or it will give a error. The format for Yuri's Function also becomes different, as instead of it being Act 4:Yuri[Function Name]ParaName1, <Stuff>, it's now Act 4:Yuri[Function Name], with nothing else after it. Though if you are defining it without Yuri's [Define] command, then replace any parameters not fully occupied by a value, with t, for time, which such things need t in them at least once. The second parameter, t, determines how long it takes for one line of code to finish in milliseconds at the start for a program that takes a constant amount of time to execute a line (Constant being t^0). It also sees if it applies to all lines, if this is false, it only activates this for loops, but if it is true, then the entire program undergoes the Zeno Machine process. This is False by default if you don't put anything to the 3rd parameter.
Act 3:Monika[SelfAware]Level, (Yuri's [Define] function)	Acts just like an Oracle of level N, and yes, you can have mathematical operations inside where Level is in, just to make it be able to go beyond Omega. Level can also accept the first uncountable ordinal, which you have to type in Omega_1 for that.

Quantum Computational Commands

MC

Command	Description
MC[Observe]QVariable	Observes a variable, which locks a variable to a Qudit value based on the probability of getting any possible digit in the current base to represent the wave function of that variable collapsing into a random value based on the probabilities of all possible values. This can be used as a argument for parameters.
MC[GivePoem]QVariable, Observe(0,1), Clone(0,1)	If Observe is 0, then it doesn't observe the variable and instead prints the probabilities of all possible values in this format: Probability of Value1: (Value1 Probability calculated by weight) (New line), Probability of Value2: (Value1 Probability calculated by weight) (New Line)... (New Line) Probability of Last Value: (Last Value Probability calculated by weight), but if Observe is 1, it immediately collapses the wave function and outputs the result. This also allows "cloning", which just makes a new Qudit, and sets it's probabilities to what the original's probabilities are (Possible by the Esolang already knowing the probabilities beforehand), and observes it before printing it out and then getting rid of the QVariable, leaving the original one intact. This allows the Esolang to NOT violate the No-Cloning Theorem, as this is only replicating the Probabilities, not the quantum state. If the QVariable has a base of infinity, it prints out the function the QVariable uses instead.
MC[PlaySaveFile] "TimelineName", Variable	Allows MC to read the underlying probability weights of a quantum variable or field inside a completely different parallel timeline without collapsing the current timeline's state.

Yuri

Command	Description
Act 2:Yuri[A-Ah!] "TimelineName", Variable, TargetLine	A multiversal conditional loop. Yuri checks if a specific quantum variable has collapsed into a deterministic state in the target parallel timeline. If true, the current timeline's execution pointer instantly teleports to TargetLine.

Monika

Command	Description
Act 3:Monika[Var]Base, WeightP(Value1), WeightP(Value2)... , WeightP(ValueBase-1)	Makes a Quantum Variable (Will shorten to QVariable) which stores a Qudit of a chosen base with each possible value it can take on when observed having a weight to how likely they can occur, the higher the weight, the more likely that value can occur.
Act 3:Monika[Var]Infinity, Yuri[FunctionName]	Makes a Quantum Variable (which stores a Qudit with a base of infinity. The weights are defined with a function from Yuri, which must have only one input for x to be put into to spit out a weight. This allows Hypercomputation to occur, meaning yes, there is now 3 ways to achieve hypercomputation. Though this can only do Countable Ordinals.
Act 3:Monika[Var]Field, Yuri[FunctionName]	This allows a QVariable to now access Uncountable Infinities by making a Quantum Field. Basically, a continuous spectrum of Qudits.
Act 3:Monika[Forever] "QEntanglementName", QVariable1, QuVariable2, QuVariable 3, ... , QuVariablen	Makes all QVariables listed be Quantum Entangled with each other.
Act 3:Monika[Delete] QEntanglementName	Severs a Quantum Entanglement.
Act 3:Monika[SaveFile] "TimelineName"	Creates a quantum milestone anchor. It snapshots the current wave function of the entire program, spinning off a new, completely stable branching pathway in the computational multiverse.
Act 3:Monika[DeleteFile] Timeline	Deletes an entire timeline branch from the multiversal registry. If a timeline is deleted, any quantum variables or fields executing inside it collapse instantly, and any entangled lines associated with it are severed.

Types of Turing Completeness

Due to the fact that the Generalized Zeno Machine [JustMonika] can execute programs based on the time it takes to execute a command with a constant amount of time happening between lines, being $t$, and putting $t$ through a function, $f(t)$ to determine how long each line of code should truly take, there are now multiple layers of Turing Complete programs. The function that is used to determine how long a line takes ends up using this formula to show how long a program/loop should take: $\sum _{t=1}^{\infty }f(t)$. Due to the fact that it is applying this to literally every line, using the line number to determine how long it should take. Also, $f(t)\neq 0,\ where\quad t>0$.

Category	Explanation	Examples
Hypercomputer	A type of program/esolang that both is faster than Turing Complete computers at executing commands, meaning that in speed, $f(t)>t^{0}$, and also has a function $f(t)$ that satisfies this: $\sum _{t=1}^{\infty }f(t)\neq \infty$.	$f(t)=t^{-2}$, where $\sum _{t=1}^{\infty }t^{-2}={\frac {\pi ^{2}}{6}}$. Xeno Machine: $f(t)=2^{-(t-1)}$ where $\sum _{t=1}^{\infty }2^{-(t-1)}=2$.
Macro-Turing Complete	A type of program/esolang that is faster than a normal Turing Complete computers at executing commands, meaning that in speed, $f(t)>t^{0}$, but it's function, $f(t)$ when calculated, results in $\sum _{t=1}^{\infty }f(t)=\infty$.	$f(t)=t^{-1}$, where $\sum _{t=1}^{\infty }t^{-1}=\infty$ due to $t^{-1}={\frac {1}{t}}$ which ends up generating the harmonic sequence, which has been proven to diverge towards $\infty$.
Turing Complete	A type of program/esolang that is a normal Turing Complete computer, meaning that it's speed is $f(t)=t^{0}$, which Turing Machines run precisely that fast.	There is only one example, $f(t)=t^{0}$. Which fun fact, $\sum _{t=1}^{\infty }t^{0}=t$ which is why it diverges towards $\infty$.
Micro-Turing Complete	A type of program/esolang that is slower than Turing Complete computers at executing commands, meaning that in speed, $f(t)<t^{0}$, and it's function, $f(t)$ when calculated, just like Macro and Normal Turing Completeness, results in $\sum _{t=1}^{\infty }f(t)=\infty$.	$f(t)={\sqrt {t}}$, due to ${\sqrt {t}}$ itself diverging towards $\infty$. Which fun fact, all functions beyond being constant, always diverge towards infinity due to this exact reason. Meaning $f(t)=t^{1}$, $f(t)=t^{2}$, or even $f(t)=t!$ all diverge towards $\infty$.

Programs in Doki!+

H (Halting Problem Solver Program)

Act 1:[Var]”T”, 0
Act 4:Yuri[Define]”TFunct”, Time<
    Act 1:Monika[Exp]2, Act 1:Monika[Par](Act 1:Monika[Sub]0, Act 1:Monika[Par](Act 1:Monika[Sub]Time, 1))
>
Act 4:Yuri[Define]”Program”<
    Stuff for Program.chr
>
Act 4:Yuri[Define]”ProgramCount”<
    Act 4:Yuri[Program]
    Act 2:Yuri[HeartPound]T, Act 4:Yuri[TFunct]Act 2:Monika[Bump+]T
>
Act 3:Monika[JustMonika]Act 4:Yuri[TFunct], 1
Act 4:Yuri[ProgramCount]
Act 1:Yuri[If](Act 1:Yuri[LessThan]T, 2)<
    MC[GivePoem]”Halts”
>
Act 1:Yuri[Else]<
<
    MC[GivePoem]”Loop Forever”
>