Extension</th>	Reason</th></tr></thead>
`ctype, iconv, json, tokenizer, xml</code></td>`	`composer check-platform-reqs</code> output</td></tr>`
`filter</code></td>`	used in `Symfony\Component\Runtime</code></td></tr>`
`mbstring</code></td>`	used in Symfony\Component\Console</code></td></tr> </tbody></table> Note: json</code> is always compiled into PHP 8+ and does not need to be listed in PHP_EXTENSIONS</code>.</p> Build and extract the standalone binary</h2> Build:</p> docker</span> build</span> -</span>t</span> hello-world-app</span> -</span>f</span> static-build.Dockerfile</span> .</span></span></code></pre> Copy the binary out of the container:</p> docker</span> cp</span> $(</span>docker</span> create</span> -</span>-name</span> hello-world-tmp</span> hello-world-app</span>)</span>:/go/src/app/dist/frankenphp-linux-x86_64</span> ./hello-world</span></span> docker</span> rm</span> hello-world-tmp</span></span></code></pre>Notes on the copy step</h3> docker create --name hello-world-tmp hello-world-app</code>: creates a container from the hello-world-app</code> image without starting it. If you re-run this step, remove the container first: docker rm hello-world-tmp</code>.</li> $(...)</code>: command substitution; the output of docker create</code> (the container ID) is passed directly to docker cp</code>.</li> docker cp <container>:/go/src/app/dist/frankenphp-linux-x86_64 ./hello-world</code>: copies the binary out of the container.</li> </ul> Run the Standalone Binary</h2> ./hello-world</span> php-cli</span> bin/console</span> app:hello-world</span></span></code></pre> php-cli</code> is the FrankenPHP subcommand that invokes the embedded PHP CLI interpreter. Everything after it is passed to PHP as a script.</p>

Elfennol - Blog

Why Rust Replaced Null with Option

2026-07-04T00:00:00+00:00

Rust has no null. It uses an enum instead: Option</code>. Is it 100% better, 100% safe, 100% secure, 100% (insert your most memorable buzzword here)? OK, stop. WHY?

The core idea: Option</code> forces you to handle the absence of a value at compile time, instead of discovering it as a crash at runtime.

Full disclosure, though:

let</span> foo</span>:</span> Option</span><</span>i32</span>></span> =</span> None</span>;</span></span>
foo</span>.</span>unwrap</span>(</span>)</span>;</span></span>
//</span> or foo.expect("foo is Some"); both panic at runtime</span></span></code></pre>

Compilation: ✅ success</li>
Execution: ❌ failed</li>
</ul>
Oops. unwrap</code> and expect</code> bypass the guarantee. Treat them as code smells, not everyday tools. A linter can flag them. The sections below show the right way.</p>
What is Rust's Option type?</h2>
Option</code> is defined by:</p>
enum</span> Option</span><</span>T</span>></span> {</span></span>
    None</span>,</span></span>
    Some</span>(</span>T</span>)</span>,</span></span>
}</span></span></code></pre>
Simple.</p>
Why use Option?</h2>
An example:</p>
struct</span> Product</span> {</span></span>
    name</span>:</span> String</span>,</span></span>
    image</span>:</span> Option</span><</span>String</span>></span></span>
}</span></span>
</span>
let</span> foo</span> =</span> Product</span> {</span></span>
    name</span>:</span> "</span>Foo</span>"</span>.</span>to_string</span>(</span>)</span>,</span></span>
    image</span>:</span> None</span>,</span></span>
}</span>;</span></span>
</span>
//</span> The trait `std::fmt::Display`</span></span>
//</span> is not implemented for `Option<String>`</span></span>
println!</span>(</span>"</span>{</span>}</span> {</span>}</span>"</span>,</span> foo</span>.</span>name</span>,</span> foo</span>.</span>image</span>)</span>;</span></span></code></pre>

