Standard-layout tuple implementation
Minor issues:


You need to include &lt;utility&gt; for std::forward.
You don't support empty tuples. It's obviously not a huge problem, but adding one line 

template &lt;&gt; struct tuple&lt;&gt; {};


is no great burden either.
You should be using std::forward for the assignments in the make functions:

t.first = std::forward&lt;T&gt;(x);


so move assignment is used when x is an rvalue reference.


Slightly bigger issue:


Having no constructors in tuple means that your tuple can never contain a type that is not default constructible. "Default construction followed by assignment" is inherently less efficient than value construction. I would write perfect forwarding constructors for the tuple specializations, something like:

template &lt;class T, class... Ts&gt;
struct tuple&lt;T, Ts...&gt;
{
    T first;
    tuple&lt;Ts...&gt; rest;

    tuple() = default;
    template &lt;class U, class...Us, class=
      typename ::std::enable_if&lt;
        !::std::is_base_of&lt;
          tuple,
          typename ::std::decay&lt;U&gt;::type
        &gt;::value
      &gt;::type
    &gt;
    tuple(U&amp;&amp; u, Us&amp;&amp;...tail) :
      first(::std::forward&lt;U&gt;(u)),
      rest(::std::forward&lt;Us&gt;(tail)...) {}
};

template &lt;class T&gt;
struct tuple&lt;T&gt;
{
    T first;

    tuple() = default;
    template &lt;class U, class=
      typename ::std::enable_if&lt;
        !::std::is_base_of&lt;
          tuple,
          typename ::std::decay&lt;U&gt;::type
        &gt;::value
      &gt;::type
    &gt;
    tuple(U&amp;&amp; u) :
      first(::std::forward&lt;U&gt;(u)) {}
};


(All that enable_if junk is to keep the perfect forwarding constructors from being used for copy/move construction from another tuple.) This allows make_tuple to become a one-liner:

return tuple&lt;typename ::std::decay&lt;Ts&gt;::type...&gt;(::std::forward&lt;Ts&gt;(x)...);



(Code demo with suggested changes and the now-unnecessary builder templates removed)