A New Take on Polymorphism

by Borislav Stanimirov

Hello, World

#include <iostream>

int main()
    std::cout << "Привет, я Борислав!\n";
    return 0;


Borislav Stanimirov

  • Mostly a C++ programmer
  • Mostly a game programmer since 2006
  • Open-source programmer
  • Currently employed at Chobolabs

DynaMix: A New Take on Polymorphism

DynaMix: A New Take on Polymorphism


  • Polymorphism means "many forms"
  • The same code does multiple things
  • Static polymorphism
    • Functon overloads
    • Templates
    • The compiler generates different binaries for the same code
    • Modern C++
  • Dynamic polymorphism and Object oriented programming (OOP)

OOP and Polymorphism

  • OOP has come to imply dynamic polymorphism
    • Dynamic polymorphism is when the compiler can see a function call but can't know which actual piece of code will be executed next
    • It's in the category of things which are slower and can't have good compilation errors
  • Totally anti modern C++
  • OOP has been criticized a lot
  • People forget that C++ is an OOP language
  • Out of the box in an OOP context C++ only gives us virtual functions for polymorphism
  • OOP can be useful for business logic (gameplay)

C++ and Business Logic

  • Is C++ is a bad choice for business logic?
  • Many projects have chosen other languages: Lua, Python, JavaScript, Ruby…
    • C++ has poor OOP capabilities
    • You can hotswap
    • You can delegate to non-programmers
  • However:
    • The code is slower
    • There is more complexity in the binding layer
    • There are duplicated functionalities (which means duplicated bugs)

DynaMix: A New Take on Polymorphism

DynaMix: A New Take on Polymorphism

Polymorphism in Modern C++