Compilation: ❌ failed</li>
</ul>
Consider an optional value (say, user input) that passes through several layers before reaching a function that accepts no optional types. If the language uses null</code>, the program crashes at runtime; the compiler has no way to distinguish a value from null. With a typed optional instead, the compiler catches the mismatch before the program runs. That single scenario justifies Option</code>.</p>
Get the value</h2>
The match</code> statement forces you to handle all cases:</p>
match</span> foo</span> {</span></span>
    Some</span>(</span>value</span>)</span> =></span> println!</span>(</span>"</span>{</span>value</span>}</span>"</span>)</span>,</span></span>
    None</span> =></span> println!</span>(</span>"</span>no value</span>"</span>)</span>,</span></span>
}</span></span></code></pre>
For a default fallback, use unwrap_or(default)</code> or unwrap_or_else(|| ...)</code>.</p>
To run code only when the value exists:</p>
if</span> let</span> Some</span>(</span>value</span>)</span> =</span> foo</span> {</span></span>
    println!</span>(</span>"</span>{</span>value</span>}</span>"</span>)</span>;</span></span>
}</span></span></code></pre>
In all three cases, you make a deliberate choice: the compiler prevents you from using an Option<T></code> as a plain T</code> without addressing the absent case first.</p>
Synergy with the borrow checker</h2>
What follows goes a step further and is a bit more complex. Some knowledge of C and Rust is helpful.</p>
Let's look at the "copy, then set to null" problem.</p>
C language</h3>
The problem is a trap in C:</p>
#</span>include</span> <</span>stdio.h</span>></span></span>
#</span>include</span> <</span>stdlib.h</span>></span></span>
#</span>include</span> <</span>string.h</span>></span></span>
</span>
struct</span> Hero </span>{</span></span>
    char</span>*</span> name</span>;</span></span>
    //</span> May be NULL if there is no weapon</span></span>
    char</span>*</span> weapon</span>;</span></span>
}</span>;</span></span>
</span>
//</span> Function that “takes” the weapon by setting it to NULL</span></span>
char</span>*</span> take_weapon</span>(</span>struct</span> Hero</span>*</span> hero</span>)</span> {</span></span>
    //</span> 1. We copy the pointer</span></span>
    char</span>*</span> weapon_copy </span>=</span> hero</span>-></span>weapon</span>;</span></span>
    //</span> 2. We set the original to NULL</span></span>
    hero</span>-></span>weapon</span> =</span> NULL</span>;</span></span>
    //</span> 3. We return the copy</span></span>
    return</span> weapon_copy</span>;</span></span>
}</span></span>
</span>
int</span> main</span>(</span>)</span> {</span></span>
    //</span> 1. Bob is created with his weapon</span></span>
    struct</span> Hero bob</span>;</span></span>
    bob</span>.</span>name</span> =</span> "</span>Bob</span>"</span>;</span></span>
    bob</span>.</span>weapon</span> =</span> malloc</span>(</span>20</span>)</span>;</span></span>
    strcpy</span>(</span>bob</span>.</span>weapon</span>,</span> "</span>sword</span>"</span>)</span>;</span></span>
</span>
    //</span> 2. Another module in the game</span></span>
    //</span> (e.g., the inventory display system)</span></span>
    //</span> Keeps a reference to this weapon,</span></span>
    //</span> so it knows what to display on the screen.</span></span>
    char</span>*</span> weapon_inventory </span>=</span> bob</span>.</span>weapon</span>;</span></span>
</span>
    //</span> 3. Later, Bob is disarmed.</span></span>
    //</span> The code uses our function</span></span>
    //</span> and properly sets the pointer to NULL.</span></span>
    char</span>*</span> lost_weapon </span>=</span> take_weapon</span>(</span>&</span>bob</span>)</span>;</span></span>
</span>
    //</span> 4. The weapon is dropped on the ground and destroyed</span></span>
    //</span> (released from memory)</span></span>
    free</span>(</span>lost_weapon</span>)</span>;</span></span>
</span>
    //</span> 5. ❌ Undefined behavior</span></span>
    //</span> because weapon_inventory is still pointing to the freed memory</span></span>
    printf</span>(</span>"</span>%s</span>\n</span>"</span>,</span> weapon_inventory</span>)</span>;</span></span>
}</span></span></code></pre>Rust language</h3>
First version</h4>
struct</span> Hero</span> {</span></span>
    name</span>:</span> String</span>,</span></span>
    weapon</span>:</span> String</span>,</span></span>
}</span></span>
</span>
fn</span> take_weapon</span>(</span>hero</span>:</span> &</span>mut</span> Hero</span>)</span> -></span> String</span> {</span></span>
    let</span> lost_weapon</span> =</span> hero</span>.</span>weapon</span>;</span></span>
    hero</span>.</span>weapon </span>=</span> String</span>::</span>new</span>(</span>)</span>;</span></span>
</span>
    lost_weapon</span></span>
}</span></span>
</span>
//</span> ...</span></span></code></pre>

