C++26 Static Reflection: From ^^ to Splicing Explained

C++26 introduces native static reflection, allowing programs to access type, variable, and member information at compile time — data previously only available to the compiler. The article motivates this by showing a simple User struct with id and name fields; historically, serializing such a struct to JSON required manual metadata, macros, template metaprogramming, or external tools like Protobuf ( .proto + protoc).

The reflection model has two stages:

Stage 1: Reflection (^^)

The ^^ operator yields a std::meta::info value describing a program entity. Examples:

#include <meta>

int global;
constexpr std::meta::info type_info = ^^int;
constexpr std::meta::info var_info  = ^^global;

^^int

produces reflection info for the int type; ^^global produces info for the variable global. std::meta::info is an opaque value type — its internal representation is unspecified (could be an index or compiler-internal handle).

Stage 2: Splicing ([: ... :])

The [: ... :] syntax (called splicing ) takes a std::meta::info and injects the described entity back into source code. Example:

int main() {
    constexpr auto r = ^^int;
    typename[:r:] x = 42; // equivalent to: int x = 42;
}

Here typename[:r:] splices the type described by r (which is int) into the declaration. The article also shows a one-liner:

typename[:^^char:] c = '*'; // equivalent to: char c = '*';

First ^^char obtains reflection info for char, then [:^^char:] splices it as a type.

The complete round-trip is: code -> ^^ -> std::meta::info -> [:...:] -> code. This two-step process — reflection then splicing — forms the foundation of C++26 static reflection, enabling generic code that inspects and generates declarations without external tooling.