User:RaiseAfloppaFan3925/Sandbox

Hi welcome to my sandbox :D

Here, you might see some of my private languages Just experimenting with stuff.

Superset

public nondefault stable immutable readonly constant variable PI: number = 3.14159265358979

public nondefault stable immutable readonly constant synchronous subroutine: number <- abs(x --> number) {
    explicitly relinquish control and return x;
}

public nondefault hazardous object structure member layout Vector3 {
    stable mutable readwrite nonconstant member x <- number;
    stable mutable readwrite nonconstant member y <- number;
    stable mutable readwrite nonconstant member z <- number;
}

public nondefault stable immutable readonly constant synchronous subroutine: number <- read_file(path --> string) {
    return anticipate asynchronous subroutine ~/dev/scope/fs/readFile(path);
}

// releasing right after this

Pain

Program

The program is stored in a 39x41 memory grid which is mirrored in the source files. Each character in the source file corresponds to a single cell in the 39x41 grid, so multi-character commands are very expensive.

Memory

The memory where the cursor resides is stored in an infinite 2D grid.

Commands

Here is a list of the current commands.

I/O

Command	Name	Operation
I	Input string	Takes in a UTF-32 string and places it into memory with the first cell containing the string's length.
O	Output string	Prints a UTF-32 string containing the N cells after the cursor's cell in the cursor's direction.
i	Input character	Takes in a UTF-32 character and places it into the memory cell at the cursor.
o	Output character	Outputs the UTF-32 character at the current memory cell.

Arithmetic

Arithmetic operations are governed by the k command which determines if their mode is CELL or DELTA. Since there are two targets, this section will refer to them as "target".

Command	Name	Operation
k	Toggle Arithmetic Mode	Switches the mode of all arithmetic operations to either CELL which performs the action on the cell at the cursor, or DELTA which performs the action on the delta register.
テト	Increment	Increments the target.
ミク	Decrement	Decrements the target. If two of these instructions are placed in a row, they must be followed by "BEAM" (example: "ミクミクBEAM")
亞北ネル	Square	Squares the target.

Memory

These programs deal with memory. They are governed by the _ command which determines if their mode is CODE, CURSOR, or CELL.

For directions, the cursor and cell start pointing up and the code starts pointing right.

Command	Name	Operation
_	Toggle Memory Mode	Switches the memory mode between CODE, CURSOR, or CELL.
@	Spiral	Turns the direction of the target clockwise.
^	Advance	Moves the target in its direction.

RaiseAfloppaFan's Stupid Idea 0

NOTE: RSI0 has now been moved to its own page, RaiseAfloppaFan's Stupid Idea 0. This is just the original base seed that resulted in my zeroeth stupid idea.

Idk if this would be greenlit or not so I just put this here, if it's greenlit then I will make it into its own page

RaiseAfloppaFan's Stupid Idea or RSI0 (not to be confused with the x86-64 register rsi) is an esolang by User:raiseAfloppaFan3925 where anyone here can add any command that they want, as long as they follow the rules.

Feel free to add any commands, as long as they meet the following criteria.

Requirements

1. Command must be computable/executable (ex: cannot make a command like "if stack top is 42 then solve the halting problem")

2. Commands must be able to be written forwards and upwards. Left and down are required, while right and up are optional. Example:

horizontal (left/right)
ミク

vertical (up/down)
ミ
ク

3. Group all of your commands into your own section marked with your username Example (wikipage source code, replace the information here with stuff):

== [[User:you]] ==

[list your commands here]

If you want (idk if its allowed tho) then make sub-pages (like Extensible Community-driven Esolang/you)

Base commands

You cannot edit this.

This might be moved to Extensible Community-driven Esolang/Base Commands.

All programs in RSI0 are stored in 2-dimensional slices (like Befunge) but with an extra third dimension of slices.

Hypnotization resistance

Hypnotization resistance is a stat in the program that starts out as 100% but decreases by 0.01% per instruction. If the hypnotization resistance is lower than 75%, then the instruction pointer will have a 5% chance of turning left per instruction. If the hypnotization resistance is lower than 50%, then it will decrease by 0.5% per instruction, making it unrecoverable. At less than 25%, the instruction pointer will start "hallucinating" and running the complete wrong instruction.