Compilation: ❌ failed</li>
</ul>
Unlike in C, let lost_weapon = hero.weapon;</code> is not a copy, but a move. But you can't transfer ownership of something you don't own: the function just borrows hero</code> (&mut Hero</code>).</p>
We can work around this with a function that takes ownership:</p>
fn</span> take_weapon</span>(</span>mut</span> hero</span>:</span> Hero</span>)</span> -></span> (</span>Hero</span>,</span> String</span>)</span> {</span></span>
    let</span> lost_weapon</span> =</span> hero</span>.</span>weapon</span>;</span></span>
    hero</span>.</span>weapon </span>=</span> String</span>::</span>new</span>(</span>)</span>;</span></span>
</span>
    (</span>hero</span>,</span> lost_weapon</span>)</span></span>
}</span></span></code></pre>
But in this case:</p>

You introduce a sentinel value to detect the absence of a weapon (if hero.weapon == ""</code>).</li>
You lose flexibility. Imagine your Hero</code> is stored in a Vec<Hero></code>: you'd have to remove it from the Vec, take the weapon, then put it back.</li>
</ul>
Second version</h4>
struct</span> Hero</span> {</span></span>
    name</span>:</span> String</span>,</span></span>
    weapon</span>:</span> Option</span><</span>String</span>></span>,</span></span>
}</span></span>
</span>
impl</span> Hero</span> {</span></span>
    fn</span> take_weapon</span>(</span>&</span>mut</span> self</span>)</span> -></span> Option</span><</span>String</span>></span> {</span></span>
        //</span> take() sets the value to None</span></span>
        //</span> and returns the original value</span></span>
        self</span>.</span>weapon</span>.</span>take</span>(</span>)</span></span>
    }</span></span>
}</span></span></code></pre>
self.weapon.take()</code> sets the value to None</code> and returns the original in a single operation, so self</code> is never in an inconsistent state. self.weapon</code> is still an Option<String></code>.</p>
Let's mirror the C scenario in Rust:</p>
fn</span> main</span>(</span>)</span> {</span></span>
    let</span> mut</span> bob</span> =</span> Hero</span> {</span></span>
        name</span>:</span> "</span>Bob</span>"</span>.</span>to_string</span>(</span>)</span>,</span></span>
        weapon</span>:</span> Some</span>(</span>"</span>sword</span>"</span>.</span>to_string</span>(</span>)</span>)</span>,</span></span>
    }</span>;</span></span>
</span>
    let</span> weapon_inventory</span> =</span> bob</span>.</span>weapon</span>.</span>as_deref</span>(</span>)</span>;</span></span>
</span>
    //</span> ❌ Compile error: cannot borrow `bob` as mutable</span></span>
    //</span> because it is also borrowed as immutable,</span></span>
    //</span> see `println!("{:?}", weapon_inventory)`</span></span>
    let</span> lost_weapon</span> =</span> bob</span>.</span>take_weapon</span>(</span>)</span>;</span></span>
</span>
    //</span> This line has no consequence here;</span></span>
    //</span> it's just to get closer to the C code.</span></span>
    drop</span>(</span>lost_weapon</span>)</span>;</span></span>
</span>
    println!</span>(</span>"</span>{</span>:?</span>}</span>"</span>,</span> weapon_inventory</span>)</span>;</span></span>
}</span></span></code></pre>

