Concept based polymorphism
There is not much to be said actually, the concept-based polymorphism seems to be well implemented. You can slightly improve your push_back method by having it emplace_back the std::unique_ptr. It will be a little bit less verbose:

template&lt;class T&gt;
void push_back(T control){
    auto t = new drawable_model&lt;T&gt;(std::move(control));
    controls_.emplace_back(t);
}


Also, I suppose that a draw shouldn't alter the object being drawn. Therefore, you better const-qualify all of your draw methods.

You could also be more consistent with the way you use inline: you inlined drawable_forwarder's draw method but not drawable_model while it basically does the same thing.



One fun addition would be to write a method that would create the drawable_model object in-place. That would require to add the following constructor to drawable_model:

template&lt;typename... Args&gt;
drawable_model(Args&amp;&amp;... args):
    model_(std::forward&lt;Args&gt;(args)...)
{}


And the following method to graphics_surface (not sure about the name):

template&lt;typename T, typename... Args&gt;
void emplace_back(Args&amp;&amp;... args)
{
    auto t = new drawable_model&lt;T&gt;(std::forward&lt;Args&gt;(args)...);
    controls_.emplace_back(t);
}


Then, you could use it this way:

int main()
{
    graphics_surface surface;

    // Assume triangle and rectangle have complete constructors
    surface.emplace_back&lt;triangle&gt;(3.5, 6.8, 4.8, 3.2);
    surface.emplace_back&lt;square&gt;(/* whatever */);

    surface.render();
}