Page namespace (page_namespace) | 0 |
Page title (without namespace) (page_title) | 'Fucking Assembly Geniusness' |
Full page title (page_prefixedtitle) | 'Fucking Assembly Geniusness' |
Old content model (old_content_model) | '' |
New content model (new_content_model) | 'wikitext' |
Old page wikitext, before the edit (old_wikitext) | '' |
New page wikitext, after the edit (new_wikitext) | '{{stub}}
{{wrongtitle|title=FAG}}
'''Fucking Assembly Geniusness''' is a [[brainfuck]] extension and esoteric programming language designed by [[User:MiloIzVannoy|MiloIzVannoy]] in 2025. It is designed to be a practical low-level language while retaining the soul-crushing difficulty of its predecessor. The language's name is a humorous backronym chosen in the tradition of esolang naming; it is intended purely for fun and not meant to cause offense.
== Overview ==
FAG is based on brainfuck but introduces several critical features for systems programming:
* Structured loops with <code>break</code>.
* Bitwise operations and shifts.
* A powerful syscall mechanism.
* An instruction repetition prefix.
== Language specification ==
=== Core brainfuck commands ===
The classic 8 commands remain unchanged: <code>> < + - . , [ ]</code>
=== New commands/features ===
==== Instruction Repetition: <code>(code)*hex</code> ====
: Repeats the code inside the parentheses <code>hex</code> times. If only a single instruction needs to be repeated, the parentheses can be omitted: <code>*hexcommand</code>. The prefix <code>*00</code> uses the next four cells as a 32-bit repeat count.
==== Zero Loop: <code>{ code }</code> ====
: A new loop that runs while the current cell is '''equal to zero'''.
==== Loop Break: <code>∞</code> ====
: Breaks out of the innermost loop immediately.
==== Bitwise Operations ====
: All binary operations (AND, OR, XOR, shifts) use the current cell as the first operand and the next cell as the second operand. The result is stored in the current cell. The pointer is not moved by the operation.
: <code>&</code> (AND): <code>*p = *p & *(p+1)</code>
: <code>|</code> (OR): <code>*p = *p | *(p+1)</code>
: <code>^</code> (XOR): <code>*p = *p ^ *(p+1)</code>
: <code>~</code> (NOT): <code>*p = ~*p</code> (Unary operation, uses only the current cell)
: <code>»</code> (Right shift): <code>*p = *p >> *(p+1)</code>
: <code>«</code> (Left shift): <code>*p = *p << *(p+1)</code>
==== System Calls ====
: The output command <code>.</code> is repurposed for syscalls. A syscall is initiated by outputting a sequence of bytes: <code>[arg1] [arg2] ... [argN] [syscall_id] 0x00</code>. The interpreter parses this stream and executes the corresponding system call. The input command <code>,</code> is used to read results from previously invoked syscalls.
== Examples ==
=== Hello World (using syscalls) ===
<pre>
// Write "Hello World!\n" to memory
>+*48 >+*65 >+*6C >+*6C >+*6F >+*20 >+*57 >+*6F >+*72 >+*6C >+*64 >+*21 >+*0A
[<]> // Move pointer to the second byte (start of the string)
[.>] // Output bytes until zero is found
+.>. // Hypothetical syscall sequence: output args + syscall ID 1 + 0
</pre>
== Computational class ==
As a superset of brainfuck, FAG is [[Turing-complete]].
[[Category:Languages]]
[[Category:Brainfuck derivatives]]
[[Category:Low-level]]
[[Category:2025]]' |
Unified diff of changes made by edit (edit_diff) | '@@ -1,0 +1,55 @@
+{{stub}}
+{{wrongtitle|title=FAG}}
+
+'''Fucking Assembly Geniusness''' is a [[brainfuck]] extension and esoteric programming language designed by [[User:MiloIzVannoy|MiloIzVannoy]] in 2025. It is designed to be a practical low-level language while retaining the soul-crushing difficulty of its predecessor. The language's name is a humorous backronym chosen in the tradition of esolang naming; it is intended purely for fun and not meant to cause offense.
+
+== Overview ==
+FAG is based on brainfuck but introduces several critical features for systems programming:
+* Structured loops with <code>break</code>.
+* Bitwise operations and shifts.
+* A powerful syscall mechanism.
+* An instruction repetition prefix.
+
+== Language specification ==
+=== Core brainfuck commands ===
+The classic 8 commands remain unchanged: <code>> < + - . , [ ]</code>
+
+=== New commands/features ===
+==== Instruction Repetition: <code>(code)*hex</code> ====
+: Repeats the code inside the parentheses <code>hex</code> times. If only a single instruction needs to be repeated, the parentheses can be omitted: <code>*hexcommand</code>. The prefix <code>*00</code> uses the next four cells as a 32-bit repeat count.
+
+==== Zero Loop: <code>{ code }</code> ====
+: A new loop that runs while the current cell is '''equal to zero'''.
+
+==== Loop Break: <code>∞</code> ====
+: Breaks out of the innermost loop immediately.
+
+==== Bitwise Operations ====
+: All binary operations (AND, OR, XOR, shifts) use the current cell as the first operand and the next cell as the second operand. The result is stored in the current cell. The pointer is not moved by the operation.
+: <code>&</code> (AND): <code>*p = *p & *(p+1)</code>
+: <code>|</code> (OR): <code>*p = *p | *(p+1)</code>
+: <code>^</code> (XOR): <code>*p = *p ^ *(p+1)</code>
+: <code>~</code> (NOT): <code>*p = ~*p</code> (Unary operation, uses only the current cell)
+: <code>»</code> (Right shift): <code>*p = *p >> *(p+1)</code>
+: <code>«</code> (Left shift): <code>*p = *p << *(p+1)</code>
+
+==== System Calls ====
+: The output command <code>.</code> is repurposed for syscalls. A syscall is initiated by outputting a sequence of bytes: <code>[arg1] [arg2] ... [argN] [syscall_id] 0x00</code>. The interpreter parses this stream and executes the corresponding system call. The input command <code>,</code> is used to read results from previously invoked syscalls.
+
+== Examples ==
+=== Hello World (using syscalls) ===
+<pre>
+// Write "Hello World!\n" to memory
+>+*48 >+*65 >+*6C >+*6C >+*6F >+*20 >+*57 >+*6F >+*72 >+*6C >+*64 >+*21 >+*0A
+[<]> // Move pointer to the second byte (start of the string)
+[.>] // Output bytes until zero is found
++.>. // Hypothetical syscall sequence: output args + syscall ID 1 + 0
+</pre>
+
+== Computational class ==
+As a superset of brainfuck, FAG is [[Turing-complete]].
+
+[[Category:Languages]]
+[[Category:Brainfuck derivatives]]
+[[Category:Low-level]]
+[[Category:2025]]
' |
Lines added in edit (added_lines) | [
0 => '{{stub}}',
1 => '{{wrongtitle|title=FAG}}',
2 => '',
3 => ''''Fucking Assembly Geniusness''' is a [[brainfuck]] extension and esoteric programming language designed by [[User:MiloIzVannoy|MiloIzVannoy]] in 2025. It is designed to be a practical low-level language while retaining the soul-crushing difficulty of its predecessor. The language's name is a humorous backronym chosen in the tradition of esolang naming; it is intended purely for fun and not meant to cause offense.',
4 => '',
5 => '== Overview ==',
6 => 'FAG is based on brainfuck but introduces several critical features for systems programming:',
7 => '* Structured loops with <code>break</code>.',
8 => '* Bitwise operations and shifts.',
9 => '* A powerful syscall mechanism.',
10 => '* An instruction repetition prefix.',
11 => '',
12 => '== Language specification ==',
13 => '=== Core brainfuck commands ===',
14 => 'The classic 8 commands remain unchanged: <code>> < + - . , [ ]</code>',
15 => '',
16 => '=== New commands/features ===',
17 => '==== Instruction Repetition: <code>(code)*hex</code> ====',
18 => ': Repeats the code inside the parentheses <code>hex</code> times. If only a single instruction needs to be repeated, the parentheses can be omitted: <code>*hexcommand</code>. The prefix <code>*00</code> uses the next four cells as a 32-bit repeat count.',
19 => '',
20 => '==== Zero Loop: <code>{ code }</code> ====',
21 => ': A new loop that runs while the current cell is '''equal to zero'''.',
22 => '',
23 => '==== Loop Break: <code>∞</code> ====',
24 => ': Breaks out of the innermost loop immediately.',
25 => '',
26 => '==== Bitwise Operations ====',
27 => ': All binary operations (AND, OR, XOR, shifts) use the current cell as the first operand and the next cell as the second operand. The result is stored in the current cell. The pointer is not moved by the operation.',
28 => ': <code>&</code> (AND): <code>*p = *p & *(p+1)</code>',
29 => ': <code>|</code> (OR): <code>*p = *p | *(p+1)</code>',
30 => ': <code>^</code> (XOR): <code>*p = *p ^ *(p+1)</code>',
31 => ': <code>~</code> (NOT): <code>*p = ~*p</code> (Unary operation, uses only the current cell)',
32 => ': <code>»</code> (Right shift): <code>*p = *p >> *(p+1)</code>',
33 => ': <code>«</code> (Left shift): <code>*p = *p << *(p+1)</code>',
34 => '',
35 => '==== System Calls ====',
36 => ': The output command <code>.</code> is repurposed for syscalls. A syscall is initiated by outputting a sequence of bytes: <code>[arg1] [arg2] ... [argN] [syscall_id] 0x00</code>. The interpreter parses this stream and executes the corresponding system call. The input command <code>,</code> is used to read results from previously invoked syscalls.',
37 => '',
38 => '== Examples ==',
39 => '=== Hello World (using syscalls) ===',
40 => '<pre>',
41 => '// Write "Hello World!\n" to memory',
42 => '>+*48 >+*65 >+*6C >+*6C >+*6F >+*20 >+*57 >+*6F >+*72 >+*6C >+*64 >+*21 >+*0A',
43 => '[<]> // Move pointer to the second byte (start of the string)',
44 => '[.>] // Output bytes until zero is found',
45 => '+.>. // Hypothetical syscall sequence: output args + syscall ID 1 + 0',
46 => '</pre>',
47 => '',
48 => '== Computational class ==',
49 => 'As a superset of brainfuck, FAG is [[Turing-complete]].',
50 => '',
51 => '[[Category:Languages]]',
52 => '[[Category:Brainfuck derivatives]]',
53 => '[[Category:Low-level]]',
54 => '[[Category:2025]]'
] |