How do I include nanobind headers in my non-module C++ library?

[dograt]

I have a working CMake project that uses nanobind to create a module, mylib_module. The bindings module links a C++ library mylib, which contains all of the non-binding logic. So, mylib_module is created using nanobind_add_module, and mylib is creating using add_library

I want to use intrusive reference counting, which requires modifying the types in mylib, but mylib doesn't link to nanobind. How do I get around this? I tried simply using target_link_libraries, i.e.:

find_package(nanobind
    CONFIG
    REQUIRED
)
...
target_link_libraries(mylib PRIVATE nanobind)

but nanobind isn't recognized as a target:

DEBUG CMake Error at projects/my_project/CMakeLists.txt:54 (target_link_libraries):
DEBUG   Target "mylib" has LINK_LIBRARIES_ONLY_TARGETS enabled, but it links to:
DEBUG 
DEBUG     nanobind
DEBUG 
DEBUG   which is not a target.  Possible reasons include:

I've tried various permutations, like nanobind::nanobind, but no dice.

Edit:

I am able to link to nanobind if I disable my set(CMAKE_LINK_LIBRARIES_ONLY_TARGETS ON) check, but this still doesn't give me the header I want:

      /home/my_project/nanobind_aliases.hpp:9:14: fatal error: nanobind/intrusive/counter.h: No such file or directory
          9 |     #include <nanobind/intrusive/counter.h>
            |              ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      compilation terminated.

Edit 2:

I seem to have made progress with:

message(STATUS "Nanobind include dir: ${NB_DIR}")
target_include_directories(mylib
    PRIVATE ${NB_DIR}/include
)

However, I sourced this variable from this thread., so I'm sure this is not the correct approach.

For what it's worth, this compiles fine, but Python is still garbage collecting the object, causing a SEGFAULT. I followed all the instructions here, so I'm not sure where to go from here.

[wjakob]

The intrusive reference counting code doesn't depend on nanobind (besides the header file). You just need a way to determine the path to the header.. which is not a nanobind issue.

[gistrec]

The author already pointed at the answer in their comment - you just need the header path, not a CMake target named nanobind. There isn't one: nanobind's CMake module doesn't expose a top-level nanobind (or nanobind::nanobind) target. What nanobind_add_module(mylib_module) builds under the hood is a per-module helper library named after the module itself, plus a link to Python::Module. Both pieces are intrinsic to building a Python extension and don't make sense for a plain non-module C++ library like your mylib

For your specific case (intrusive ref counting), that's actually the designed situation. From the comment at the top of nanobind/intrusive/counter.h:

The code in this file is designed to be truly minimal: it depends neither
on Python, nanobind, nor the STL. This enables its use in small projects
with a 100% optional Python interface.

So you really do only need the include directory. nanobind's CMake config
exposes a cache variable NB_DIR pointing to its root - use it:

find_package(nanobind CONFIG REQUIRED)

# Pure header inclusion - no link to nanobind, no Python dependency.
target_include_directories(mylib PRIVATE ${NB_DIR}/include)

# The bindings module side stays as it was.
nanobind_add_module(mylib_module ...)
target_link_libraries(mylib_module PRIVATE mylib)

After this, mylib can #include <nanobind/intrusive/counter.h> and use
nb::intrusive_base / nb::ref<T> directly, without becoming a Python
extension itself

If LINK_LIBRARIES_ONLY_TARGETS keeps biting you in similar contexts, you
can wrap the include path as an INTERFACE IMPORTED target locally:

add_library(nanobind::headers INTERFACE IMPORTED)
target_include_directories(nanobind::headers INTERFACE ${NB_DIR}/include)

target_link_libraries(mylib PRIVATE nanobind::headers)

• but that's purely stylistic, not required