Code

Code in RSI0 is stored in blocks, which extend the available dimensions.

Memory

The base memory for the language is a tape consisting of 2,763 memory cells 32 bits in size. Along with the tape are three registers, A, B, and C, which store 32-bit unsigned integers.

Instruction pointer

The instruction pointer in RSI moves to the right by default, but its direction can be changed with the ^, v, <, and > instructions.

Command	Action	Example
みく or ミク	Decrements hypnotization resistance by 0.1%
てと or テト	Increments hypnotization resistance by 0.02%
|	Reflects the IP horizontally
-	Reflects the IP vertically
<	Makes the IP move left
>	Makes the IP move right
^	Makes the IP move up
v	Makes the IP move down
o	Makes the IP move forward along the Z-axis
O	Makes the IP move backward along the Z-axis
.	Outputs a UTF-32 string starting at the cursor with the A register containing the amount of characters to output.
,	Asks the user for a string and lays it out in the memory tape, with the A register containing the length.
X	No-op. If any of the registers or the cell at the memory cursor contains a "7" then
0	Swaps the values of A and B
1	Swaps the values of B and C
w	Writes the value in the A register to the current memory cell
r	Reads the value from the current memory cell to the A register
+	Increments the A register
-	Decrements the A register
=[ and ]=	Makes the dimension into a loop that ends when the current memory cell is equal to 2,763	{ =[ テト+w ]=, { ,. } }

Examples

Infinite loop

{ >テト< }

Vertical version

{
    { v },
    { テ },
    { ト },
    { ^ },
}

Cat program

{ ,. }

Vertical version

{
    { v },
    { , },
    { . },
}

User:Esolangist

Yay, first command creator!

My commands!

Command	What Does It Do?	Pseudocode
↓	Moves the pointer forward in the 4th dimension (this is 4d now. implementations are probably possible with multiple command cubes)	Esolangist.4d.moveForward()
↑	Opposite of ↓.	Esolangist.4d.moveBackward()
™	Truth Machine.	Esolangist.other.TruthMachine()
➕	Adds 1 to N.	Esolangist.Accumulator.add(1)
🔝	Goes forward in Nd.	Esolangist.Dimensions.Forward(N)
🔙	Opposite of 🔝.	Esolangist.Dimensions.Backward(N)

Features (Base)

• N-dimensional
• Tape/cell memory
• Non-deterministic probabilistic (only if the hypnotization resistance is below 75%)

Btw User:Esolangist, should I move this into its own page? Thanks!

Yes, you should :) Esolangist (talk) 14:31, 1 November 2025 (UTC)

Thanks! RSI0 is on its way! (talk)(User:RaiseAfloppaFan3925)---- 14:33, 1 November 2025 (UTC)

RaiseAfloppaFan's Stupid Idea 1

Potential names

• 私の愚かな考えの融合 (The fusion of my stupid ideas) [watashi no orokana kangae no yougou] - could be
• 私の愚かな観念の極致は頭がおかしくて愚かだ (The culmination of my stupid ideas is insane and stupid) [watashi no oroka na kannen no kyokuchi ha atamagaokashikute orokata] - Much longer, will sound weird if you are a native Japanese speaker or understand the language at a level higher than "absolute beginner", but it does work somehow

"RSI1" is just a temporary placeholder name for this language. If I ever decide to make this language serious, then it will be named something else.

The sequel has arrived.

RSI1, the sequel to RSI0 (not to be confused with the RSI0 above, which is a draft) is a proto-esolang (what) that has taken on a more traditional text-based form, taking major inspiration from languages such as LOLCODE and INTERCAL. RSI1 is statically typed.

Paradigms: Imperative, Functional, Object-Oriented (Class-based)

Type system: Static

Computational Class: Turing-complete (unproven)

Categories (Wiki): CJK, Pseudonatural, Concurrent programming

Command	Action	Note
please	Same as PLEASE in INTERCAL.
thank you	please but as a postfix operator
ください, formal form 下さい	please but only used when working with Teto

In RSI1, there are two entities, the program and the VM. The program does some of the basic stuff like arithmetic, comparisons, and basic control flow. However, the VM does the heavy lifting such as calling functions, reserving room for variables, and manipulating timelines.

