Finally: Memory Safety for C Without Rewriting Everything

Attila Torda — Wed, 29 Apr 2026 23:16:02 +0000

SaferCode is a header-only C library that brings modern memory safety patterns directly into your C code – with no new toolchains, no new languages, and no heavy dependencies.

It gives you:

Arena allocators – fast, linear, and leak-free
RAII macros – automatic resource cleanup (yes, in C)
String and string builder – length-prefixed, bound-checked strings
Sentinel checks – detect stack buffer over/underflows at runtime
Dangling pointer tracking – use-after-free? Caught.
Memory file abstraction – unified file/memory I/O
Structured logging & panic handling – consistent error flow

All of this without a C++ compiler or a runtime VM!

Here's a quick taste:

Arena allocator – no explicit free needed

#include "sc_arena.h"

ScArena arena = {0};
sc_arena_create(&arena, 1024);

int *arr = sc_arena_alloc(&arena, 10 * sizeof(int));
char *name = sc_arena_alloc(&arena, 64);

// ... use memory ...

sc_arena_reset(&arena);   // frees everything at once
sc_arena_destroy(&arena);

Safe strings that know their length

#include "sc_string.h"

ScString s = sc_string_new("Hello, ");
sc_string_append_cstr(&s, "world!");
printf("%s\n", sc_string_cstr(&s));  // "Hello, world!"
sc_string_free(&s);

No strcpy disasters, no missing null terminators.

RAII-style cleanup

#include "sc_raii.h"

void do_something() {
    sc_raii_scope {
        FILE *f = sc_raii_register(fopen("data.txt", "r"), (sc_raii_cb)fclose);
        void *buf = sc_raii_register(malloc(1024), free);

        // Use f and buf...

    } // Both automatically freed/closed when scope ends
}

Why this is a good idea?

Immediate improvement – You can start using it tomorrow in a single .c file. No build system overhaul.
No dependency hell – It's just headers. Copy them into your project and go.
Gradual adoption – Use one component (e.g., sc_string) without touching the rest.
Learn once, use everywhere – The patterns (arena, RAII, etc.) are universal. You'll write better C even if you later drop SaferCode.
Safety without performance loss – Arena allocators are faster than malloc/free. String builder reduces reallocation.

Is it production-ready?

The library is relatively new (version 0.x), but:

It has unit tests (ctest).

The API is stable-ish.

The author clearly knows modern C safety techniques.

For hobby projects, prototypes, or internal tools – absolutely yes. For safety-critical, million-line production code – test it thoroughly first, but the ideas are sound.

What's missing?

Like any young project:

Documentation could be more comprehensive (but the headers are well commented).
No official package manager integration yet (though easy to vendor).
Some advanced patterns (e.g., generics) would need macros or code generation.

The bottom line

SaferCode doesn't turn C into Rust. But it gives you many of Rust's ergonomic safety patterns without leaving C.

If you're tired of chasing memory bugs and want to write cleaner, safer C today, give it a try. Clone the repo, run the tests, and drop a header into your next project.

GitHub: attilatorda/SaferCode

Shift-To-Middle Array

Attila Torda — Wed, 16 Apr 2025 09:08:02 +0000

Hi all!

I created a new way to implement lists. Essentially it's the same as array deques, however I've never seen this approach for lists. I wrote a publication (currently working on the second version) and there is freely available C++ implementation with benchmarks: https://github.com/attilatorda/Shift-To-Middle_Array

Take a look at the readme.md for more details!

Have fun!

DEV Community: Attila Torda

Finally: Memory Safety for C Without Rewriting Everything

Shift-To-Middle Array