Starting with version 1.8.0, pybind11 releases use a semantic versioning policy.

v2.3.0 (Not yet released)

  • TBD

v2.2.1 (September 14, 2017)

  • Added py::module::reload() member function for reloading a module. #1040.
  • Fixed a reference leak in the number converter. #1078.
  • Fixed compilation with Clang on host GCC < 5 (old libstdc++ which isn’t fully C++11 compliant). #1062.
  • Fixed a regression where the automatic std::vector<bool> caster would fail to compile. The same fix also applies to any container which returns element proxies instead of references. #1053.
  • Fixed a regression where the py::keep_alive policy could not be applied to constructors. #1065.
  • Fixed a nullptr dereference when loading a py::module_local type that’s only registered in an external module. #1058.
  • Fixed implicit conversion of accessors to types derived from py::object. #1076.
  • The name in PYBIND11_MODULE(name, variable) can now be a macro. #1082.
  • Relaxed overly strict py::pickle() check for matching get and set types. #1064.
  • Conversion errors now try to be more informative when it’s likely that a missing header is the cause (e.g. forgetting <pybind11/stl.h>). #1077.

v2.2.0 (August 31, 2017)

  • Support for embedding the Python interpreter. See the documentation page for a full overview of the new features. #774, #889, #892, #920.

    #include <pybind11/embed.h>
    namespace py = pybind11;
    int main() {
        py::scoped_interpreter guard{}; // start the interpreter and keep it alive
        py::print("Hello, World!"); // use the Python API
  • Support for inheriting from multiple C++ bases in Python. #693.

    from cpp_module import CppBase1, CppBase2
    class PyDerived(CppBase1, CppBase2):
        def __init__(self):
            CppBase1.__init__(self)  # C++ bases must be initialized explicitly
  • PYBIND11_MODULE is now the preferred way to create module entry points. PYBIND11_PLUGIN is deprecated. See Macros for details. #879.

    // new
    PYBIND11_MODULE(example, m) {
        m.def("add", [](int a, int b) { return a + b; });
    // old
    PYBIND11_PLUGIN(example) {
        py::module m("example");
        m.def("add", [](int a, int b) { return a + b; });
        return m.ptr();
  • pybind11’s headers and build system now more strictly enforce hidden symbol visibility for extension modules. This should be seamless for most users, but see the Upgrade guide if you use a custom build system. #995.

  • Support for py::module_local types which allow multiple modules to export the same C++ types without conflicts. This is useful for opaque types like std::vector<int>. py::bind_vector and py::bind_map now default to py::module_local if their elements are builtins or local types. See Module-local class bindings for details. #949, #981, #995, #997.

  • Custom constructors can now be added very easily using lambdas or factory functions which return a class instance by value, pointer or holder. This supersedes the old placement-new __init__ technique. See Custom constructors for details. #805, #1014.

    struct Example {
    py::class_<Example>(m, "Example")
        .def(py::init<std::string>()) // existing constructor
        .def(py::init([](int n) { // custom constructor
            return std::make_unique<Example>(std::to_string(n));
  • Similarly to custom constructors, pickling support functions are now bound using the py::pickle() adaptor which improves type safety. See the Upgrade guide and Pickling support for details. #1038.

  • Builtin support for converting C++17 standard library types and general conversion improvements:

    1. C++17 std::variant is supported right out of the box. C++11/14 equivalents (e.g. boost::variant) can also be added with a simple user-defined specialization. See C++17 library containers for details. #811, #845, #989.
    2. Out-of-the-box support for C++17 std::string_view. #906.
    3. Improved compatibility of the builtin optional converter. #874.
    4. The bool converter now accepts numpy.bool_ and types which define __bool__ (Python 3.x) or __nonzero__ (Python 2.7). #925.
    5. C++-to-Python casters are now more efficient and move elements out of rvalue containers whenever possible. #851, #936, #938.
    6. Fixed bytes to std::string/char* conversion on Python 3. #817.
    7. Fixed lifetime of temporary C++ objects created in Python-to-C++ conversions. #924.
  • Scope guard call policy for RAII types, e.g. py::call_guard<py::gil_scoped_release>(), py::call_guard<py::scoped_ostream_redirect>(). See Additional call policies for details. #740.

  • Utility for redirecting C++ streams to Python (e.g. std::cout -> sys.stdout). Scope guard py::scoped_ostream_redirect in C++ and a context manager in Python. See Capturing standard output from ostream. #1009.

  • Improved handling of types and exceptions across module boundaries. #915, #951, #995.

  • Fixed destruction order of py::keep_alive nurse/patient objects in reference cycles. #856.

  • Numpy and buffer protocol related improvements:

    1. Support for negative strides in Python buffer objects/numpy arrays. This required changing integers from unsigned to signed for the related C++ APIs. Note: If you have compiler warnings enabled, you may notice some new conversion warnings after upgrading. These can be resolved with static_cast. #782.
    2. Support std::complex and arrays inside PYBIND11_NUMPY_DTYPE. #831, #832.
    3. Support for constructing py::buffer_info and py::arrays using arbitrary containers or iterators instead of requiring a std::vector. #788, #822, #860.
    4. Explicitly check numpy version and require >= 1.7.0. #819.
  • Support for allowing/prohibiting None for specific arguments and improved None overload resolution order. See Allow/Prohibiting None arguments for details. #843. #859.

  • Added py::exec() as a shortcut for py::eval<py::eval_statements>() and support for C++11 raw string literals as input. See Evaluating Python expressions from strings and files. #766, #827.

  • py::vectorize() ignores non-vectorizable arguments and supports member functions. #762.

  • Support for bound methods as callbacks (pybind11/functional.h). #815.

  • Allow aliasing pybind11 methods: cls.attr("foo") = cls.attr("bar"). #802.

  • Don’t allow mixed static/non-static overloads. #804.

  • Fixed overriding static properties in derived classes. #784.

  • Improved deduction of member functions of a derived class when its bases aren’t registered with pybind11. #855.

    struct Base {
        int foo() { return 42; }
    struct Derived : Base {}
    // Now works, but previously required also binding `Base`
    py::class_<Derived>(m, "Derived")
        .def("foo", &Derived::foo); // function is actually from `Base`
  • The implementation of py::init<> now uses C++11 brace initialization syntax to construct instances, which permits binding implicit constructors of aggregate types. #1015.

    struct Aggregate {
        int a;
        std::string b;
    py::class_<Aggregate>(m, "Aggregate")
        .def(py::init<int, const std::string &>());
  • Fixed issues with multiple inheritance with offset base/derived pointers. #812, #866, #960.

  • Fixed reference leak of type objects. #1030.

  • Improved support for the /std:c++14 and /std:c++latest modes on MSVC 2017. #841, #999.

  • Fixed detection of private operator new on MSVC. #893, #918.

  • Intel C++ compiler compatibility fixes. #937.

  • Fixed implicit conversion of py::enum_ to integer types on Python 2.7. #821.

  • Added py::hash to fetch the hash value of Python objects, and .def(hash(py::self)) to provide the C++ std::hash as the Python __hash__ method. #1034.

  • Fixed __truediv__ on Python 2 and __itruediv__ on Python 3. #867.

  • py::capsule objects now support the name attribute. This is useful for interfacing with scipy.LowLevelCallable. #902.

  • Fixed py::make_iterator‘s __next__() for past-the-end calls. #897.

  • Added error_already_set::matches() for checking Python exceptions. #772.

  • Deprecated py::error_already_set::clear(). It’s no longer needed following a simplification of the py::error_already_set class. #954.

  • Deprecated py::handle::operator==() in favor of py::handle::is() #825.

  • Deprecated py::object::borrowed/py::object::stolen. Use py::object::borrowed_t{}/py::object::stolen_t{} instead. #771.

  • Changed internal data structure versioning to avoid conflicts between modules compiled with different revisions of pybind11. #1012.

  • Additional compile-time and run-time error checking and more informative messages. #786, #794, #803.

  • Various minor improvements and fixes. #764, #791, #795, #840, #844, #846, #849, #858, #862, #871, #872, #881, #888, #899, #928, #931, #944, #950, #952, #962, #965, #970, #978, #979, #986, #1020, #1027, #1037.

  • Testing improvements. #798, #882, #898, #900, #921, #923, #963.

v2.1.1 (April 7, 2017)

  • Fixed minimum version requirement for MSVC 2015u3 #773.

v2.1.0 (March 22, 2017)

  • pybind11 now performs function overload resolution in two phases. The first phase only considers exact type matches, while the second allows for implicit conversions to take place. A special noconvert() syntax can be used to completely disable implicit conversions for specific arguments. #643, #634, #650.
  • Fixed a regression where static properties no longer worked with classes using multiple inheritance. The py::metaclass attribute is no longer necessary (and deprecated as of this release) when binding classes with static properties. #679,
  • Classes bound using pybind11 can now use custom metaclasses. #679,
  • py::args and py::kwargs can now be mixed with other positional arguments when binding functions using pybind11. #611.
  • Improved support for C++11 unicode string and character types; added extensive documentation regarding pybind11’s string conversion behavior. #624, #636, #715.
  • pybind11 can now avoid expensive copies when converting Eigen arrays to NumPy arrays (and vice versa). #610.
  • The “fast path” in py::vectorize now works for any full-size group of C or F-contiguous arrays. The non-fast path is also faster since it no longer performs copies of the input arguments (except when type conversions are necessary). #610.
  • Added fast, unchecked access to NumPy arrays via a proxy object. #746.
  • Transparent support for class-specific operator new and operator delete implementations. #755.
  • Slimmer and more efficient STL-compatible iterator interface for sequence types. #662.
  • Improved custom holder type support. #607.
  • nullptr to None conversion fixed in various builtin type casters. #732.
  • enum_ now exposes its members via a special __members__ attribute. #666.
  • std::vector bindings created using stl_bind.h can now optionally implement the buffer protocol. #488.
  • Automated C++ reference documentation using doxygen and breathe. #598.
  • Added minimum compiler version assertions. #727.
  • Improved compatibility with C++1z. #677.
  • Improved py::capsule API. Can be used to implement cleanup callbacks that are involved at module destruction time. #752.
  • Various minor improvements and fixes. #595, #588, #589, #603, #619, #648, #695, #720, #723, #729, #724, #742, #753.

v2.0.1 (Jan 4, 2017)

  • Fix pointer to reference error in type_caster on MSVC #583.
  • Fixed a segmentation in the test suite due to a typo cd7eac.

v2.0.0 (Jan 1, 2017)

  • Fixed a reference counting regression affecting types with custom metaclasses (introduced in v2.0.0-rc1). #571.
  • Quenched a CMake policy warning. #570.

v2.0.0-rc1 (Dec 23, 2016)

The pybind11 developers are excited to issue a release candidate of pybind11 with a subsequent v2.0.0 release planned in early January next year.

An incredible amount of effort by went into pybind11 over the last ~5 months, leading to a release that is jam-packed with exciting new features and numerous usability improvements. The following list links PRs or individual commits whenever applicable.

Happy Christmas!

  • Support for binding C++ class hierarchies that make use of multiple inheritance. #410.

  • PyPy support: pybind11 now supports nightly builds of PyPy and will interoperate with the future 5.7 release. No code changes are necessary, everything “just” works as usual. Note that we only target the Python 2.7 branch for now; support for 3.x will be added once its cpyext extension support catches up. A few minor features remain unsupported for the time being (notably dynamic attributes in custom types). #527.

  • Significant work on the documentation – in particular, the monolitic advanced.rst file was restructured into a easier to read hierarchical organization. #448.

  • Many NumPy-related improvements:

    1. Object-oriented API to access and modify NumPy ndarray instances, replicating much of the corresponding NumPy C API functionality. #402.

    2. NumPy array dtype array descriptors are now first-class citizens and are exposed via a new class py::dtype.

    3. Structured dtypes can be registered using the PYBIND11_NUMPY_DTYPE() macro. Special array constructors accepting dtype objects were also added.

      One potential caveat involving this change: format descriptor strings should now be accessed via format_descriptor::format() (however, for compatibility purposes, the old syntax format_descriptor::value will still work for non-structured data types). #308.

    4. Further improvements to support structured dtypes throughout the system. #472, #474, #459, #453, #452, and #505.

    5. Fast access operators. #497.

    6. Constructors for arrays whose storage is owned by another object. #440.

    7. Added constructors for array and array_t explicitly accepting shape and strides; if strides are not provided, they are deduced assuming C-contiguity. Also added simplified constructors for 1-dimensional case.

    8. Added buffer/NumPy support for char[N] and std::array<char, N> types.

    9. Added memoryview wrapper type which is constructible from buffer_info.

  • Eigen: many additional conversions and support for non-contiguous arrays/slices. #427, #315, #316, #312, and #267

  • Incompatible changes in class_<...>::class_():

    1. Declarations of types that provide access via the buffer protocol must now include the py::buffer_protocol() annotation as an argument to the class_ constructor.

    2. Declarations of types that require a custom metaclass (i.e. all classes which include static properties via commands such as def_readwrite_static()) must now include the py::metaclass() annotation as an argument to the class_ constructor.

      These two changes were necessary to make type definitions in pybind11 future-proof, and to support PyPy via its cpyext mechanism. #527.

    3. This version of pybind11 uses a redesigned mechnism for instantiating trempoline classes that are used to override virtual methods from within Python. This led to the following user-visible syntax change: instead of



      py::class_<MyClass, TrampolineClass>("MyClass")

      Importantly, both the original and the trampoline class are now specified as an arguments (in arbitrary order) to the py::class_ template, and the alias<..>() call is gone. The new scheme has zero overhead in cases when Python doesn’t override any functions of the underlying C++ class. rev. 86d825.

  • Added eval and eval_file functions for evaluating expressions and statements from a string or file. rev. 0d3fc3.

  • pybind11 can now create types with a modifiable dictionary. #437 and #444.

  • Support for translation of arbitrary C++ exceptions to Python counterparts. #296 and #273.

  • Report full backtraces through mixed C++/Python code, better reporting for import errors, fixed GIL management in exception processing. #537, #494, rev. e72d95, and rev. 099d6e.

  • Support for bit-level operations, comparisons, and serialization of C++ enumerations. #503, #508, #380, #309. #311.

  • The class_ constructor now accepts its template arguments in any order. #385.

  • Attribute and item accessors now have a more complete interface which makes it possible to chain attributes as in obj.attr("a")[key].attr("b").attr("method")(1, 2, 3). #425.

  • Major redesign of the default and conversion constructors in pytypes.h. #464.

  • Added built-in support for std::shared_ptr holder type. It is no longer necessary to to include a declaration of the form PYBIND11_DECLARE_HOLDER_TYPE(T, std::shared_ptr<T>) (though continuing to do so won’t cause an error). #454.

  • New py::overload_cast casting operator to select among multiple possible overloads of a function. An example:

    py::class_<Pet>(m, "Pet")
        .def("set", py::overload_cast<int>(&Pet::set), "Set the pet's age")
        .def("set", py::overload_cast<const std::string &>(&Pet::set), "Set the pet's name");

    This feature only works on C++14-capable compilers. #541.

  • C++ types are automatically cast to Python types, e.g. when assigning them as an attribute. For instance, the following is now legal:

    py::module m = /* ... */
    m.attr("constant") = 123;

    (Previously, a py::cast call was necessary to avoid a compilation error.) #551.

  • Redesigned pytest-based test suite. #321.

  • Instance tracking to detect reference leaks in test suite. #324

  • pybind11 can now distinguish between multiple different instances that are located at the same memory address, but which have different types. #329.

  • Improved logic in move return value policy. #510, #297.

  • Generalized unpacking API to permit calling Python functions from C++ using notation such as foo(a1, a2, *args, "ka"_a=1, "kb"_a=2, **kwargs). #372.

  • py::print() function whose behavior matches that of the native Python print() function. #372.

  • Added py::dict keyword constructor:auto d = dict("number"_a=42, "name"_a="World");. #372.

  • Added py::str::format() method and _s literal: py::str s = "1 + 2 = {}"_s.format(3);. #372.

  • Added py::repr() function which is equivalent to Python’s builtin repr(). #333.

  • Improved construction and destruction logic for holder types. It is now possible to reference instances with smart pointer holder types without constructing the holder if desired. The PYBIND11_DECLARE_HOLDER_TYPE macro now accepts an optional second parameter to indicate whether the holder type uses intrusive reference counting. #533 and #561.

  • Mapping a stateless C++ function to Python and back is now “for free” (i.e. no extra indirections or argument conversion overheads). rev. 954b79.

  • Bindings for std::valarray<T>. #545.

  • Improved support for C++17 capable compilers. #562.

  • Bindings for std::optional<t>. #475, #476, #479, #499, and #501.

  • stl_bind.h: general improvements and support for std::map and std::unordered_map. #490, #282, #235.

  • The std::tuple, std::pair, std::list, and std::vector type casters now accept any Python sequence type as input. rev. 107285.

  • Improved CMake Python detection on multi-architecture Linux. #532.

  • Infrastructure to selectively disable or enable parts of the automatically generated docstrings. #486.

  • reference and reference_internal are now the default return value properties for static and non-static properties, respectively. #473. (the previous defaults were automatic). #473.

  • Support for std::unique_ptr with non-default deleters or no deleter at all (py::nodelete). #384.

  • Deprecated handle::call() method. The new syntax to call Python functions is simply handle(). It can also be invoked explicitly via handle::operator<X>(), where X is an optional return value policy.

  • Print more informative error messages when make_tuple() or cast() fail. #262.

  • Creation of holder types for classes deriving from std::enable_shared_from_this<> now also works for const values. #260.

  • make_iterator() improvements for better compatibility with various types (now uses prefix increment operator); it now also accepts iterators with different begin/end types as long as they are equality comparable. #247.

  • arg() now accepts a wider range of argument types for default values. #244.

  • Support keep_alive where the nurse object may be None. #341.

  • Added constructors for str and bytes from zero-terminated char pointers, and from char pointers and length. Added constructors for str from bytes and for bytes from str, which will perform UTF-8 decoding/encoding as required.

  • Many other improvements of library internals without user-visible changes

1.8.1 (July 12, 2016)

  • Fixed a rare but potentially very severe issue when the garbage collector ran during pybind11 type creation.

1.8.0 (June 14, 2016)

  • Redesigned CMake build system which exports a convenient pybind11_add_module function to parent projects.
  • std::vector<> type bindings analogous to Boost.Python’s indexing_suite
  • Transparent conversion of sparse and dense Eigen matrices and vectors (eigen.h)
  • Added an ExtraFlags template argument to the NumPy array_t<> wrapper to disable an enforced cast that may lose precision, e.g. to create overloads for different precisions and complex vs real-valued matrices.
  • Prevent implicit conversion of floating point values to integral types in function arguments
  • Fixed incorrect default return value policy for functions returning a shared pointer
  • Don’t allow registering a type via class_ twice
  • Don’t allow casting a None value into a C++ lvalue reference
  • Fixed a crash in enum_::operator== that was triggered by the help() command
  • Improved detection of whether or not custom C++ types can be copy/move-constructed
  • Extended str type to also work with bytes instances
  • Added a "name"_a user defined string literal that is equivalent to py::arg("name").
  • When specifying function arguments via py::arg, the test that verifies the number of arguments now runs at compile time.
  • Added [[noreturn]] attribute to pybind11_fail() to quench some compiler warnings
  • List function arguments in exception text when the dispatch code cannot find a matching overload
  • Added PYBIND11_OVERLOAD_NAME and PYBIND11_OVERLOAD_PURE_NAME macros which can be used to override virtual methods whose name differs in C++ and Python (e.g. __call__ and operator())
  • Various minor iterator and make_iterator() improvements
  • Transparently support __bool__ on Python 2.x and Python 3.x
  • Fixed issue with destructor of unpickled object not being called
  • Minor CMake build system improvements on Windows
  • New pybind11::args and pybind11::kwargs types to create functions which take an arbitrary number of arguments and keyword arguments
  • New syntax to call a Python function from C++ using *args and *kwargs
  • The functions def_property_* now correctly process docstring arguments (these formerly caused a segmentation fault)
  • Many improvements (enumerations, template arguments, DOC() macro accepts more arguments)
  • Cygwin support
  • Documentation improvements (pickling support, keep_alive, macro usage)

1.7 (April 30, 2016)

  • Added a new move return value policy that triggers C++11 move semantics. The automatic return value policy falls back to this case whenever a rvalue reference is encountered
  • Significantly more general GIL state routines that are used instead of Python’s troublesome PyGILState_Ensure and PyGILState_Release API
  • Redesign of opaque types that drastically simplifies their usage
  • Extended ability to pass values of type [const] void *
  • keep_alive fix: don’t fail when there is no patient
  • functional.h: acquire the GIL before calling a Python function
  • Added Python RAII type wrappers none and iterable
  • Added *args and *kwargs pass-through parameters to pybind11.get_include() function
  • Iterator improvements and fixes
  • Documentation on return value policies and opaque types improved

1.6 (April 30, 2016)

1.5 (April 21, 2016)

  • For polymorphic types, use RTTI to try to return the closest type registered with pybind11
  • Pickling support for serializing and unserializing C++ instances to a byte stream in Python
  • Added a convenience routine make_iterator() which turns a range indicated by a pair of C++ iterators into a iterable Python object
  • Added len() and a variadic make_tuple() function
  • Addressed a rare issue that could confuse the current virtual function dispatcher and another that could lead to crashes in multi-threaded applications
  • Added a get_include() function to the Python module that returns the path of the directory containing the installed pybind11 header files
  • Documentation improvements: import issues, symbol visibility, pickling, limitations
  • Added casting support for std::reference_wrapper<>

1.4 (April 7, 2016)

  • Transparent type conversion for std::wstring and wchar_t
  • Allow passing nullptr-valued strings
  • Transparent passing of void * pointers using capsules
  • Transparent support for returning values wrapped in std::unique_ptr<>
  • Improved docstring generation for compatibility with Sphinx
  • Nicer debug error message when default parameter construction fails
  • Support for “opaque” types that bypass the transparent conversion layer for STL containers
  • Redesigned type casting interface to avoid ambiguities that could occasionally cause compiler errors
  • Redesigned property implementation; fixes crashes due to an unfortunate default return value policy
  • Anaconda package generation support

1.3 (March 8, 2016)

  • Added support for the Intel C++ compiler (v15+)
  • Added support for the STL unordered set/map data structures
  • Added support for the STL linked list data structure
  • NumPy-style broadcasting support in pybind11::vectorize
  • pybind11 now displays more verbose error messages when arg::operator=() fails
  • pybind11 internal data structures now live in a version-dependent namespace to avoid ABI issues
  • Many, many bugfixes involving corner cases and advanced usage

1.2 (February 7, 2016)

  • Optional: efficient generation of function signatures at compile time using C++14
  • Switched to a simpler and more general way of dealing with function default arguments. Unused keyword arguments in function calls are now detected and cause errors as expected
  • New keep_alive call policy analogous to Boost.Python’s with_custodian_and_ward
  • New pybind11::base<> attribute to indicate a subclass relationship
  • Improved interface for RAII type wrappers in pytypes.h
  • Use RAII type wrappers consistently within pybind11 itself. This fixes various potential refcount leaks when exceptions occur
  • Added new bytes RAII type wrapper (maps to string in Python 2.7)
  • Made handle and related RAII classes const correct, using them more consistently everywhere now
  • Got rid of the ugly __pybind11__ attributes on the Python side—they are now stored in a C++ hash table that is not visible in Python
  • Fixed refcount leaks involving NumPy arrays and bound functions
  • Vastly improved handling of shared/smart pointers
  • Removed an unnecessary copy operation in pybind11::vectorize
  • Fixed naming clashes when both pybind11 and NumPy headers are included
  • Added conversions for additional exception types
  • Documentation improvements (using multiple extension modules, smart pointers, other minor clarifications)
  • unified infrastructure for parsing variadic arguments in class_ and cpp_function
  • Fixed license text (was: ZLIB, should have been: 3-clause BSD)
  • Python 3.2 compatibility
  • Fixed remaining issues when accessing types in another plugin module
  • Added enum comparison and casting methods
  • Improved SFINAE-based detection of whether types are copy-constructible
  • Eliminated many warnings about unused variables and the use of offsetof()
  • Support for std::array<> conversions

1.1 (December 7, 2015)

  • Documentation improvements (GIL, wrapping functions, casting, fixed many typos)
  • Generalized conversion of integer types
  • Improved support for casting function objects
  • Improved support for std::shared_ptr<> conversions
  • Initial support for std::set<> conversions
  • Fixed type resolution issue for types defined in a separate plugin module
  • Cmake build system improvements
  • Factored out generic functionality to non-templated code (smaller code size)
  • Added a code size / compile time benchmark vs Boost.Python
  • Added an appveyor CI script

1.0 (October 15, 2015)

  • Initial release