Run Time Type Reflection

An open source library, which adds reflection to C++.

What is RTTR?

RTTR stands for Run Time Type Reflection. It describes the ability of a computer program to introspect and modify an object at runtime. It is also the name of the library itself, which is written in C++ and released as open source library.

The goal of this project is to provide an easy and intuitive way to use reflection in C++.

How to use?

Manual registration

Register your properties, methods or constructors in your source files.

Adjusting the class interface is only necessary when using inheritance.

#include <rttr/registration>
using namespace rttr;

struct MyStruct { MyStruct() {}; void func(double) {}; int data; };

         .property("data", &MyStruct::data)
         .method("func", &MyStruct::func);

Iterate over members

With the type object you can query your previously registered members.

Of course including all previously registered base classes.

type t = type::get<MyStruct>();
for (auto& prop : t.get_properties())
    std::cout << "name: " << prop.get_name() << std::endl;

for (auto& meth : t.get_methods())
    std::cout << "name: " << meth.get_name() << std::endl;

Constructing types

You don't have to include the actual class declaration to work with a type.

Via the type object or constructor object you can create instances of your type, wrapped inside a variant object.

type t = type::get_by_name("MyStruct");
variant var = t.create();    // will invoke the previously registered ctor

constructor ctor = t.get_constructor();  // 2nd way with the constructor class
var = ctor.invoke();
std::cout << var.get_type().get_name();  // prints 'MyStruct'

Set/get properties

It is pretty simple to set or get a property. Take a look at the following code:

MyStruct obj;

property prop = type::get(obj).get_property("data");
prop.set_value(obj, 23);

variant var_prop = prop.get_value(obj);
std::cout << var_prop.to_int(); // prints '23'

Invoke methods

Calling a method is straight forward.

It is also possible to use the variant object to invoke a method.

MyStruct obj;

method meth = type::get(obj).get_method("func");
meth.invoke(obj, 42.0);

variant var = type::get(obj).create();
meth.invoke(var, 42.0);


Following features are supported:

  • reflect constructors, methods, data member or enums
  • classes; with single-, multiple- and virtual-inheritance
  • constructors (arbitrary argument count)
  • methods (virtual, abstract, overloaded, arbitrary argument count)
  • arrays (incl. raw-arrays; arbitrary dimension count)
  • ability to invoke properties and methods of classes from any arbitrary class level
  • no header pollution; the reflection information is created in the cpp file to minimize compile time when modifying the data
  • working with custom types without the need of having the declaration of the type available at compile time (useful for plugins)
  • possibility to add additional metadata to all reflection objects
  • possibility to add default arguments to methods or constructors
  • adjust registration behaviour through policies
  • minimal macro usage
  • no additional 3rd party dependencies are needed
  • no rtti required; contains a faster and across shared libraries working replacement
  • no exceptions (this feature come with cost and is also regularly disabled on consoles)
  • no external compiler or tool needed, only standard ISO C++11

View More »


Tested and compiled with:

  • Microsoft Visual Studio 2013, 2015
  • GCC 4.8.1
  • Clang 3.7
  • MinGW 4.8.1

View More »


RTTR is released under the terms of the MIT license, so it is free to use in your free or commercial projects.


The repository is hosted under GitHub.

Get Started

Feel free to grab the source code and go through the tutorial section.