Adding Reflection to C

Adding reflection to C

Home

Adding reflection to C

David Priver, May 27th, 2026

Reflection in programming is the ability for a program to introspect its own datastructures and procedures, either at compile time or at run time. This is a key building block of metaprogramming. This is frequently used for automatically generating serialization and deserialization code, in-app debuggers and structure explorers.

C, as a venerable and minimalistic language, offers no such capability. As a result, C programmers are forced to resort to a few options:

Duplicate the metadata in parallel structures that need to be kept up to date with the real data structure definitions.

Stop using the native syntax for declaring structures/enums/etc. and instead do it with the primitive metaprogramming of the C preprocessor. Instead of directly declaring a structure, add a new X-macro that can be used to generate the struct and also its type info.

Stop using the C language at all for declaring your structures and instead use an external tool to generate code, such as ad-hoc scripts or some kind of IDL.

Keep declaring your types in C, write a C parser yourself to get that information into your hands and generate the needed reflection data or as inputs to codegen.

I've tried all of these options. They all have severe downsides.

For now we will focus on runtime type info. The goal is to have a datastructure like:

// typeinfo.h #include #include #include struct TypeInfo { const char *name; size_t size, align; size_t fields; struct FieldInfo { const struct TypeInfo *type; const char* name; size_t offset; _Bool is_bitfield; size_t bf_width; size_t bf_offset; } field[1]; // fake FAM, so it can be a member of a union }; #define TYPEINFO_INT32 (struct TypeInfo*)0x1 #define TYPEINFO_UINT32 (struct TypeInfo*)0x2 void print_as_json(const struct TypeInfo* ti, const void* data){ if(ti == TYPEINFO_INT32){ printf("%d", *(const int*)data); return; if(ti == TYPEINFO_UINT32){ printf("%u", *(const unsigned*)data); return; printf("{"); for(size_t i = 0; i fields; i++){ if(i != 0) printf(", "); const struct FieldInfo* fi = &ti->field[i]; printf("\"%s\": ", fi->name); const void* base = (const char*)data + fi->offset; if(fi->is_bitfield){ uint32_t v = *(uint32_t*)base; v >>= fi->bf_offset; uint32_t mask = (1u bf_width) - 1; v &= mask; printf("%u", v); else print_as_json(fi->type, base); printf("}");

This is greatly simplified: in practice you'd want info for arrays, unions, function types, pointers, etc.

Option 1: Hand-maintained Parallel Type Info

// option-1.c #include "typeinfo.h" struct Foo { int32_t x, y; union { uint32_t bf_bits; // fake field as you can't // take the address of a bitfield uint32_t is_baz: 1, is_bar: 1, is_foo: 1, _padding: 29; }; }; const struct FooInfo { union { struct TypeInfo info; struct { const char *name; size_t size, align; size_t fields; struct FieldInfo field[5]; }; }; } typeinfo_Foo = { .name = "Foo", .size = sizeof(struct Foo), .align = _Alignof(struct Foo), .fields = 5, .field = { .type = TYPEINFO_INT32, .name = "x", .offset = offsetof(struct Foo, x), }, .type = TYPEINFO_INT32, .name = "y", .offset = offsetof(struct Foo, y), }, .type = TYPEINFO_UINT32, .name = "is_baz", .offset = offsetof(struct Foo, bf_bits), .is_bitfield = 1, // no intrinsic to detect this .bf_width = 1, // no intrinsic to get this .bf_offset = 0, // no intrinsic to get this }, .type = TYPEINFO_UINT32, .name = "is_bar", .offset = offsetof(struct Foo, bf_bits), .is_bitfield = 1, // no intrinsic to detect this .bf_width = 1, // no intrinsic to get this .bf_offset = 1, // no intrinsic to get this }, .type = TYPEINFO_UINT32, .name = "is_foo", .offset = offsetof(struct Foo, bf_bits), .is_bitfield = 1, // no intrinsic to detect this .bf_width = 1, // no intrinsic to get this .bf_offset = 1, // no intrinsic to get this }, }, };

Option 1 is error-prone, laborious and hard to keep in sync, although it does give you the most control and the ability to customize things (such as serializing simple structs as a json array instead of json objects for vector types, using exactly the right allocator). This option is actually not as bad as people think, but it does take the joy out of programming.

The real drawback is if you get things wrong, the compiler won't help. For example, if you use bitfields (and contrary to popular belief, you should as they lead to significant size savings, with better syntax than #define flags and it's not actually hard to get portable bitfields between compilers, but that's a different blog post), compilers don't offer bitfield offset or width intrinsics so you have to maintain those by hand, which means you can end up reading or writing the wrong bits. (Did you notice that is_foo has the wrong bf_offset?)

#include "option-1.c"

int main(void){ struct Foo f = { 1, 2, .is_baz = 1, .is_bar = 0, .is_foo = 1, }; print_as_json(&typeinfo_Foo.info, &f); // {"x": 1, "y": 2, "is_baz": 1, "is_bar": 0, "is_foo": 0} // oops:...

Adding Reflection to C

Related Articles

Amazon, Facebook, FBI have access to a private intelligence-sharing network

Show HN: GoPeek – open links in live mini browser windows without new tabs

Agent Memory: An Anatomy

SpaceX not the behemoth everyone thought

The Mirror Is Part of the Machine