Compilation: ❌ failed</li>
</ul>
Good news: the Rust compiler does not allow this.</p>
To share weapon access across multiple owners, we need interior mutability:</p>
use</span> std</span>::</span>cell</span>::</span>RefCell</span>;</span></span>
</span>
type</span> SharedWeapon</span><</span>'</span>a</span>></span> =</span> &</span>'</span>a</span> RefCell</span><</span>Option</span><</span>String</span>></span>></span>;</span></span>
</span>
struct</span> Hero</span><</span>'</span>a</span>></span> {</span></span>
    name</span>:</span> String</span>,</span></span>
    weapon</span>:</span> SharedWeapon</span><</span>'</span>a</span>></span>,</span></span>
}</span></span>
</span>
fn</span> take_weapon</span>(</span>hero</span>:</span> &</span>Hero</span>)</span> -></span> Option</span><</span>String</span>></span> {</span></span>
    hero</span>.</span>weapon</span>.</span>borrow_mut</span>(</span>)</span>.</span>take</span>(</span>)</span></span>
}</span></span>
</span>
fn</span> main</span>(</span>)</span> {</span></span>
    let</span> shared_weapon_source</span> =</span> RefCell</span>::</span>new</span>(</span>Some</span>(</span>"</span>sword</span>"</span>.</span>to_string</span>(</span>)</span>)</span>)</span>;</span></span>
</span>
    let</span> bob</span> =</span> Hero</span> {</span></span>
        name</span>:</span> "</span>Bob</span>"</span>.</span>to_string</span>(</span>)</span>,</span></span>
        weapon</span>:</span> &</span>shared_weapon_source</span>,</span></span>
    }</span>;</span></span>
</span>
    let</span> weapon_inventory</span>:</span> SharedWeapon</span> =</span> &</span>shared_weapon_source</span>;</span></span>
</span>
    let</span> lost_weapon</span> =</span> take_weapon</span>(</span>&</span>bob</span>)</span>;</span></span>
</span>
    drop</span>(</span>lost_weapon</span>)</span>;</span></span>
</span>
    //</span> 5. ✅ No undefined behaviour</span></span>
    println!</span>(</span>"</span>The inventory displays: </span>{</span>:?</span>}</span>"</span>,</span> weapon_inventory</span>.</span>borrow</span>(</span>)</span>)</span>;</span></span>
    //</span> Display: The inventory displays: None</span></span>
}</span></span></code></pre>
RefCell</code> "works," but it trades compile-time safety for runtime panics: the very problem we started with. A better design avoids shared references entirely. Rust-based game engines have developed patterns for this. Here is one clean approach:</p>
struct</span> Hero</span> {</span></span>
    name</span>:</span> String</span>,</span></span>
    weapon</span>:</span> Option</span><</span>String</span>></span>,</span></span>
}</span></span>
</span>
struct</span> Inventory</span> {</span></span>
    items</span>:</span> Vec</span><</span>String</span>></span>,</span></span>
}</span></span>
</span>
impl</span> Hero</span> {</span></span>
    fn</span> take_weapon</span>(</span>&</span>mut</span> self</span>)</span> -></span> Option</span><</span>String</span>></span> {</span></span>
        self</span>.</span>weapon</span>.</span>take</span>(</span>)</span></span>
    }</span></span>
}</span></span>
</span>
fn</span> main</span>(</span>)</span> {</span></span>
    let</span> mut</span> bob</span> =</span> Hero</span> {</span></span>
        name</span>:</span> "</span>Bob</span>"</span>.</span>to_string</span>(</span>)</span>,</span></span>
        weapon</span>:</span> Some</span>(</span>"</span>sword</span>"</span>.</span>to_string</span>(</span>)</span>)</span>,</span></span>
    }</span>;</span></span>
</span>
    let</span> mut</span> inventory</span> =</span> Inventory</span> {</span> items</span>:</span> vec!</span>[</span>]</span> }</span>;</span></span>
</span>
    //</span> The hero drops his weapon and places it in his inventory.</span></span>
    if</span> let</span> Some</span>(</span>weapon</span>)</span> =</span> bob</span>.</span>take_weapon</span>(</span>)</span> {</span></span>
        inventory</span>.</span>items</span>.</span>push</span>(</span>weapon</span>)</span>;</span></span>
    }</span></span>
</span>
    println!</span>(</span>"</span>{</span>:?</span>}</span>"</span>,</span> bob</span>.</span>weapon</span>)</span>;</span>      //</span> None</span></span>
    println!</span>(</span>"</span>{</span>:?</span>}</span>"</span>,</span> inventory</span>.</span>items</span>)</span>;</span> //</span> ["sword"]</span></span>
}</span></span></code></pre>Porting Option to another language</h2>
PHP has no built-in Option</code> type, so we'll build one.</p>
First creation attempt</h3>
interface</span> Option</span></span>
{</span></span>
    public</span> function</span> isSome</span>(</span>)</span>:</span> bool</span>;</span></span>
</span>
    public</span> function</span> isNone</span>(</span>)</span>:</span> bool</span>;</span></span>
</span>
    public</span> function</span> unwrap</span>(</span>)</span>:</span> mixed</span>;</span></span>
</span>
    public</span> function</span> unwrapOr</span>(</span>mixed</span> $</span>default</span>)</span>:</span> mixed</span>;</span></span>
}</span></span></code></pre>
Too many mixed</code> types make it clunky.</p>
Second creation attempt</h3>
interface</span> Option</span><T></span></span>
{</span></span>
    public</span> function</span> isSome</span>(</span>)</span>:</span> bool</span>;</span></span>
</span>
    public</span> function</span> isNone</span>(</span>)</span>:</span> bool</span>;</span></span>
</span>
    public</span> function</span> unwrap</span>(</span>)</span>:</span> T</span>;</span></span>
</span>
    public</span> function</span> unwrapOr</span>(</span>T</span> $</span>default</span>)</span>:</span> T</span>;</span></span>
}</span></span></code></pre>
Yes, you can't do that in PHP.</p>
Third creation attempt</h3>
/**</span> @template T </span>*/</span></span>
interface</span> Option</span></span>
{</span></span>
    public</span> function</span> isSome</span>(</span>)</span>:</span> bool</span>;</span></span>
</span>
    public</span> function</span> isNone</span>(</span>)</span>:</span> bool</span>;</span></span>
</span>
    /**</span> @return</span> T</span> */</span></span>
    public</span> function</span> unwrap</span>(</span>)</span>:</span> mixed</span>;</span></span>
</span>
    /**</span></span>
     * </span>@param</span> T</span> $default</span></span>
     *</span></span>
     * </span>@return</span> T</span></span>
     */</span></span>
    public</span> function</span> unwrapOr</span>(</span>mixed</span> $</span>default</span>)</span>:</span> mixed</span>;</span></span>
}</span></span></code></pre>
Generics can be emulated using the annotation @template</code>. We can use PHPStan to validate the use of this annotation. A good IDE like PhpStorm supports these annotations and offers autocompletion for these types.</p>
We need Some</code> and None</code>, which we will define now:</p>
/**</span></span>
 * @template T</span></span>
 * @implements Option<T></span></span>
 */</span></span>
