Initial commit
diff --git a/include/pybind/cast.h b/include/pybind/cast.h
new file mode 100644
index 0000000..6b3b96e
--- /dev/null
+++ b/include/pybind/cast.h
@@ -0,0 +1,526 @@
+/*
+    pybind/cast.h: Partial template specializations to cast between
+    C++ and Python types
+
+    Copyright (c) 2015 Wenzel Jakob <wenzel@inf.ethz.ch>
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE file.
+*/
+
+#if !defined(__PYBIND_CAST)
+#define __PYBIND_CAST
+
+#include "pytypes.h"
+#include "mpl.h"
+#include "typeid.h"
+#include <map>
+#include <array>
+
+NAMESPACE_BEGIN(pybind)
+NAMESPACE_BEGIN(detail)
+
+/// Generic type caster for objects stored on the heap
+template <typename type> class type_caster {
+public:
+    typedef instance<type> instance_type;
+
+    static std::string name() { return type_id<type>(); }
+
+    type_caster() {
+        auto const& registered_types = get_internals().registered_types;
+        auto it = registered_types.find(type_id<type>());
+        if (it != registered_types.end())
+            typeinfo = &it->second;
+    }
+
+    bool load(PyObject *src, bool convert) {
+        if (src == nullptr || typeinfo == nullptr)
+            return false;
+        if (PyType_IsSubtype(Py_TYPE(src), typeinfo->type)) {
+            value = ((instance_type *) src)->value;
+            return true;
+        }
+        if (convert) {
+            for (auto &converter : typeinfo->implicit_conversions) {
+                temp = object(converter(src, typeinfo->type), false);
+                if (load(temp.ptr(), false))
+                    return true;
+            }
+        }
+        return false;
+    }
+
+    static PyObject *cast(const type &src, return_value_policy policy, PyObject *parent) {
+        if (policy == return_value_policy::automatic)
+            policy = return_value_policy::copy;
+        return cast(&src, policy, parent);
+    }
+
+    static PyObject *cast(const type *_src, return_value_policy policy, PyObject *parent) {
+        type *src = const_cast<type *>(_src);
+        if (src == nullptr) {
+            Py_INCREF(Py_None);
+            return Py_None;
+        }
+        // avoid an issue with internal references matching their parent's address
+        bool dont_cache = parent && ((instance<void> *) parent)->value == (void *) src;
+        auto& internals = get_internals();
+        auto it_instance = internals.registered_instances.find(src);
+        if (it_instance != internals.registered_instances.end() && !dont_cache) {
+            PyObject *inst = it_instance->second;
+            Py_INCREF(inst);
+            return inst;
+        }
+        auto it = internals.registered_types.find(type_id<type>());
+        if (it == internals.registered_types.end()) {
+            std::string msg = std::string("Unregistered type : ") + type_id<type>();
+            PyErr_SetString(PyExc_TypeError, msg.c_str());
+            return nullptr;
+        }
+        auto &type_info = it->second;
+        instance_type *inst = (instance_type *) PyType_GenericAlloc(type_info.type, 0);
+        inst->value = src;
+        inst->owned = true;
+        inst->parent = nullptr;
+        if (policy == return_value_policy::automatic)
+            policy = return_value_policy::take_ownership;
+        handle_return_value_policy<type>(inst, policy, parent);
+        PyObject *inst_pyobj = (PyObject *) inst;
+        type_info.init_holder(inst_pyobj);
+        if (!dont_cache)
+            internals.registered_instances[inst->value] = inst_pyobj;
+        return inst_pyobj;
+    }
+
+    template <class T, typename std::enable_if<std::is_copy_constructible<T>::value, int>::type = 0>
+    static void handle_return_value_policy(instance<T> *inst, return_value_policy policy, PyObject *parent) {
+        if (policy == return_value_policy::copy) {
+            inst->value = new T(*(inst->value));
+        } else if (policy == return_value_policy::reference) {
+            inst->owned = false;
+        } else if (policy == return_value_policy::reference_internal) {
+            inst->owned = false;
+            inst->parent = parent;
+            Py_XINCREF(parent);
+        }
+    }
+
+    template <class T, typename std::enable_if<!std::is_copy_constructible<T>::value, int>::type = 0>
+    static void handle_return_value_policy(instance<T> *inst, return_value_policy policy, PyObject *parent) {
+        if (policy == return_value_policy::copy) {
+            throw cast_error("return_value_policy = copy, but the object is non-copyable!");
+        } else if (policy == return_value_policy::reference) {
+            inst->owned = false;
+        } else if (policy == return_value_policy::reference_internal) {
+            inst->owned = false;
+            inst->parent = parent;
+            Py_XINCREF(parent);
+        }
+    }
+
+    operator type*() { return value; }
+    operator type&() { return *value; }
+protected:
+    type *value = nullptr;
+    const type_info *typeinfo = nullptr;
+    object temp;
+};
+
+#define TYPE_CASTER(type, py_name) \
+    protected: \
+        type value; \
+    public: \
+        static std::string name() { return py_name; } \
+        static PyObject *cast(const type *src, return_value_policy policy, PyObject *parent) { \
+            return cast(*src, policy, parent); \
+        } \
+        operator type*() { return &value; } \
+        operator type&() { return value; } \
+
+#define TYPE_CASTER_NUMBER(type, py_type, from_type, to_pytype) \
+    template <> class type_caster<type> { \
+    public: \
+        bool load(PyObject *src, bool) { \
+            value = (type) from_type(src); \
+            if (value == (type) -1 && PyErr_Occurred()) { \
+                PyErr_Clear(); \
+                return false; \
+            } \
+            return true; \
+        } \
+        static PyObject *cast(type src, return_value_policy /* policy */, PyObject * /* parent */) { \
+            return to_pytype((py_type) src); \
+        } \
+        TYPE_CASTER(type, #type); \
+    };
+
+TYPE_CASTER_NUMBER(int32_t, long, PyLong_AsLong, PyLong_FromLong)
+TYPE_CASTER_NUMBER(uint32_t, unsigned long, PyLong_AsUnsignedLong, PyLong_FromUnsignedLong)
+TYPE_CASTER_NUMBER(int64_t, PY_LONG_LONG, PyLong_AsLongLong, PyLong_FromLongLong)
+TYPE_CASTER_NUMBER(uint64_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong, PyLong_FromUnsignedLongLong)
+
+#if defined(__APPLE__) // size_t/ssize_t are separate types on Mac OS X
+TYPE_CASTER_NUMBER(ssize_t, Py_ssize_t, PyLong_AsSsize_t, PyLong_FromSsize_t)
+TYPE_CASTER_NUMBER(size_t, size_t, PyLong_AsSize_t, PyLong_FromSize_t)
+#endif
+
+TYPE_CASTER_NUMBER(float, float, PyFloat_AsDouble, PyFloat_FromDouble)
+TYPE_CASTER_NUMBER(double, double, PyFloat_AsDouble, PyFloat_FromDouble)
+
+template <> class type_caster<mpl::detail::void_type> {
+public:
+    bool load(PyObject *, bool) { return true; }
+    static PyObject *cast(mpl::detail::void_type, return_value_policy /* policy */, PyObject * /* parent */) {
+        Py_INCREF(Py_None);
+        return Py_None;
+    }
+    TYPE_CASTER(mpl::detail::void_type, "None");
+};
+
+template <> class type_caster<bool> {
+public:
+    bool load(PyObject *src, bool) {
+        if (src == Py_True) { value = true; return true; }
+        else if (src == Py_False) { value = false; return true; }
+        else return false;
+    }
+    static PyObject *cast(bool src, return_value_policy /* policy */, PyObject * /* parent */) {
+        PyObject *result = src ? Py_True : Py_False;
+        Py_INCREF(result);
+        return result;
+    }
+    TYPE_CASTER(bool, "bool");
+};
+
+template <> class type_caster<std::string> {
+public:
+    bool load(PyObject *src, bool) {
+        const char *ptr = PyUnicode_AsUTF8(src);
+        if (!ptr) { PyErr_Clear(); return false; }
+        value = std::string(ptr);
+        return true;
+    }
+    static PyObject *cast(const std::string &src, return_value_policy /* policy */, PyObject * /* parent */) {
+        return PyUnicode_FromString(src.c_str());
+    }
+    TYPE_CASTER(std::string, "str");
+};
+
+template <> class type_caster<char> {
+public:
+    bool load(PyObject *src, bool) {
+        char *ptr = PyUnicode_AsUTF8(src);
+        if (!ptr) { PyErr_Clear(); return false; }
+        value = ptr;
+        return true;
+    }
+
+    static PyObject *cast(const char *src, return_value_policy /* policy */, PyObject * /* parent */) {
+        return PyUnicode_FromString(src);
+    }
+
+    static PyObject *cast(char src, return_value_policy /* policy */, PyObject * /* parent */) {
+        char str[2] = { src, '\0' };
+        return PyUnicode_DecodeLatin1(str, 1, nullptr);
+    }
+
+    static std::string name() { return "str"; }
+
+    operator char*() { return value; }
+    operator char() { return *value; }
+protected:
+    char *value;
+};
+
+template <typename Value> struct type_caster<std::vector<Value>> {
+    typedef std::vector<Value> type;
+    typedef type_caster<Value> value_conv;
+public:
+    bool load(PyObject *src, bool convert) {
+        if (!PyList_Check(src))
+            return false;
+        size_t size = (size_t) PyList_GET_SIZE(src);
+        value.reserve(size);
+        value.clear();
+        for (size_t i=0; i<size; ++i) {
+            value_conv conv;
+            if (!conv.load(PyList_GetItem(src, (ssize_t) i), convert))
+                return false;
+            value.push_back((Value) conv);
+        }
+        return true;
+    }
+
+    static PyObject *cast(const type &src, return_value_policy policy, PyObject *parent) {
+        PyObject *list = PyList_New(src.size());
+        size_t index = 0;
+        for (auto const &value: src) {
+            PyObject *value_ = value_conv::cast(value, policy, parent);
+            if (!value_) {
+                Py_DECREF(list);
+                return nullptr;
+            }
+            PyList_SetItem(list, index++, value_);
+        }
+        return list;
+    }
+    TYPE_CASTER(type, "list<" + value_conv::name() + ">");
+};
+
+template <typename Key, typename Value> struct type_caster<std::map<Key, Value>> {
+public:
+    typedef std::map<Key, Value>  type;
+    typedef type_caster<Key>   key_conv;
+    typedef type_caster<Value> value_conv;
+
+    bool load(PyObject *src, bool convert) {
+        if (!PyDict_Check(src))
+            return false;
+
+        value.clear();
+        PyObject *key_, *value_;
+        ssize_t pos = 0;
+        key_conv kconv;
+        value_conv vconv;
+        while (PyDict_Next(src, &pos, &key_, &value_)) {
+            if (!kconv.load(key_, convert) || !vconv.load(value_, convert))
+                return false;
+            value[kconv] = vconv;
+        }
+        return true;
+    }
+
+    static PyObject *cast(const type &src, return_value_policy policy, PyObject *parent) {
+        PyObject *dict = PyDict_New();
+        for (auto const &kv: src) {
+            PyObject *key   = key_conv::cast(kv.first, policy, parent);
+            PyObject *value = value_conv::cast(kv.second, policy, parent);
+            if (!key || !value || PyDict_SetItem(dict, key, value) < 0) {
+                Py_XDECREF(key);
+                Py_XDECREF(value);
+                Py_DECREF(dict);
+                return nullptr;
+            }
+            Py_DECREF(key);
+            Py_DECREF(value);
+        }
+        return dict;
+    }
+    TYPE_CASTER(type, "dict<" + key_conv::name() + ", " + value_conv::name() + ">");
+};
+
+template <typename T1, typename T2> class type_caster<std::pair<T1, T2>> {
+    typedef std::pair<T1, T2> type;
+public:
+    bool load(PyObject *src, bool convert) {
+        if (!PyTuple_Check(src) || PyTuple_Size(src) != 2)
+            return false;
+        if (!first.load(PyTuple_GetItem(src, 0), convert))
+            return false;
+        return second.load(PyTuple_GetItem(src, 1), convert);
+    }
+
+    static PyObject *cast(const type &src, return_value_policy policy, PyObject *parent) {
+        PyObject *o1 = type_caster<typename mpl::normalize_type<T1>::type>::cast(src.first, policy, parent);
+        PyObject *o2 = type_caster<typename mpl::normalize_type<T2>::type>::cast(src.second, policy, parent);
+        if (!o1 || !o2) {
+            Py_XDECREF(o1);
+            Py_XDECREF(o2);
+            return nullptr;
+        }
+        PyObject *tuple = PyTuple_New(2);
+        PyTuple_SetItem(tuple, 0, o1);
+        PyTuple_SetItem(tuple, 1, o2);
+        return tuple;
+    }
+
+    static std::string name() {
+        return "(" + type_caster<T1>::name() + ", " + type_caster<T2>::name() + ")";
+    }
+
+    operator type() {
+        return type(first, second);
+    }
+protected:
+    type_caster<typename mpl::normalize_type<T1>::type> first;
+    type_caster<typename mpl::normalize_type<T2>::type> second;
+};
+
+template <typename ... Tuple> class type_caster<std::tuple<Tuple...>> {
+    typedef std::tuple<Tuple...> type;
+public:
+    enum { size = sizeof...(Tuple) };
+
+    bool load(PyObject *src, bool convert) {
+        return load(src, convert, typename mpl::make_index_sequence<sizeof...(Tuple)>::type());
+    }
+
+    static PyObject *cast(const type &src, return_value_policy policy, PyObject *parent) {
+        return cast(src, policy, parent, typename mpl::make_index_sequence<size>::type());
+    }
+
+    static std::string name() {
+        std::array<std::string, size> names {{
+            type_caster<typename mpl::normalize_type<Tuple>::type>::name()...
+        }};
+        std::string result("(");
+        int counter = 0;
+        for (auto const &name : names) {
+            result += name;
+            if (++counter < size)
+                result += ", ";
+        }
+        result += ")";
+        return result;
+    }
+
+    operator type() {
+        return cast(typename mpl::make_index_sequence<sizeof...(Tuple)>::type());
+    }
+protected:
+    template <size_t ... Index> type cast(mpl::index_sequence<Index...>) {
+        return type((Tuple) std::get<Index>(value)...);
+    }
+
+    template <size_t ... Indices> bool load(PyObject *src, bool convert, mpl::index_sequence<Indices...>) {
+        if (!PyTuple_Check(src))
+            return false;
+        if (PyTuple_Size(src) != size)
+            return false;
+        std::array<bool, size> results {{
+            std::get<Indices>(value).load(PyTuple_GetItem(src, Indices), convert)...
+        }};
+        for (bool r : results)
+            if (!r)
+                return false;
+        return true;
+    }
+
+    /* Implementation: Convert a C++ tuple into a Python tuple */
+    template <size_t ... Indices> static PyObject *cast(const type &src, return_value_policy policy, PyObject *parent, mpl::index_sequence<Indices...>) {
+        std::array<PyObject *, size> results {{
+            type_caster<typename mpl::normalize_type<Tuple>::type>::cast(std::get<Indices>(src), policy, parent)...
+        }};
+        bool success = true;
+        for (auto result : results)
+            if (result == nullptr)
+                success = false;
+        if (success) {
+            PyObject *tuple = PyTuple_New(size);
+            int counter = 0;
+            for (auto result : results)
+                PyTuple_SetItem(tuple, counter++, result);
+            return tuple;
+        } else {
+            for (auto result : results) {
+                Py_XDECREF(result);
+            }
+            return nullptr;
+        }
+    }
+
+protected:
+    std::tuple<type_caster<typename mpl::normalize_type<Tuple>::type>...> value;
+};
+
+/// Type caster for holder types like std::shared_ptr, etc.
+template <typename type, typename holder_type> class type_caster_holder : public type_caster<type> {
+public:
+    typedef type_caster<type> parent;
+    bool load(PyObject *src, bool convert) {
+        if (!parent::load(src, convert))
+            return false;
+        holder = holder_type(parent::value);
+        return true;
+    }
+    explicit operator type*() { return this->value; }
+    explicit operator type&() { return *(this->value); }
+    explicit operator holder_type&() { return holder; }
+    explicit operator holder_type*() { return &holder; }
+protected:
+    holder_type holder;
+};
+
+template <> class type_caster<handle> {
+public:
+    bool load(PyObject *src) {
+        value = handle(src);
+        return true;
+    }
+    static PyObject *cast(const handle &src, return_value_policy /* policy */, PyObject * /* parent */) {
+        src.inc_ref();
+        return (PyObject *) src.ptr();
+    }
+    TYPE_CASTER(handle, "handle");
+};
+
+#define TYPE_CASTER_PYTYPE(name) \
+    template <> class type_caster<name> { \
+    public: \
+        bool load(PyObject *src, bool) { value = name(src, true); return true; } \
+        static PyObject *cast(const name &src, return_value_policy /* policy */, PyObject * /* parent */) { \
+            src.inc_ref(); return (PyObject *) src.ptr(); \
+        } \
+        TYPE_CASTER(name, #name); \
+    };
+
+TYPE_CASTER_PYTYPE(object)
+TYPE_CASTER_PYTYPE(buffer)
+TYPE_CASTER_PYTYPE(capsule)
+TYPE_CASTER_PYTYPE(dict)
+TYPE_CASTER_PYTYPE(float_)
+TYPE_CASTER_PYTYPE(int_)
+TYPE_CASTER_PYTYPE(list)
+TYPE_CASTER_PYTYPE(slice)
+TYPE_CASTER_PYTYPE(tuple)
+
+#undef TYPE_CASTER
+#undef TYPE_CASTER_NUMBER
+#undef TYPE_CASTER_PYTYPE
+
+NAMESPACE_END(detail)
+
+template <typename T> inline T cast(PyObject *object) {
+    detail::type_caster<typename mpl::normalize_type<T>::type> conv;
+    if (!conv.load(object, true))
+        throw cast_error("Unable to cast Python object to C++ type");
+    return conv;
+}
+
+template <typename T> inline object cast(const T &value, return_value_policy policy = return_value_policy::automatic, PyObject *parent = nullptr) {
+    if (policy == return_value_policy::automatic)
+        policy = std::is_pointer<T>::value ? return_value_policy::take_ownership : return_value_policy::copy;
+    return object(detail::type_caster<typename mpl::normalize_type<T>::type>::cast(value, policy, parent), false);
+}
+
+template <typename T> inline T handle::cast() { return pybind::cast<T>(m_ptr); }
+
+template <typename ... Args> inline object handle::call(Args&&... args_) {
+    const size_t size = sizeof...(Args);
+    std::array<PyObject *, size> args{
+        { detail::type_caster<typename mpl::normalize_type<Args>::type>::cast(
+            std::forward<Args>(args_), return_value_policy::automatic, nullptr)... }
+    };
+    bool fail = false;
+    for (auto result : args)
+        if (result == nullptr)
+            fail = true;
+    if (fail) {
+        for (auto result : args) {
+            Py_XDECREF(result);
+        }
+        throw cast_error("handle::call(): unable to convert input arguments to Python objects");
+    }
+    PyObject *tuple = PyTuple_New(size);
+    int counter = 0;
+    for (auto result : args)
+        PyTuple_SetItem(tuple, counter++, result);
+    PyObject *result = PyObject_CallObject(m_ptr, tuple);
+    Py_DECREF(tuple);
+    return object(result, false);
+}
+
+NAMESPACE_END(pybind)
+
+#endif /* __PYBIND_CAST */
diff --git a/include/pybind/common.h b/include/pybind/common.h
new file mode 100644
index 0000000..8310096
--- /dev/null
+++ b/include/pybind/common.h
@@ -0,0 +1,149 @@
+/*
+    pybind/common.h -- Basic macros
+
+    Copyright (c) 2015 Wenzel Jakob <wenzel@inf.ethz.ch>
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE file.
+*/
+
+#if !defined(__PYBIND_COMMON_H)
+#define __PYBIND_COMMON_H
+
+#if !defined(NAMESPACE_BEGIN)
+#define NAMESPACE_BEGIN(name) namespace name {
+#endif
+#if !defined(NAMESPACE_END)
+#define NAMESPACE_END(name) }
+#endif
+
+#if !defined(PYTHON_EXPORT)
+#if defined(WIN32)
+#define PYTHON_EXPORT __declspec(dllexport)
+#else
+#define PYTHON_EXPORT __attribute__ ((visibility("default")))
+#endif
+#endif
+
+#define PYTHON_PLUGIN(name) \
+    extern "C" PYTHON_EXPORT PyObject *PyInit_##name()
+
+#include <vector>
+#include <string>
+#include <stdexcept>
+#include <functional>
+#include <unordered_map>
+#include <iostream>
+#include <memory>
+
+/// Include Python header, disable linking to pythonX_d.lib on Windows in debug mode
+#if defined(_MSC_VER)
+#define HAVE_ROUND
+#pragma warning(push)
+#pragma warning(disable: 4510 4610 4512)
+#if _DEBUG
+#define _DEBUG_MARKER
+#undef _DEBUG
+#endif
+#endif
+#include <Python.h>
+#if defined(_MSC_VER)
+#if defined(_DEBUG_MARKER)
+#define _DEBUG
+#undef _DEBUG_MARKER
+#endif
+#pragma warning(pop)
+#endif
+
+NAMESPACE_BEGIN(pybind)
+
+typedef Py_ssize_t ssize_t;
+
+/// Approach used to cast a previously unknown C++ instance into a Python object
+enum class return_value_policy : int {
+    /** Automatic: copy objects returned as values and take ownership of objects
+        returned as pointers */
+    automatic = 0,
+    /** Reference the object and take ownership. Python will call the
+        destructor and delete operator when the reference count reaches zero */
+    take_ownership,
+    /** Reference the object, but do not take ownership (dangerous when C++ code
+        deletes it and Python still has a nonzero reference count) */
+    reference,
+    /** Reference the object, but do not take ownership. The object is considered
+        be owned by the C++ instance whose method or property returned it. The
+        Python object will increase the reference count of this 'parent' by 1 */
+    reference_internal,
+    /// Create a new copy of the returned object, which will be owned by Python
+    copy
+};
+
+/// Format strings for basic number types
+template <typename type> struct format_descriptor { };
+template<> struct format_descriptor<int8_t>   { static std::string value() { return "b"; }; };
+template<> struct format_descriptor<uint8_t>  { static std::string value() { return "B"; }; };
+template<> struct format_descriptor<int16_t>  { static std::string value() { return "h"; }; };
+template<> struct format_descriptor<uint16_t> { static std::string value() { return "H"; }; };
+template<> struct format_descriptor<int32_t>  { static std::string value() { return "i"; }; };
+template<> struct format_descriptor<uint32_t> { static std::string value() { return "I"; }; };
+template<> struct format_descriptor<int64_t>  { static std::string value() { return "q"; }; };
+template<> struct format_descriptor<uint64_t> { static std::string value() { return "Q"; }; };
+template<> struct format_descriptor<float>    { static std::string value() { return "f"; }; };
+template<> struct format_descriptor<double>   { static std::string value() { return "d"; }; };
+
+/// Information record describing a Python buffer object
+struct buffer_info {
+    void *ptr;
+    size_t itemsize;
+    std::string format; // for dense contents, this should be set to format_descriptor<T>::value
+    int ndim;
+    std::vector<size_t> shape;
+    std::vector<size_t> strides;
+
+    buffer_info(void *ptr, size_t itemsize, const std::string &format,
+                int ndim, const std::vector<size_t> &shape,
+                const std::vector<size_t> &strides)
+        : ptr(ptr), itemsize(itemsize), format(format), ndim(ndim),
+          shape(shape), strides(strides) {}
+};
+
+// C++ bindings of core Python exceptions
+struct stop_iteration    : public std::runtime_error { public: stop_iteration(const std::string &w="") : std::runtime_error(w)   {} };
+struct index_error       : public std::runtime_error { public: index_error(const std::string &w="")    : std::runtime_error(w)   {} };
+struct error_already_set : public std::exception     { public: error_already_set()                                               {} };
+/// Thrown when pybind::cast or handle::call fail due to a type casting error
+struct cast_error        : public std::runtime_error { public: cast_error(const std::string &w = "") : std::runtime_error(w) {} };
+
+NAMESPACE_BEGIN(detail)
+
+/// PyObject wrapper around generic types
+template <typename type, typename holder_type = std::unique_ptr<type>> struct instance {
+    PyObject_HEAD
+    type *value;
+    PyObject *parent;
+    bool owned : 1;
+    bool constructed : 1;
+    holder_type holder;
+};
+
+/// Additional type information which does not fit into the PyTypeObjet
+struct type_info {
+    PyTypeObject *type;
+    size_t type_size;
+    void (*init_holder)(PyObject *);
+    std::function<buffer_info *(PyObject *)> get_buffer;
+    std::vector<PyObject *(*)(PyObject *, PyTypeObject *)> implicit_conversions;
+};
+
+/// Internal data struture used to track registered instances and types 
+struct internals {
+    std::unordered_map<std::string, type_info> registered_types;
+    std::unordered_map<void *, PyObject *> registered_instances;
+};
+
+inline internals &get_internals();
+
+NAMESPACE_END(detail)
+NAMESPACE_END(pybind)
+
+#endif /* __PYBIND_COMMON_H */
diff --git a/include/pybind/mpl.h b/include/pybind/mpl.h
new file mode 100644
index 0000000..ff9c6eb
--- /dev/null
+++ b/include/pybind/mpl.h
@@ -0,0 +1,190 @@
+/*
+    pybind/mpl.h: Simple library for type manipulation and template metaprogramming
+
+    Copyright (c) 2015 Wenzel Jakob <wenzel@inf.ethz.ch>
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE file.
+*/
+
+#if !defined(__PYBIND_MPL_H)
+#define __PYBIND_MPL_H
+
+#include "common.h"
+#include <tuple>
+
+NAMESPACE_BEGIN(pybind)
+NAMESPACE_BEGIN(mpl)
+
+/// Index sequence for convenient template metaprogramming involving tuples
+template<size_t ...> struct index_sequence  { };
+template<size_t N, size_t ...S> struct make_index_sequence : make_index_sequence <N - 1, N - 1, S...> { };
+template<size_t ...S> struct make_index_sequence <0, S...> { typedef index_sequence<S...> type; };
+
+/// Helper template to strip away type modifiers
+template <typename T> struct normalize_type                       { typedef T type; };
+template <typename T> struct normalize_type<const T>              { typedef typename normalize_type<T>::type type; };
+template <typename T> struct normalize_type<T*>                   { typedef typename normalize_type<T>::type type; };
+template <typename T> struct normalize_type<T&>                   { typedef typename normalize_type<T>::type type; };
+template <typename T> struct normalize_type<T&&>                  { typedef typename normalize_type<T>::type type; };
+template <typename T, size_t N> struct normalize_type<const T[N]> { typedef typename normalize_type<T>::type type; };
+template <typename T, size_t N> struct normalize_type<T[N]>       { typedef typename normalize_type<T>::type type; };
+
+NAMESPACE_BEGIN(detail)
+
+/// Strip the class from a method type
+template <typename T> struct remove_class {};
+template <typename C, typename R, typename... A> struct remove_class<R (C::*)(A...)> { typedef R type(A...); };
+template <typename C, typename R, typename... A> struct remove_class<R (C::*)(A...) const> { typedef R type(A...); };
+
+/**
+ * \brief Convert a lambda function to a std::function
+ * From http://stackoverflow.com/questions/11893141/inferring-the-call-signature-of-a-lambda-or-arbitrary-callable-for-make-functio
+ */
+template <typename T> struct lambda_signature_impl {
+    using type = typename remove_class<
+        decltype(&std::remove_reference<T>::type::operator())>::type;
+};
+template <typename R, typename... A> struct lambda_signature_impl<R    (A...)> { typedef R type(A...); };
+template <typename R, typename... A> struct lambda_signature_impl<R (&)(A...)> { typedef R type(A...); };
+template <typename R, typename... A> struct lambda_signature_impl<R (*)(A...)> { typedef R type(A...); };
+template <typename T> using lambda_signature = typename lambda_signature_impl<T>::type;
+template <typename F> using make_function_type = std::function<lambda_signature<F>>;
+
+NAMESPACE_END(detail)
+
+template<typename F> detail::make_function_type<F> make_function(F &&f) {
+    return detail::make_function_type<F>(std::forward<F>(f)); }
+
+NAMESPACE_BEGIN(detail)
+
+struct void_type { };
+
+/// Helper functions for calling a function using a tuple argument while dealing with void/non-void return values
+template <typename RetType> struct tuple_dispatch {
+    typedef RetType return_type;
+    template<typename Func, typename Arg, size_t ... S> return_type operator()(const Func &f, Arg && args, index_sequence<S...>) {
+        return f(std::get<S>(std::forward<Arg>(args))...);
+    }
+};
+
+/// Helper functions for calling a function using a tuple argument (special case for void return values)
+template <> struct tuple_dispatch<void> {
+    typedef void_type return_type;
+    template<typename Func, typename Arg, size_t ... S> return_type operator()(const Func &f, Arg &&args, index_sequence<S...>) {
+        f(std::get<S>(std::forward<Arg>(args))...);
+        return return_type();
+    }
+};
+
+NAMESPACE_END(detail)
+
+/// For lambda functions delegate to their 'operator()'
+template <typename T> struct function_traits : public function_traits<typename detail::make_function_type<T>> { };
+
+/// Type traits for function pointers
+template <typename ReturnType, typename... Args>
+struct function_traits<ReturnType(*)(Args...)> {
+    enum {
+        nargs = sizeof...(Args),
+        is_method = 0,
+        is_const = 0
+    };
+    typedef std::function<ReturnType (Args...)>    f_type;
+    typedef detail::tuple_dispatch<ReturnType>     dispatch_type;
+    typedef typename dispatch_type::return_type    return_type;
+    typedef std::tuple<Args...>                    args_type;
+
+    template <size_t i> struct arg {
+        typedef typename std::tuple_element<i, args_type>::type type;
+    };
+
+    static f_type cast(ReturnType (*func)(Args ...)) { return func; }
+
+    static return_type dispatch(const f_type &f, args_type &&args) {
+        return dispatch_type()(f, std::move(args),
+            typename make_index_sequence<nargs>::type());
+    }
+};
+
+/// Type traits for ordinary methods
+template <typename ClassType, typename ReturnType, typename... Args>
+struct function_traits<ReturnType(ClassType::*)(Args...)> {
+    enum {
+        nargs = sizeof...(Args),
+        is_method = 1,
+        is_const = 0
+    };
+    typedef std::function<ReturnType(ClassType &, Args...)>  f_type;
+    typedef detail::tuple_dispatch<ReturnType>               dispatch_type;
+    typedef typename dispatch_type::return_type              return_type;
+    typedef std::tuple<ClassType&, Args...>                  args_type;
+
+    template <size_t i> struct arg {
+        typedef typename std::tuple_element<i, args_type>::type type;
+    };
+
+    static f_type cast(ReturnType (ClassType::*func)(Args ...)) { return std::mem_fn(func); }
+
+    static return_type dispatch(const f_type &f, args_type &&args) {
+        return dispatch_type()(f, std::move(args),
+            typename make_index_sequence<nargs+1>::type());
+    }
+};
+
+/// Type traits for const methods
+template <typename ClassType, typename ReturnType, typename... Args>
+struct function_traits<ReturnType(ClassType::*)(Args...) const> {
+    enum {
+        nargs = sizeof...(Args),
+        is_method = 1,
+        is_const = 1
+    };
+    typedef std::function<ReturnType (const ClassType &, Args...)>  f_type;
+    typedef detail::tuple_dispatch<ReturnType>                      dispatch_type;
+    typedef typename dispatch_type::return_type                     return_type;
+    typedef std::tuple<const ClassType&, Args...>                   args_type;
+
+    template <size_t i> struct arg {
+        typedef typename std::tuple_element<i, args_type>::type type;
+    };
+
+    static f_type cast(ReturnType (ClassType::*func)(Args ...) const) {
+        return std::mem_fn(func);
+    }
+
+    static return_type dispatch(const f_type &f, args_type &&args) {
+        return dispatch_type()(f, std::move(args),
+            typename make_index_sequence<nargs+1>::type());
+    }
+};
+
+/// Type traits for std::functions
+template <typename ReturnType, typename... Args>
+struct function_traits<std::function<ReturnType(Args...)>> {
+    enum {
+        nargs = sizeof...(Args),
+        is_method = 0,
+        is_const = 0
+    };
+    typedef std::function<ReturnType (Args...)>  f_type;
+    typedef detail::tuple_dispatch<ReturnType>   dispatch_type;
+    typedef typename dispatch_type::return_type  return_type;
+    typedef std::tuple<Args...>                  args_type;
+
+    template <size_t i> struct arg {
+        typedef typename std::tuple_element<i, args_type>::type type;
+    };
+
+    static f_type cast(const f_type &func) { return func; }
+
+    static return_type dispatch(const f_type &f, args_type &&args) {
+        return dispatch_type()(f, std::move(args),
+            typename make_index_sequence<nargs>::type());
+    }
+};
+
+NAMESPACE_END(mpl)
+NAMESPACE_END(pybind)
+
+#endif /* __PYBIND_MPL_H */
diff --git a/include/pybind/operators.h b/include/pybind/operators.h
new file mode 100644
index 0000000..08fcd99
--- /dev/null
+++ b/include/pybind/operators.h
@@ -0,0 +1,151 @@
+/*
+    pybind/operator.h: Metatemplates for operator overloading
+
+    Copyright (c) 2015 Wenzel Jakob <wenzel@inf.ethz.ch>
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE file.
+*/
+
+#if !defined(__PYBIND_OPERATOR)
+#define __PYBIND_OPERATOR
+
+#include "pybind.h"
+#include <type_traits>
+
+NAMESPACE_BEGIN(pybind)
+NAMESPACE_BEGIN(detail)
+
+/// Enumeration with all supported operator types
+enum op_id : int {
+    op_add, op_sub, op_mul, op_div, op_mod, op_divmod, op_pow,
+    op_lshift, op_rshift, op_and, op_xor, op_or, op_neg,
+    op_pos, op_abs, op_invert, op_int, op_long, op_float,
+    op_str, op_cmp, op_gt, op_ge, op_lt, op_le, op_eq, op_ne,
+    op_iadd, op_isub, op_imul, op_idiv, op_imod, op_ilshift,
+    op_irshift, op_iand, op_ixor, op_ior, op_complex, op_bool,
+    op_nonzero, op_repr, op_truediv
+};
+
+enum op_type : int {
+    op_l, /* base type on left */
+    op_r, /* base type on right */
+    op_u  /* unary operator */
+};
+
+struct self_t { };
+
+/// Type for an unused type slot
+struct undefined_t { };
+
+static const self_t self = self_t();
+
+/// Don't warn about an unused variable
+inline self_t __self() { return self; }
+
+/// base template of operator implementations
+template <op_id, op_type, typename B, typename L, typename R> struct op_impl { };
+
+/// Operator implementation generator
+template <op_id id, op_type ot, typename L, typename R> struct op_ {
+    template <typename base, typename holder> void execute(pybind::class_<base, holder> &class_, const char *doc, return_value_policy policy) const {
+        typedef typename std::conditional<std::is_same<L, self_t>::value, base, L>::type L_type;
+        typedef typename std::conditional<std::is_same<R, self_t>::value, base, R>::type R_type;
+        typedef op_impl<id, ot, base, L_type, R_type> op;
+        class_.def(op::name(), &op::execute, doc, policy);
+    }
+    template <typename base, typename holder> void execute_cast(pybind::class_<base, holder> &class_, const char *doc, return_value_policy policy) const {
+        typedef typename std::conditional<std::is_same<L, self_t>::value, base, L>::type L_type;
+        typedef typename std::conditional<std::is_same<R, self_t>::value, base, R>::type R_type;
+        typedef op_impl<id, ot, base, L_type, R_type> op;
+        class_.def(op::name(), &op::execute_cast, doc, policy);
+    }
+};
+
+#define PYBIND_BINARY_OPERATOR(id, rid, op, expr)                                      \
+template <typename B, typename L, typename R> struct op_impl<op_##id, op_l, B, L, R> { \
+    static char const* name() { return "__" #id "__"; }                                \
+    static auto execute(const L &l, const R &r) -> decltype(expr) { return (expr); }   \
+    static B execute_cast(const L &l, const R &r) { return B(expr); }                  \
+};                                                                                     \
+template <typename B, typename L, typename R> struct op_impl<op_##id, op_r, B, L, R> { \
+    static char const* name() { return "__" #rid "__"; }                               \
+    static auto execute(const L &l, const R &r) -> decltype(expr) { return (expr); }   \
+    static B execute_cast(const L &l, const R &r) { return B(expr); }                  \
+};                                                                                     \
+inline op_<op_##id, op_l, self_t, self_t> op(const self_t &, const self_t &) {         \
+    return op_<op_##id, op_l, self_t, self_t>();                                       \
+};                                                                                     \
+template <typename T> op_<op_##id, op_l, self_t, T> op(const self_t &, const T &) {    \
+    return op_<op_##id, op_l, self_t, T>();                                            \
+};                                                                                     \
+template <typename T> op_<op_##id, op_r, T, self_t> op(const T &, const self_t &) {    \
+    return op_<op_##id, op_r, T, self_t>();                                            \
+};
+
+#define PYBIND_INPLACE_OPERATOR(id, op, expr)                                          \
+template <typename B, typename L, typename R> struct op_impl<op_##id, op_l, B, L, R> { \
+    static char const* name() { return "__" #id "__"; }                                \
+    static auto execute(L &l, const R &r) -> decltype(expr) { return expr; }           \
+    static B execute_cast(L &l, const R &r) { return B(expr); }                        \
+};                                                                                     \
+template <typename T> op_<op_##id, op_l, self_t, T> op(const self_t &, const T &) {    \
+    return op_<op_##id, op_l, self_t, T>();                                            \
+};
+
+#define PYBIND_UNARY_OPERATOR(id, op, expr)                                            \
+template <typename B, typename L> struct op_impl<op_##id, op_u, B, L, undefined_t> {   \
+    static char const* name() { return "__" #id "__"; }                                \
+    static auto execute(const L &l) -> decltype(expr) { return expr; }                 \
+    static B execute_cast(const L &l) { return B(expr); }                              \
+};                                                                                     \
+inline op_<op_##id, op_u, self_t, undefined_t> op(const self_t &) {                    \
+    return op_<op_##id, op_u, self_t, undefined_t>();                                  \
+};
+
+PYBIND_BINARY_OPERATOR(sub,       rsub,         operator-,    l - r)
+PYBIND_BINARY_OPERATOR(add,       radd,         operator+,    l + r)
+PYBIND_BINARY_OPERATOR(mul,       rmul,         operator*,    l * r)
+PYBIND_BINARY_OPERATOR(truediv,   rtruediv,     operator/,    l / r)
+PYBIND_BINARY_OPERATOR(mod,       rmod,         operator%,    l % r)
+PYBIND_BINARY_OPERATOR(lshift,    rlshift,      operator<<,   l << r)
+PYBIND_BINARY_OPERATOR(rshift,    rrshift,      operator>>,   l >> r)
+PYBIND_BINARY_OPERATOR(and,       rand,         operator&,    l & r)
+PYBIND_BINARY_OPERATOR(xor,       rxor,         operator^,    l ^ r)
+PYBIND_BINARY_OPERATOR(eq,        eq,           operator==,   l == r)
+PYBIND_BINARY_OPERATOR(ne,        ne,           operator!=,   l != r)
+PYBIND_BINARY_OPERATOR(or,        ror,          operator|,    l | r)
+PYBIND_BINARY_OPERATOR(gt,        lt,           operator>,    l > r)
+PYBIND_BINARY_OPERATOR(ge,        le,           operator>=,   l >= r)
+PYBIND_BINARY_OPERATOR(lt,        gt,           operator<,    l < r)
+PYBIND_BINARY_OPERATOR(le,        ge,           operator<=,   l <= r)
+//PYBIND_BINARY_OPERATOR(pow,       rpow,         pow,          std::pow(l,  r))
+PYBIND_INPLACE_OPERATOR(iadd,     operator+=,   l += r)
+PYBIND_INPLACE_OPERATOR(isub,     operator-=,   l -= r)
+PYBIND_INPLACE_OPERATOR(imul,     operator*=,   l *= r)
+PYBIND_INPLACE_OPERATOR(idiv,     operator/=,   l /= r)
+PYBIND_INPLACE_OPERATOR(imod,     operator%=,   l %= r)
+PYBIND_INPLACE_OPERATOR(ilshift,  operator<<=,  l <<= r)
+PYBIND_INPLACE_OPERATOR(irshift,  operator>>=,  l >>= r)
+PYBIND_INPLACE_OPERATOR(iand,     operator&=,   l &= r)
+PYBIND_INPLACE_OPERATOR(ixor,     operator^=,   l ^= r)
+PYBIND_INPLACE_OPERATOR(ior,      operator|=,   l |= r)
+PYBIND_UNARY_OPERATOR(neg,        operator-,    -l)
+PYBIND_UNARY_OPERATOR(pos,        operator+,    +l)
+PYBIND_UNARY_OPERATOR(abs,        abs,          std::abs(l))
+PYBIND_UNARY_OPERATOR(invert,     operator~,    ~l)
+PYBIND_UNARY_OPERATOR(bool,       operator!,    !!l)
+PYBIND_UNARY_OPERATOR(int,        int_,         (int) l)
+PYBIND_UNARY_OPERATOR(float,      float_,       (double) l)
+
+#undef PYBIND_BINARY_OPERATOR
+#undef PYBIND_INPLACE_OPERATOR
+#undef PYBIND_UNARY_OPERATOR
+
+NAMESPACE_END(detail)
+
+using detail::self;
+
+NAMESPACE_END(pybind)
+
+#endif /* __PYBIND_OPERATOR */
diff --git a/include/pybind/pybind.h b/include/pybind/pybind.h
new file mode 100644
index 0000000..ad92a82
--- /dev/null
+++ b/include/pybind/pybind.h
@@ -0,0 +1,587 @@
+/*
+    pybind/pybind.h: Main header file of the C++11 python binding generator library
+
+    Copyright (c) 2015 Wenzel Jakob <wenzel@inf.ethz.ch>
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE file.
+*/
+
+#if !defined(__PYBIND_H)
+#define __PYBIND_H
+
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable: 4127) // warning C4127: Conditional expression is constant
+#pragma warning(disable: 4800) // warning C4800: 'int': forcing value to bool 'true' or 'false' (performance warning)
+#pragma warning(disable: 4996) // warning C4996: The POSIX name for this item is deprecated. Instead, use the ISO C and C++ conformant name
+#pragma warning(disable: 4100) // warning C4100: Unreferenced formal parameter
+#pragma warning(disable: 4512) // warning C4512: Assignment operator was implicitly defined as deleted
+#endif
+
+#include "cast.h"
+
+NAMESPACE_BEGIN(pybind)
+
+class function : public object {
+private:
+    struct function_entry {
+        std::function<PyObject* (PyObject *)> impl;
+        std::string signature, doc;
+        bool is_constructor;
+        function_entry *next = nullptr;
+    };
+public:
+    PYTHON_OBJECT_DEFAULT(function, object, PyFunction_Check)
+
+    template <typename Func>
+    function(const char *name, Func _func, bool is_method,
+             function overload_sibling = function(), const char *doc = nullptr,
+             return_value_policy policy = return_value_policy::automatic) {
+        /* Function traits extracted from the template type 'Func' */
+        typedef mpl::function_traits<Func> f_traits;
+
+        /* Suitable input and output casters */
+        typedef typename detail::type_caster<typename f_traits::args_type> cast_in;
+        typedef typename detail::type_caster<typename mpl::normalize_type<typename f_traits::return_type>::type> cast_out;
+        typename f_traits::f_type func = f_traits::cast(_func);
+
+        auto impl = [func, policy](PyObject *pyArgs) -> PyObject *{
+            cast_in args;
+            if (!args.load(pyArgs, true))
+                return nullptr;
+            PyObject *parent = policy != return_value_policy::reference_internal
+                ? nullptr : PyTuple_GetItem(pyArgs, 0);
+            return cast_out::cast(
+                f_traits::dispatch(func, (typename f_traits::args_type) args),
+                policy, parent);
+        };
+
+        /* Linked list of function call handlers (for overloading) */
+        function_entry *entry = new function_entry();
+        entry->impl = impl;
+        entry->signature = std::string(name) + cast_in::name() + std::string(" -> ") + cast_out::name();
+        entry->is_constructor = !strcmp(name, "__init__");
+        if (doc) entry->doc = doc;
+
+        install_function(name, entry, is_method, overload_sibling);
+    }
+
+private:
+    static PyObject *dispatcher(PyObject *self, PyObject *args, PyObject * /* kwargs */) {
+        function_entry *overloads = (function_entry *) PyCapsule_GetPointer(self, nullptr);
+        PyObject *result = nullptr;
+        try {
+            for (function_entry *it = overloads; it != nullptr; it = it->next) {
+                if ((result = it->impl(args)) != nullptr)
+                    break;
+            }
+        } catch (const error_already_set &) {                                               return nullptr;
+        } catch (const index_error &e)    { PyErr_SetString(PyExc_IndexError,    e.what()); return nullptr;
+        } catch (const stop_iteration &e) { PyErr_SetString(PyExc_StopIteration, e.what()); return nullptr;
+        } catch (const std::exception &e) { PyErr_SetString(PyExc_RuntimeError,  e.what()); return nullptr;
+        } catch (...) {
+            PyErr_SetString(PyExc_RuntimeError, "Caught an unknown exception!");
+            return nullptr;
+        }
+        if (result) {
+            if (overloads->is_constructor) {
+                PyObject *inst = PyTuple_GetItem(args, 0);
+                const detail::type_info *type_info =
+                    capsule(PyObject_GetAttrString((PyObject *) Py_TYPE(inst),
+                                const_cast<char *>("__pybind__")), false);
+                type_info->init_holder(inst);
+            }
+            return result;
+        } else {
+            std::string signatures = "Incompatible function arguments. The "
+                                     "following argument types are supported:\n";
+            int ctr = 0;
+            for (function_entry *it = overloads; it != nullptr; it = it->next) {
+                signatures += "    "+ std::to_string(++ctr) + ". ";
+                signatures += it->signature;
+                signatures += "\n";
+            }
+            PyErr_SetString(PyExc_TypeError, signatures.c_str());
+            return nullptr;
+        }
+    }
+
+    void install_function(const char *name, function_entry *entry, bool is_method, function overload_sibling) {
+        if (!overload_sibling.ptr() || !PyCFunction_Check(overload_sibling.ptr())) {
+            PyMethodDef *def = new PyMethodDef();
+            memset(def, 0, sizeof(PyMethodDef));
+            def->ml_name = strdup(name);
+            def->ml_meth = reinterpret_cast<PyCFunction>(*dispatcher);
+            def->ml_flags = METH_VARARGS | METH_KEYWORDS;
+            capsule entry_capsule(entry);
+            m_ptr = PyCFunction_New(def, entry_capsule.ptr());
+            if (!m_ptr)
+                throw std::runtime_error("function::function(): Could not allocate function object");
+        } else {
+            m_ptr = overload_sibling.ptr();
+            inc_ref();
+            capsule entry_capsule(PyCFunction_GetSelf(m_ptr), true);
+            function_entry *parent = (function_entry *) entry_capsule, *backup = parent;
+            while (parent->next)
+                parent = parent->next;
+            parent->next = entry;
+            entry = backup;
+        }
+        std::string signatures;
+        while (entry) { /* Create pydoc entry */
+            signatures += "Signature : " + std::string(entry->signature) + "\n";
+            if (!entry->doc.empty())
+                signatures += "\n" + std::string(entry->doc) + "\n";
+            if (entry->next)
+                signatures += "\n";
+            entry = entry->next;
+        }
+        PyCFunctionObject *func = (PyCFunctionObject *) m_ptr;
+        if (func->m_ml->ml_doc)
+            std::free((char *) func->m_ml->ml_doc);
+        func->m_ml->ml_doc = strdup(signatures.c_str());
+        if (is_method) {
+            m_ptr = PyInstanceMethod_New(m_ptr);
+            if (!m_ptr)
+                throw std::runtime_error("function::function(): Could not allocate instance method object");
+            Py_DECREF(func);
+        }
+    }
+};
+
+class module : public object {
+public:
+    PYTHON_OBJECT_DEFAULT(module, object, PyModule_Check)
+
+    module(const char *name, const char *doc = nullptr) {
+        PyModuleDef *def = new PyModuleDef();
+        memset(def, 0, sizeof(PyModuleDef));
+        def->m_name = name;
+        def->m_doc = doc;
+        def->m_size = -1;
+        Py_INCREF(def);
+        m_ptr = PyModule_Create(def);
+        if (m_ptr == nullptr)
+            throw std::runtime_error("Internal error in module::module()");
+        inc_ref();
+    }
+
+    template <typename Func> module& def(const char *name, Func f, const char *doc = nullptr) {
+        function func(name, f, false, (function) attr(name), doc);
+        func.inc_ref(); /* The following line steals a reference to 'func' */
+        PyModule_AddObject(ptr(), name, func.ptr());
+        return *this;
+    }
+
+    module def_submodule(const char *name) {
+        std::string full_name = std::string(PyModule_GetName(m_ptr))
+            + std::string(".") + std::string(name);
+        module result(PyImport_AddModule(full_name.c_str()), true);
+        attr(name) = result;
+        return result;
+    }
+};
+
+NAMESPACE_BEGIN(detail)
+/* Forward declarations */
+enum op_id : int;
+enum op_type : int;
+struct undefined_t;
+template <op_id id, op_type ot, typename L = undefined_t, typename R = undefined_t> struct op_;
+template <typename ... Args> struct init;
+
+/// Basic support for creating new Python heap types
+class custom_type : public object {
+public:
+    PYTHON_OBJECT_DEFAULT(custom_type, object, PyType_Check)
+
+    custom_type(object &scope, const char *name_, const std::string &type_name,
+                size_t type_size, size_t instance_size,
+                void (*init_holder)(PyObject *), const destructor &dealloc,
+                PyObject *parent, const char *doc) {
+        PyHeapTypeObject *type = (PyHeapTypeObject*) PyType_Type.tp_alloc(&PyType_Type, 0);
+        PyObject *name = PyUnicode_FromString(name_);
+        if (type == nullptr || name == nullptr)
+            throw std::runtime_error("Internal error in custom_type::custom_type()");
+        Py_INCREF(name);
+        std::string full_name(name_);
+
+        pybind::str scope_name = (object) scope.attr("__name__"),
+                    module_name = (object) scope.attr("__module__");
+
+        if (scope_name.check())
+            full_name =  std::string(scope_name) + "." + full_name;
+        if (module_name.check())
+            full_name =  std::string(module_name) + "." + full_name;
+
+        type->ht_name = type->ht_qualname = name;
+        type->ht_type.tp_name = strdup(full_name.c_str());
+        type->ht_type.tp_basicsize = instance_size;
+        type->ht_type.tp_doc = doc;
+        type->ht_type.tp_init = (initproc) init;
+        type->ht_type.tp_new = (newfunc) new_instance;
+        type->ht_type.tp_dealloc = dealloc;
+        type->ht_type.tp_flags |=
+            Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HEAPTYPE;
+        type->ht_type.tp_flags &= ~Py_TPFLAGS_HAVE_GC;
+        type->ht_type.tp_as_number = &type->as_number;
+        type->ht_type.tp_as_sequence = &type->as_sequence;
+        type->ht_type.tp_as_mapping = &type->as_mapping;
+        type->ht_type.tp_base = (PyTypeObject *) parent;
+        Py_XINCREF(parent);
+
+        if (PyType_Ready(&type->ht_type) < 0)
+            throw std::runtime_error("Internal error in custom_type::custom_type()");
+        m_ptr = (PyObject *) type;
+
+        /* Needed by pydoc */
+        if (((module &) scope).check())
+            attr("__module__") = scope_name;
+
+        auto &type_info = detail::get_internals().registered_types[type_name];
+        type_info.type = (PyTypeObject *) m_ptr;
+        type_info.type_size = type_size;
+        type_info.init_holder = init_holder;
+        attr("__pybind__") = capsule(&type_info);
+
+        scope.attr(name) = *this;
+    }
+
+protected:
+    /* Allocate a metaclass on demand (for static properties) */
+    handle metaclass() {
+        auto &ht_type = ((PyHeapTypeObject *) m_ptr)->ht_type;
+        auto &ob_type = ht_type.ob_base.ob_base.ob_type;
+        if (ob_type == &PyType_Type) {
+            std::string name_ = std::string(ht_type.tp_name) + "_meta";
+            PyHeapTypeObject *type = (PyHeapTypeObject*) PyType_Type.tp_alloc(&PyType_Type, 0);
+            PyObject *name = PyUnicode_FromString(name_.c_str());
+            if (type == nullptr || name == nullptr)
+                throw std::runtime_error("Internal error in custom_type::metaclass()");
+            Py_INCREF(name);
+            type->ht_name = type->ht_qualname = name;
+            type->ht_type.tp_name = strdup(name_.c_str());
+            type->ht_type.tp_base = &PyType_Type;
+            type->ht_type.tp_flags |= Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HEAPTYPE;
+            type->ht_type.tp_flags &= ~Py_TPFLAGS_HAVE_GC;
+            if (PyType_Ready(&type->ht_type) < 0)
+                throw std::runtime_error("Internal error in custom_type::metaclass()");
+            ob_type = (PyTypeObject *) type;
+            Py_INCREF(type);
+        }
+        return handle((PyObject *) ob_type);
+    }
+
+    static int init(void *self, PyObject *, PyObject *) {
+        std::string msg = std::string(Py_TYPE(self)->tp_name) + ": No constructor defined!";
+        PyErr_SetString(PyExc_TypeError, msg.c_str());
+        return -1;
+    }
+
+    static PyObject *new_instance(PyTypeObject *type, PyObject *, PyObject *) {
+        const detail::type_info *type_info = capsule(
+            PyObject_GetAttrString((PyObject *) type, const_cast<char*>("__pybind__")), false);
+        instance<void> *self = (instance<void> *) PyType_GenericAlloc(type, 0);
+        self->value = ::operator new(type_info->type_size);
+        self->owned = true;
+        self->parent = nullptr;
+        self->constructed = false;
+        detail::get_internals().registered_instances[self->value] = (PyObject *) self;
+        return (PyObject *) self;
+    }
+
+    static void dealloc(instance<void> *self) {
+        if (self->value) {
+            bool dont_cache = self->parent && ((instance<void> *) self->parent)->value == self->value;
+            if (!dont_cache) { // avoid an issue with internal references matching their parent's address
+                auto &registered_instances = detail::get_internals().registered_instances;
+                auto it = registered_instances.find(self->value);
+                if (it == registered_instances.end())
+                    throw std::runtime_error("Deallocating unregistered instance!");
+                registered_instances.erase(it);
+            }
+            Py_XDECREF(self->parent);
+        }
+        Py_TYPE(self)->tp_free((PyObject*) self);
+    }
+
+    void install_buffer_funcs(const std::function<buffer_info *(PyObject *)> &func) {
+        PyHeapTypeObject *type = (PyHeapTypeObject*) m_ptr;
+        type->ht_type.tp_as_buffer = &type->as_buffer;
+        type->as_buffer.bf_getbuffer = getbuffer;
+        type->as_buffer.bf_releasebuffer = releasebuffer;
+        ((detail::type_info *) capsule(attr("__pybind__")))->get_buffer = func;
+    }
+
+    static int getbuffer(PyObject *obj, Py_buffer *view, int flags) {
+        auto const &info_func = ((detail::type_info *) capsule(handle(obj).attr("__pybind__")))->get_buffer;
+        if (view == nullptr || obj == nullptr || !info_func) {
+            PyErr_SetString(PyExc_BufferError, "Internal error");
+            return -1;
+        }
+        memset(view, 0, sizeof(Py_buffer));
+        buffer_info *info = info_func(obj);
+        view->obj = obj;
+        view->ndim = 1;
+        view->internal = info;
+        view->buf = info->ptr;
+        view->itemsize = info->itemsize;
+        view->len = view->itemsize;
+        for (auto s : info->shape)
+            view->len *= s;
+        if ((flags & PyBUF_FORMAT) == PyBUF_FORMAT)
+            view->format = const_cast<char *>(info->format.c_str());
+        if ((flags & PyBUF_STRIDES) == PyBUF_STRIDES) {
+            view->ndim = info->ndim;
+            view->strides = (Py_ssize_t *)&info->strides[0];
+            view->shape = (Py_ssize_t *) &info->shape[0];
+        }
+        Py_INCREF(view->obj);
+        return 0;
+    }
+
+    static void releasebuffer(PyObject *, Py_buffer *view) { delete (buffer_info *) view->internal; }
+};
+
+NAMESPACE_END(detail)
+
+template <typename type, typename holder_type = std::unique_ptr<type>> class class_ : public detail::custom_type {
+public:
+    typedef detail::instance<type, holder_type> instance_type;
+
+    PYTHON_OBJECT(class_, detail::custom_type, PyType_Check)
+
+    class_(object &scope, const char *name, const char *doc = nullptr)
+        : detail::custom_type(scope, name, type_id<type>(), sizeof(type),
+                              sizeof(instance_type), init_holder, dealloc,
+                              nullptr, doc) { }
+
+    class_(object &scope, const char *name, object &parent,
+           const char *doc = nullptr)
+        : detail::custom_type(scope, name, type_id<type>(), sizeof(type),
+                              sizeof(instance_type), init_holder, dealloc,
+                              parent.ptr(), doc) { }
+
+    template <typename Func>
+    class_ &def(const char *name, Func f, const char *doc = nullptr,
+                return_value_policy policy = return_value_policy::automatic) {
+        attr(name) = function(name, f, true, (function) attr(name), doc, policy);
+        return *this;
+    }
+
+    template <typename Func> class_ &
+    def_static(const char *name, Func f, const char *doc = nullptr,
+               return_value_policy policy = return_value_policy::automatic) {
+        attr(name) = function(name, f, false, (function) attr(name), doc, policy);
+        return *this;
+    }
+
+    template <detail::op_id id, detail::op_type ot, typename L, typename R>
+    class_ &def(const detail::op_<id, ot, L, R> &op, const char *doc = nullptr,
+                return_value_policy policy = return_value_policy::automatic) {
+        op.template execute<type>(*this, doc, policy);
+        return *this;
+    }
+
+    template <detail::op_id id, detail::op_type ot, typename L, typename R> class_ &
+    def_cast(const detail::op_<id, ot, L, R> &op, const char *doc = nullptr,
+             return_value_policy policy = return_value_policy::automatic) {
+        op.template execute_cast<type>(*this, doc, policy);
+        return *this;
+    }
+
+    template <typename... Args>
+    class_ &def(const detail::init<Args...> &init, const char *doc = nullptr) {
+        init.template execute<type>(*this, doc);
+        return *this;
+    }
+
+    class_& def_buffer(const std::function<buffer_info(type&)> &func) {
+        install_buffer_funcs([func](PyObject *obj) -> buffer_info* {
+            detail::type_caster<type> caster;
+            if (!caster.load(obj, false))
+                return nullptr;
+            return new buffer_info(func(caster));
+        });
+        return *this;
+    }
+
+    template <typename C, typename D>
+    class_ &def_readwrite(const char *name, D C::*pm,
+                          const char *doc = nullptr) {
+        function fget("", [=](C * ptr) -> D & { return ptr->*pm; }, true,
+                      function(), doc, return_value_policy::reference_internal),
+                 fset("", [=](C *ptr, const D &value) { ptr->*pm = value; }, true, function(), doc);
+        def_property(name, fget, fset, doc);
+        return *this;
+    }
+
+    template <typename C, typename D>
+    class_ &def_readonly(const char *name, const D C::*pm,
+                         const char *doc = nullptr) {
+        function fget("", [=](C * ptr) -> const D & { return ptr->*pm; }, true,
+                      function(), doc, return_value_policy::reference_internal);
+        def_property(name, fget, doc);
+        return *this;
+    }
+
+    template <typename D>
+    class_ &def_readwrite_static(const char *name, D *pm,
+                                 const char *doc = nullptr) {
+        function fget("", [=](object) -> D & { return *pm; }, true),
+                 fset("", [=](object, const D &value) { *pm = value; }, true);
+        def_property_static(name, fget, fset, doc);
+        return *this;
+    }
+
+    template <typename D>
+    class_ &def_readonly_static(const char *name, const D *pm,
+                                const char *doc = nullptr) {
+        function fget("", [=](object) -> const D & { return *pm; }, true);
+        def_property_static(name, fget, doc);
+        return *this;
+    }
+
+    class_ &def_property(const char *name, const function &fget,
+                         const char *doc = nullptr) {
+        def_property(name, fget, function(), doc);
+        return *this;
+    }
+
+    class_ &def_property_static(const char *name, const function &fget,
+                                const char *doc = nullptr) {
+        def_property_static(name, fget, function(), doc);
+        return *this;
+    }
+
+    class_ &def_property(const char *name, const function &fget,
+                         const function &fset, const char *doc = nullptr) {
+        object property(
+            PyObject_CallFunction((PyObject *)&PyProperty_Type,
+                                  const_cast<char *>("OOOs"), fget.ptr() ? fget.ptr() : Py_None,
+                                  fset.ptr() ? fset.ptr() : Py_None, Py_None, doc), false);
+        attr(name) = property;
+        return *this;
+    }
+
+    class_ &def_property_static(const char *name, const function &fget,
+                                const function &fset,
+                                const char *doc = nullptr) {
+        object property(
+            PyObject_CallFunction((PyObject *)&PyProperty_Type,
+                                  const_cast<char *>("OOOs"), fget.ptr() ? fget.ptr() : Py_None,
+                                  fset.ptr() ? fset.ptr() : Py_None, Py_None, doc), false);
+        metaclass().attr(name) = property;
+        return *this;
+    }
+private:
+    static void init_holder(PyObject *inst_) {
+        instance_type *inst = (instance_type *) inst_;
+        new (&inst->holder) holder_type(inst->value);
+        inst->constructed = true;
+    }
+    static void dealloc(PyObject *inst_) {
+        instance_type *inst = (instance_type *) inst_;
+        if (inst->owned) {
+            if (inst->constructed)
+                inst->holder.~holder_type();
+            else
+                ::operator delete(inst->value);
+        }
+        custom_type::dealloc((detail::instance<void> *) inst);
+    }
+};
+
+/// Binds C++ enumerations and enumeration classes to Python
+template <typename Type> class enum_ : public class_<Type> {
+public:
+    enum_(object &scope, const char *name, const char *doc = nullptr)
+      : class_<Type>(scope, name, doc), m_parent(scope) {
+        auto entries = new std::unordered_map<int, const char *>();
+        this->def("__str__", [name, entries](Type value) -> std::string {
+            auto it = entries->find(value);
+            return std::string(name) + "." +
+                ((it == entries->end()) ? std::string("???")
+                                        : std::string(it->second));
+        });
+        m_entries = entries;
+    }
+
+    /// Export enumeration entries into the parent scope
+    void export_values() {
+        PyObject *dict = ((PyTypeObject *) this->m_ptr)->tp_dict;
+        PyObject *key, *value;
+        Py_ssize_t pos = 0;
+        while (PyDict_Next(dict, &pos, &key, &value))
+            if (PyObject_IsInstance(value, this->m_ptr))
+                m_parent.attr(key) = value;
+    }
+
+    /// Add an enumeration entry
+    enum_& value(char const* name, Type value) {
+        this->attr(name) = pybind::cast(value, return_value_policy::copy);
+        (*m_entries)[(int) value] = name;
+        return *this;
+    }
+private:
+    std::unordered_map<int, const char *> *m_entries;
+    object &m_parent;
+};
+
+NAMESPACE_BEGIN(detail)
+template <typename ... Args> struct init {
+    template <typename Base, typename Holder> void execute(pybind::class_<Base, Holder> &class_, const char *doc) const {
+        /// Function which calls a specific C++ in-place constructor
+        class_.def("__init__", [](Base *instance, Args... args) { new (instance) Base(args...); }, doc);
+    }
+};
+NAMESPACE_END(detail)
+
+template <typename... Args> detail::init<Args...> init() { return detail::init<Args...>(); };
+
+template <typename InputType, typename OutputType> void implicitly_convertible() {
+    auto implicit_caster = [](PyObject *obj, PyTypeObject *type) -> PyObject *{
+        if (!detail::type_caster<InputType>().load(obj, false))
+            return nullptr;
+        tuple args(1);
+        args[0] = obj;
+        PyObject *result = PyObject_Call((PyObject *) type, args.ptr(), nullptr);
+        if (result == nullptr)
+            PyErr_Clear();
+        return result;
+    };
+    std::string output_type_name = type_id<OutputType>();
+    auto & registered_types = detail::get_internals().registered_types;
+    auto it = registered_types.find(output_type_name);
+    if (it == registered_types.end())
+        throw std::runtime_error("implicitly_convertible: Unable to find type " + output_type_name);
+    it->second.implicit_conversions.push_back(implicit_caster);
+}
+
+inline void init_threading() { PyEval_InitThreads(); }
+
+class gil_scoped_acquire {
+    PyGILState_STATE state;
+public:
+    inline gil_scoped_acquire() { state = PyGILState_Ensure(); }
+    inline ~gil_scoped_acquire() { PyGILState_Release(state); }
+};
+
+class gil_scoped_release {
+    PyThreadState *state;
+public:
+    inline gil_scoped_release() { state = PyEval_SaveThread(); }
+    inline ~gil_scoped_release() { PyEval_RestoreThread(state); }
+};
+
+NAMESPACE_END(pybind)
+
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
+
+#undef PYTHON_OBJECT
+#undef PYTHON_OBJECT_DEFAULT
+
+#endif /* __PYBIND_H */
diff --git a/include/pybind/pytypes.h b/include/pybind/pytypes.h
new file mode 100644
index 0000000..3a7b1cd
--- /dev/null
+++ b/include/pybind/pytypes.h
@@ -0,0 +1,339 @@
+/*
+    pybind/typeid.h: Convenience wrapper classes for basic Python types
+
+    Copyright (c) 2015 Wenzel Jakob <wenzel@inf.ethz.ch>
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE file.
+*/
+
+#if !defined(__PYBIND_PYTYPES_H)
+#define __PYBIND_PYTYPES_H
+
+#include "common.h"
+#include <utility>
+
+NAMESPACE_BEGIN(pybind)
+
+/* A few forward declarations */
+class object;
+class str;
+class object;
+class dict;
+NAMESPACE_BEGIN(detail)
+class accessor;
+NAMESPACE_END(detail)
+
+/// Holds a reference to a Python object (no reference counting)
+class handle {
+public:
+    handle() : m_ptr(nullptr) { }
+    handle(const handle &other) : m_ptr(other.m_ptr) { }
+    handle(PyObject *ptr) : m_ptr(ptr) { }
+    PyObject *ptr() { return m_ptr; }
+    const PyObject *ptr() const { return m_ptr; }
+    void inc_ref() const { Py_XINCREF(m_ptr); }
+    void dec_ref() const { Py_XDECREF(m_ptr); }
+    int ref_count() const { return (int) Py_REFCNT(m_ptr); }
+    inline detail::accessor operator[](handle key);
+    inline detail::accessor operator[](const char *key);
+    inline detail::accessor attr(handle key);
+    inline detail::accessor attr(const char *key);
+    inline pybind::str str() const;
+    template <typename T> T cast();
+    template <typename ... Args> object call(Args&&... args_);
+    operator bool() const { return m_ptr != nullptr; }
+protected:
+    PyObject *m_ptr;
+};
+
+/// Holds a reference to a Python object (with reference counting)
+class object : public handle {
+public:
+    object() { }
+    object(const object &o) : handle(o) { inc_ref(); }
+    object(const handle &h, bool borrowed) : handle(h) { if (borrowed) inc_ref(); }
+    object(PyObject *ptr, bool borrowed) : handle(ptr) { if (borrowed) inc_ref(); }
+    object(object &&other) { m_ptr = other.m_ptr; other.m_ptr = nullptr; }
+    ~object() { dec_ref(); }
+
+    object& operator=(object &other) {
+        Py_XINCREF(other.m_ptr);
+        Py_XDECREF(m_ptr);
+        m_ptr = other.m_ptr;
+        return *this;
+    }
+
+    object& operator=(object &&other) {
+        if (this != &other) {
+            PyObject *temp = m_ptr;
+            m_ptr = other.m_ptr;
+            other.m_ptr = nullptr;
+            Py_XDECREF(temp);
+        }
+        return *this;
+    }
+};
+
+NAMESPACE_BEGIN(detail)
+class accessor {
+public:
+    accessor(PyObject *obj, PyObject *key, bool attr)
+        : obj(obj), key(key), attr(attr) { Py_INCREF(key);  }
+    accessor(PyObject *obj, const char *key, bool attr)
+        : obj(obj), key(PyUnicode_FromString(key)), attr(attr) { }
+    accessor(const accessor &a) : obj(a.obj), key(a.key), attr(a.attr)
+        { Py_INCREF(key); }
+    ~accessor() { Py_DECREF(key); }
+
+    void operator=(accessor o) { operator=(object(o)); }
+
+    void operator=(const handle &h) {
+        if (attr) {
+            if (PyObject_SetAttr(obj, key, (PyObject *) h.ptr()) < 0)
+                throw std::runtime_error("Unable to set object attribute");
+        } else {
+            if (PyObject_SetItem(obj, key, (PyObject *) h.ptr()) < 0)
+                throw std::runtime_error("Unable to set object item");
+        }
+    }
+
+    operator object() const {
+        object result(attr ? PyObject_GetAttr(obj, key)
+                           : PyObject_GetItem(obj, key), false);
+        if (!result) PyErr_Clear();
+        return result;
+    }
+
+    operator bool() const {
+        if (attr) {
+            return (bool) PyObject_HasAttr(obj, key);
+        } else {
+            object result(PyObject_GetItem(obj, key), false);
+            if (!result) PyErr_Clear();
+            return (bool) result;
+        }
+    };
+
+private:
+    PyObject *obj;
+    PyObject *key;
+    bool attr;
+};
+
+struct list_accessor {
+public:
+    list_accessor(PyObject *list, size_t index) : list(list), index(index) { }
+    void operator=(list_accessor o) { return operator=(object(o)); }
+    void operator=(const handle &o) {
+        o.inc_ref(); // PyList_SetItem steals a reference
+        if (PyList_SetItem(list, (ssize_t) index, (PyObject *) o.ptr()) < 0)
+            throw std::runtime_error("Unable to assign value in Python list!");
+    }
+    operator object() const {
+        PyObject *result = PyList_GetItem(list, (ssize_t) index);
+        if (!result)
+            throw std::runtime_error("Unable to retrieve value from Python list!");
+        return object(result, true);
+    }
+private:
+    PyObject *list;
+    size_t index;
+};
+
+struct tuple_accessor {
+public:
+    tuple_accessor(PyObject *tuple, size_t index) : tuple(tuple), index(index) { }
+    void operator=(tuple_accessor o) { return operator=(object(o)); }
+    void operator=(const handle &o) {
+        o.inc_ref(); // PyTuple_SetItem steals a reference
+        if (PyTuple_SetItem(tuple, (ssize_t) index, (PyObject *) o.ptr()) < 0)
+            throw std::runtime_error("Unable to assign value in Python tuple!");
+    }
+    operator object() const {
+        PyObject *result = PyTuple_GetItem(tuple, (ssize_t) index);
+        if (!result)
+            throw std::runtime_error("Unable to retrieve value from Python tuple!");
+        return object(result, true);
+    }
+private:
+    PyObject *tuple;
+    size_t index;
+};
+
+class list_iterator {
+public:
+    list_iterator(PyObject *list, ssize_t pos) : list(list), pos(pos) { }
+    list_iterator& operator++() { ++pos; return *this; }
+    object operator*() { return object(PyList_GetItem(list, pos), true); }
+    bool operator==(const list_iterator &it) const { return it.pos == pos; }
+    bool operator!=(const list_iterator &it) const { return it.pos != pos; }
+private:
+    PyObject *list;
+    ssize_t pos;
+};
+
+struct dict_iterator {
+public:
+    dict_iterator(PyObject *dict = nullptr, ssize_t pos = -1) : dict(dict), pos(pos) { }
+    dict_iterator& operator++() {
+        if (!PyDict_Next(dict, &pos, &key, &value))
+            pos = -1;
+        return *this;
+    }
+    std::pair<object, object> operator*() {
+        return std::make_pair(object(key, true), object(value, true));
+    }
+    bool operator==(const dict_iterator &it) const { return it.pos == pos; }
+    bool operator!=(const dict_iterator &it) const { return it.pos != pos; }
+private:
+    PyObject *dict, *key, *value;
+    ssize_t pos = 0;
+};
+
+NAMESPACE_END(detail)
+
+inline detail::accessor handle::operator[](handle key) { return detail::accessor(ptr(), key.ptr(), false); }
+inline detail::accessor handle::operator[](const char *key) { return detail::accessor(ptr(), key, false); }
+inline detail::accessor handle::attr(handle key) { return detail::accessor(ptr(), key.ptr(), true); }
+inline detail::accessor handle::attr(const char *key) { return detail::accessor(ptr(), key, true); }
+
+#define PYTHON_OBJECT(Name, Parent, CheckFun) \
+    Name(const handle &h, bool borrowed) : Parent(h, borrowed) { } \
+    Name(const object& o): Parent(o) { } \
+    Name(object&& o): Parent(std::move(o)) { } \
+    Name& operator=(object&& o) { return static_cast<Name&>(object::operator=(std::move(o))); } \
+    Name& operator=(object& o) { return static_cast<Name&>(object::operator=(o)); } \
+    bool check() const { return m_ptr != nullptr && (bool) CheckFun(m_ptr); }
+
+#define PYTHON_OBJECT_DEFAULT(Name, Parent, CheckFun) \
+    PYTHON_OBJECT(Name, Parent, CheckFun) \
+    Name() : object() { }
+
+class str : public object {
+public:
+    PYTHON_OBJECT_DEFAULT(str, object, PyUnicode_Check)
+    str(const char *s) : object(PyUnicode_FromString(s), false) { }
+    operator const char *() const { return PyUnicode_AsUTF8(m_ptr); }
+};
+
+inline pybind::str handle::str() const { return pybind::str(PyObject_Str(m_ptr), false); }
+inline std::ostream &operator<<(std::ostream &os, const object &obj) { os << (const char *) obj.str(); return os; }
+
+class bool_ : public object {
+public:
+    PYTHON_OBJECT_DEFAULT(bool_, object, PyBool_Check)
+    operator bool() const { return m_ptr && PyLong_AsLong(m_ptr) != 0; }
+};
+
+class int_ : public object {
+public:
+    PYTHON_OBJECT_DEFAULT(int_, object, PyLong_Check)
+    int_(int value) : object(PyLong_FromLong((long) value), false) { }
+    int_(size_t value) : object(PyLong_FromSize_t(value), false) { }
+    int_(ssize_t value) : object(PyLong_FromSsize_t(value), false) { }
+    operator int() const { return (int) PyLong_AsLong(m_ptr); }
+};
+
+class float_ : public object {
+public:
+    PYTHON_OBJECT_DEFAULT(float_, object, PyFloat_Check)
+    float_(float value) : object(PyFloat_FromDouble((double) value), false) { }
+    float_(double value) : object(PyFloat_FromDouble((double) value), false) { }
+    operator float() const { return (float) PyFloat_AsDouble(m_ptr); }
+    operator double() const { return (double) PyFloat_AsDouble(m_ptr); }
+};
+
+class slice : public object {
+public:
+    PYTHON_OBJECT_DEFAULT(slice, object, PySlice_Check)
+    slice(ssize_t start_, ssize_t stop_, ssize_t step_) {
+        int_ start(start_), stop(stop_), step(step_);
+        m_ptr = PySlice_New(start.ptr(), stop.ptr(), step.ptr());
+    }
+    bool compute(ssize_t length, ssize_t *start, ssize_t *stop, ssize_t *step, ssize_t *slicelength) const {
+        return PySlice_GetIndicesEx(m_ptr, length, start, stop, step, slicelength) == 0;
+    }
+};
+
+class capsule : public object {
+public:
+    PYTHON_OBJECT_DEFAULT(capsule, object, PyCapsule_CheckExact)
+    capsule(void *value) : object(PyCapsule_New(value, nullptr, nullptr), false) { }
+    template <typename T> operator T *() const {
+        T * result = static_cast<T *>(PyCapsule_GetPointer(m_ptr, nullptr));
+        if (!result) throw std::runtime_error("Unable to extract capsule contents!");
+        return result;
+    }
+};
+
+class tuple : public object {
+public:
+    PYTHON_OBJECT_DEFAULT(tuple, object, PyTuple_Check)
+    tuple(size_t size) : object(PyTuple_New((Py_ssize_t) size), false) { }
+    size_t size() const { return (size_t) PyTuple_Size(m_ptr); }
+    detail::tuple_accessor operator[](size_t index) { return detail::tuple_accessor(ptr(), index); }
+};
+
+class dict : public object {
+public:
+    PYTHON_OBJECT(dict, object, PyDict_Check)
+    dict() : object(PyDict_New(), false) { }
+    size_t size() const { return (size_t) PyDict_Size(m_ptr); }
+    detail::dict_iterator begin() { return (++detail::dict_iterator(ptr(), 0)); }
+    detail::dict_iterator end() { return detail::dict_iterator(); }
+};
+
+class list : public object {
+public:
+    PYTHON_OBJECT(list, object, PyList_Check)
+    list(size_t size = 0) : object(PyList_New((ssize_t) size), false) { }
+    size_t size() const { return (size_t) PyList_Size(m_ptr); }
+    detail::list_iterator begin() { return detail::list_iterator(ptr(), 0); }
+    detail::list_iterator end() { return detail::list_iterator(ptr(), (ssize_t) size()); }
+    detail::list_accessor operator[](size_t index) { return detail::list_accessor(ptr(), index); }
+    void append(const object &object) { PyList_Append(m_ptr, (PyObject *) object.ptr()); }
+};
+
+class buffer : public object {
+public:
+    PYTHON_OBJECT_DEFAULT(buffer, object, PyObject_CheckBuffer)
+
+    buffer_info request(bool writable = false) {
+        int flags = PyBUF_STRIDES | PyBUF_FORMAT;
+        if (writable) flags |= PyBUF_WRITABLE;
+        view = new Py_buffer();
+        if (PyObject_GetBuffer(m_ptr, view, flags) != 0)
+            throw error_already_set();
+        std::vector<size_t> shape(view->ndim), strides(view->ndim);
+        for (int i=0; i<view->ndim; ++i) {
+            shape[i] = (size_t) view->shape[i];
+            strides[i] = (size_t) view->strides[i];
+        }
+        return buffer_info(view->buf, view->itemsize, view->format,
+                           view->ndim, shape, strides);
+    }
+    ~buffer() { if (view) { PyBuffer_Release(view); delete view; } }
+private:
+    Py_buffer *view = nullptr;
+};
+
+NAMESPACE_BEGIN(detail)
+inline internals &get_internals() {
+    static internals *internals_ptr = nullptr;
+    if (internals_ptr)
+        return *internals_ptr;
+    handle builtins(PyEval_GetBuiltins());
+    capsule caps(builtins["__pybind__"]);
+    if (caps.check()) {
+        internals_ptr = caps;
+    } else {
+        internals_ptr = new internals();
+        builtins["__pybind__"] = capsule(internals_ptr);
+    }
+    return *internals_ptr;
+}
+NAMESPACE_END(detail)
+NAMESPACE_END(pybind)
+
+#endif /* __PYBIND_PYTYPES_H */
diff --git a/include/pybind/typeid.h b/include/pybind/typeid.h
new file mode 100644
index 0000000..ee0b023
--- /dev/null
+++ b/include/pybind/typeid.h
@@ -0,0 +1,53 @@
+/*
+    pybind/typeid.h: Compiler-independent access to type identifiers
+
+    Copyright (c) 2015 Wenzel Jakob <wenzel@inf.ethz.ch>
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE file.
+*/
+
+#if !defined(__PYBIND_TYPEID_H)
+#define __PYBIND_TYPEID_H
+
+#include "common.h"
+#include <cstdio>
+#include <cstdlib>
+#if defined(__GNUG__)
+#include <cxxabi.h>
+#endif
+
+NAMESPACE_BEGIN(pybind)
+NAMESPACE_BEGIN(detail)
+/// Erase all occurrences of a substring
+inline void erase_all(std::string &string, const std::string &search) {
+    for (size_t pos = 0;;) {
+        pos = string.find(search, pos);
+        if (pos == std::string::npos) break;
+        string.erase(pos, search.length());
+    }
+}
+NAMESPACE_END(detail)
+
+/// Return a string representation of a C++ type
+template <typename T> static std::string type_id() {
+    std::string name(typeid(T).name());
+    #if defined(__GNUG__)
+        int status = 0;
+        std::unique_ptr<char, void (*)(void *)> res {
+            abi::__cxa_demangle(name.c_str(), nullptr, nullptr, &status), std::free };
+        if (status == 0)
+            name = res.get();
+    #else
+        detail::erase_all(name, "class ");
+        detail::erase_all(name, "struct ");
+        detail::erase_all(name, "enum ");
+    #endif
+    detail::erase_all(name, "pybind::");
+    return name;
+}
+
+NAMESPACE_END(pybind)
+
+#endif /* __PYBIND_TYPEID_H */
+