Fil-C's Simplified Model

If you simplify Fil-C, you can see it as a system that transforms pointers in C/C++ source code along with traceable metadata.

Each pointer local variable is attached with a corresponding AllocationRecord*, and this metadata moves together during assignment, operations, function calls, and returns.

• malloc creates a triple structure of visible_bytes, invisible_bytes, and AllocationRecord, not just the actual data.
• On dereference, it checks whether the location the pointer points to is within the allocation range and satisfies size conditions.
• When reading or writing a pointer, the corresponding metadata stored in invisible_bytes follows along, and alignment conditions must be met.

free releases the data region and invisible_bytes, but does not immediately erase the AllocationRecord itself. This gap is filled by GC, which tracks and cleans up unreachable AllocationRecords.

GC additionally does two things:

• Records with length == 0 are converged into a single canonical AllocationRecord.
• If the address of a local variable can escape its scope, the compiler promotes that variable to a heap allocation.

memmove is trickier because it deals with pointers inside arbitrary memory. An aligned 8-byte move moves invisible_bytes along with it, but multiple 1-byte unit moves do not.

Points that become more complex in a production implementation are as follows.

• Threads: contention between GC and free, preservation of atomic pointer operations
• Function pointers: metadata for executable code and ABI verification
• Memory optimization: lazy allocation of invisible_bytes, merging of structs/metadata
• Performance optimization: various optimizations to reduce the cost of safety

The cases where this model is useful are clear.

• When you need to run large-scale C/C++ code in a memory-safe way, but can't rewrite it right away
• When you want to run it for the purpose of finding memory bugs, like ASan
• When you want safe compile-time evaluation in an environment like Zig, where the runtime and compile-time are the same language
• When you want to concretely understand pointer provenance

The core message is that Fil-C is not simply "safe C," but a system that enforces memory safety through pointer tracking with accompanying metadata + GC + ABI reconstruction.