readonly</span> class</span> Some</span> implements</span> Option</span></span>
{</span></span>
    /**</span> @param</span> T</span> $value </span>*/</span></span>
    public</span> function</span> __construct</span>(</span></span>
        private</span> mixed</span> $</span>value</span></span>
    )</span> {</span></span>
    }</span></span>
</span>
    public</span> function</span> isSome</span>(</span>)</span>:</span> bool</span></span>
    {</span></span>
        return</span> true</span>;</span></span>
    }</span></span>
</span>
    public</span> function</span> isNone</span>(</span>)</span>:</span> bool</span></span>
    {</span></span>
        return</span> false</span>;</span></span>
    }</span></span>
</span>
    public</span> function</span> unwrap</span>(</span>)</span>:</span> mixed</span></span>
    {</span></span>
        return</span> $</span>this</span>-></span>value</span>;</span></span>
    }</span></span>
</span>
    public</span> function</span> unwrapOr</span>(</span>mixed</span> $</span>default</span>)</span>:</span> mixed</span></span>
    {</span></span>
        return</span> $</span>this</span>-></span>unwrap</span>(</span>)</span>;</span></span>
    }</span></span>
}</span></span></code></pre>/**</span></span>
 * @implements Option<mixed></span></span>
 */</span></span>
readonly</span> class</span> None</span> implements</span> Option</span></span>
{</span></span>
    public</span> function</span> isSome</span>(</span>)</span>:</span> bool</span></span>
    {</span></span>
        return</span> false</span>;</span></span>
    }</span></span>
</span>
    public</span> function</span> isNone</span>(</span>)</span>:</span> bool</span></span>
    {</span></span>
        return</span> true</span>;</span></span>
    }</span></span>
</span>
    public</span> function</span> unwrap</span>(</span>)</span>:</span> never</span></span>
    {</span></span>
        throw</span> new</span> Exception</span>(</span>'</span>Attempt to call unwrap() on None value</span>'</span>)</span>;</span></span>
    }</span></span>
</span>
    public</span> function</span> unwrapOr</span>(</span>mixed</span> $</span>default</span>)</span>:</span> mixed</span></span>
    {</span></span>
        return</span> $</span>default</span>;</span></span>
    }</span></span>
}</span></span></code></pre>In practice</h3>
readonly</span> class</span> Image</span></span>
{</span></span>
    public</span> function</span> __construct</span>(</span>public</span> string</span> $</span>url</span>)</span> {</span>}</span></span>
}</span></span>
</span>
readonly</span> class</span> Product</span></span>
{</span></span>
    /**</span> @param</span> Option</span><</span>Image</span>></span> $image </span>*/</span></span>
    public</span> function</span> __construct</span>(</span></span>
        public</span> string</span> $</span>name</span>,</span></span>
        public</span> Option</span> $</span>image</span></span>
    )</span> {</span></span>
    }</span></span>
}</span></span></code></pre>
PHP is not a compiled language, but PHPStan enforces correct Option</code> usage before execution. We get the type-safety benefits described in Why use Option?</a>.</p>
We also get IDE autocompletion. If $image</code> is a Some<Image></code> in Product</code>, writing $product->image->unwrapOr(new Image('/default.jpg'))-></code> surfaces url</code> as a completion in PhpStorm. If you pass an argument of the wrong type to unwrapOr</code>, PHPStan will flag it.</p>
The pattern ports cleanly. Whatever language you work in, wrapping optional values in a dedicated type (enforced by the compiler or a static analyser) eliminates an entire category of null-related bugs before the program ever runs. That is the real argument for Option</code>.</p>