Core Entities

RSI1 is held together by three entities, the Runtime, the Program, and Teto, who is referred to as 重音テトさん in code.

Program

Program (or Programさん) is the entity that holds the program code and executes most code, reaching out to Runtime if needed.

Runtime

Runtime (or Runtimeさん) is the entity that performs complicated tasks that Program cannot execute by themselves, such as importing libraries (and Teto) or manipulating timelines. They must be addressed with respect as they can just decide to not execute their tasks.

Kasane Teto

Teto (or 重音テトさん), pretty obviously the UTAUloid that made her way to ultimate fame in the Vocaloid community, is core to RSI1. (at least unless TwinDrill sends me a copyright notice in which I will gladly take this down) Teto will protect your program from hypnosis but must be given baguettes every now and then.

Sanity

Just like RSI0, RSI1 has a sanity feature that goes down by 0.01 per instruction. Since RSI1 is still unimplemented and is more "traditional" unlike the Befunge-like RSI0, it is unclear how this will work.

The lower the sanity level is, the faster your program gets hypnotized.

Politeness

Just like INTERCAL, RSI1 has a politeness mechanic. The please keyword makes the program more polite. However, RSI1 also has the thank you keyword which should come after a "significant" expression such as a function call or a timeline-related command.

Hypnotization

A feature that was scrapped in RSI0 in favor of sanity, hypnotization starts at 0% and increases constantly. If the hypnotization meter ever exceeds 50%, then the Mesmerizer song (by Satsuki/32ki) and MV (by channel) (https://www.youtube.com/watch?v=19y8YTbvri8&pp=ygUKbWVzbWVyaXplctIHCQkDCgGHKiGM7w%3D%3D) will be opened at random. (until Satsuki and/or channel send me a copyright notice, in that case understandable) If it ever hits 100%, then the program halts.

Hypnotization Resistance

Hypnotization resistance is another feature from RSI0 that was scrapped. In RSI1, hypnotization resistance is the ability of the program to resist hypnotization. It is constantly decreasing and will decrease a lot if time travel operations are used. The only way to regain hypnotization resistance is by giving Teto a baguette.

Time travel

The RSI series now has time travel to compensate for the "normalization" from Befunge to INTERCAL.

Command	Example	Action	Notes
merge		Merges the current timeline with the last created timeline, adding a new instruction pointer that executes in parallel. Brings over the locals and globals of the previous timeline. If a local/global from the previous timeline conflicts with a local/global in the merged timeline, then the instruction pointers will use their own versions of the local/global.	I can't explain it that well, but just picture this. Timeline A has a global singer which is equal to "teto", and spawns a timeline Timeline B. Timeline B overrides its own singer variable to be "miku", then merges with Timeline A. Timeline A still sees singer to be "teto", but Timeline B's instruction pointer which is now in Timeline A still sees singer to be "miku".
reincarnate right now		If the current timeline has been ended, then it will be restarted at the first command AFTER the one that ended the timeline.
travel	travel N, travel function	Spawns a new timeline and travels N lines forward. If N is less than zero, then travels backward N lines. If a function (not a function call, so no parentheses) is given instead of a number, then a new timeline is spawned where that function is the starting point.

Classes

RSI1 is object-oriented.

class Vector2
    public member x
    public member y

    public static func new(x, y)
        Runtimeさん、please reserve vector: Vector2 thank you
        Programはvectorさんのxにxをあげる
        Programはvectorさんのyにyをあげる
        please take vector
    end
end

Member/Method Access

Accessing a member or method is pretty simple, just write thingのthing_you_want. An exception though is with the 重音テトさん entity module, where methods are in the form of Japanese sentences.

an alternative for both of these is . like in normal languages because User:Hammy hates copy+pasting japanese a bunch of times >:(

Core Modules

重音テトさん

重音テトさん is a special core module which is required to run long-running programs or time-travelling programs. The module's name is actually 重音テト, but the さん is necessary as it is a sign of respect. The primary purpose of 重音テトさん is to regenerate your program's hypnotization resistance and combat hypnosis. This is done by giving her a baguette.

Food

Food is a special core module which comes with exactly one class: Food::Baguette. Baguette exists for the 重音テトさん module, since you give her baguettes to regenerate hypnosis resistance.

Miscellaneous

• io

Examples

Hello world program

// shameless intercal clone
please import io thank you
please ioのprint("Hello, world!") thank you

Here is what happens if you don't add the please before importing the io module

Output:

[Runtime] Listen, could you PLEASE learn to use the word "please"? Importing
modules is a pretty difficult job since I have to find them and repeatedly ask
them to participate in whatever you're doing, and it's pretty unrewarding too.
So I would appreciate it if you at least showed some respect.

Either thank you doesn't matter that much here since the program is short, but always thank Runtime.

Alternated

// shameless intercal clone but with string escapers
please import io thank you
please ioのprint("＼⟨hw⟩) thank you

Cat program

please import 重音テトさん 下さい
please import Food thank you
please import io thank you

Programさん, please reserve my_input: string thank you
Programさんはmy_inputさんにioのinput()をあげる
Programさんは重音テトさんにFoodのBaguetteのfrom_length(10km)をあげる // 10 km baguette for Teto!
if my_input == '' then
    Runtimeさん, please end the timeline thank you
end
please ioのprint(my_input) thank you
travel -7 thank you // look i have time travel!

Here is what happens if you don't add the thank yous and the politeness meter goes down after making a couple of timelines.

[Runtime] Not even gonna thank me? How rude of you, I went through so much trying to do what you wanted me to do. I even made a new timeline JUST for you. And you're not even gonna thank me? Why don't YOU make these timelines yourself?

Truth Machine

please import 重音テトさん ください
please import io thank you

Runtimeさん, please reserve my_input: string thank you
Programさんはmy_inputさんにioのinput()をあげる
Programさんは重音テトさんにFoodのBaguetteのfrom_length(10km)をあげる
if my_input == "1" then
    please ioのprint(1) thank you
    Programさんは重音テトさんにFoodのBaguetteのfrom_length(10km)をあげる
    travel -2
end
please ioのprint(0) thank you

Extensions

Just like RSI0, RSI1 can be extended with unofficial extensions.

User:Esolangist

wait I thought my joke thread wouldn't happen? anyway here's commands yay

RSI1 COMMANDS BY ESOLANGIST

Command	Meaning	Example
push (n)	Pushes (n) to the stack	you really need an example?
get me out of here	Discards the top value on the stack. MUST be after "please"	just look at the meaning...
π	Outputs 3.141592653589... (infinitely.)	not now
baguettes yay	Prints "baguette", then the top value of the stack. Then print "baguette" then the second-from-top value of the stack etc... Can be thought of as a debug command.	Esolangistさんのpush(123) Esolangistさんのpush(456) Esolangistさんのpush("Hi world") Esolangistさんのbaguettes yay The output will be: baguetteHi world baguette456 baguette123

here's the types yay

Types in RSI1

Type	Look at it.
String	"something"
Number	#1 or №1
Boolean	?1 for true, ?0 for false
Lambda	{λa.E}, see Lambda calculus
Mojibake/Character	『Windows-1252 mojibake for the character you are making』

and here's some string escapers or whatever they are called

THIS USES THE FULLWIDTH BACKWARDS SOLIDIUS (＼) AND NOT THE BACKWARDS SOLIDIUS (\) SO IT IS PAINFUL LOL

also you can use windows-1252 mojibake inside 『』for characters so it is painful

also ALSO if you use a \ instead it outputs "Normal backslashes are for babies. You know how to type unicode characters, don't you?" and halts

String Escapers/Replacers/Whatever they are called

Replacement	What it looks like
＼⟨n⟩	(Newline)
＼⟨o/ca⟩	⟨/⟩
＼⟨hw⟩	Hello, world!
＼⟨fwbs⟩ or 『ï¼¼』	＼

Extension Examples

User:Esolangist extensions

please import ExtensionsのEsolangistさん thank you
please import io thank you

Esolangistさんのpush(69)
Esolangistさん、please get me out of here
please ioのprint(Esolangistさんのπ) thank you // Unless Esolangist specifies otherwise, then Esolangistさんのπ is actually a hidden object of class LazyPi, which when outputted just infinitely prints the digits of pi.
Programさん、please reserve e_boolean: EsolangistさんのBoolean
Programあんはe_stringに?1をあげる // Modules can add custom literal syntaxes, further complicating any potential RSI1 compiler.
please ioのprint(e_boolean) thank you

Note from User:Esolangist (if this edit is from User:Hammy, that's my new account, i accidentally signed out D:): The π command-ish can be a hidden object that is hiding in Esolangist class, or it could just return pi, depending on implementation, language implemented in, how the program is feeling or how good baguettes taste.

Redshift

Shift everything away.

Commands

Command	Action	Example	Memory Layout
lda	Stores the cell at the pointer in Register A.	self-explanatory
ldb	Stores the cell at the pointer in Register B.	self-explanatory
swap	Swaps Register A and Register B.	self-explanatory
sta	Stores the value in Register A in the cell at the pointer.	self-explanatory
stb	Stores the value in Register B in the cell at the pointer.	self-explanatory
si	Copies the memory unit at absolute byte address N from the program memory into the current memory cell.	si byte 0	Has options byte, short, word, and quad, which take up an extra byte
li	Loads the current memory cell into the memory unit at absolute byte address N.	li quad 8	Has options byte, short, word, and quad, which take up an extra byte
ica	Increment the A register	self-explanatory
icb	Increment the B register	self-explanatory
dca	Decrement the A register	self-explanatory
dcb	Decrement the B register	self-explanatory
add	Adds A and B and stores the result in A.	self-explanatory
sub	Subtracts B from A (A - B) and stores the result in A.	self-explanatory
shl	Left-shifts the value in A by B bits.	self-explanatory
shr	Right-shifts the value in A by B bits.	self-explanatory
up, down, left, right	Moves the cell pointer in their respective directions.	self-explanatory
in	Takes in a UTF-32 character as input.	self-explanatory
out	Outputs the current cell as a UTF-32 character.	self-explanatory
ge	Sets the GE flag if A is greater than B.	self-explanatory
sg	Sets the GE flag unconditionally.	self-explanatory
cg	Clears the GE flag.	self-explanatory
jge	Jumps to the Nth byte, starting at zero. N is an absolute address.	jge 5 jumps to the 6th BYTE, not instruction.	1 byte (instruction) followed by 16 bytes (target address)

Memory

Memory is stored in the form of a grid which is constantly expanding from the first memory cell at the "speed of light". The expansion follows Hubble's law, so cells farther from the pointer will move away faster than cells closer to the pointer.

Time 0 (pointer is represented with P)

A y 0 0 B
x a X b 0
0 Y P Z 0
0 c W d z
C 0 0 w D

Time 1
A 0 y 0 0 0 0 0 B
0 0 0 0 0 0 0 0 0
x 0 a 0 X 0 b 0 0
0 0 0 0 0 0 0 0 0
0 0 Y 0 P 0 Z 0 0
0 0 0 0 0 0 0 0 0
0 0 c 0 W 0 d 0 z
0 0 0 0 0 0 0 0 0
C 0 0 0 0 0 w 0 D

The pointer moves faster than the speed of light, so any memory location is accessible.

Examples

Infinite loop

sg
jge 1

With assembler extensions

sg
jge $

XKCD Random Number =

ica
icb
add
; a = 2, b = 1
swap ; a = 1, b = 2
add
ica ; a = 4, b = 2
swap ; a = 2, b = 4
ica ; a = 3, b = 4
shl ; a = 48, b = 4
add ; a = 52
out ; '4'

Assembler Extensions

Redshift can be thought of as an assembly language, and so can have some extensions to the assembler. These only alter the syntax of the language, not the underlying behavior.

Base Extensions

Command	Action	Example	Notes
$	The current absolute address.	self-explanatory	Address is in bytes, since some instructions (like jge) are multi-byte.
Labels (text followed by a colon)	Gives an absolute memory address.	label:

Redshift-A

Redshift-A is a higher-level version of Redshift with some syntactic abstractions. It compiles to Redshift.

Redshift-A Examples

Infinite Loop

while true do end

Generated Redshift

cg
jge 1

XKCD Random Number

store 52 ; same as setting a to 52 and storing a
out cell

Generated Redshift

ica (repeated 51 more times)
out