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