using Drawable = Library_Magic(void, draw, (ostream&));
struct Square {
    void draw(ostream& out) const { out << "Square\n"; }
struct Circle {
    void draw(ostream& out) const { out < "Circle\n"; }
void f(const Drawable& d) {
int main() {

Polymorphic Wrappers

  • Better than classic virtual functions
    • Information hiding (PIMPL)
    • Non-intrusive
    • More extensible
    • Potentially faster

  • … but more or less the same
    • Interface types
    • Implementation types
    • Basically improved virtual functions
    • Don’t seem compelling enough to ditch scripting languages

Other C++ polymorphism

  • Signals/slots (Multicasts)

  • Multiple dispatch
    • collide(obj1, obj2);
    • Obscure feature
    • Relatively easy to mimic
    • Folly.Poly, yomm11

  • Functional programming libraries

DynaMix: A New Take on Polymorphism

DynaMix: A New Take on Polymorphism


  • Open source, MIT license, C++ library

  • This talk is an introduction to the library
    • Focus on the what and why
    • Hardly even mention the “how”
    • There will also be a small demo

  • History
    • 2007: Interface. Zahary Karadjov
    • 2013: Rebirth as Boost.Mixin
    • 2016: Bye, Boost. Hello, DynaMix


Epic Pirate Story

Blitz Brigade: Rival Tactics

War Planet Online

Two more mobile games in development

What is DynaMix?

  • Not a physics library
  • Not even a game library
  • A new take on polymorphism

Compose and modify polymorphic objects at run time

Some Inspirational Ruby

module FlyingCreature
  def move_to(target)
    puts can_move_to?(target) ?
      "flying to #{target}"
      : "can't fly to #{target}"
  def can_move_to?(target)
    true # flying creatures don't care
module AfraidOfEvens
  def can_move_to?(target)
    target % 2 != 0
a = Object.new
a.move_to(10) # -> flying to 10
a.move_to(10) # -> can’t fly to 10

DynaMix means "Dynamic Mixins"

Static (CRTP) Mixins

struct cd_reader {
    string get_sound() const {
        return cd.empty() ? "silence" : ("cd: " + cd);
    string cd;
template <typename Self>
struct headphones {
    const Self* self() const {
        return static_cast<const Self*>(this);
    void play() {
        cout << "Playing " << self()->get_sound()
            << " through headphones\n";
struct diskman : public cd_reader, public headphones<diskman> {};
struct boombox : public cd_reader, public speakers<boombox> {};
struct ipod : public mp3_reader, public headphones<ipod> {};

Static Polymorphism with Mixins

template <typename Player>
void use_player(Player& player) {

int main() {
    diskman dm;
    dm.cd = "Led Zeppelin IV (1971)";
    use_player(dm); // -> Playing "Led Zeppelin IV (1971)"

    ipod ip;
    ip.mp3 = "Led Zeppelin - Black Dog.mp3";
    use_player(ip); // -> Playing "Led Zeppelin - Black Dog.mp3"

DynaMix: The Gist

  • Building blocks
    • dynamix::object – just an empty object
    • Mixins – classes that you've written which actually implement messages
    • Messages – function-like pieces of interface, that an object might implement

  • Usage
    • Mutation – the process of adding and removing mixins from objects
    • Calling messages – like calling methods, this is where the actual business logic lies

DynaMix Sound Player

dynamix::object sound_player; // just an empty dynamix::object


sound_player.get<cd_reader>()->insert("Led Zeppelin IV (1971)");

// play is a message
play(sound_player); // cant have sound_player.play() :(
// -> Playing CD "Led Zeppelin IV (1971)" through headphones


// -> Playing CD "Led Zeppelin IV (1971)" THROUGH SPEAKERS

Inevitable Boilerplate


 // Declare
DYNAMIX_MESSAGE_0(string, get_sound);
DYNAMIX_MESSAGE_1(void, play);
DYNAMIX_MESSAGE_2(int, foo, float, arg1, string, arg2);
 // Define

We fully separate the interface from the implementation.

Message vs Method

Late binding and Smalltalk

struct Foo {
    void bar();
Foo foo;

foo.bar(); // message
void Foo::bar() {} // method

Boilerplate Continued


// That’s all we need to mutate

class cd_reader {
    string get_sound() {
        return cd.empty() ? "silence" : ("CD " + cd);
    void insert(const string& cd) {
        _cd = cd;
    string _cd;
DYNAMIX_DEFINE_MIXIN(cd_reader, get_sound_msg);
// ...
DYNAMIX_DEFINE_MIXIN(mp3_reader, get_sound_msg);

Referring to the Owning Object

class headphones_output {
    void play() {
        cout << "Playing " << get_sound(dm_this)
            << " through headphones\n";

DYNAMIX_DEFINE_MIXIN(headphones_output, play_msg);

  • dm_this is like self: the owning object
  • No inheritance. The library is non-intrusive

Eye candy time!


DynaMix vs Scripts

  • Cons of using a scripting language
    • The code is slower V
    • More complexity in the binding layer V
    • There are duplicated functionalities (which means duplicated bugs) V
  • Pros of using a scripting language
    • C++ has poor OOP capabilities V
    • You can hotswap V
    • You can delegate to non-programmers X
      • Not yet. But you can mix.
  • The library has found a niche in mobile games, which are less likely to sacrifice performance

When to Use DynaMix?

  • When you're writing software with complex polymorphic objects
  • When you have subsystems which care about interface (rather than data)
  • When you want plugins which enable various aspects of your objects
  • Such types of projects include
    • Most CAD systems
    • Some games: especially RPGs and strategies
    • Some enterprise systems

When Not to Use DynaMix?

  • DynaMix is a means to create a project's architecture rather than achieve its purpose
  • Small scale projects
  • Projects which have little use of polymorphism
  • Existing large projects
  • In performance critical code. As any other dynamic polymorphism.


  • Message calls, as any polymorphic call, are slower than function calls
  • They are comparable to std::function
  • Mutations can be fairly slow. Internal types
  • Memory overhead
    • For objects: pointers but mainly size of mixins
    • For unique types: sparse arrays of mixins
  • Thread safety
    • Calling messages is safe
    • Mutating an object in one thread and calling messages on it in another is not safe
    • Mutating two objects in two threads is safe


  • Compose and mutate objects from mixins
  • Have uni- and multicast messages
  • Manage message execution with priorities
  • Easily have hot-swappable or even releaseble plugins
  • There was no time for:
    • Custom allocators
    • Message bids
    • Multicast result combinators
    • Implementation details



Borislav Stanimirov / ibob.github.io / @stanimirovb

DynaMix is here: github.com/ibob/dynamix/
Link to these slides: http://ibob.github.io/slides/dynamixv2/
Slides license Creative Commons By 3.0
Creative Commons License