Note: I posted this message a very long time ago on this list and still haven't found a solution. Several months ago David suggested that I repost the message again to see if anyone can help out. I am finally getting back to this project so here is the repost. I am wrapping a C++ library with boost.python that has multiple types of smart ptrs for it's objects. It has a ptr<> type that holds the object and provides a ref counting interface (through and addRef()/subRef() interface). It then has a ref_ptr<> type that acts like a "standard" smart pointer by holding a ptr<> internally and calling the ref handling operations upon construction and destruction. To correctly handle the memory for the objects, I want my boost.python class wrappers for a class T to be held using ref_ptr<T>. I can do this with: class_<T, bases<...>, ref_ptr<T> >("T",...); This all works fine. I run into a problem though when I want to use wrapped method that return ptr<>'s to objects instead of a full ref_ptr<>. For example if I wrap a method like this: ptr<Base> createObject() { ... } then when I call this from boost.python it needs to figure out that it should convert the ptr<Base> to a ref_ptr<Base>. I know that I can use register_ptr_to_python<ptr<Base> > to register a to_python converter for the type, but as I understand it this will cause the python wrapper to store the C++ object using a ptr<> type internally. This won't work correctly because it will not do any memory reference counting. What I need is a way to tell boost python that anytime it needs to convert a ptr<Base> to python it should first convert it to a ref_ptr<Base> (using a standard copy constructor in ref_ptr<>) and then use this ref_ptr as the held type like normal. At first I thought that implicitly_convertible<> would help: implicitly_convertible<ptr<Base>, ref_ptr<Base> >(); But this doesn't seem to do anything for me. (this really isn't too surprising since this isn't what implicitly_convertible is for, but it seemed worth a try). Has anyone else ran into anything similar? Any ideas? Thanks, Allen