The Dark Truth About Gods and Souls 2026-07-02T00:00:00+00:00 A small warning: these are a few wandering thoughts on death in the Forgotten Realms setting, and therefore my own interpretation. If you scour the bookshelves in Baldur's Gate 3, you might stumble upon a book called On Death & Resurrection. One line particularly draws attention: Lord Kelemvor weighing our souls against how thoroughly we have given them over to other gods, empowering them in turn. </blockquote> Gods seem to fuel themselves with souls like a battery. When a mortal dies, their soul goes to the Fugue Plane, Kelemvor's home plane. From there, the soul is usually picked up by the god they worshipped in life. Once a soul reaches its god’s divine realm, that soul becomes a Petitioner. The mere presence of these souls in a god's realm, combined with their ongoing belief and essence, provides the divine spark that keeps the god powerful. We can imagine most gods let souls live on in a peaceful afterlife. The soul isn't destroyed, but its energy is merged into the fabric of the god’s realm. The gods look a bit like villains. Even the kind gods agreed to this system. And if a mortal didn't pick a god to worship, their soul was plastered into a literal wall around the City of Judgment to slowly dissolve into nothingness. The Wall is the enforcement mechanism of the system; it ensures that mortal fear of non-existence compels them to pledge their souls to a divine owner. If everyone stopped believing in a god tomorrow, that god would literally shrink, lose their immortality, and eventually become a floating corpse in the Astral Plane. This makes the gods dependent parasites on mortal existence. Or does this make gods superpredators? They seem to protect the world not necessarily out of pure love, but because the world is the farm where they grow their power. But if the gods didn't have soul-fuel to maintain their power, the infinite hordes of Demons and Devils would have won a long time ago. Using souls is also the price of keeping the universe from collapsing into primordial chaos. In the Forgotten Realms, immortality seems an illusion. Even if you go to a good heaven, your individuality has an expiration date. When a soul reaches the realm of their god, they become a Petitioner. They look like they did in life (usually at their best), and they live in a paradise or a realm that matches their deity's nature. Over time, the soul slowly loses its memories of its mortal life. You forget your name, your family, and your favorite meal. You become a pure version of that god's alignment. Eventually, a soul reaches a point of total peace or total exhaustion. At this stage, the soul dissolves and merges into the literal fabric of the divine plane itself. If you are in the realm of the God of Nature, you might literally become a part of the wind or a tree. This is how the divine battery actually works: the god absorbs your essence to maintain their realm's existence. The soul is gone, but its energy keeps the heaven or hell standing. There are surely plenty of exceptions. Druid souls? Elven souls? If souls dissolve, what then creates new souls? There is the Positive Energy Plane. A place of pure, blinding creation, it constantly sheds tiny fragments of pure life force. These fragments float down through the layers of the multiverse and eventually find their way to the Material Plane (the world of mortals). When a new life is conceived (whether it’s a human, an elf, or even a squirrel), one of these sparks of energy attaches to the physical body. That spark becomes a soul. Let's play at being a great scholar and break down the journey of a soul: Creation: Pure energy leaves the Positive Energy Plane.</li> Incarnation: The energy becomes a soul in a mortal body.</li> Experience: The soul grows and shapes itself through life, choices, and worship.</li> Transition: Upon death, the soul goes to the Fugue Plane.</li> Fueling: The soul goes to a god's realm (not always, but let's keep it simple), providing power through its essence.</li> Dissolution: The soul finally breaks down and merges with the planes.</li> Entropy: Part of the remaining energy eventually drifts to the Negative Energy Plane, completing the cycle.</li> </ul> If souls lived forever and never dissolved, the planes would eventually get so crowded and powerful that they would expand and destroy the world of mortals. By making souls dissolvable, the energy is eventually dissipated. The planes stay the same size, the gods stay at a certain power level, and there is always room for new souls to be born. That might be why Jergal talks about "balance" in BG3. There is a similarity with the lore of Pillars of Eternity, which also speaks of a cycle of souls. In Pillars of Eternity (Eora): The journey of souls is a process governed by machines.</li> The gods are Artificial Intelligences (built from hundreds of thousands of sacrificed souls)</li> When you die, your soul goes to the Adra (the green glowing pillars) to be scrubbed clean of memories and sent back down. The gods siphon off fragments of souls during the soul's transit through the Beyond. To what extent? Is it a slow-burning fire like Dark Souls?</li> </ul> In the Forgotten Realms: The journey of souls is a process governed by natural cosmic law. The Positive Energy Plane is an infinite energy source. The Negative Energy Plane is a bottomless pit.</li> The gods are ancient powers.</li> The scrubbing happens on the planes. Instead of being sent back down to a new body, you are consumed (yes, not always).</li> </ul> Both games ask the player the same terrifying question: If you know that your soul is just fuel or recyclable material, does your life still have meaning? Build a Standalone Binary from a Symfony App with FrankenPHP 2026-07-01T00:00:00+00:00 If we want a self-contained binary, we would normally reach for a language like Go or Rust. But with FrankenPHP's static builder, we can package a Symfony CLI application into a standalone binary. No PHP runtime required on the target machine. This guide produces a binary for Linux; other target operating systems will require adjustments. Steps: Create a Symfony CLI app</li> Create the Dockerfile</li> Build and extract the standalone binary</li> Run the standalone binary</li> </ol> Create a Symfony CLI app</h2> symfony new hello-world --version="7.4.*" cd hello-world/ composer require --dev symfony/maker-bundle bin/console make:command app:hello-world bin/console app:hello-world</code></pre>Create the Dockerfile</h2> Create a static-build.Dockerfile</code> file: # https://frankenphp.dev/docs/embed/ FROM php:8.2-cli AS prepare COPY --from=composer:latest /usr/bin/composer /usr/bin/composer WORKDIR /app COPY . . ENV APP_ENV=prod APP_DEBUG=0 RUN composer install --ignore-platform-reqs --no-dev -a && \ composer dump-env prod FROM dunglas/frankenphp:static-builder-gnu WORKDIR /go/src/app/dist/app COPY --from=prepare /app . WORKDIR /go/src/app/ RUN EMBED=dist/app/ \ PHP_EXTENSIONS="ctype,iconv,filter,tokenizer,mbstring,xml" \ ./build-static.sh</code></pre>Dockerfile notes</h3> COPY . .</code>: Yes, we need a .dockerignore</code>. An example:</li> </ul> .git .env.local .env.*.local .env.dev /vendor/ /var/</code></pre> --ignore-platform-reqs</code>: The php:8.2-cli</code> Docker image may not have all the PHP extensions.</li> APP_ENV=prod</code>, APP_DEBUG=0</code>: APP_ENV=prod</code> sets the Symfony environment to production; APP_DEBUG=0</code> disables debug mode. Both affect how Symfony behaves when running composer post-install scripts like cache:clear</code>. See Deployment: clear your Symfony Cache</a>.</li> PHP_EXTENSIONS</code>:</li> </ul> Extension</th> Reason</th></tr></thead> ctype, iconv, json, tokenizer, xml</code></td> composer check-platform-reqs</code> output</td></tr> filter</code></td> used in Symfony\Component\Runtime</code></td></tr> mbstring</code></td> used in Symfony\Component\Console</code></td></tr> </tbody></table> Note: json</code> is always compiled into PHP 8+ and does not need to be listed in PHP_EXTENSIONS</code>. Build and extract the standalone binary</h2> Build: docker build -t hello-world-app -f static-build.Dockerfile .</code></pre> Copy the binary out of the container: docker cp $(docker create --name hello-world-tmp hello-world-app):/go/src/app/dist/frankenphp-linux-x86_64 ./hello-world docker rm hello-world-tmp</code></pre>Notes on the copy step</h3> docker create --name hello-world-tmp hello-world-app</code>: creates a container from the hello-world-app</code> image without starting it. If you re-run this step, remove the container first: docker rm hello-world-tmp</code>.</li> $(...)</code>: command substitution; the output of docker create</code> (the container ID) is passed directly to docker cp</code>.</li> docker cp <container>:/go/src/app/dist/frankenphp-linux-x86_64 ./hello-world</code>: copies the binary out of the container.</li> </ul> Run the Standalone Binary</h2> ./hello-world php-cli bin/console app:hello-world</code></pre> php-cli</code> is the FrankenPHP subcommand that invokes the embedded PHP CLI interpreter. Everything after it is passed to PHP as a script.

