New page wikitext, after the edit (new_wikitext) | '= Frontal Lobe Lobotomy (FLL) =
'''Frontal Lobe Lobotomy (1.1.0 COMPILER / 1.2.0 VM => FLL 1.1.0)''' is a '''x86-64''' esoteric programming language inspired by brain surgery metaphors 'Lobotomy'. It uses pointer-addressable neurons and suture levels to represent stateful, context-sensitive operations. It was designed to feel like doing live neurosurgery on a floating-point brain, where execution is done line-by-line with surgical "masks" that manipulate the brain tape.
<br> '''Developed by [[User:Creepy]]''' : ''“FLL doesn't just manipulate memory — it performs psychological operations.”'' </br>
== Design Goals ==
* To create a compact yet Turing-complete language
* To blend dark humor with real computation in a small binary
== Frontal Lobe Lobotomy Components ==
* '''Brain Tape''': A contiguous block of '''65536 memory cells''', indexed from 0 to 65535. Each cell holds a 32-bit floating-point number '''(float32)''' and is initialized to 0.0.
* '''Brain Pointer (BP)''': An unsigned integer that holds the index of the currently active cell on the '''Brain Tape'''. It is initialized to 0. Its value can range from 0 to 65535.
* '''Suture Lever 1 (SL1)''': An integer state variable that '''modifies the function''' of many mask symbols. It is initialized to 0. SL1 cycles through the values 0, 1, 2, 3. '''Incrementing SL1 from 3 resets it to 0.'''
* '''Line Pointer (LP)''': An unsigned integer that points to the '''current line of code to be executed'''. It is initialized to 0 and increments by one after each instruction, unless a jump occurs.
* '''RAM''': A single '''float32 memory slot''' used for temporary storage. It is initialized to 0.0.
== Language Overview ==
* Memory Model: One brain, 65,536 neurons (cells). Each cell holds a '''float32''', initialized to 0.0.
* Instruction Model: '''Fixed 3-part line: [line][dir][mask]'''
* SL1 State: '''Stateful''' modifier that '''alters the meaning''' of mask symbols
* Execution: '''Sequential''' per line, unless jumped '''via J'''
* Output: Values are “cast” to cast.bin, one '''line''' per call.
* One RAM State: Stores a '''float32''' that is initialized to 0.0.
* Uses <code>.fll</code> as the native '''FLL Program Filetype'''.
* Has an '''output system''' (outputs to <code>cast.bin</code>)
=== Comments ===
A comment is denoted by <code>`//`</code>. All text from <code>`//`</code> to the end of the line is '''ignored''' by the '''interpreter'''.
== Instructions ==
=== [dir] Commands ===
{| class="wikitable"
! dir !! Name !! Description
|-
| <code>=</code> || Operate || Executes the <code>[mask]</code> surgery on the cell at the current Brain Pointer (<code>Tape[BP]</code>).
|-
| <code><</code> || Decrement and Operate || Decrements <code>BP</code> by 1, then executes the <code>[mask]</code> surgery on the new <code>Tape[BP]</code>.
|-
| <code>></code> || Increment and Operate || Increments <code>BP</code> by 1, then executes the <code>[mask]</code> surgery on the new <code>Tape[BP]</code>.
|-
| <code>$</code> || Cast || Outputs the value of <code>Tape[BP]</code> to an external file named <code>cast.bin</code>. The <code>[mask]</code> is <b>not</b> executed. The output format is: <code>[BP] [Tape[BP]]\n</code>. File is created/truncated on first cast, then appended.
|-
| <code>#</code> || Operate and Reset || Executes the <code>[mask]</code> surgery on <code>Tape[BP]</code>, then immediately resets <code>Tape[BP]</code> to <code>0.0</code>.
|-
| <code>J</code> || Operate and Jump || Executes the <code>[mask]</code> surgery on <code>Tape[BP]</code>. Then checks if <code>Tape[BP]</code> is exactly <code>1.0</code>. If true, sets <code>LP</code> to this line number, creating a loop.
|-
| <code>!</code> || Mask Modifier || Replaces the <code>[mask]</code> in <code>Program[LP]</code> with the current one from this instruction. Does not execute the mask.
|}
''`LP` is set to the `[line]` number of the current instruction, causing an effective loop or jump to the same line '''(for [dir] J)'''. If false, execution proceeds to the next line as normal.''
=== [mask] Symbols ===
The `mask` contains a sequence of '''16 symbols''' that are executed from '''left to right'''. Many symbols are '''context-sensitive''' and change their '''behavior''' based on the current value of `SL1`.
{| class="wikitable"
! Symbol !! Name !! SL1=0 !! SL1=1 !! SL1=2 !! SL1=3
|-
| <code>~</code> || N-OP || No operation. || (Same) || (Same) || (Same)
|-
| <code>@</code> || Swapper || Increments <code>SL1</code> by 1. Resets to 0 after 3. || (Same) || (Same) || (Same)
|-
| <code>+</code> || Increment || <code>Tape[BP] += 1.0</code> || <code>Tape[BP] += 0.1</code> || <code>Tape[BP] += 0.01</code> || <code>Tape[BP] += 0.001</code>
|-
| <code>-</code> || Decrement || <code>Tape[BP] -= 1.0</code> || <code>Tape[BP] -= 0.1</code> || <code>Tape[BP] -= 0.01</code> || <code>Tape[BP] -= 0.001</code>
|-
| <code>*</code> || Multiply || <code>Tape[BP] *= Tape[BP-1]</code> || <code>Tape[BP] *= Tape[BP+1]</code> || (Undefined) || (Undefined)
|-
| <code>A</code> || Add || <code>Tape[BP] += Tape[BP-1]</code> || <code>Tape[BP] += Tape[BP+1]</code> || (Undefined) || (Undefined)
|-
| <code>D</code> || Divide || <code>Tape[BP] /= Tape[BP-1]</code> || <code>Tape[BP] /= Tape[BP+1]</code> || (Undefined) || (Undefined)
|-
| <code>S</code> || Subtract || <code>Tape[BP] -= Tape[BP-1]</code> || <code>Tape[BP] -= Tape[BP+1]</code> || (Undefined) || (Undefined)
|-
| <code>&</code> || Get || <code>Tape[BP] = Tape[BP-1]</code> || <code>Tape[BP] = Tape[BP+1]</code> || <code>Tape[BP] = Tape[BP-2]</code> || <code>Tape[BP] = Tape[BP+2]</code>
|-
| <code>=</code> || Equals || <code>Tape[BP] = (Tape[BP] == Tape[BP-1]) ? 1.0 : 0.0</code> || <code>Tape[BP] = (Tape[BP] == Tape[BP+1]) ? 1.0 : 0.0</code> || (Undefined) || (Undefined)
|-
| <code>></code> || Compare || <code>Tape[BP] = (Tape[BP] > Tape[BP-1]) ? 1.0 : 0.0</code> || <code>Tape[BP] = (Tape[BP] > Tape[BP+1]) ? 1.0 : 0.0</code> || <code>Tape[BP] = (Tape[BP] < Tape[BP-1]) ? 1.0 : 0.0</code> || <code>Tape[BP] = (Tape[BP] < Tape[BP+1]) ? 1.0 : 0.0</code>
|-
| <code>^</code> || LP Control || <code>LP += 1</code> || <code>LP -= 1</code> || <code>LP += 2</code> || <code>LP -= 2</code>
|-
| <code>;</code> || RAM Store/Load || <code>RAM = Tape[BP]</code> || <code>RAM = Tape[BP-1]</code> || <code>RAM = Tape[BP+2]</code> || <code>Tape[BP] = RAM</code>
|-
| <code>:</code> || RAM Set/Clear || <code>Tape[BP-1] = RAM</code> || <code>Tape[BP+1] = RAM</code> || <code>RAM = 0.0</code> || <code>RAM = 1.0</code>
|-
| <code>%</code> || Copy || <code>Tape[BP-1] = Tape[BP]</code> || <code>Tape[BP-1] = Tape[BP]</code> || <code>Tape[BP-2] = Tape[BP]</code> || <code>Tape[BP+2] = Tape[BP]</code>
|}
''*Note: Operations that reference adjacent tape cells (e.g., `Tape[BP-1]`) are subject to boundary conditions. For instance, `Tape[BP-1]` is only valid if `BP > 0`.*''
== Execution Flow ==
# Initialize '''Brain Tape, BP, SL1, LP, and RAM''' to their default starting values.
# The '''interpreter''' begins at the '''instruction specified''' by the '''Line Pointer''' (`LP=0`).
# The `dir` command of the '''current instruction is evaluated'''. This may involve '''pre-operation modifications''' to `BP`.
# If the `dir` command '''requires it''', the 16 `mask` symbols are '''executed sequentially from left to right'''.
# After the `dir` and `mask` operations are '''complete''', '''post-operation actions''' (like value resets or conditional jumps) are '''performed'''.
# Unless a '''jump''' occurred '''(`J`)''', the `LP` is '''incremented by 1'''.
# The process '''repeats''' from step 3 with the new `LP`.
# The program '''halts''' when the `LP` points to a '''line number''' that does not '''exist''' in the '''program source.'''
== Example ==
<pre>
// prog.fll - A Small Value Decay Calculation Program
[0][>][+@+++++~~~~~~@@@]
[1][>][+@@@-~~~~~~~~~~@]
[2][<][@*~~~~~~~~~~~@@@]
[3][$][~~~~~~~~~~~~~~~~]
</pre>
=== Explanation ===
We move the '''pointer''' from '''N[0] to N[1] with [>]''', then '''Add 1.0 (SL1-0)''' to it. Then '''Increment to SL1-1''', then '''repeat 5 times of Add''' (which since its SL1-1 = 0.1). Then reset SL1 at the end for '''cleanliness'''. N[1] = 1.5. Then, '''move the pointer''' to N[2], Add 1.0, '''Increment to SL1-3''', then minus (since its SL1-3 then -0.001). So the value of '''N[2] is 0.999.'''
<br>
'''Compute Step:'''
</br>
Move back to '''N[1]''', Now '''Increment''' to SL1-1 (Ahead-Multiply), do '*', so this is basically '''N[1]=N[1]*N[2]'''.
<br>
If you did not '''increment SL1 to SL1-1''' (example like SL1-0) - this will multiply the '''previous neuron''' which is,
</br>
'''N[1] = N[1] * N[0]'''. Now, we output by using '''"$"'''.
<br>
'''Saving''': This Saves N[1] with the value of 1.4985.
</br>
'''Expected Output''': N[1] = 1.4985
=== '''Expected Output as cast.bin''' ===
<br>
1 1.4985
</br>
''Note, cast.bin outputs with a structure of '''[Neuron ID] [Neuron Value]'''.''
= Download Tooling =
[https://drive.google.com/file/d/1utPotfZ4XyPMacthol7mAP1ykC3eshOU/view?usp=sharing Tooling for FLL 1.1.0 (123kb)]
* <code>fllc.exe</code> converts your <code>.fll</code> programs into a <code>.cpp</code> file. You can '''follow the instructions''' given by <code>fllc.exe</code> and compile it with '''g++ (mingw64 needed!)'''
* <code>fllcvm.exe</code> runs your <code>.fll</code> programs instantly '''(act as an interpreter)'''
= Frontal Lobe Lobotomy Versions =
* '''FLL 1.0.0''' ''(unstable)'' - Initial Release
* '''FLL 1.1.0''' ''(stable)'' - Added new '''[dir] command''' <code>!</code>. Added <code>%</code> as the '''copy symbol'''.
= Future Ideas =
* Supporting '''x86-based''' machines.
* Adding the '''Brainstem Surgery''', harder than '''normal frontal lobe lobotomy surgery''' but harder to be '''reverse-engineered'''.
* Adding '''Input''' system <code>(uncast.bin)</code>
[[Category:2025]] [[Category:Turing complete]] [[Category:Implemented]] [[Category:Cell-based]] [[Category:Low-level]] [[Category:Self-modifying]] [[Category:Languages]]' |
Unified diff of changes made by edit (edit_diff) | '@@ -1,0 +1,142 @@
+= Frontal Lobe Lobotomy (FLL) =
+'''Frontal Lobe Lobotomy (1.1.0 COMPILER / 1.2.0 VM => FLL 1.1.0)''' is a '''x86-64''' esoteric programming language inspired by brain surgery metaphors 'Lobotomy'. It uses pointer-addressable neurons and suture levels to represent stateful, context-sensitive operations. It was designed to feel like doing live neurosurgery on a floating-point brain, where execution is done line-by-line with surgical "masks" that manipulate the brain tape.
+<br> '''Developed by [[User:Creepy]]''' : ''“FLL doesn't just manipulate memory — it performs psychological operations.”'' </br>
+
+== Design Goals ==
+* To create a compact yet Turing-complete language
+* To blend dark humor with real computation in a small binary
+
+== Frontal Lobe Lobotomy Components ==
+* '''Brain Tape''': A contiguous block of '''65536 memory cells''', indexed from 0 to 65535. Each cell holds a 32-bit floating-point number '''(float32)''' and is initialized to 0.0.
+* '''Brain Pointer (BP)''': An unsigned integer that holds the index of the currently active cell on the '''Brain Tape'''. It is initialized to 0. Its value can range from 0 to 65535.
+* '''Suture Lever 1 (SL1)''': An integer state variable that '''modifies the function''' of many mask symbols. It is initialized to 0. SL1 cycles through the values 0, 1, 2, 3. '''Incrementing SL1 from 3 resets it to 0.'''
+* '''Line Pointer (LP)''': An unsigned integer that points to the '''current line of code to be executed'''. It is initialized to 0 and increments by one after each instruction, unless a jump occurs.
+* '''RAM''': A single '''float32 memory slot''' used for temporary storage. It is initialized to 0.0.
+
+== Language Overview ==
+* Memory Model: One brain, 65,536 neurons (cells). Each cell holds a '''float32''', initialized to 0.0.
+* Instruction Model: '''Fixed 3-part line: [line][dir][mask]'''
+* SL1 State: '''Stateful''' modifier that '''alters the meaning''' of mask symbols
+* Execution: '''Sequential''' per line, unless jumped '''via J'''
+* Output: Values are “cast” to cast.bin, one '''line''' per call.
+* One RAM State: Stores a '''float32''' that is initialized to 0.0.
+* Uses <code>.fll</code> as the native '''FLL Program Filetype'''.
+* Has an '''output system''' (outputs to <code>cast.bin</code>)
+
+=== Comments ===
+A comment is denoted by <code>`//`</code>. All text from <code>`//`</code> to the end of the line is '''ignored''' by the '''interpreter'''.
+
+== Instructions ==
+=== [dir] Commands ===
+{| class="wikitable"
+! dir !! Name !! Description
+|-
+| <code>=</code> || Operate || Executes the <code>[mask]</code> surgery on the cell at the current Brain Pointer (<code>Tape[BP]</code>).
+|-
+| <code><</code> || Decrement and Operate || Decrements <code>BP</code> by 1, then executes the <code>[mask]</code> surgery on the new <code>Tape[BP]</code>.
+|-
+| <code>></code> || Increment and Operate || Increments <code>BP</code> by 1, then executes the <code>[mask]</code> surgery on the new <code>Tape[BP]</code>.
+|-
+| <code>$</code> || Cast || Outputs the value of <code>Tape[BP]</code> to an external file named <code>cast.bin</code>. The <code>[mask]</code> is <b>not</b> executed. The output format is: <code>[BP] [Tape[BP]]\n</code>. File is created/truncated on first cast, then appended.
+|-
+| <code>#</code> || Operate and Reset || Executes the <code>[mask]</code> surgery on <code>Tape[BP]</code>, then immediately resets <code>Tape[BP]</code> to <code>0.0</code>.
+|-
+| <code>J</code> || Operate and Jump || Executes the <code>[mask]</code> surgery on <code>Tape[BP]</code>. Then checks if <code>Tape[BP]</code> is exactly <code>1.0</code>. If true, sets <code>LP</code> to this line number, creating a loop.
+|-
+| <code>!</code> || Mask Modifier || Replaces the <code>[mask]</code> in <code>Program[LP]</code> with the current one from this instruction. Does not execute the mask.
+|}
+''`LP` is set to the `[line]` number of the current instruction, causing an effective loop or jump to the same line '''(for [dir] J)'''. If false, execution proceeds to the next line as normal.''
+
+=== [mask] Symbols ===
+The `mask` contains a sequence of '''16 symbols''' that are executed from '''left to right'''. Many symbols are '''context-sensitive''' and change their '''behavior''' based on the current value of `SL1`.
+{| class="wikitable"
+! Symbol !! Name !! SL1=0 !! SL1=1 !! SL1=2 !! SL1=3
+|-
+| <code>~</code> || N-OP || No operation. || (Same) || (Same) || (Same)
+|-
+| <code>@</code> || Swapper || Increments <code>SL1</code> by 1. Resets to 0 after 3. || (Same) || (Same) || (Same)
+|-
+| <code>+</code> || Increment || <code>Tape[BP] += 1.0</code> || <code>Tape[BP] += 0.1</code> || <code>Tape[BP] += 0.01</code> || <code>Tape[BP] += 0.001</code>
+|-
+| <code>-</code> || Decrement || <code>Tape[BP] -= 1.0</code> || <code>Tape[BP] -= 0.1</code> || <code>Tape[BP] -= 0.01</code> || <code>Tape[BP] -= 0.001</code>
+|-
+| <code>*</code> || Multiply || <code>Tape[BP] *= Tape[BP-1]</code> || <code>Tape[BP] *= Tape[BP+1]</code> || (Undefined) || (Undefined)
+|-
+| <code>A</code> || Add || <code>Tape[BP] += Tape[BP-1]</code> || <code>Tape[BP] += Tape[BP+1]</code> || (Undefined) || (Undefined)
+|-
+| <code>D</code> || Divide || <code>Tape[BP] /= Tape[BP-1]</code> || <code>Tape[BP] /= Tape[BP+1]</code> || (Undefined) || (Undefined)
+|-
+| <code>S</code> || Subtract || <code>Tape[BP] -= Tape[BP-1]</code> || <code>Tape[BP] -= Tape[BP+1]</code> || (Undefined) || (Undefined)
+|-
+| <code>&</code> || Get || <code>Tape[BP] = Tape[BP-1]</code> || <code>Tape[BP] = Tape[BP+1]</code> || <code>Tape[BP] = Tape[BP-2]</code> || <code>Tape[BP] = Tape[BP+2]</code>
+|-
+| <code>=</code> || Equals || <code>Tape[BP] = (Tape[BP] == Tape[BP-1]) ? 1.0 : 0.0</code> || <code>Tape[BP] = (Tape[BP] == Tape[BP+1]) ? 1.0 : 0.0</code> || (Undefined) || (Undefined)
+|-
+| <code>></code> || Compare || <code>Tape[BP] = (Tape[BP] > Tape[BP-1]) ? 1.0 : 0.0</code> || <code>Tape[BP] = (Tape[BP] > Tape[BP+1]) ? 1.0 : 0.0</code> || <code>Tape[BP] = (Tape[BP] < Tape[BP-1]) ? 1.0 : 0.0</code> || <code>Tape[BP] = (Tape[BP] < Tape[BP+1]) ? 1.0 : 0.0</code>
+|-
+| <code>^</code> || LP Control || <code>LP += 1</code> || <code>LP -= 1</code> || <code>LP += 2</code> || <code>LP -= 2</code>
+|-
+| <code>;</code> || RAM Store/Load || <code>RAM = Tape[BP]</code> || <code>RAM = Tape[BP-1]</code> || <code>RAM = Tape[BP+2]</code> || <code>Tape[BP] = RAM</code>
+|-
+| <code>:</code> || RAM Set/Clear || <code>Tape[BP-1] = RAM</code> || <code>Tape[BP+1] = RAM</code> || <code>RAM = 0.0</code> || <code>RAM = 1.0</code>
+|-
+| <code>%</code> || Copy || <code>Tape[BP-1] = Tape[BP]</code> || <code>Tape[BP-1] = Tape[BP]</code> || <code>Tape[BP-2] = Tape[BP]</code> || <code>Tape[BP+2] = Tape[BP]</code>
+|}
+''*Note: Operations that reference adjacent tape cells (e.g., `Tape[BP-1]`) are subject to boundary conditions. For instance, `Tape[BP-1]` is only valid if `BP > 0`.*''
+
+== Execution Flow ==
+# Initialize '''Brain Tape, BP, SL1, LP, and RAM''' to their default starting values.
+# The '''interpreter''' begins at the '''instruction specified''' by the '''Line Pointer''' (`LP=0`).
+# The `dir` command of the '''current instruction is evaluated'''. This may involve '''pre-operation modifications''' to `BP`.
+# If the `dir` command '''requires it''', the 16 `mask` symbols are '''executed sequentially from left to right'''.
+# After the `dir` and `mask` operations are '''complete''', '''post-operation actions''' (like value resets or conditional jumps) are '''performed'''.
+# Unless a '''jump''' occurred '''(`J`)''', the `LP` is '''incremented by 1'''.
+# The process '''repeats''' from step 3 with the new `LP`.
+# The program '''halts''' when the `LP` points to a '''line number''' that does not '''exist''' in the '''program source.'''
+
+== Example ==
+<pre>
+// prog.fll - A Small Value Decay Calculation Program
+[0][>][+@+++++~~~~~~@@@]
+[1][>][+@@@-~~~~~~~~~~@]
+[2][<][@*~~~~~~~~~~~@@@]
+[3][$][~~~~~~~~~~~~~~~~]
+</pre>
+
+=== Explanation ===
+We move the '''pointer''' from '''N[0] to N[1] with [>]''', then '''Add 1.0 (SL1-0)''' to it. Then '''Increment to SL1-1''', then '''repeat 5 times of Add''' (which since its SL1-1 = 0.1). Then reset SL1 at the end for '''cleanliness'''. N[1] = 1.5. Then, '''move the pointer''' to N[2], Add 1.0, '''Increment to SL1-3''', then minus (since its SL1-3 then -0.001). So the value of '''N[2] is 0.999.'''
+<br>
+
+'''Compute Step:'''
+</br>
+Move back to '''N[1]''', Now '''Increment''' to SL1-1 (Ahead-Multiply), do '*', so this is basically '''N[1]=N[1]*N[2]'''.
+<br>
+If you did not '''increment SL1 to SL1-1''' (example like SL1-0) - this will multiply the '''previous neuron''' which is,
+</br>
+'''N[1] = N[1] * N[0]'''. Now, we output by using '''"$"'''.
+<br>
+
+'''Saving''': This Saves N[1] with the value of 1.4985.
+</br>
+'''Expected Output''': N[1] = 1.4985
+=== '''Expected Output as cast.bin''' ===
+<br>
+ 1 1.4985
+</br>
+''Note, cast.bin outputs with a structure of '''[Neuron ID] [Neuron Value]'''.''
+
+= Download Tooling =
+[https://drive.google.com/file/d/1utPotfZ4XyPMacthol7mAP1ykC3eshOU/view?usp=sharing Tooling for FLL 1.1.0 (123kb)]
+* <code>fllc.exe</code> converts your <code>.fll</code> programs into a <code>.cpp</code> file. You can '''follow the instructions''' given by <code>fllc.exe</code> and compile it with '''g++ (mingw64 needed!)'''
+* <code>fllcvm.exe</code> runs your <code>.fll</code> programs instantly '''(act as an interpreter)'''
+
+= Frontal Lobe Lobotomy Versions =
+* '''FLL 1.0.0''' ''(unstable)'' - Initial Release
+* '''FLL 1.1.0''' ''(stable)'' - Added new '''[dir] command''' <code>!</code>. Added <code>%</code> as the '''copy symbol'''.
+
+= Future Ideas =
+* Supporting '''x86-based''' machines.
+* Adding the '''Brainstem Surgery''', harder than '''normal frontal lobe lobotomy surgery''' but harder to be '''reverse-engineered'''.
+* Adding '''Input''' system <code>(uncast.bin)</code>
+
+[[Category:2025]] [[Category:Turing complete]] [[Category:Implemented]] [[Category:Cell-based]] [[Category:Low-level]] [[Category:Self-modifying]] [[Category:Languages]]
' |
Lines added in edit (added_lines) | [
0 => '= Frontal Lobe Lobotomy (FLL) =',
1 => ''''Frontal Lobe Lobotomy (1.1.0 COMPILER / 1.2.0 VM => FLL 1.1.0)''' is a '''x86-64''' esoteric programming language inspired by brain surgery metaphors 'Lobotomy'. It uses pointer-addressable neurons and suture levels to represent stateful, context-sensitive operations. It was designed to feel like doing live neurosurgery on a floating-point brain, where execution is done line-by-line with surgical "masks" that manipulate the brain tape.',
2 => '<br> '''Developed by [[User:Creepy]]''' : ''“FLL doesn't just manipulate memory — it performs psychological operations.”'' </br>',
3 => '',
4 => '== Design Goals ==',
5 => '* To create a compact yet Turing-complete language',
6 => '* To blend dark humor with real computation in a small binary',
7 => '',
8 => '== Frontal Lobe Lobotomy Components ==',
9 => '* '''Brain Tape''': A contiguous block of '''65536 memory cells''', indexed from 0 to 65535. Each cell holds a 32-bit floating-point number '''(float32)''' and is initialized to 0.0.',
10 => '* '''Brain Pointer (BP)''': An unsigned integer that holds the index of the currently active cell on the '''Brain Tape'''. It is initialized to 0. Its value can range from 0 to 65535.',
11 => '* '''Suture Lever 1 (SL1)''': An integer state variable that '''modifies the function''' of many mask symbols. It is initialized to 0. SL1 cycles through the values 0, 1, 2, 3. '''Incrementing SL1 from 3 resets it to 0.'''',
12 => '* '''Line Pointer (LP)''': An unsigned integer that points to the '''current line of code to be executed'''. It is initialized to 0 and increments by one after each instruction, unless a jump occurs.',
13 => '* '''RAM''': A single '''float32 memory slot''' used for temporary storage. It is initialized to 0.0.',
14 => '',
15 => '== Language Overview ==',
16 => '* Memory Model: One brain, 65,536 neurons (cells). Each cell holds a '''float32''', initialized to 0.0.',
17 => '* Instruction Model: '''Fixed 3-part line: [line][dir][mask]'''',
18 => '* SL1 State: '''Stateful''' modifier that '''alters the meaning''' of mask symbols',
19 => '* Execution: '''Sequential''' per line, unless jumped '''via J'''',
20 => '* Output: Values are “cast” to cast.bin, one '''line''' per call.',
21 => '* One RAM State: Stores a '''float32''' that is initialized to 0.0.',
22 => '* Uses <code>.fll</code> as the native '''FLL Program Filetype'''.',
23 => '* Has an '''output system''' (outputs to <code>cast.bin</code>)',
24 => '',
25 => '=== Comments ===',
26 => 'A comment is denoted by <code>`//`</code>. All text from <code>`//`</code> to the end of the line is '''ignored''' by the '''interpreter'''.',
27 => '',
28 => '== Instructions ==',
29 => '=== [dir] Commands ===',
30 => '{| class="wikitable"',
31 => '! dir !! Name !! Description',
32 => '|-',
33 => '| <code>=</code> || Operate || Executes the <code>[mask]</code> surgery on the cell at the current Brain Pointer (<code>Tape[BP]</code>).',
34 => '|-',
35 => '| <code><</code> || Decrement and Operate || Decrements <code>BP</code> by 1, then executes the <code>[mask]</code> surgery on the new <code>Tape[BP]</code>.',
36 => '|-',
37 => '| <code>></code> || Increment and Operate || Increments <code>BP</code> by 1, then executes the <code>[mask]</code> surgery on the new <code>Tape[BP]</code>.',
38 => '|-',
39 => '| <code>$</code> || Cast || Outputs the value of <code>Tape[BP]</code> to an external file named <code>cast.bin</code>. The <code>[mask]</code> is <b>not</b> executed. The output format is: <code>[BP] [Tape[BP]]\n</code>. File is created/truncated on first cast, then appended.',
40 => '|-',
41 => '| <code>#</code> || Operate and Reset || Executes the <code>[mask]</code> surgery on <code>Tape[BP]</code>, then immediately resets <code>Tape[BP]</code> to <code>0.0</code>.',
42 => '|-',
43 => '| <code>J</code> || Operate and Jump || Executes the <code>[mask]</code> surgery on <code>Tape[BP]</code>. Then checks if <code>Tape[BP]</code> is exactly <code>1.0</code>. If true, sets <code>LP</code> to this line number, creating a loop.',
44 => '|-',
45 => '| <code>!</code> || Mask Modifier || Replaces the <code>[mask]</code> in <code>Program[LP]</code> with the current one from this instruction. Does not execute the mask.',
46 => '|}',
47 => '''`LP` is set to the `[line]` number of the current instruction, causing an effective loop or jump to the same line '''(for [dir] J)'''. If false, execution proceeds to the next line as normal.''',
48 => '',
49 => '=== [mask] Symbols ===',
50 => 'The `mask` contains a sequence of '''16 symbols''' that are executed from '''left to right'''. Many symbols are '''context-sensitive''' and change their '''behavior''' based on the current value of `SL1`.',
51 => '{| class="wikitable"',
52 => '! Symbol !! Name !! SL1=0 !! SL1=1 !! SL1=2 !! SL1=3',
53 => '|-',
54 => '| <code>~</code> || N-OP || No operation. || (Same) || (Same) || (Same)',
55 => '|-',
56 => '| <code>@</code> || Swapper || Increments <code>SL1</code> by 1. Resets to 0 after 3. || (Same) || (Same) || (Same)',
57 => '|-',
58 => '| <code>+</code> || Increment || <code>Tape[BP] += 1.0</code> || <code>Tape[BP] += 0.1</code> || <code>Tape[BP] += 0.01</code> || <code>Tape[BP] += 0.001</code>',
59 => '|-',
60 => '| <code>-</code> || Decrement || <code>Tape[BP] -= 1.0</code> || <code>Tape[BP] -= 0.1</code> || <code>Tape[BP] -= 0.01</code> || <code>Tape[BP] -= 0.001</code>',
61 => '|-',
62 => '| <code>*</code> || Multiply || <code>Tape[BP] *= Tape[BP-1]</code> || <code>Tape[BP] *= Tape[BP+1]</code> || (Undefined) || (Undefined)',
63 => '|-',
64 => '| <code>A</code> || Add || <code>Tape[BP] += Tape[BP-1]</code> || <code>Tape[BP] += Tape[BP+1]</code> || (Undefined) || (Undefined)',
65 => '|-',
66 => '| <code>D</code> || Divide || <code>Tape[BP] /= Tape[BP-1]</code> || <code>Tape[BP] /= Tape[BP+1]</code> || (Undefined) || (Undefined)',
67 => '|-',
68 => '| <code>S</code> || Subtract || <code>Tape[BP] -= Tape[BP-1]</code> || <code>Tape[BP] -= Tape[BP+1]</code> || (Undefined) || (Undefined)',
69 => '|-',
70 => '| <code>&</code> || Get || <code>Tape[BP] = Tape[BP-1]</code> || <code>Tape[BP] = Tape[BP+1]</code> || <code>Tape[BP] = Tape[BP-2]</code> || <code>Tape[BP] = Tape[BP+2]</code>',
71 => '|-',
72 => '| <code>=</code> || Equals || <code>Tape[BP] = (Tape[BP] == Tape[BP-1]) ? 1.0 : 0.0</code> || <code>Tape[BP] = (Tape[BP] == Tape[BP+1]) ? 1.0 : 0.0</code> || (Undefined) || (Undefined)',
73 => '|-',
74 => '| <code>></code> || Compare || <code>Tape[BP] = (Tape[BP] > Tape[BP-1]) ? 1.0 : 0.0</code> || <code>Tape[BP] = (Tape[BP] > Tape[BP+1]) ? 1.0 : 0.0</code> || <code>Tape[BP] = (Tape[BP] < Tape[BP-1]) ? 1.0 : 0.0</code> || <code>Tape[BP] = (Tape[BP] < Tape[BP+1]) ? 1.0 : 0.0</code>',
75 => '|-',
76 => '| <code>^</code> || LP Control || <code>LP += 1</code> || <code>LP -= 1</code> || <code>LP += 2</code> || <code>LP -= 2</code>',
77 => '|-',
78 => '| <code>;</code> || RAM Store/Load || <code>RAM = Tape[BP]</code> || <code>RAM = Tape[BP-1]</code> || <code>RAM = Tape[BP+2]</code> || <code>Tape[BP] = RAM</code>',
79 => '|-',
80 => '| <code>:</code> || RAM Set/Clear || <code>Tape[BP-1] = RAM</code> || <code>Tape[BP+1] = RAM</code> || <code>RAM = 0.0</code> || <code>RAM = 1.0</code>',
81 => '|-',
82 => '| <code>%</code> || Copy || <code>Tape[BP-1] = Tape[BP]</code> || <code>Tape[BP-1] = Tape[BP]</code> || <code>Tape[BP-2] = Tape[BP]</code> || <code>Tape[BP+2] = Tape[BP]</code>',
83 => '|}',
84 => '''*Note: Operations that reference adjacent tape cells (e.g., `Tape[BP-1]`) are subject to boundary conditions. For instance, `Tape[BP-1]` is only valid if `BP > 0`.*''',
85 => '',
86 => '== Execution Flow ==',
87 => '# Initialize '''Brain Tape, BP, SL1, LP, and RAM''' to their default starting values.',
88 => '# The '''interpreter''' begins at the '''instruction specified''' by the '''Line Pointer''' (`LP=0`).',
89 => '# The `dir` command of the '''current instruction is evaluated'''. This may involve '''pre-operation modifications''' to `BP`.',
90 => '# If the `dir` command '''requires it''', the 16 `mask` symbols are '''executed sequentially from left to right'''.',
91 => '# After the `dir` and `mask` operations are '''complete''', '''post-operation actions''' (like value resets or conditional jumps) are '''performed'''.',
92 => '# Unless a '''jump''' occurred '''(`J`)''', the `LP` is '''incremented by 1'''.',
93 => '# The process '''repeats''' from step 3 with the new `LP`.',
94 => '# The program '''halts''' when the `LP` points to a '''line number''' that does not '''exist''' in the '''program source.'''',
95 => '',
96 => '== Example ==',
97 => '<pre>',
98 => '// prog.fll - A Small Value Decay Calculation Program',
99 => '[0][>][+@+++++~~~~~~@@@]',
100 => '[1][>][+@@@-~~~~~~~~~~@]',
101 => '[2][<][@*~~~~~~~~~~~@@@]',
102 => '[3][$][~~~~~~~~~~~~~~~~]',
103 => '</pre>',
104 => '',
105 => '=== Explanation ===',
106 => 'We move the '''pointer''' from '''N[0] to N[1] with [>]''', then '''Add 1.0 (SL1-0)''' to it. Then '''Increment to SL1-1''', then '''repeat 5 times of Add''' (which since its SL1-1 = 0.1). Then reset SL1 at the end for '''cleanliness'''. N[1] = 1.5. Then, '''move the pointer''' to N[2], Add 1.0, '''Increment to SL1-3''', then minus (since its SL1-3 then -0.001). So the value of '''N[2] is 0.999.'''',
107 => '<br>',
108 => '',
109 => ''''Compute Step:'''',
110 => '</br>',
111 => 'Move back to '''N[1]''', Now '''Increment''' to SL1-1 (Ahead-Multiply), do '*', so this is basically '''N[1]=N[1]*N[2]'''.',
112 => '<br>',
113 => 'If you did not '''increment SL1 to SL1-1''' (example like SL1-0) - this will multiply the '''previous neuron''' which is,',
114 => '</br>',
115 => ''''N[1] = N[1] * N[0]'''. Now, we output by using '''"$"'''.',
116 => '<br>',
117 => '',
118 => ''''Saving''': This Saves N[1] with the value of 1.4985.',
119 => '</br>',
120 => ''''Expected Output''': N[1] = 1.4985',
121 => '=== '''Expected Output as cast.bin''' ===',
122 => '<br>',
123 => ' 1 1.4985',
124 => '</br>',
125 => '''Note, cast.bin outputs with a structure of '''[Neuron ID] [Neuron Value]'''.''',
126 => '',
127 => '= Download Tooling =',
128 => '[https://drive.google.com/file/d/1utPotfZ4XyPMacthol7mAP1ykC3eshOU/view?usp=sharing Tooling for FLL 1.1.0 (123kb)]',
129 => '* <code>fllc.exe</code> converts your <code>.fll</code> programs into a <code>.cpp</code> file. You can '''follow the instructions''' given by <code>fllc.exe</code> and compile it with '''g++ (mingw64 needed!)'''',
130 => '* <code>fllcvm.exe</code> runs your <code>.fll</code> programs instantly '''(act as an interpreter)'''',
131 => '',
132 => '= Frontal Lobe Lobotomy Versions =',
133 => '* '''FLL 1.0.0''' ''(unstable)'' - Initial Release',
134 => '* '''FLL 1.1.0''' ''(stable)'' - Added new '''[dir] command''' <code>!</code>. Added <code>%</code> as the '''copy symbol'''.',
135 => '',
136 => '= Future Ideas =',
137 => '* Supporting '''x86-based''' machines.',
138 => '* Adding the '''Brainstem Surgery''', harder than '''normal frontal lobe lobotomy surgery''' but harder to be '''reverse-engineered'''.',
139 => '* Adding '''Input''' system <code>(uncast.bin)</code>',
140 => '',
141 => '[[Category:2025]] [[Category:Turing complete]] [[Category:Implemented]] [[Category:Cell-based]] [[Category:Low-level]] [[Category:Self-modifying]] [[Category:Languages]]'
] |