I was responding to some of the examples in Robert Stewart's reply, which I snipped unfortunately. I hadn't even looked at your library yet. I see that most of my comments do not apply to your code. Often, when I receive a "message" over-the-wire, I only want to examine some fields of the message and ignore the rest. Different sections of code process different parts of received messages, so it would be dangerous to do in-place swapping (for my way of doing things). Beman's approach has gradually become more integer-centric over time, with alignment support and supporting odd-sized integers. I believe that the endian problem is primarily an interface problem. Here is a simplified version of Beman's approach that is quite simple and just wraps a user-type T, so you would just write struct MyMessage { endian<big, MyType> big_field; endian<little, MyType> lil_field; endian<native, MyType> scary_field; }; // Message in your over-the-wire messages and then MyType x = msg.big_field; msg.lil_field = x; Here's the (draft, possibly naive) code for this approach. terry namespace boost { namespace interface { struct uninitialized_t { }; static const uninitialized_t uninitialized; enum endian_t { little, big }; #ifdef BOOST_BIG_ENDIAN static const endian_t native = big; #else static const endian_t native = little; #endif namespace detail { template<endian_t E, class T, std::size_t L> inline void Retrieve(T* value, const array<uint8_t, L>& bytes); template<endian_t E, class T std::size_t L> inline void Store(array<uint8_t, L>& bytes, const T& value); } // detail #pragma pack(push, 1) template<endian_t E, class T> class endian { public: static const endian_t endian_type = E; typedef T value_type; private: static const std::size_t storage_size = sizeof(T); array<uint8_t, storage_size> m_storage; public: endian() { detail::Store<endian_type>(m_storage, T()); } endian(uninitialized_t) { } endian(const value_type& x) { detail::Store<endian_type>(m_storage, x); } value_type value() const { value_type rval; detail::Retrieve<endian_type>(&rval, m_storage); return rval; } // value operator value_type() const { return value(); } endian& operator=(const value_type& rhs) { detail::Store<endian_type>(m_storage, rhs); return *this; } // operator= }; // endian // Specialize for native endian types. template<endian_t E, class T> class endian<native, T> { public: static const endian_t endian_type = native; typedef T value_type; private: T m_value; public: endian() : m_value() { } endian(uninitiazed_t) { } endian(const value_type& x) : m_value(x) { } value_type value() const { return m_value; } operator value_type() const { return value(); } endian& operator=(const value_type& rhs) { m_value = rhs; } }; // endian #pragma pack(pop) } } // boost::interface