Run the Standalone Binary</h2>
`./hello-world</span> php-cli</span> bin/console</span> app:hello-world</span></span></code></pre> php-cli</code> is the FrankenPHP subcommand that invokes the embedded PHP CLI interpreter. Everything after it is passed to PHP as a script.</p>`

Elfennol - Blog

Why Rust Replaced Null with Option

Rust language</h3>

Porting Option to another language</h2>
PHP has no built-in `Option</code> type, so we'll build one.</p>`

The Dark Truth About Gods and Souls

Build a Standalone Binary from a Symfony App with FrankenPHP

Elfennol - Blog

Why Rust Replaced Null with Option

Rust language</h3>

Porting Option to another language</h2> PHP has no built-in Option</code> type, so we'll build one.</p>

The Dark Truth About Gods and Souls

Build a Standalone Binary from a Symfony App with FrankenPHP

Create the Dockerfile</h2> Create a static-build.Dockerfile</code> file:</p>

Run the Standalone Binary</h2> ./hello-world</span> php-cli</span> bin/console</span> app:hello-world</span></span></code></pre> php-cli</code> is the FrankenPHP subcommand that invokes the embedded PHP CLI interpreter. Everything after it is passed to PHP as a script.</p>

Porting Option to another language</h2>
PHP has no built-in `Option</code> type, so we'll build one.</p>`

Run the Standalone Binary</h2>
`./hello-world</span> php-cli</span> bin/console</span> app:hello-world</span></span></code></pre> php-cli</code> is the FrankenPHP subcommand that invokes the embedded PHP CLI interpreter. Everything after it is passed to PHP as a script.</p>`