diff --git a/doc/guide.qbk b/doc/guide.qbk
index 4de2be20..a27c79ef 100644
--- a/doc/guide.qbk
+++ b/doc/guide.qbk
@@ -20,7 +20,7 @@ The term /histogram/ is usually reserved for something that has bins over contin
 
 [section Static or dynamic histogram]
 
-The histogram class comes in two variants with a common interface, see the [link histogram.rationale.histogram_types rationale] for more information. Using a [classref boost::histogram::histogram<Static,Axes,Storage> static histogram] is recommended. You need a [classref boost::histogram::histogram<Dynamic,Axes,Storage> dynamic histogram] instead, if:
+The histogram class comes in two variants with a common interface, see the [link histogram.rationale.histogram_types rationale] for more information. Using a [classref boost::histogram::static_histogram static histogram] is recommended. You need a [classref boost::histogram::dynamic_histogram dynamic histogram] instead, if:
 
 * you only know the histogram configurations at runtime, not at compile-time
 
@@ -40,6 +40,7 @@ int main() {
         create a 1d-histogram in default configuration which
         covers the real line from -1 to 1 in 100 bins, the same
         call with `make_dynamic_histogram` would also work
+    */
     auto h = bh::make_static_histogram(bh::axis::regular<>(100, -1, 1));
 
     // do something with h
@@ -394,7 +395,7 @@ Simple ostream operators are shipped with the library, which are internally used
 
 [c++]``
 #include <boost/histogram.hpp>
-#include <boost/histogram/histogram_ostream_operators.hpp>
+#include <boost/histogram/ostream_operators.hpp>
 #include <iostream>
 
 namespace bh = boost::histogram;
@@ -686,7 +687,7 @@ namespace bh = boost::histogram;
 namespace bp = boost::python;
 
 // function that runs in C++ and accepts reference to dynamic histogram
-void process(bh::histogram<bh::Dynamic, bh::axis::builtins>& h) {
+void process(bh::dynamic_histogram<bh::axis::builtins>& h) {
   // fill histogram, in reality this would be arbitrarily complex code
   for (int i = 0; i < 4; ++i)
       h.fill(0.25 * i, i);
diff --git a/include/boost/histogram.hpp b/include/boost/histogram.hpp
index 9a33c6b2..f965d376 100644
--- a/include/boost/histogram.hpp
+++ b/include/boost/histogram.hpp
@@ -7,7 +7,7 @@
 #ifndef BOOST_HISTOGRAM_HPP_
 #define BOOST_HISTOGRAM_HPP_
 
-#include <boost/histogram/axis.hpp>
+#include <boost/histogram/axis/axis.hpp>
 #include <boost/histogram/histogram.hpp>
 #include <boost/histogram/literals.hpp>
 #include <boost/histogram/storage/adaptive_storage.hpp>
diff --git a/include/boost/histogram/arithmetic_operators.hpp b/include/boost/histogram/arithmetic_operators.hpp
new file mode 100644
index 00000000..7372cce7
--- /dev/null
+++ b/include/boost/histogram/arithmetic_operators.hpp
@@ -0,0 +1,96 @@
+// Copyright 2015-2016 Hans Dembinski
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt
+// or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef _BOOST_HISTOGRAM_HISTOGRAM_ARITHMETIC_OPERATORS_HPP_
+#define _BOOST_HISTOGRAM_HISTOGRAM_ARITHMETIC_OPERATORS_HPP_
+
+#include <boost/histogram/histogram_fwd.hpp>
+
+namespace boost {
+namespace histogram {
+
+template <template <class, class> class H, typename A, typename S>
+H<A, S> &&
+operator+(H<A, S> &&a,
+          const H<A, S> &b) {
+  a += b;
+  return std::move(a);
+}
+
+template <template <class, class> class H, typename A, typename S>
+H<A, S> &&
+operator+(H<A, S> &&a,
+          H<A, S> &&b) {
+  a += b;
+  return std::move(a);
+}
+
+template <template <class, class> class H, typename A, typename S>
+H<A, S> &&
+operator+(const H<A, S> &a,
+          H<A, S> &&b) {
+  b += a;
+  return std::move(b);
+}
+
+template <template <class, class> class H, typename A, typename S>
+H<A, S>
+operator+(const H<A, S> &a,
+          const H<A, S> &b) {
+  H<A, S> r(a);
+  r += b;
+  return r;
+}
+
+template <template <class, class> class H, typename A, typename S>
+H<A, S> &&
+operator*(H<A, S> &&a, const double x) {
+  a *= x;
+  return std::move(a);
+}
+
+template <template <class, class> class H, typename A, typename S>
+H<A, S> &&
+operator*(const double x, H<A, S> &&b) {
+  b *= x;
+  return std::move(b);
+}
+
+template <template <class, class> class H, typename A, typename S>
+H<A, S>
+operator*(const H<A, S> &a, const double x) {
+  H<A, S> r(a);
+  r *= x;
+  return r;
+}
+
+template <template <class, class> class H, typename A, typename S>
+H<A, S>
+operator*(const double x, const H<A, S> &b) {
+  H<A, S> r(b);
+  r *= x;
+  return r;
+}
+
+template <template <class, class> class H, typename A, typename S>
+H<A, S> &&
+operator/(H<A, S> &&a, const double x) {
+  a /= x;
+  return std::move(a);
+}
+
+template <template <class, class> class H, typename A, typename S>
+H<A, S>
+operator/(const H<A, S> &a, const double x) {
+  H<A, S> r(a);
+  r /= x;
+  return r;
+}
+
+} // namespace histogram
+} // namespace boost
+
+#endif
diff --git a/include/boost/histogram/axis/any.hpp b/include/boost/histogram/axis/any.hpp
new file mode 100644
index 00000000..573e5406
--- /dev/null
+++ b/include/boost/histogram/axis/any.hpp
@@ -0,0 +1,196 @@
+// Copyright 2015-2016 Hans Dembinski
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt
+// or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef _BOOST_HISTOGRAM_AXIS_ANY_HPP_
+#define _BOOST_HISTOGRAM_AXIS_ANY_HPP_
+
+#include <boost/histogram/axis/iterator.hpp>
+#include <boost/histogram/interval.hpp>
+#include <boost/utility/string_view.hpp>
+#include <boost/histogram/detail/axis_visitor.hpp>
+#include <boost/mpl/contains.hpp>
+#include <boost/variant.hpp>
+#include <stdexcept>
+#include <type_traits>
+#include <utility>
+
+// forward declaration for serialization
+namespace boost {
+namespace serialization {
+class access;
+} // namespace serialization
+} // namespace boost
+
+namespace boost {
+namespace histogram {
+namespace axis {
+
+namespace detail {
+struct size : public static_visitor<int> {
+  template <typename A> int operator()(const A &a) const { return a.size(); }
+};
+
+struct shape : public static_visitor<int> {
+  template <typename A> int operator()(const A &a) const { return a.shape(); }
+};
+
+struct uoflow : public static_visitor<bool> {
+  template <typename A> bool operator()(const A &a) const { return a.uoflow(); }
+};
+
+struct get_label : public static_visitor<string_view> {
+  template <typename A> ::boost::string_view operator()(const A& a) const { return a.label(); }
+};
+
+struct set_label : public static_visitor<void> {
+  const ::boost::string_view label;
+  set_label(const ::boost::string_view x) : label(x) {}
+  template <typename A> void operator()(A& a) const { a.label(label); }
+};
+
+template <typename T> struct index : public static_visitor<int> {
+  const T &t;
+  explicit index(const T &arg) : t(arg) {}
+  template <typename Axis> int operator()(const Axis &a) const {
+    return impl(std::is_convertible<T, typename Axis::value_type>(), a);
+  }
+  template <typename Axis> int impl(std::true_type, const Axis& a) const {
+    return a.index(t);
+  }
+  template <typename Axis> int impl(std::false_type, const Axis&) const {
+    throw std::runtime_error("index argument not convertible to axis value type");
+  }
+};
+
+struct bin : public static_visitor<axis::interval<double>> {
+  using double_interval = axis::interval<double>;
+  const int i;
+  bin(const int v) : i(v) {}
+  template <typename A> double_interval operator()(const A &a) const {
+    return impl(is_convertible<typename A::bin_type, double_interval>(),
+                std::forward<typename A::bin_type>(a[i]));
+  }
+  template <typename B> double_interval impl(true_type, B &&b) const {
+    return b;
+  }
+  template <typename B> double_interval impl(false_type, B &&) const {
+    throw std::runtime_error("cannot convert bin_type to interval<double>");
+  }
+};
+} // namespace detail
+
+/// Polymorphic axis type
+template <typename Axes>
+class any : public make_variant_over<Axes>::type {
+  using base_type = typename make_variant_over<Axes>::type;
+public:
+  using types = typename base_type::types;
+  using value_type = double;
+  using bin_type = interval<double>;
+  using const_iterator = axis_iterator<any>;
+
+  any() = default;
+  any(const any& t) = default;
+  any(any&& t) = default;
+  any& operator=(const any& t) = default;
+  any& operator=(any&& t) = default;
+
+  template <typename T, typename = typename std::enable_if<
+    mpl::contains<Axes, T>::value
+  >::type>
+  any(const T& t) : base_type(t) {}
+
+  template <typename T, typename = typename std::enable_if<
+    mpl::contains<Axes, T>::value
+  >::type>
+  any& operator=(const T& t) {
+    // ugly workaround for compiler bug
+    return reinterpret_cast<any&>(base_type::operator=(t));
+  }
+
+  template <typename T, typename = typename std::enable_if<
+    mpl::contains<Axes, T>::value
+  >::type>
+  any& operator=(T&& t) {
+    // ugly workaround for compiler bug
+    return reinterpret_cast<any&>(base_type::operator=(std::move(t)));
+  }
+
+  int size() const {
+    return apply_visitor(detail::size(), *this);
+  }
+
+  int shape() const {
+    return apply_visitor(detail::shape(), *this);
+  }
+
+  bool uoflow() const {
+    return apply_visitor(detail::uoflow(), *this);
+  }
+
+  // note: this only works for axes with compatible value type
+  int index(const value_type x) const {
+    return apply_visitor(detail::index<value_type>(x), *this);
+  }
+
+  string_view label() const {
+    return apply_visitor(detail::get_label(), *this);
+  }
+
+  void label(const string_view x) {
+    return apply_visitor(detail::set_label(x), *this);
+  }
+
+  // this only works for axes with compatible bin type
+  // and will raise an error otherwise
+  bin_type operator[](const int i) const {
+    return apply_visitor(detail::bin(i), *this);
+  }
+
+  bool operator==(const any& rhs) const {
+    return base_type::operator==(static_cast<const base_type&>(rhs));
+  }
+
+  const_iterator begin() const { return const_iterator(*this, 0); }
+
+  const_iterator end() const { return const_iterator(*this, size()); }
+
+private:
+  friend class ::boost::serialization::access;
+  template <typename Archive> void serialize(Archive&, unsigned);
+};
+
+// dynamic casts
+template <typename T, typename Axes>
+typename std::add_lvalue_reference<T>::type cast(any<Axes>& any) { return get<T>(any); }
+
+template <typename T, typename Axes>
+const typename std::add_lvalue_reference<T>::type cast(const any<Axes>& any) { return get<T>(any); }
+
+template <typename T, typename Axes>
+typename std::add_pointer<T>::type cast(any<Axes>* any) { return get<T>(&any); }
+
+template <typename T, typename Axes>
+const typename std::add_pointer<T>::type cast(const any<Axes>* any) { return get<T>(&any); }
+
+// pass-through versions for generic programming, i.e. when you switch to static histogram
+template <typename T>
+typename std::add_lvalue_reference<T>::type cast(T& t) { return t; }
+
+template <typename T>
+const typename std::add_lvalue_reference<T>::type cast(const T& t) { return t; }
+
+template <typename T>
+typename std::add_pointer<T>::type cast(T* t) { return t; }
+
+template <typename T>
+const typename std::add_pointer<T>::type cast(const T* t) { return t; }
+
+} // namespace axis
+} // namespace histogram
+} // namespace boost
+
+#endif
diff --git a/include/boost/histogram/axis.hpp b/include/boost/histogram/axis/axis.hpp
similarity index 73%
rename from include/boost/histogram/axis.hpp
rename to include/boost/histogram/axis/axis.hpp
index 3929c659..c011c329 100644
--- a/include/boost/histogram/axis.hpp
+++ b/include/boost/histogram/axis/axis.hpp
@@ -9,14 +9,10 @@
 
 #include <algorithm>
 #include <boost/bimap.hpp>
-#include <boost/histogram/histogram_fwd.hpp>
+#include <boost/histogram/axis/iterator.hpp>
 #include <boost/histogram/interval.hpp>
-#include <boost/iterator/iterator_facade.hpp>
 #include <boost/math/constants/constants.hpp>
-#include <boost/mpl/vector.hpp>
 #include <boost/utility/string_view.hpp>
-#include <boost/histogram/detail/axis_visitor.hpp>
-#include <boost/mpl/contains.hpp>
 #include <cmath>
 #include <limits>
 #include <memory>
@@ -25,7 +21,6 @@
 #include <type_traits>
 #include <unordered_map>
 #include <utility>
-#include <vector>
 
 // forward declaration for serialization
 namespace boost {
@@ -36,41 +31,10 @@ class access;
 
 namespace boost {
 namespace histogram {
-
 namespace axis {
 
 enum class uoflow { off = false, on = true };
 
-template <typename Axis>
-class axis_iterator
-    : public iterator_facade<axis_iterator<Axis>,
-                             std::pair<int, typename Axis::bin_type>,
-                             random_access_traversal_tag,
-                             std::pair<int, typename Axis::bin_type>> {
-public:
-  explicit axis_iterator(const Axis &axis, int idx) : axis_(axis), idx_(idx) {}
-
-  axis_iterator(const axis_iterator &o) = default;
-  axis_iterator &operator=(const axis_iterator &o) = default;
-
-private:
-  void increment() noexcept { ++idx_; }
-  void decrement() noexcept { --idx_; }
-  void advance(int n) noexcept { idx_ += n; }
-  int distance_to(const axis_iterator &other) const noexcept {
-    return other.idx_ - idx_;
-  }
-  bool equal(const axis_iterator &other) const noexcept {
-    return idx_ == other.idx_;
-  }
-  std::pair<int, typename Axis::bin_type> dereference() const {
-    return std::make_pair(idx_, axis_[idx_]);
-  }
-  const Axis& axis_;
-  int idx_;
-  friend class boost::iterator_core_access;
-};
-
 /// Base class for all axes.
 class axis_base {
 public:
@@ -591,168 +555,6 @@ private:
   friend class ::boost::serialization::access;
   template <class Archive> void serialize(Archive &, unsigned);
 };
-
-namespace detail {
-struct size : public static_visitor<int> {
-  template <typename A> int operator()(const A &a) const { return a.size(); }
-};
-
-struct shape : public static_visitor<int> {
-  template <typename A> int operator()(const A &a) const { return a.shape(); }
-};
-
-struct uoflow : public static_visitor<bool> {
-  template <typename A> bool operator()(const A &a) const { return a.uoflow(); }
-};
-
-struct get_label : public static_visitor<string_view> {
-  template <typename A> ::boost::string_view operator()(const A& a) const { return a.label(); }
-};
-
-struct set_label : public static_visitor<void> {
-  const ::boost::string_view label;
-  set_label(const ::boost::string_view x) : label(x) {}
-  template <typename A> void operator()(A& a) const { a.label(label); }
-};
-
-template <typename T> struct index : public static_visitor<int> {
-  const T &t;
-  explicit index(const T &arg) : t(arg) {}
-  template <typename Axis> int operator()(const Axis &a) const {
-    return impl(std::is_convertible<T, typename Axis::value_type>(), a);
-  }
-  template <typename Axis> int impl(std::true_type, const Axis& a) const {
-    return a.index(t);
-  }
-  template <typename Axis> int impl(std::false_type, const Axis&) const {
-    throw std::runtime_error("index argument not convertible to axis value type");
-  }
-};
-
-struct bin : public static_visitor<axis::interval<double>> {
-  using double_interval = axis::interval<double>;
-  const int i;
-  bin(const int v) : i(v) {}
-  template <typename A> double_interval operator()(const A &a) const {
-    return impl(is_convertible<typename A::bin_type, double_interval>(),
-                std::forward<typename A::bin_type>(a[i]));
-  }
-  template <typename B> double_interval impl(true_type, B &&b) const {
-    return b;
-  }
-  template <typename B> double_interval impl(false_type, B &&) const {
-    throw std::runtime_error("cannot convert bin_type to interval<double>");
-  }
-};
-} // namespace detail
-
-/// Polymorphic axis type
-template <typename Axes = builtins>
-class any : public make_variant_over<Axes>::type {
-  using base_type = typename make_variant_over<Axes>::type;
-public:
-  using types = typename base_type::types;
-  using value_type = double;
-  using bin_type = interval<double>;
-  using const_iterator = axis_iterator<any>;
-
-  any() = default;
-  any(const any& t) = default;
-  any(any&& t) = default;
-  any& operator=(const any& t) = default;
-  any& operator=(any&& t) = default;
-
-  template <typename T, typename = typename std::enable_if<
-    mpl::contains<Axes, T>::value
-  >::type>
-  any(const T& t) : base_type(t) {}
-
-  template <typename T, typename = typename std::enable_if<
-    mpl::contains<Axes, T>::value
-  >::type>
-  any& operator=(const T& t) {
-    // ugly workaround for compiler bug
-    return reinterpret_cast<any&>(base_type::operator=(t));
-  }
-
-  template <typename T, typename = typename std::enable_if<
-    mpl::contains<Axes, T>::value
-  >::type>
-  any& operator=(T&& t) {
-    // ugly workaround for compiler bug
-    return reinterpret_cast<any&>(base_type::operator=(std::move(t)));
-  }
-
-  int size() const {
-    return apply_visitor(detail::size(), *this);
-  }
-
-  int shape() const {
-    return apply_visitor(detail::shape(), *this);
-  }
-
-  bool uoflow() const {
-    return apply_visitor(detail::uoflow(), *this);
-  }
-
-  // note: this only works for axes with compatible value type
-  int index(const value_type x) const {
-    return apply_visitor(detail::index<value_type>(x), *this);
-  }
-
-  string_view label() const {
-    return apply_visitor(detail::get_label(), *this);
-  }
-
-  void label(const string_view x) {
-    return apply_visitor(detail::set_label(x), *this);
-  }
-
-  // this only works for axes with compatible bin type
-  // and will raise an error otherwise
-  bin_type operator[](const int i) const {
-    return apply_visitor(detail::bin(i), *this);
-  }
-
-  bool operator==(const any& rhs) const {
-    return base_type::operator==(static_cast<const base_type&>(rhs));
-  }
-
-  const_iterator begin() const { return const_iterator(*this, 0); }
-
-  const_iterator end() const { return const_iterator(*this, size()); }
-
-private:
-  friend class ::boost::serialization::access;
-  template <typename Archive> void serialize(Archive&, unsigned);
-};
-
-// dynamic casts
-template <typename T, typename Axes>
-typename std::add_lvalue_reference<T>::type cast(any<Axes>& any) { return get<T>(any); }
-
-template <typename T, typename Axes>
-const typename std::add_lvalue_reference<T>::type cast(const any<Axes>& any) { return get<T>(any); }
-
-template <typename T, typename Axes>
-typename std::add_pointer<T>::type cast(any<Axes>* any) { return get<T>(&any); }
-
-template <typename T, typename Axes>
-const typename std::add_pointer<T>::type cast(const any<Axes>* any) { return get<T>(&any); }
-
-// pass-through versions for generic programming, i.e. when you switch to static histogram
-template <typename T>
-typename std::add_lvalue_reference<T>::type cast(T& t) { return t; }
-
-template <typename T>
-const typename std::add_lvalue_reference<T>::type cast(const T& t) { return t; }
-
-template <typename T>
-typename std::add_pointer<T>::type cast(T* t) { return t; }
-
-template <typename T>
-const typename std::add_pointer<T>::type cast(const T* t) { return t; }
-
 } // namespace axis
 } // namespace histogram
 } // namespace boost
diff --git a/include/boost/histogram/axis/iterator.hpp b/include/boost/histogram/axis/iterator.hpp
new file mode 100644
index 00000000..7e4908e9
--- /dev/null
+++ b/include/boost/histogram/axis/iterator.hpp
@@ -0,0 +1,47 @@
+// Copyright 2015-2016 Hans Dembinski
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt
+// or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef _BOOST_HISTOGRAM_AXIS_ITERATOR_HPP_
+#define _BOOST_HISTOGRAM_AXIS_ITERATOR_HPP_
+
+#include <boost/iterator/iterator_facade.hpp>
+#include <utility>
+
+namespace boost { namespace histogram { namespace axis {
+
+template <typename Axis>
+class axis_iterator
+    : public iterator_facade<axis_iterator<Axis>,
+                             std::pair<int, typename Axis::bin_type>,
+                             random_access_traversal_tag,
+                             std::pair<int, typename Axis::bin_type>> {
+public:
+  explicit axis_iterator(const Axis &axis, int idx) : axis_(axis), idx_(idx) {}
+
+  axis_iterator(const axis_iterator &o) = default;
+  axis_iterator &operator=(const axis_iterator &o) = default;
+
+private:
+  void increment() noexcept { ++idx_; }
+  void decrement() noexcept { --idx_; }
+  void advance(int n) noexcept { idx_ += n; }
+  int distance_to(const axis_iterator &other) const noexcept {
+    return other.idx_ - idx_;
+  }
+  bool equal(const axis_iterator &other) const noexcept {
+    return idx_ == other.idx_;
+  }
+  std::pair<int, typename Axis::bin_type> dereference() const {
+    return std::make_pair(idx_, axis_[idx_]);
+  }
+  const Axis& axis_;
+  int idx_;
+  friend class boost::iterator_core_access;
+};
+
+}}}
+
+#endif
diff --git a/include/boost/histogram/axis_ostream_operators.hpp b/include/boost/histogram/axis/ostream_operators.hpp
similarity index 98%
rename from include/boost/histogram/axis_ostream_operators.hpp
rename to include/boost/histogram/axis/ostream_operators.hpp
index b32e3f5a..77916326 100644
--- a/include/boost/histogram/axis_ostream_operators.hpp
+++ b/include/boost/histogram/axis/ostream_operators.hpp
@@ -9,7 +9,7 @@
 #ifndef _BOOST_HISTOGRAM_AXIS_OSTREAM_OPERATORS_HPP_
 #define _BOOST_HISTOGRAM_AXIS_OSTREAM_OPERATORS_HPP_
 
-#include <boost/histogram/axis.hpp>
+#include <boost/histogram/axis/axis.hpp>
 #include <boost/histogram/detail/utility.hpp>
 #include <boost/histogram/interval.hpp>
 #include <boost/math/constants/constants.hpp>
diff --git a/include/boost/histogram/histogram_impl_dynamic.hpp b/include/boost/histogram/dynamic_histogram.hpp
similarity index 79%
rename from include/boost/histogram/histogram_impl_dynamic.hpp
rename to include/boost/histogram/dynamic_histogram.hpp
index 55c27b10..4d5db349 100644
--- a/include/boost/histogram/histogram_impl_dynamic.hpp
+++ b/include/boost/histogram/dynamic_histogram.hpp
@@ -9,7 +9,8 @@
 
 #include <algorithm>
 #include <boost/config.hpp>
-#include <boost/histogram/axis.hpp>
+#include <boost/histogram/axis/axis.hpp>
+#include <boost/histogram/axis/any.hpp>
 #include <boost/histogram/detail/axis_visitor.hpp>
 #include <boost/histogram/detail/meta.hpp>
 #include <boost/histogram/detail/utility.hpp>
@@ -43,7 +44,7 @@ namespace boost {
 namespace histogram {
 
 template <typename Axes, typename Storage>
-class histogram<Dynamic, Axes, Storage> {
+class dynamic_histogram {
   static_assert(!mpl::empty<Axes>::value, "at least one axis required");
 public:
   using any_axis_type = axis::any<Axes>;
@@ -53,31 +54,45 @@ private:
   using axes_type = std::vector<any_axis_type>;
 
 public:
-  histogram() = default;
-  histogram(const histogram &) = default;
-  histogram(histogram &&) = default;
-  histogram &operator=(const histogram &) = default;
-  histogram &operator=(histogram &&) = default;
+  dynamic_histogram() = default;
+  dynamic_histogram(const dynamic_histogram &) = default;
+  dynamic_histogram(dynamic_histogram &&) = default;
+  dynamic_histogram &operator=(const dynamic_histogram &) = default;
+  dynamic_histogram &operator=(dynamic_histogram &&) = default;
 
   template <typename... Axes1>
-  explicit histogram(const Axes1 &... axes) : axes_({any_axis_type(axes)...}) {
+  explicit dynamic_histogram(const Axes1 &... axes) : axes_({any_axis_type(axes)...}) {
     storage_ = Storage(bincount_from_axes());
   }
 
   template <typename Iterator, typename = detail::is_iterator<Iterator>>
-  histogram(Iterator axes_begin, Iterator axes_end)
-      : axes_(std::distance(axes_begin, axes_end)) {
-    std::copy(axes_begin, axes_end, axes_.begin());
+  dynamic_histogram(Iterator begin, Iterator end)
+      : axes_(std::distance(begin, end)) {
+    std::copy(begin, end, axes_.begin());
     storage_ = Storage(bincount_from_axes());
   }
 
-  template <typename D, typename A, typename S>
-  explicit histogram(const histogram<D, A, S> &rhs) : storage_(rhs.storage_) {
+  template <typename A, typename S>
+  explicit dynamic_histogram(const static_histogram<A, S> &rhs) : storage_(rhs.storage_) {
     detail::axes_assign(axes_, rhs.axes_);
   }
 
-  template <typename D, typename A, typename S>
-  histogram &operator=(const histogram<D, A, S> &rhs) {
+  template <typename A, typename S>
+  explicit dynamic_histogram(const dynamic_histogram<A, S> &rhs) : storage_(rhs.storage_) {
+    detail::axes_assign(axes_, rhs.axes_);
+  }
+
+  template <typename A, typename S>
+  dynamic_histogram &operator=(const static_histogram<A, S> &rhs) {
+    if (static_cast<const void *>(this) != static_cast<const void *>(&rhs)) {
+      detail::axes_assign(axes_, rhs.axes_);
+      storage_ = rhs.storage_;
+    }
+    return *this;
+  }
+
+  template <typename A, typename S>
+  dynamic_histogram &operator=(const dynamic_histogram<A, S> &rhs) {
     if (static_cast<const void *>(this) != static_cast<const void *>(&rhs)) {
       detail::axes_assign(axes_, rhs.axes_);
       storage_ = rhs.storage_;
@@ -86,11 +101,11 @@ public:
   }
 
   template <typename S>
-  explicit histogram(histogram<Dynamic, Axes, S> &&rhs)
+  explicit dynamic_histogram(dynamic_histogram<Axes, S> &&rhs)
       : axes_(std::move(rhs.axes_)), storage_(std::move(rhs.storage_)) {}
 
   template <typename S>
-  histogram &operator=(histogram<Dynamic, Axes, S> &&rhs) {
+  dynamic_histogram &operator=(dynamic_histogram<Axes, S> &&rhs) {
     if (static_cast<const void *>(this) != static_cast<const void *>(&rhs)) {
       axes_ = std::move(rhs.axes_);
       storage_ = std::move(rhs.storage_);
@@ -98,30 +113,48 @@ public:
     return *this;
   }
 
-  template <typename D, typename A, typename S>
-  bool operator==(const histogram<D, A, S> &rhs) const noexcept {
+  template <typename A, typename S>
+  bool operator==(const static_histogram<A, S> &rhs) const noexcept {
     return detail::axes_equal(axes_, rhs.axes_) && storage_ == rhs.storage_;
   }
 
-  template <typename D, typename A, typename S>
-  bool operator!=(const histogram<D, A, S> &rhs) const noexcept {
+  template <typename A, typename S>
+  bool operator==(const dynamic_histogram<A, S> &rhs) const noexcept {
+    return detail::axes_equal(axes_, rhs.axes_) && storage_ == rhs.storage_;
+  }
+
+  template <typename A, typename S>
+  bool operator!=(const static_histogram<A, S> &rhs) const noexcept {
     return !operator==(rhs);
   }
 
-  template <typename D, typename A, typename S>
-  histogram &operator+=(const histogram<D, A, S> &rhs) {
+  template <typename A, typename S>
+  bool operator!=(const dynamic_histogram<A, S> &rhs) const noexcept {
+    return !operator==(rhs);
+  }
+
+  template <typename A, typename S>
+  dynamic_histogram &operator+=(const static_histogram<A, S> &rhs) {
     if (!detail::axes_equal(axes_, rhs.axes_))
       throw std::logic_error("axes of histograms differ");
     storage_ += rhs.storage_;
     return *this;
   }
 
-  histogram &operator*=(const value_type rhs) {
+  template <typename A, typename S>
+  dynamic_histogram &operator+=(const dynamic_histogram<A, S> &rhs) {
+    if (!detail::axes_equal(axes_, rhs.axes_))
+      throw std::logic_error("axes of histograms differ");
+    storage_ += rhs.storage_;
+    return *this;
+  }
+
+  dynamic_histogram &operator*=(const value_type rhs) {
     storage_ *= rhs;
     return *this;
   }
 
-  histogram &operator/=(const value_type rhs) {
+  dynamic_histogram &operator/=(const value_type rhs) {
     storage_ *= 1.0 / rhs;
     return *this;
   }
@@ -259,13 +292,13 @@ public:
   }
 
   /// Return a lower dimensional histogram
-  template <int N, typename... Rest> histogram reduce_to(mpl::int_<N>, Rest...) const {
+  template <int N, typename... Rest> dynamic_histogram reduce_to(mpl::int_<N>, Rest...) const {
     const auto b = detail::bool_mask<mpl::vector<mpl::int_<N>, Rest...>>(dim(), true);
     return reduce_impl(b);
   }
 
   /// Return a lower dimensional histogram
-  template <typename... Rest> histogram reduce_to(int n, Rest... rest) const {
+  template <typename... Rest> dynamic_histogram reduce_to(int n, Rest... rest) const {
     std::vector<bool> b(dim(), false);
     for (const auto &i : {n, rest...})
       b[i] = true;
@@ -274,7 +307,7 @@ public:
 
   /// Return a lower dimensional histogram
   template <typename Iterator, typename = detail::is_iterator<Iterator>>
-  histogram reduce_to(Iterator begin, Iterator end) const {
+  dynamic_histogram reduce_to(Iterator begin, Iterator end) const {
     std::vector<bool> b(dim(), false);
     for (; begin != end; ++begin)
       b[*begin] = true;
@@ -426,7 +459,7 @@ private:
     }
   }
 
-  histogram reduce_impl(const std::vector<bool> &b) const {
+  dynamic_histogram reduce_impl(const std::vector<bool> &b) const {
     axes_type axes;
     std::vector<unsigned> n(b.size());
     auto axes_iter = axes_.begin();
@@ -438,7 +471,7 @@ private:
       ++axes_iter;
       ++n_iter;
     }
-    histogram h(axes.begin(), axes.end());
+    dynamic_histogram h(axes.begin(), axes.end());
     detail::index_mapper m(n, b);
     do {
       detail::storage_add(h.storage_, storage_, m.second, m.first);
@@ -446,43 +479,42 @@ private:
     return h;
   }
 
-  template <typename D, typename A, typename S> friend class histogram;
+  template <typename A, typename S> friend class dynamic_histogram;
+  template <typename A, typename S> friend class static_histogram;
   friend class ::boost::python::access;
   friend class ::boost::serialization::access;
   template <typename Archive> void serialize(Archive &, unsigned);
 };
 
 template <typename... Axes>
-histogram<Dynamic, detail::combine_t<axis::builtins, mpl::vector<Axes...>>>
+dynamic_histogram<detail::combine_t<axis::builtins, mpl::vector<Axes...>>>
 make_dynamic_histogram(Axes &&... axes) {
 
-  return histogram<Dynamic,
+  return dynamic_histogram<
                    detail::combine_t<axis::builtins, mpl::vector<Axes...>>>(
       std::forward<Axes>(axes)...);
 }
 
 template <typename Storage, typename... Axes>
-histogram<Dynamic, detail::combine_t<axis::builtins, mpl::vector<Axes...>>,
+dynamic_histogram<detail::combine_t<axis::builtins, mpl::vector<Axes...>>,
                  Storage>
 make_dynamic_histogram_with(Axes &&... axes) {
-  return histogram<
-      Dynamic, detail::combine_t<axis::builtins, mpl::vector<Axes...>>, Storage>(
+  return dynamic_histogram<
+    detail::combine_t<axis::builtins, mpl::vector<Axes...>>, Storage>(
       std::forward<Axes>(axes)...);
 }
 
 template <typename Iterator, typename = detail::is_iterator<Iterator>>
-histogram<Dynamic, detail::combine_t<axis::builtins, typename Iterator::value_type::types>>
+dynamic_histogram<detail::combine_t<axis::builtins, typename Iterator::value_type::types>>
 make_dynamic_histogram(Iterator begin, Iterator end) {
-  return histogram<
-      Dynamic, detail::combine_t<axis::builtins, typename Iterator::value_type::types>>(
+  return dynamic_histogram<detail::combine_t<axis::builtins, typename Iterator::value_type::types>>(
       begin, end);
 }
 
 template <typename Storage, typename Iterator, typename = detail::is_iterator<Iterator>>
-histogram<Dynamic, detail::combine_t<axis::builtins, typename Iterator::value_type::types>, Storage>
+dynamic_histogram<detail::combine_t<axis::builtins, typename Iterator::value_type::types>, Storage>
 make_dynamic_histogram_with(Iterator begin, Iterator end) {
-  return histogram<
-      Dynamic, detail::combine_t<axis::builtins, typename Iterator::value_type::types>, Storage>(
+  return dynamic_histogram<detail::combine_t<axis::builtins, typename Iterator::value_type::types>, Storage>(
       begin, end);
 }
 
diff --git a/include/boost/histogram/histogram.hpp b/include/boost/histogram/histogram.hpp
index 3b95aad7..4745278e 100644
--- a/include/boost/histogram/histogram.hpp
+++ b/include/boost/histogram/histogram.hpp
@@ -7,8 +7,8 @@
 #ifndef _BOOST_HISTOGRAM_HISTOGRAM_HPP_
 #define _BOOST_HISTOGRAM_HISTOGRAM_HPP_
 
-#include <boost/histogram/histogram_impl_dynamic.hpp>
-#include <boost/histogram/histogram_impl_static.hpp>
-#include <boost/histogram/histogram_arithmetic_operators.hpp>
+#include <boost/histogram/dynamic_histogram.hpp>
+#include <boost/histogram/static_histogram.hpp>
+#include <boost/histogram/arithmetic_operators.hpp>
 
 #endif
diff --git a/include/boost/histogram/histogram_arithmetic_operators.hpp b/include/boost/histogram/histogram_arithmetic_operators.hpp
deleted file mode 100644
index 5d85b101..00000000
--- a/include/boost/histogram/histogram_arithmetic_operators.hpp
+++ /dev/null
@@ -1,96 +0,0 @@
-// Copyright 2015-2016 Hans Dembinski
-//
-// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt
-// or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef _BOOST_HISTOGRAM_HISTOGRAM_ARITHMETIC_OPERATORS_HPP_
-#define _BOOST_HISTOGRAM_HISTOGRAM_ARITHMETIC_OPERATORS_HPP_
-
-#include <boost/histogram/histogram_fwd.hpp>
-
-namespace boost {
-namespace histogram {
-
-template <typename Variant, typename Axes, typename Storage>
-histogram<Variant, Axes, Storage> &&
-operator+(histogram<Variant, Axes, Storage> &&a,
-          const histogram<Variant, Axes, Storage> &b) {
-  a += b;
-  return std::move(a);
-}
-
-template <typename Variant, typename Axes, typename Storage>
-histogram<Variant, Axes, Storage> &&
-operator+(histogram<Variant, Axes, Storage> &&a,
-          histogram<Variant, Axes, Storage> &&b) {
-  a += b;
-  return std::move(a);
-}
-
-template <typename Variant, typename Axes, typename Storage>
-histogram<Variant, Axes, Storage> &&
-operator+(const histogram<Variant, Axes, Storage> &a,
-          histogram<Variant, Axes, Storage> &&b) {
-  b += a;
-  return std::move(b);
-}
-
-template <typename Variant, typename Axes, typename Storage>
-histogram<Variant, Axes, Storage>
-operator+(const histogram<Variant, Axes, Storage> &a,
-          const histogram<Variant, Axes, Storage> &b) {
-  histogram<Variant, Axes, Storage> r(a);
-  r += b;
-  return r;
-}
-
-template <typename Variant, typename Axes, typename Storage>
-histogram<Variant, Axes, Storage> &&
-operator*(histogram<Variant, Axes, Storage> &&a, const double x) {
-  a *= x;
-  return std::move(a);
-}
-
-template <typename Variant, typename Axes, typename Storage>
-histogram<Variant, Axes, Storage> &&
-operator*(const double x, histogram<Variant, Axes, Storage> &&b) {
-  b *= x;
-  return std::move(b);
-}
-
-template <typename Variant, typename Axes, typename Storage>
-histogram<Variant, Axes, Storage>
-operator*(const histogram<Variant, Axes, Storage> &a, const double x) {
-  histogram<Variant, Axes, Storage> r(a);
-  r *= x;
-  return r;
-}
-
-template <typename Variant, typename Axes, typename Storage>
-histogram<Variant, Axes, Storage>
-operator*(const double x, const histogram<Variant, Axes, Storage> &b) {
-  histogram<Variant, Axes, Storage> r(b);
-  r *= x;
-  return r;
-}
-
-template <typename Variant, typename Axes, typename Storage>
-histogram<Variant, Axes, Storage> &&
-operator/(histogram<Variant, Axes, Storage> &&a, const double x) {
-  a /= x;
-  return std::move(a);
-}
-
-template <typename Variant, typename Axes, typename Storage>
-histogram<Variant, Axes, Storage>
-operator/(const histogram<Variant, Axes, Storage> &a, const double x) {
-  histogram<Variant, Axes, Storage> r(a);
-  r /= x;
-  return r;
-}
-
-} // namespace histogram
-} // namespace boost
-
-#endif
diff --git a/include/boost/histogram/histogram_fwd.hpp b/include/boost/histogram/histogram_fwd.hpp
index 5470db0f..2a4d76e2 100644
--- a/include/boost/histogram/histogram_fwd.hpp
+++ b/include/boost/histogram/histogram_fwd.hpp
@@ -7,17 +7,12 @@
 #ifndef _BOOST_HISTOGRAM_HISTOGRAM_FWD_HPP_
 #define _BOOST_HISTOGRAM_HISTOGRAM_FWD_HPP_
 
-#include <boost/histogram/detail/meta.hpp>
-#include <boost/mpl/int.hpp>
 #include <boost/mpl/vector.hpp>
-#include <set>
+#include <string>
 
 namespace boost {
 namespace histogram {
 
-using Static = std::integral_constant<int, 0>;
-using Dynamic = std::integral_constant<int, 1>;
-
 class adaptive_storage;
 
 namespace axis {
@@ -43,10 +38,17 @@ using builtins =
                 axis::regular<double, axis::transform::pow>, axis::circular<>,
                 axis::variable<>, axis::integer<>,
                 axis::category<>, axis::category<std::string>>;
-}
 
-template <class Variant, class Axes, class Storage = adaptive_storage>
-class histogram;
+template <typename Axes = builtins>
+class any;
+
+} // namespace axis
+
+template <class Axes, class Storage = adaptive_storage>
+class static_histogram;
+
+template <class Axes, class Storage = adaptive_storage>
+class dynamic_histogram;
 
 struct weight {
   weight(double w) : value(w) {}
diff --git a/include/boost/histogram/histogram_ostream_operators.hpp b/include/boost/histogram/ostream_operators.hpp
similarity index 67%
rename from include/boost/histogram/histogram_ostream_operators.hpp
rename to include/boost/histogram/ostream_operators.hpp
index d728a76d..a8fc8f81 100644
--- a/include/boost/histogram/histogram_ostream_operators.hpp
+++ b/include/boost/histogram/ostream_operators.hpp
@@ -4,11 +4,10 @@
 // (See accompanying file LICENSE_1_0.txt
 // or copy at http://www.boost.org/LICENSE_1_0.txt)
 
-#ifndef _BOOST_HISTOGRAM_HISTOGRAM_OSTREAM_OPERATORS_HPP_
-#define _BOOST_HISTOGRAM_HISTOGRAM_OSTREAM_OPERATORS_HPP_
+#ifndef _BOOST_HISTOGRAM_OSTREAM_OPERATORS_HPP_
+#define _BOOST_HISTOGRAM_OSTREAM_OPERATORS_HPP_
 
-#include <boost/histogram/axis_ostream_operators.hpp>
-#include <boost/histogram/histogram_fwd.hpp>
+#include <boost/histogram/axis/ostream_operators.hpp>
 #include <ostream>
 
 namespace boost {
@@ -24,8 +23,8 @@ struct axis_ostream_visitor {
 };
 } // namespace detail
 
-template <typename D, typename A, typename S>
-inline std::ostream &operator<<(std::ostream &os, const histogram<D, A, S> &h) {
+template <template <class, class> class H, typename A, typename S>
+inline std::ostream &operator<<(std::ostream &os, const H<A, S> &h) {
   os << "histogram(";
   detail::axis_ostream_visitor sh(os);
   h.for_each_axis(sh);
diff --git a/include/boost/histogram/serialization.hpp b/include/boost/histogram/serialization.hpp
index e39b3a3c..a266e30e 100644
--- a/include/boost/histogram/serialization.hpp
+++ b/include/boost/histogram/serialization.hpp
@@ -192,7 +192,7 @@ void any<Axes>::serialize(Archive &ar, unsigned /* version */) {
 
 template <class A, class S>
 template <class Archive>
-void histogram<Static, A, S>::serialize(Archive &ar, unsigned /* version */) {
+void static_histogram<A, S>::serialize(Archive &ar, unsigned /* version */) {
   detail::serialize_helper<Archive> sh(ar);
   fusion::for_each(axes_, sh);
   ar &storage_;
@@ -200,7 +200,7 @@ void histogram<Static, A, S>::serialize(Archive &ar, unsigned /* version */) {
 
 template <class A, class S>
 template <class Archive>
-void histogram<Dynamic, A, S>::serialize(Archive &ar, unsigned /* version */) {
+void dynamic_histogram<A, S>::serialize(Archive &ar, unsigned /* version */) {
   ar &axes_;
   ar &storage_;
 }
diff --git a/include/boost/histogram/histogram_impl_static.hpp b/include/boost/histogram/static_histogram.hpp
similarity index 78%
rename from include/boost/histogram/histogram_impl_static.hpp
rename to include/boost/histogram/static_histogram.hpp
index 92c828bb..8d6b935d 100644
--- a/include/boost/histogram/histogram_impl_static.hpp
+++ b/include/boost/histogram/static_histogram.hpp
@@ -19,7 +19,7 @@
 #include <boost/fusion/include/sequence.hpp>
 #include <boost/fusion/sequence.hpp>
 #include <boost/fusion/sequence/comparison.hpp>
-#include <boost/histogram/axis.hpp>
+#include <boost/histogram/axis/axis.hpp>
 #include <boost/histogram/detail/axis_visitor.hpp>
 #include <boost/histogram/detail/meta.hpp>
 #include <boost/histogram/detail/utility.hpp>
@@ -42,7 +42,7 @@ namespace boost {
 namespace histogram {
 
 template <typename Axes, typename Storage>
-class histogram<Static, Axes, Storage> {
+class static_histogram {
   static_assert(!mpl::empty<Axes>::value, "at least one axis required");
   using axes_size = typename fusion::result_of::size<Axes>::type;
 
@@ -50,28 +50,33 @@ public:
   using axes_type = typename fusion::result_of::as_vector<Axes>::type;
   using value_type = typename Storage::value_type;
 
-  histogram() = default;
-  histogram(const histogram &rhs) = default;
-  histogram(histogram &&rhs) = default;
-  histogram &operator=(const histogram &rhs) = default;
-  histogram &operator=(histogram &&rhs) = default;
+  static_histogram() = default;
+  static_histogram(const static_histogram &rhs) = default;
+  static_histogram(static_histogram &&rhs) = default;
+  static_histogram &operator=(const static_histogram &rhs) = default;
+  static_histogram &operator=(static_histogram &&rhs) = default;
 
   template <typename... Axis>
-  explicit histogram(const Axis &... axis) : axes_(axis...) {
+  explicit static_histogram(const Axis &... axis) : axes_(axis...) {
     storage_ = Storage(bincount_from_axes());
   }
 
-  explicit histogram(axes_type &&axes) : axes_(std::move(axes)) {
+  explicit static_histogram(axes_type &&axes) : axes_(std::move(axes)) {
     storage_ = Storage(bincount_from_axes());
   }
 
-  template <typename D, typename A, typename S>
-  explicit histogram(const histogram<D, A, S> &rhs) : storage_(rhs.storage_) {
+  template <typename S>
+  explicit static_histogram(const static_histogram<Axes, S> &rhs) : storage_(rhs.storage_) {
     detail::axes_assign(axes_, rhs.axes_);
   }
 
-  template <typename D, typename A, typename S>
-  histogram &operator=(const histogram<D, A, S> &rhs) {
+  template <typename A, typename S>
+  explicit static_histogram(const dynamic_histogram<A, S> &rhs) : storage_(rhs.storage_) {
+    detail::axes_assign(axes_, rhs.axes_);
+  }
+
+  template <typename S>
+  static_histogram &operator=(const static_histogram<Axes, S> &rhs) {
     if (static_cast<const void *>(this) != static_cast<const void *>(&rhs)) {
       detail::axes_assign(axes_, rhs.axes_);
       storage_ = rhs.storage_;
@@ -79,30 +84,62 @@ public:
     return *this;
   }
 
-  template <typename D, typename A, typename S>
-  bool operator==(const histogram<D, A, S> &rhs) const {
+  template <typename A, typename S>
+  static_histogram &operator=(const dynamic_histogram<A, S> &rhs) {
+    if (static_cast<const void *>(this) != static_cast<const void *>(&rhs)) {
+      detail::axes_assign(axes_, rhs.axes_);
+      storage_ = rhs.storage_;
+    }
+    return *this;
+  }
+
+  template <typename A, typename S>
+  bool operator==(const static_histogram<A, S> &rhs) const noexcept {
+    return false;
+  }
+
+  template <typename S>
+  bool operator==(const static_histogram<Axes, S> &rhs) const noexcept {
     return detail::axes_equal(axes_, rhs.axes_) && storage_ == rhs.storage_;
   }
 
-  template <typename D, typename A, typename S>
-  bool operator!=(const histogram<D, A, S> &rhs) const {
+  template <typename A, typename S>
+  bool operator==(const dynamic_histogram<A, S> &rhs) const noexcept {
+    return detail::axes_equal(axes_, rhs.axes_) && storage_ == rhs.storage_;
+  }
+
+  template <typename A, typename S>
+  bool operator!=(const static_histogram<A, S> &rhs) const noexcept {
     return !operator==(rhs);
   }
 
-  template <typename D, typename A, typename S>
-  histogram &operator+=(const histogram<D, A, S> &rhs) {
+  template <typename A, typename S>
+  bool operator!=(const dynamic_histogram<A, S> &rhs) const noexcept {
+    return !operator==(rhs);
+  }
+
+  template <typename S>
+  static_histogram &operator+=(const static_histogram<Axes, S> &rhs) {
     if (!detail::axes_equal(axes_, rhs.axes_))
       throw std::logic_error("axes of histograms differ");
     storage_ += rhs.storage_;
     return *this;
   }
 
-  histogram &operator*=(const value_type rhs) {
+  template <typename A, typename S>
+  static_histogram &operator+=(const dynamic_histogram<A, S> &rhs) {
+    if (!detail::axes_equal(axes_, rhs.axes_))
+      throw std::logic_error("axes of histograms differ");
+    storage_ += rhs.storage_;
+    return *this;
+  }
+
+  static_histogram &operator*=(const value_type rhs) {
     storage_ *= rhs;
     return *this;
   }
 
-  histogram &operator/=(const value_type rhs) {
+  static_histogram &operator/=(const value_type rhs) {
     storage_ *= 1.0 / rhs;
     return *this;
   }
@@ -199,8 +236,8 @@ public:
   /// Returns a lower-dimensional histogram
   template <int N, typename... Rest>
   auto reduce_to(mpl::int_<N>, Rest...) const
-      -> histogram<Static, detail::axes_select<Axes, mpl::vector<mpl::int_<N>, Rest...>>, Storage> {
-    using HR = histogram<Static, detail::axes_select<Axes, mpl::vector<mpl::int_<N>, Rest...>>, Storage>;
+      -> static_histogram<detail::axes_select<Axes, mpl::vector<mpl::int_<N>, Rest...>>, Storage> {
+    using HR = static_histogram<detail::axes_select<Axes, mpl::vector<mpl::int_<N>, Rest...>>, Storage>;
     typename HR::axes_type axes;
     detail::axes_assign_subset<mpl::vector<mpl::int_<N>, Rest...>>(axes, axes_);
     auto hr = HR(std::move(axes));
@@ -323,25 +360,26 @@ private:
     } while (m.next());
   }
 
-  template <typename D, typename A, typename S> friend class histogram;
+  template <typename A, typename S> friend class static_histogram;
+  template <typename A, typename S> friend class dynamic_histogram;
   friend class ::boost::serialization::access;
   template <typename Archive> void serialize(Archive &, unsigned);
 };
 
 /// default static type factory
 template <typename... Axis>
-inline histogram<Static, mpl::vector<Axis...>>
+inline static_histogram<mpl::vector<Axis...>>
 make_static_histogram(Axis &&... axis) {
-  using h = histogram<Static, mpl::vector<Axis...>>;
+  using h = static_histogram<mpl::vector<Axis...>>;
   auto axes = typename h::axes_type(std::forward<Axis>(axis)...);
   return h(std::move(axes));
 }
 
 /// static type factory with variable storage type
 template <typename Storage, typename... Axis>
-inline histogram<Static, mpl::vector<Axis...>, Storage>
+inline static_histogram<mpl::vector<Axis...>, Storage>
 make_static_histogram_with(Axis &&... axis) {
-  using h = histogram<Static, mpl::vector<Axis...>, Storage>;
+  using h = static_histogram<mpl::vector<Axis...>, Storage>;
   auto axes = typename h::axes_type(std::forward<Axis>(axis)...);
   return h(std::move(axes));
 }
diff --git a/src/python/axis.cpp b/src/python/axis.cpp
index e6215161..36321a6d 100644
--- a/src/python/axis.cpp
+++ b/src/python/axis.cpp
@@ -5,8 +5,10 @@
 // or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 #include "utility.hpp"
-#include <boost/histogram/axis.hpp>
-#include <boost/histogram/axis_ostream_operators.hpp>
+#include <boost/histogram/histogram_fwd.hpp>
+#include <boost/histogram/axis/axis.hpp>
+#include <boost/histogram/axis/any.hpp>
+#include <boost/histogram/axis/ostream_operators.hpp>
 #include <boost/math/constants/constants.hpp>
 #include <boost/python.hpp>
 #include <boost/python/def_visitor.hpp>
diff --git a/src/python/histogram.cpp b/src/python/histogram.cpp
index e5bef8da..561c232f 100644
--- a/src/python/histogram.cpp
+++ b/src/python/histogram.cpp
@@ -6,9 +6,8 @@
 
 #include "serialization_suite.hpp"
 #include "utility.hpp"
-#include <boost/histogram/axis.hpp>
-#include <boost/histogram/histogram.hpp>
-#include <boost/histogram/histogram_ostream_operators.hpp>
+#include <boost/histogram/dynamic_histogram.hpp>
+#include <boost/histogram/ostream_operators.hpp>
 #include <boost/histogram/serialization.hpp>
 #include <boost/python.hpp>
 #include <boost/python/raw_function.hpp>
@@ -29,7 +28,7 @@ namespace np = boost::python::numpy;
 namespace boost {
 
 namespace histogram {
-using dynamic_histogram = histogram<Dynamic, axis::builtins, adaptive_storage>;
+using histogram = dynamic_histogram<axis::builtins, adaptive_storage>;
 } // namespace histogram
 
 namespace python {
@@ -92,7 +91,7 @@ public:
     }
   };
 
-  static object array_interface(const histogram::dynamic_histogram &self) {
+  static object array_interface(const histogram::histogram &self) {
     dict d;
     list shapes;
     list strides;
@@ -124,9 +123,9 @@ struct axis_visitor : public static_visitor<python::object> {
 
 struct axes_appender {
   python::object obj;
-  std::vector<dynamic_histogram::any_axis_type>& axes;
+  std::vector<histogram::any_axis_type>& axes;
   bool& success;
-  axes_appender(python::object o, std::vector<dynamic_histogram::any_axis_type>& a,
+  axes_appender(python::object o, std::vector<histogram::any_axis_type>& a,
                 bool& s) : obj(o), axes(a), success(s) {}
   template <typename A> void operator()(const A&) const {
     if (success) return;
@@ -138,7 +137,7 @@ struct axes_appender {
   }
 };
 
-python::object histogram_axis(const dynamic_histogram &self, int i) {
+python::object histogram_axis(const histogram &self, int i) {
   if (i < 0)
     i += self.dim();
   if (i < 0 || i >= int(self.dim())) {
@@ -161,11 +160,11 @@ python::object histogram_init(python::tuple args, python::dict kwargs) {
   const unsigned dim = len(args) - 1;
 
   // normal constructor
-  std::vector<dynamic_histogram::any_axis_type> axes;
+  std::vector<histogram::any_axis_type> axes;
   for (unsigned i = 0; i < dim; ++i) {
     python::object pa = args[i + 1];
     bool success = false;
-    mpl::for_each<dynamic_histogram::any_axis_type::types>(
+    mpl::for_each<histogram::any_axis_type::types>(
       axes_appender(pa, axes, success)
     );
     if (!success) {
@@ -175,7 +174,7 @@ python::object histogram_init(python::tuple args, python::dict kwargs) {
       python::throw_error_already_set();
     }
   }
-  dynamic_histogram h(axes.begin(), axes.end());
+  histogram h(axes.begin(), axes.end());
   return pyinit(h);
 }
 
@@ -214,7 +213,7 @@ struct fetcher {
 
 python::object histogram_fill(python::tuple args, python::dict kwargs) {
   const auto nargs = python::len(args);
-  dynamic_histogram &self = python::extract<dynamic_histogram &>(args[0]);
+  histogram &self = python::extract<histogram &>(args[0]);
 
   const unsigned dim = nargs - 1;
   if (dim != self.dim()) {
@@ -293,7 +292,7 @@ python::object histogram_fill(python::tuple args, python::dict kwargs) {
 }
 
 python::object histogram_value(python::tuple args, python::dict kwargs) {
-  const dynamic_histogram & self = python::extract<const dynamic_histogram &>(args[0]);
+  const histogram & self = python::extract<const histogram &>(args[0]);
 
   const unsigned dim = len(args) - 1;
   if (self.dim() != dim) {
@@ -321,8 +320,8 @@ python::object histogram_value(python::tuple args, python::dict kwargs) {
 }
 
 python::object histogram_variance(python::tuple args, python::dict kwargs) {
-  const dynamic_histogram &self =
-      python::extract<const dynamic_histogram &>(args[0]);
+  const histogram &self =
+      python::extract<const histogram &>(args[0]);
 
   const unsigned dim = len(args) - 1;
   if (self.dim() != dim) {
@@ -349,7 +348,7 @@ python::object histogram_variance(python::tuple args, python::dict kwargs) {
   return python::object(self.variance(idx, idx + self.dim()));
 }
 
-std::string histogram_repr(const dynamic_histogram &h) {
+std::string histogram_repr(const histogram &h) {
   std::ostringstream os;
   os << h;
   return os.str();
@@ -358,17 +357,17 @@ std::string histogram_repr(const dynamic_histogram &h) {
 void register_histogram() {
   python::docstring_options dopt(true, true, false);
 
-  python::class_<dynamic_histogram, boost::shared_ptr<dynamic_histogram>>(
+  python::class_<histogram, boost::shared_ptr<histogram>>(
       "histogram", "N-dimensional histogram for real-valued data.", python::no_init)
       .def("__init__", python::raw_function(histogram_init),
            ":param axis args: axis objects"
            "\nPass one or more axis objects to configure the histogram.")
       // shadowed C++ ctors
-      .def(python::init<const dynamic_histogram &>())
+      .def(python::init<const histogram &>())
 #ifdef HAVE_NUMPY
       .add_property("__array_interface__", &python::access::array_interface)
 #endif
-      .add_property("dim", &dynamic_histogram::dim)
+      .add_property("dim", &histogram::dim)
       .def("axis", histogram_axis, python::arg("i") = 0,
            ":param int i: axis index"
            "\n:return: corresponding axis object")
@@ -380,9 +379,9 @@ void register_histogram() {
            "\nIf Numpy support is enabled, 1d-arrays can be passed instead of"
            "\nvalues, which must be equal in lenght. Arrays and values can"
            "\nbe mixed arbitrarily in the same call.")
-      .add_property("bincount", &dynamic_histogram::bincount,
+      .add_property("bincount", &histogram::bincount,
            ":return: total number of bins, including under- and overflow")
-      .add_property("sum", &dynamic_histogram::sum,
+      .add_property("sum", &histogram::sum,
            ":return: sum of all entries, including under- and overflow bins")
       .def("value", python::raw_function(histogram_value),
            ":param int args: indices of the bin (number must match dimension)"
@@ -398,7 +397,7 @@ void register_histogram() {
       .def(python::self * double())
       .def(double() * python::self)
       .def(python::self + python::self)
-      .def_pickle(serialization_suite<dynamic_histogram>());
+      .def_pickle(serialization_suite<histogram>());
 }
 
 } // NS histogram
diff --git a/test/axis_size.cpp b/test/axis_size.cpp
index dcd16d1f..7d7bcab3 100644
--- a/test/axis_size.cpp
+++ b/test/axis_size.cpp
@@ -4,7 +4,9 @@
 // (See accompanying file LICENSE_1_0.txt
 // or copy at http://www.boost.org/LICENSE_1_0.txt)
 
-#include <boost/histogram/axis.hpp>
+#include <boost/histogram/histogram_fwd.hpp>
+#include <boost/histogram/axis/axis.hpp>
+#include <boost/histogram/axis/any.hpp>
 #include <boost/variant.hpp>
 #include <iostream>
 
@@ -15,13 +17,13 @@ namespace boost { namespace histogram {
 
 int main() {
 
-#define SIZEOF(axis)                                                           \
+#define SIZEOF(axis)                                                        \
   std::cout << #axis << " " << sizeof(boost::histogram::axis) << std::endl
 SIZEOF(axis::regular<>);
 SIZEOF(axis::circular<>);
 SIZEOF(axis::variable<>);
 SIZEOF(axis::integer<>);
 SIZEOF(axis::category<>);
-SIZEOF(axis_variant);
+SIZEOF(axis::any<>);
 
 }
diff --git a/test/axis_test.cpp b/test/axis_test.cpp
index 8afeb835..6e0076fd 100644
--- a/test/axis_test.cpp
+++ b/test/axis_test.cpp
@@ -8,8 +8,10 @@
 #include <boost/fusion/container/generation/make_vector.hpp>
 #include <boost/fusion/include/make_vector.hpp>
 #include <boost/fusion/include/vector.hpp>
-#include <boost/histogram/axis.hpp>
-#include <boost/histogram/axis_ostream_operators.hpp>
+#include <boost/histogram/axis/axis.hpp>
+#include <boost/histogram/axis/any.hpp>
+#include <boost/histogram/histogram_fwd.hpp>
+#include <boost/histogram/axis/ostream_operators.hpp>
 #include <boost/histogram/detail/axis_visitor.hpp>
 #include <boost/histogram/detail/utility.hpp>
 #include <boost/math/constants/constants.hpp>
diff --git a/test/histogram_test.cpp b/test/histogram_test.cpp
index 5fd3eea2..a2e6994e 100644
--- a/test/histogram_test.cpp
+++ b/test/histogram_test.cpp
@@ -7,13 +7,13 @@
 #include <boost/archive/text_iarchive.hpp>
 #include <boost/archive/text_oarchive.hpp>
 #include <boost/core/lightweight_test.hpp>
-#include <boost/histogram/axis_ostream_operators.hpp>
 #include <boost/histogram/histogram.hpp>
-#include <boost/histogram/histogram_ostream_operators.hpp>
+#include <boost/histogram/ostream_operators.hpp>
 #include <boost/histogram/literals.hpp>
 #include <boost/histogram/serialization.hpp>
 #include <boost/histogram/storage/adaptive_storage.hpp>
 #include <boost/histogram/storage/array_storage.hpp>
+#include <boost/mpl/int.hpp>
 #include <limits>
 #include <sstream>
 #include <vector>
@@ -23,6 +23,9 @@ using namespace boost::histogram;
 using namespace boost::histogram::literals; // to get _c suffix
 namespace mpl = boost::mpl;
 
+using Static = mpl::int_<0>;
+using Dynamic = mpl::int_<1>;
+
 template <typename S, typename... Axes>
 auto make_histogram(Static, Axes &&... axes)
     -> decltype(make_static_histogram_with<S>(std::forward<Axes>(axes)...)) {
@@ -50,14 +53,14 @@ template <typename Type> void run_tests() {
   // init_0
   {
     auto h =
-        histogram<Static, mpl::vector<axis::integer<>>, adaptive_storage>();
+        static_histogram<mpl::vector<axis::integer<>>, adaptive_storage>();
     BOOST_TEST_EQ(h.dim(), 1);
     BOOST_TEST_EQ(h.bincount(), 0);
-    auto h2 = histogram<Static, mpl::vector<axis::integer<>>,
+    auto h2 = static_histogram<mpl::vector<axis::integer<>>,
                         array_storage<unsigned>>();
     BOOST_TEST_EQ(h2, h);
     auto h3 =
-        histogram<Static, mpl::vector<axis::regular<>>, adaptive_storage>();
+        static_histogram<mpl::vector<axis::regular<>>, adaptive_storage>();
     BOOST_TEST_NE(h3, h);
   }
 
@@ -136,7 +139,7 @@ template <typename Type> void run_tests() {
     h.fill(0, 0);
     auto h2 = decltype(h)(h);
     BOOST_TEST(h2 == h);
-    auto h3 = histogram<Static, mpl::vector<axis::integer<>, axis::integer<>>,
+    auto h3 = static_histogram<mpl::vector<axis::integer<>, axis::integer<>>,
                         array_storage<unsigned>>(h);
     BOOST_TEST_EQ(h3, h);
   }
@@ -153,7 +156,7 @@ template <typename Type> void run_tests() {
     // test self-assign
     h2 = h2;
     BOOST_TEST_EQ(h, h2);
-    auto h3 = histogram<Static, mpl::vector<axis::integer<>, axis::integer<>>,
+    auto h3 = static_histogram<mpl::vector<axis::integer<>, axis::integer<>>,
                         array_storage<unsigned>>();
     h3 = h;
     BOOST_TEST_EQ(h, h3);
@@ -808,8 +811,8 @@ template <typename T1, typename T2> void run_mixed_tests() {
 int main() {
 
   // common interface
-  run_tests<boost::histogram::Static>();
-  run_tests<boost::histogram::Dynamic>();
+  run_tests<Static>();
+  run_tests<Dynamic>();
 
   // special stuff that only works with Dynamic
 
@@ -873,8 +876,8 @@ int main() {
     BOOST_TEST(axis_equal(Dynamic(), h1_1.axis(), h1.axis(1_c)));
   }
 
-  run_mixed_tests<boost::histogram::Static, boost::histogram::Dynamic>();
-  run_mixed_tests<boost::histogram::Dynamic, boost::histogram::Static>();
+  run_mixed_tests<Static, Dynamic>();
+  run_mixed_tests<Dynamic, Static>();
 
   return boost::report_errors();
 }
diff --git a/test/speed_cpp.cpp b/test/speed_cpp.cpp
index 1f3c587f..36289ef1 100644
--- a/test/speed_cpp.cpp
+++ b/test/speed_cpp.cpp
@@ -108,18 +108,18 @@ int main() {
     else
       printf("normal distribution\n");
     printf("hs_ss %.3f\n",
-           compare_1d<histogram<Static,mpl::vector<axis::regular<>>,
+           compare_1d<static_histogram<mpl::vector<axis::regular<>>,
                                 array_storage<int>>>(
                6000000, itype));
     printf("hs_sd %.3f\n",
-           compare_1d<histogram<Static,mpl::vector<axis::regular<>>,
+           compare_1d<static_histogram<mpl::vector<axis::regular<>>,
                                 adaptive_storage>>(6000000, itype));
     printf("hd_ss %.3f\n",
-           compare_1d<histogram<Dynamic, axis::builtins,
+           compare_1d<dynamic_histogram<axis::builtins,
                                 array_storage<int>>>(
                6000000, itype));
     printf("hd_sd %.3f\n",
-           compare_1d<histogram<Dynamic, axis::builtins, adaptive_storage>>(
+           compare_1d<dynamic_histogram<axis::builtins, adaptive_storage>>(
                6000000, itype));
   }
 
@@ -130,19 +130,19 @@ int main() {
     else
       printf("normal distribution\n");
     printf("hs_ss %.3f\n",
-           compare_2d<histogram<Static,
+           compare_2d<static_histogram<
                mpl::vector<axis::regular<>, axis::regular<>>,
                array_storage<int>>>(6000000, itype));
     printf("hs_sd %.3f\n",
-           compare_2d<histogram<Static,
+           compare_2d<static_histogram<
                mpl::vector<axis::regular<>, axis::regular<>>,
                adaptive_storage>>(6000000, itype));
     printf("hd_ss %.3f\n",
-           compare_2d<histogram<Dynamic, axis::builtins,
+           compare_2d<dynamic_histogram<axis::builtins,
                       array_storage<int>>>(
                6000000, itype));
     printf("hd_sd %.3f\n",
-           compare_2d<histogram<Dynamic, axis::builtins, adaptive_storage>>(
+           compare_2d<dynamic_histogram<axis::builtins, adaptive_storage>>(
                6000000, itype));
   }
 
@@ -153,19 +153,19 @@ int main() {
     else
       printf("normal distribution\n");
     printf("hs_ss %.3f\n",
-           compare_3d<histogram<Static,
+           compare_3d<static_histogram<
                mpl::vector<axis::regular<>, axis::regular<>, axis::regular<>>,
                array_storage<int>>>(6000000, itype));
     printf("hs_sd %.3f\n",
-           compare_3d<histogram<Static,
+           compare_3d<static_histogram<
                mpl::vector<axis::regular<>, axis::regular<>, axis::regular<>>,
                adaptive_storage>>(6000000, itype));
     printf("hd_ss %.3f\n",
-           compare_3d<histogram<Dynamic, axis::builtins,
+           compare_3d<dynamic_histogram<axis::builtins,
                                 array_storage<int>>>(
                6000000, itype));
     printf("hd_sd %.3f\n",
-           compare_3d<histogram<Dynamic, axis::builtins, adaptive_storage>>(
+           compare_3d<dynamic_histogram<axis::builtins, adaptive_storage>>(
                6000000, itype));
   }
 
@@ -176,21 +176,21 @@ int main() {
     else
       printf("normal distribution\n");
     printf("hs_ss %.3f\n",
-           compare_6d<histogram<Static,
+           compare_6d<static_histogram<
                mpl::vector<axis::regular<>, axis::regular<>, axis::regular<>,
                            axis::regular<>, axis::regular<>, axis::regular<>>,
                array_storage<int>>>(6000000, itype));
     printf("hs_sd %.3f\n",
-           compare_6d<histogram<Static,
+           compare_6d<static_histogram<
                mpl::vector<axis::regular<>, axis::regular<>, axis::regular<>,
                            axis::regular<>, axis::regular<>, axis::regular<>>,
                adaptive_storage>>(6000000, itype));
     printf("hd_ss %.3f\n",
-           compare_6d<histogram<Dynamic, axis::builtins,
+           compare_6d<dynamic_histogram<axis::builtins,
                                 array_storage<int>>>(
                6000000, itype));
     printf("hd_sd %.3f\n",
-           compare_6d<histogram<Dynamic, axis::builtins, adaptive_storage>>(
+           compare_6d<dynamic_histogram<axis::builtins, adaptive_storage>>(
                6000000, itype));
   }
 }