!Frontal Lobe Lobotomy
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.
Developed by User:Creepy : “FLL doesn't just manipulate memory — it performs psychological operations.”
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
.fll
as the native FLL Program Filetype. - Has an output system (outputs to
cast.bin
)
Comments
A comment is denoted by `//`
. All text from `//`
to the end of the line is ignored by the interpreter.
Instructions
[dir] Commands
dir | Name | Description |
---|---|---|
= |
Operate | Executes the [mask] surgery on the cell at the current Brain Pointer (Tape[BP] ).
|
< |
Decrement and Operate | Decrements BP by 1, then executes the [mask] surgery on the new Tape[BP] .
|
> |
Increment and Operate | Increments BP by 1, then executes the [mask] surgery on the new Tape[BP] .
|
$ |
Cast | Outputs the value of Tape[BP] to an external file named cast.bin . The [mask] is not executed. The output format is: [BP] [Tape[BP]]\n . File is created/truncated on first cast, then appended.
|
# |
Operate and Reset | Executes the [mask] surgery on Tape[BP] , then immediately resets Tape[BP] to 0.0 .
|
J |
Operate and Jump | Executes the [mask] surgery on Tape[BP] . Then checks if Tape[BP] is exactly 1.0 . If true, sets LP to this line number, creating a loop.
|
! |
Mask Modifier | Replaces the [mask] in Program[LP] 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`.
Symbol | Name | SL1=0 | SL1=1 | SL1=2 | SL1=3 |
---|---|---|---|---|---|
~ |
N-OP | No operation. | (Same) | (Same) | (Same) |
@ |
Swapper | Increments SL1 by 1. Resets to 0 after 3. |
(Same) | (Same) | (Same) |
+ |
Increment | Tape[BP] += 1.0 |
Tape[BP] += 0.1 |
Tape[BP] += 0.01 |
Tape[BP] += 0.001
|
- |
Decrement | Tape[BP] -= 1.0 |
Tape[BP] -= 0.1 |
Tape[BP] -= 0.01 |
Tape[BP] -= 0.001
|
* |
Multiply | Tape[BP] *= Tape[BP-1] |
Tape[BP] *= Tape[BP+1] |
(Undefined) | (Undefined) |
A |
Add | Tape[BP] += Tape[BP-1] |
Tape[BP] += Tape[BP+1] |
(Undefined) | (Undefined) |
D |
Divide | Tape[BP] /= Tape[BP-1] |
Tape[BP] /= Tape[BP+1] |
(Undefined) | (Undefined) |
S |
Subtract | Tape[BP] -= Tape[BP-1] |
Tape[BP] -= Tape[BP+1] |
(Undefined) | (Undefined) |
& |
Get | Tape[BP] = Tape[BP-1] |
Tape[BP] = Tape[BP+1] |
Tape[BP] = Tape[BP-2] |
Tape[BP] = Tape[BP+2]
|
= |
Equals | Tape[BP] = (Tape[BP] == Tape[BP-1]) ? 1.0 : 0.0 |
Tape[BP] = (Tape[BP] == Tape[BP+1]) ? 1.0 : 0.0 |
(Undefined) | (Undefined) |
> |
Compare | Tape[BP] = (Tape[BP] > Tape[BP-1]) ? 1.0 : 0.0 |
Tape[BP] = (Tape[BP] > Tape[BP+1]) ? 1.0 : 0.0 |
Tape[BP] = (Tape[BP] < Tape[BP-1]) ? 1.0 : 0.0 |
Tape[BP] = (Tape[BP] < Tape[BP+1]) ? 1.0 : 0.0
|
^ |
LP Control | LP += 1 |
LP -= 1 |
LP += 2 |
LP -= 2
|
; |
RAM Store/Load | RAM = Tape[BP] |
RAM = Tape[BP-1] |
RAM = Tape[BP+2] |
Tape[BP] = RAM
|
: |
RAM Set/Clear | Tape[BP-1] = RAM |
Tape[BP+1] = RAM |
RAM = 0.0 |
RAM = 1.0
|
% |
Copy | Tape[BP-1] = Tape[BP] |
Tape[BP-1] = Tape[BP] |
Tape[BP-2] = Tape[BP] |
Tape[BP+2] = Tape[BP]
|
*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
// prog.fll - A Small Value Decay Calculation Program [0][>][+@+++++~~~~~~@@@] [1][>][+@@@-~~~~~~~~~~@] [2][<][@*~~~~~~~~~~~@@@] [3][$][~~~~~~~~~~~~~~~~]
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.
Compute Step:
Move back to N[1], Now Increment to SL1-1 (Ahead-Multiply), do '*', so this is basically N[1]=N[1]*N[2].
If you did not increment SL1 to SL1-1 (example like SL1-0) - this will multiply the previous neuron which is,
N[1] = N[1] * N[0]. Now, we output by using "$".
Saving: This Saves N[1] with the value of 1.4985.
Expected Output: N[1] = 1.4985
Expected Output as cast.bin
1 1.4985
Note, cast.bin outputs with a structure of [Neuron ID] [Neuron Value].
Download Tooling
Tooling for FLL 1.1.0 (123kb, Queued to be Reviewed by Google)
Tooling for FLL 1.1.0 (123kb, Alternative Download)
C++ Source Code for FLL-VM
fllc.exe
converts your.fll
programs into a.cpp
file. You can follow the instructions given byfllc.exe
and compile it with g++ (mingw64 needed!)fllcvm.exe
runs your.fll
programs instantly (act as an interpreter)fllcvm.cpp
can be compiled into fllcvm.exe using g++ (mingw64).
Frontal Lobe Lobotomy Versions
- FLL 1.0.0 (unstable) - Initial Release
- FLL 1.1.0 (stable) - Added new [dir] command
!
. Added%
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
(uncast.bin)