diff --git a/.appveyor.yml b/.appveyor.yml
index 3acbf4677..c41b326a7 100644
--- a/.appveyor.yml
+++ b/.appveyor.yml
@@ -13,18 +13,11 @@ environment:
     - arch: x64
       CMAKE_GENERATOR: Visual Studio 16 2019
       CMAKE_CONFIG: RelWithDebInfo
-      CMAKE_ARGS: -DCMAKE_CXX_STANDARD=11 -DPython_EXECUTABLE="C:\\Python310-x64\\python.exe" -DBUILD_SHARED_LIBS=OFF -DVCPKG_TARGET_TRIPLET=x64-windows-static -DCMAKE_TOOLCHAIN_FILE=C:/Tools/vcpkg/scripts/buildsystems/vcpkg.cmake
+      CMAKE_ARGS: -DCMAKE_CXX_STANDARD=17 -DPython_EXECUTABLE="C:\\Python310-x64\\python.exe" -DBUILD_SHARED_LIBS=OFF -DVCPKG_TARGET_TRIPLET=x64-windows-static -DCMAKE_TOOLCHAIN_FILE=C:/Tools/vcpkg/scripts/buildsystems/vcpkg.cmake
       APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
       VCPKG_BUILD_TYPE: "release"
       PY_PYTHON: 3.10
 
-    - arch: x86
-      CMAKE_GENERATOR: Visual Studio 15 2017
-      CMAKE_CONFIG: MinSizeRel
-      CMAKE_ARGS: -DPython_EXECUTABLE="C:\\Python38\\python.exe"
-      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-      PY_PYTHON: 3.8-32
-
     - arch: x64
       CMAKE_GENERATOR: MSYS Makefiles
       COMPILER: MinGW64-gcc-8.1.0
@@ -43,7 +36,7 @@ for:
   build_script:
   - path
   - cmake --version
-  - git clone --depth=1 -b stable https://github.com/pybind/pybind11.git
+  - git clone --depth=1 --recursive https://github.com/wjakob/nanobind.git
   - cmake -G "%CMAKE_GENERATOR%" -DUSE_PYTHON=1 %CMAKE_ARGS% .
   - cmake --build . --config %CMAKE_CONFIG%
   - cmake --build . --config %CMAKE_CONFIG% --target check
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 649293731..468574244 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -22,10 +22,13 @@ jobs:
     - name: Python Tests
       run: |
         source pyenv/bin/activate
-        python3 -m unittest discover -v -s tests/
         python3 -m pip install sphinx
-        cd docs
-        sphinx-build -M doctest . _build -n -E
+        # run tests twice: without and with numpy
+        python3 -m unittest discover -s tests/
+        (cd docs && sphinx-build -M doctest . _build -n -E)
+        python3 -m pip install numpy
+        python3 -m unittest discover -v -s tests/
+        (cd docs && sphinx-build -M doctest . _build -n -E)
     - uses: actions/upload-artifact@v4
       with:
         name: gemmi-macos14
@@ -96,7 +99,7 @@ jobs:
     - name: apt-get
       run: |
         sudo apt-get update
-        sudo apt-get install python3-full g++ gfortran python3-numpy
+        sudo apt-get install python3-full g++ gfortran
     - name: build and test
       run: |
         g++ --version
@@ -104,6 +107,7 @@ jobs:
         source pyenv/bin/activate
         export SKBUILD_CMAKE_ARGS='-DFETCH_ZLIB_NG=ON;-DCMAKE_BUILD_TYPE=None'
         python3 -m pip install -v .
+        python3 -m pip install numpy
         python3 -m unittest discover -v -s tests/
     - name: run doctest
       run: |
@@ -122,13 +126,9 @@ jobs:
       run: |
         sudo apt-get update
         sudo apt-get install libz-dev python3-pip g++ gfortran python3-numpy
-    - name: install pybind11
+    - name: install nanobind
       run: |
-        git clone --depth=1 https://github.com/pybind/pybind11.git
-        #cd pybind11
-        #cmake . -Wno-dev -DPYTHON_EXECUTABLE=/usr/bin/python3 -DPYBIND11_TEST=OFF
-        #make
-        #sudo make install
+        git clone --recursive --depth=1 https://github.com/wjakob/nanobind.git
     - name: build and test
       run: |
         g++ --version
@@ -158,9 +158,9 @@ jobs:
       run: |
         sudo apt-get update
         sudo apt-get install libz-dev python3-pip g++ gfortran python3-numpy valgrind
-    - name: install pybind11
+    - name: install nanobind
       run: |
-        python3 -m pip install pybind11
+        python3 -m pip install nanobind
     - name: build and test
       run: |
         g++ --version
@@ -181,21 +181,21 @@ jobs:
     - name: run tests under valgrind
       run: PYTHONMALLOC=malloc valgrind python3 -m unittest discover -v -s tests/
 
-  ubuntu2004_clang6:
-    name: "Ubuntu 20.04 with Clang 6.0"
+  ubuntu2004_clang9:
+    name: "Ubuntu 20.04 with Clang 9"
     runs-on: ubuntu-20.04
     if: "!contains(github.event.head_commit.message, '[skip ci]')"
     env:
-      CC: clang-6.0
-      CXX: clang++-6.0
+      CC: clang-9
+      CXX: clang++-9
       SKBUILD_CMAKE_ARGS: "-DCMAKE_CXX_STANDARD=11;-DEXTRA_WARNINGS=ON;-DSTANDALONE_PYTHON_MODULE=OFF"
       SKBUILD_CMAKE_TARGETS: "all;check"
     steps:
     - uses: actions/checkout@v4
-    - run: sudo apt-get install clang-6.0 libz-dev python3-pip python3-numpy
-    - name: install pybind11
+    - run: sudo apt-get install clang-9 libz-dev python3-pip python3-numpy
+    - name: install nanobind
       run: |
-        sudo /usr/bin/python3 -m pip install "pybind11[global]" build
+        sudo /usr/bin/python3 -m pip install nanobind build
     - name: build and test
       run: |
         $CXX --version
@@ -224,11 +224,11 @@ jobs:
         python3.8 --version
         cmake --version
         type python3.8
-    - name: install pybind11
+    - name: install nanobind
       run: |
-        git clone --branch stable --depth=1 https://github.com/pybind/pybind11.git
-        cd pybind11
-        cmake . -Wno-dev -DPYTHON_EXECUTABLE=/usr/bin/python3.8 -DPYBIND11_TEST=OFF
+        git clone --recursive --depth=1 https://github.com/wjakob/nanobind.git
+        cd nanobind
+        cmake . -Wno-dev -DPYTHON_EXECUTABLE=/usr/bin/python3.8 -DNB_TEST=OFF
         make
         make install
     - name: build and test
diff --git a/.gitignore b/.gitignore
index 0918f40b2..cef044c1c 100644
--- a/.gitignore
+++ b/.gitignore
@@ -22,8 +22,8 @@ tags
 /CTestTestfile.cmake
 /Makefile
 
-# local pybind11 is used for testing new versions, don't add to the repo
-third_party/pybind11
+# local nanobind can be used for testing new versions, don't add to the repo
+/nanobind
 
 # ignore random data files in the top and source directory
 /*.cif
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 3d78c563e..45308b378 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -67,9 +67,8 @@ endif()
 set(CMAKE_POLICY_DEFAULT_CMP0069 NEW)
 
 # Unless it's explicitly specifed, we want LTO for non-debug builds only.
-# pybind11Common.cmake has its own logic to set LTO options.
-# Having different options in pybind11_add_module than for gemmi_cpp
-# may cause problems -- we may need to handle it at some point.
+# TODO: check that it's compatible with nanobind_add_module, which has
+# its own logic of setting LTO options.
 if (NOT DEFINED CMAKE_INTERPROCEDURAL_OPTIMIZATION)
   include(CheckIPOSupported)
   check_ipo_supported(RESULT is_ipo_supported OUTPUT ipo_error)
@@ -108,10 +107,9 @@ if (DEFINED ENV{CXXFLAGS})
 endif()
 
 # Set default build mode (based on CMake FAQ)
-if (NOT CMAKE_BUILD_TYPE AND NOT USING_ENV_CXXFLAGS)
-  set(CMAKE_BUILD_TYPE Release CACHE STRING
-      "Choose the type of build, options are: None Debug Release RelWithDebInfo MinSizeRel."
-      FORCE)
+if (NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES AND NOT USING_ENV_CXXFLAGS)
+  set(CMAKE_BUILD_TYPE Release CACHE STRING "Choose the type of build." FORCE)
+  set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS "Debug" "Release" "MinSizeRel" "RelWithDebInfo")
 endif()
 message(STATUS "Build type: ${CMAKE_BUILD_TYPE}")
 
@@ -458,29 +456,28 @@ if (USE_PYTHON)
   else()
     find_package(Python ${PYTHON_VERSION} REQUIRED COMPONENTS Interpreter Development.Module)
   endif()
-  # pybind11 macros use PYTHON_EXECUTABLE
-  if (DEFINED Python_EXECUTABLE AND NOT DEFINED PYTHON_EXECUTABLE)
-    set(PYTHON_EXECUTABLE "${Python_EXECUTABLE}")
-  endif()
-  if (EXISTS "${CMAKE_HOME_DIRECTORY}/pybind11")
-    message(STATUS "Using ${CMAKE_HOME_DIRECTORY}/pybind11 (internal copy).")
-    add_subdirectory(pybind11)
+  if (EXISTS "${CMAKE_HOME_DIRECTORY}/nanobind")
+    message(STATUS "Using ${CMAKE_HOME_DIRECTORY}/nanobind (internal copy).")
+    add_subdirectory(nanobind)
   else()
-    # use pybind11-config (if available) to determine pybind11_DIR
-    execute_process(COMMAND pybind11-config --cmakedir OUTPUT_VARIABLE pybind11_DIR)
-    string(STRIP "${pybind11_DIR}" pybind11_DIR)
-    find_package(pybind11 2.6 CONFIG REQUIRED)
-    message(STATUS "Found pybind11 ${pybind11_VERSION}: ${pybind11_INCLUDE_DIRS}")
+    # Detect the installed nanobind package and import it into CMake
+    execute_process(
+      COMMAND "${Python_EXECUTABLE}" -m nanobind --cmake_dir
+      OUTPUT_STRIP_TRAILING_WHITESPACE OUTPUT_VARIABLE NB_DIR)
+    list(APPEND CMAKE_PREFIX_PATH "${NB_DIR}")
+    find_package(nanobind 2.1.0 CONFIG REQUIRED)
+    message(STATUS "Found nanobind ${nanobind_VERSION}: ${NB_DIR}")
   endif()
-  pybind11_add_module(gemmi_py
-          python/mol.cpp python/gemmi.cpp python/align.cpp
+  nanobind_add_module(gemmi_py NOMINSIZE
+          python/gemmi.cpp python/align.cpp
           python/ccp4.cpp python/chemcomp.cpp python/cif.cpp python/custom.cpp
           python/elem.cpp python/grid.cpp python/hkl.cpp
-          python/meta.cpp python/monlib.cpp
+          python/meta.cpp python/mol.cpp python/monlib.cpp
           python/mtz.cpp python/read.cpp python/recgrid.cpp
           python/scaling.cpp python/search.cpp
           python/sf.cpp python/sym.cpp python/topo.cpp
           python/unitcell.cpp python/write.cpp)
+
   if (STANDALONE_PYTHON_MODULE)
     target_sources(gemmi_py PRIVATE $<TARGET_OBJECTS:gemmi_cpp>)
     get_target_property(_gemmi_cpp_libs gemmi_cpp LINK_LIBRARIES)
@@ -489,9 +486,25 @@ if (USE_PYTHON)
     target_link_libraries(gemmi_py PRIVATE gemmi_cpp)
   endif()
   set_property(TARGET gemmi_py PROPERTY OUTPUT_NAME gemmi)
+
+  # nanobind gives warnings with -Wpedantic and -Wshadow
   if(CMAKE_CXX_FLAGS MATCHES "-Wshadow")
+    if (TARGET nanobind-static)
+      target_compile_options(nanobind-static PRIVATE "-Wno-shadow")
+    endif()
     target_compile_options(gemmi_py PRIVATE "-Wno-shadow")
   endif()
+  if (CMAKE_CXX_FLAGS MATCHES "-Wpedantic")
+    if (TARGET nanobind-static)
+      target_compile_options(nanobind-static PRIVATE "-Wno-pedantic")
+    endif()
+    target_compile_options(gemmi_py PRIVATE "-Wno-pedantic")
+  endif()
+  if (CMAKE_CXX_FLAGS MATCHES "-Wredundant-decls")
+    if (TARGET nanobind-static)
+      target_compile_options(nanobind-static PRIVATE "-Wno-redundant-decls")
+    endif()
+  endif()
 
   if (USE_NLOPT)
     message(STATUS "Using NLopt.")
@@ -503,22 +516,14 @@ if (USE_PYTHON)
   if (GENERATE_STUBS AND CMAKE_CROSSCOMPILING)
     message(WARNING "Stubs cannot be generated when cross-compiling - skipping.")
   elseif (GENERATE_STUBS)
-    set(sep ":")
-    if (WIN32)
-      set(sep ";")
-    endif()
-    add_custom_command(TARGET gemmi_py POST_BUILD
-    COMMAND ${CMAKE_COMMAND} -E env
-         "PYTHONPATH=$<TARGET_FILE_DIR:gemmi_py>${sep}$ENV{PYTHONPATH}"
-       ${Python_EXECUTABLE} -m pybind11_stubgen gemmi
-         --enum-class-locations=Ignore:gemmi.ContactSearch
-         --enum-class-locations=.+:gemmi
-         --numpy-array-remove-parameters
-         --output-dir stubs
-     COMMAND ${CMAKE_COMMAND} -E touch stubs/gemmi/py.typed
-     COMMENT "Generate type stubs with pybind11-stubgen"
-     BYPRODUCTS stubs/gemmi/__init__.pyi stubs/gemmi/cif.pyi stubs/gemmi/py.typed
-     VERBATIM)
+    #nanobind_add_stub(
+    #  gemmi_py_stub
+    #  MODULE gemmi_py
+    #  OUTPUT stubs/gemmi/__init__.pyi
+    #  PYTHON_PATH $<TARGET_FILE_DIR:gemmi_py>
+    #  DEPENDS gemmi_py
+    #  MARKER_FILE stubs/py.typed
+    #)
   endif()
 else()
   message(STATUS "Skipping Python module. Add -D USE_PYTHON=1 to build it.")
@@ -579,8 +584,8 @@ if (USE_PYTHON)
   install(DIRECTORY examples DESTINATION "${Python_SITEARCH}/gemmi" COMPONENT py
           FILES_MATCHING PATTERN "*.py"
           PATTERN "[._]*" EXCLUDE)
-  if (GENERATE_STUBS AND NOT CMAKE_CROSSCOMPILING)
-    install(DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/stubs/gemmi"
-            DESTINATION "${Python_SITEARCH}" COMPONENT py)
-  endif()
+  #if (GENERATE_STUBS AND NOT CMAKE_CROSSCOMPILING)
+  #  install(DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/stubs/gemmi"
+  #          DESTINATION "${Python_SITEARCH}" COMPONENT py)
+  #endif()
 endif()
diff --git a/docs/cif.rst b/docs/cif.rst
index 43183c576..bbc00412a 100644
--- a/docs/cif.rst
+++ b/docs/cif.rst
@@ -225,9 +225,6 @@ element found in mmCIF:
 
 More complex examples are shown in the :ref:`cif_examples` section.
 
-Internally, Python bindings use
-`pybind11 <https://github.com/pybind/pybind11>`_.
-
 
 DOM and SAX
 ===========
diff --git a/docs/conf.py b/docs/conf.py
index 773d56ef4..296fdd6e8 100644
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -54,7 +54,6 @@
 doctest_global_setup = '''
 import os
 import sys
-assert sys.version_info[0] > 2, "Tests in docs are for Python 3 only"
 disabled_features = []
 try:
     import numpy
diff --git a/docs/grid.rst b/docs/grid.rst
index 847647a90..1521247f1 100644
--- a/docs/grid.rst
+++ b/docs/grid.rst
@@ -504,7 +504,7 @@ The parameters of SolventMasker can be inspected and changed:
 .. doctest::
 
   >>> masker.atomic_radii_set
-  <AtomicRadiiSet.Cctbx: 1>
+  AtomicRadiiSet.Cctbx
   >>> masker.rprobe
   1.1
   >>> masker.rshrink
diff --git a/docs/hkl.rst b/docs/hkl.rst
index 1f5fad278..3e5db8aa7 100644
--- a/docs/hkl.rst
+++ b/docs/hkl.rst
@@ -114,7 +114,7 @@ Datasets are stored in the variable `datasets`::
 .. doctest::
 
   >>> mtz.datasets
-  MtzDatasets[<gemmi.Mtz.Dataset 0 HKL_base/HKL_base/HKL_base>, <gemmi.Mtz.Dataset 1 5e5z/5e5z/1>]
+  gemmi.MtzDatasets([<gemmi.Mtz.Dataset 0 HKL_base/HKL_base/HKL_base>, <gemmi.Mtz.Dataset 1 5e5z/5e5z/1>])
 
 In the MTZ file, each dataset is identified internally by an integer
 "dataset ID". To get dataset with the specified ID use function::
@@ -820,7 +820,7 @@ Blocks are moved from the Document to the new list:
   >>> doc
   <gemmi.cif.Document with 0 blocks ()>
   >>> rblocks
-  ReflnBlocks[<gemmi.ReflnBlock r5wkdsf with 17 x 406 loop>]
+  gemmi.ReflnBlocks([<gemmi.ReflnBlock r5wkdsf with 17 x 406 loop>])
 
 When ReflnBlock is created some of the mmCIF tags are interpreted
 to initialize the following properties:
@@ -1209,7 +1209,7 @@ The unit cell and the upper bin boundaries (in Å\ :sup:`--2`) are stored intern
   >>> binner.cell
   <gemmi.UnitCell(50.347, 4.777, 14.746, 90, 101.73, 90)>
   >>> binner.limits  # doctest: +ELLIPSIS
-  [0.12224713046942721, 0.19395414269012246, 0.254107666379415..., inf]
+  [0.122247130469427..., 0.193954142690122..., 0.254107666379415..., inf]
   >>> binner.size  # number of bins
   4
 
diff --git a/docs/install.rst b/docs/install.rst
index aa45896ef..b68230374 100644
--- a/docs/install.rst
+++ b/docs/install.rst
@@ -90,8 +90,10 @@ To install the gemmi module do::
 We have binary wheels for several Python versions (for all supported CPython
 versions and one PyPy version), so the command usually downloads binaries.
 If a matching wheel is not available,
-the module is compiled from source -- it takes several minutes
-and requires a C++ compiler.
+the module is compiled from source -- it takes a few minutes
+and requires a C++ compiler that supports C++17.
+
+Gemmi 0.7+ supports only Python 3.8+.
 
 Other binaries
 ~~~~~~~~~~~~~~
@@ -136,10 +138,11 @@ for details.
 If gemmi is already installed, uninstall the old version first
 (`pip uninstall`) or add option `--upgrade`.
 
-Alternatively, you can build a cloned project directly with CMake::
+Alternatively, you can manually install nanobind and cmake (using pip)
+and build a cloned project directly with CMake::
 
     cmake -D USE_PYTHON=1 .
-    make -j4 py
+    make -j4 gemmi_py
 
 Fortran and C bindings
 ----------------------
@@ -246,6 +249,8 @@ Code derived from the following projects is used in the library:
 Projects included under `third_party/` that are not used in the library
 itself, but are used in command-line utilities, python bindings or tests:
 
+* `zpp serializer <https://github.com/eyalz800/serializer>`_ --
+  serialization framework. License: MIT.
 * `The Lean Mean C++ Option Parser <http://optionparser.sourceforge.net/>`_ --
   command-line option parser. License: MIT.
 * `doctest <https://github.com/onqtam/doctest>`_ -- testing framework.
@@ -258,7 +263,7 @@ itself, but are used in command-line utilities, python bindings or tests:
 
 Not distributed with Gemmi:
 
-* `pybind11 <https://github.com/pybind/pybind11>`_ -- used for creating
+* `nanobind <https://github.com/wjakob/nanobind>`_ -- used for creating
   Python bindings. License: 3-clause BSD.
 * `zlib-ng <https://github.com/zlib-ng/zlib-ng>`_ -- optional, can be used
   instead of zlib for faster reading of gzipped files.
diff --git a/docs/mol.rst b/docs/mol.rst
index 6623375f2..cb7fba163 100644
--- a/docs/mol.rst
+++ b/docs/mol.rst
@@ -1637,9 +1637,9 @@ Properties of the Entity class are shown in this example:
   >>> ent.subchains
   ['Axp']
   >>> ent.entity_type
-  <EntityType.Polymer: 1>
+  EntityType.Polymer
   >>> ent.polymer_type
-  <PolymerType.PeptideL: 1>
+  PolymerType.PeptideL
   >>> ent.full_sequence[:5]
   ['MET', 'GLU', 'GLN', 'ARG', 'ILE']
 
@@ -1696,7 +1696,7 @@ Each connection stores:
   .. doctest::
 
     >>> st.connections[0].type
-    <ConnectionType.Disulf: 1>
+    ConnectionType.Disulf
 
 * name -- a unique name corresponding to _struct_conn.id in the mmCIF format;
   it is auto-generated the connections are read from the PDB format,
@@ -1727,9 +1727,9 @@ Each connection stores:
   .. doctest::
 
     >>> st.connections[2].asu
-    <Asu.Same: 0>
+    Asu.Same
     >>> st.connections[-1].asu
-    <Asu.Different: 1>
+    Asu.Different
 
 * and a distance read from the file.
 
@@ -2262,9 +2262,9 @@ ResidueKind can be obtained from PolymerType:
 .. doctest::
 
   >>> st.get_entity('2').polymer_type
-  <PolymerType.PeptideL: 1>
+  PolymerType.PeptideL
   >>> gemmi.sequence_kind(_)
-  <ResidueKind.AA: 1>
+  ResidueKind.AA
 
 In mmCIF `_entity_poly.pdbx_seq_one_letter_code` and in the OneDep interface,
 the PDB uses a hybrid sequence format: a single letter for standard
@@ -3043,7 +3043,7 @@ If it's a polymer, we can ask for polymer type and sequence:
 .. doctest::
 
   >>> polymer_b.check_polymer_type()
-  <PolymerType.PeptideL: 1>
+  PolymerType.PeptideL
   >>> polymer_b.make_one_letter_sequence()
   'sAXvsAXv'
 
@@ -3149,7 +3149,7 @@ Residue contains also a number of properties:
   >>> residue.label_seq
   2
   >>> residue.entity_type
-  <EntityType.Polymer: 1>
+  EntityType.Polymer
   >>> residue.het_flag
   'A'
   >>> residue.flag
diff --git a/include/gemmi/asudata.hpp b/include/gemmi/asudata.hpp
index abdd45f5c..ccb44ee09 100644
--- a/include/gemmi/asudata.hpp
+++ b/include/gemmi/asudata.hpp
@@ -96,7 +96,7 @@ int count_equal_values(const std::vector<T>& a, const std::vector<T>& b) {
 
 template<typename T>
 struct HklValue {
-  Miller hkl;
+  alignas(8) Miller hkl;
   T value;
 
   bool operator<(const Miller& m) const { return hkl < m; }
diff --git a/include/gemmi/binner.hpp b/include/gemmi/binner.hpp
index 333f5cc30..cc4fea431 100644
--- a/include/gemmi/binner.hpp
+++ b/include/gemmi/binner.hpp
@@ -148,15 +148,19 @@ struct Binner {
     return nums;
   }
 
-  std::vector<int> get_bins_from_1_d2(const std::vector<double>& inv_d2) const {
+  std::vector<int> get_bins_from_1_d2(const double* inv_d2, size_t size) const {
     ensure_limits_are_set();
     int hint = 0;
-    std::vector<int> nums(inv_d2.size());
-    for (size_t i = 0; i < inv_d2.size(); ++i)
+    std::vector<int> nums(size);
+    for (size_t i = 0; i < size; ++i)
       nums[i] = get_bin_from_1_d2_hinted(inv_d2[i], hint);
     return nums;
   }
 
+  std::vector<int> get_bins_from_1_d2(const std::vector<double>& inv_d2) const {
+    return get_bins_from_1_d2(inv_d2.data(), inv_d2.size());
+  }
+
   double dmin_of_bin(int n) const {
     return 1. / std::sqrt(limits.at(n));
   }
@@ -198,7 +202,8 @@ struct HklMatch {
   std::vector<int> pos;
   size_t hkl_size;
 
-  HklMatch(const Miller* hkl, size_t hkl_size_, const Miller* ref, size_t ref_size)
+  HklMatch(const Miller* hkl, size_t hkl_size_,
+           const Miller* ref, size_t ref_size)
       : pos(ref_size, -1), hkl_size(hkl_size_) {
     // Usually, both datasets are sorted. This make things faster.
     if (std::is_sorted(hkl, hkl + hkl_size) &&
@@ -229,14 +234,17 @@ struct HklMatch {
   HklMatch(const std::vector<Miller>& hkl, const std::vector<Miller>& ref)
     : HklMatch(hkl.data(), hkl.size(), ref.data(), ref.size()) {}
 
-  template <typename T> std::vector<T> aligned(const std::vector<T>& v, T nan) {
-    if (v.size() != hkl_size)
+  template <typename T> std::vector<T> aligned_(const T* v, size_t size, T nan) {
+    if (size != hkl_size)
       fail("HklMatch.aligned(): wrong data, size differs");
     std::vector<T> result(pos.size());
     for (size_t i = 0; i != pos.size(); ++i)
       result[i] = pos[i] >= 0 ? v[pos[i]] : nan;
     return result;
   }
+  template <typename T> std::vector<T> aligned(const std::vector<T>& v, T nan) {
+    return aligned_(v.data(), v.size(), nan);
+  }
 };
 
 } // namespace gemmi
diff --git a/include/gemmi/grid.hpp b/include/gemmi/grid.hpp
index 83eee4a24..1dc2e8113 100644
--- a/include/gemmi/grid.hpp
+++ b/include/gemmi/grid.hpp
@@ -211,6 +211,9 @@ struct GridMeta {
   size_t index_q(int u, int v, int w) const {
     return size_t(w * nv + v) * nu + u;
   }
+  size_t index_q(size_t u, size_t v, size_t w) const {
+    return (w * nv + v) * nu + u;
+  }
 
   /// Faster than index_s(), but works only if `-nu <= u < 2*nu`, etc.
   size_t index_n(int u, int v, int w) const { return index_n_ref(u, v, w); }
diff --git a/pyproject.toml b/pyproject.toml
index c31db5772..a0db8e8f2 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,6 +1,5 @@
 [build-system]
-requires = ["scikit-build-core~=0.10.5", "pybind11>=2.6.2",
-            "pybind11-stubgen~=2.5.1", "numpy"]
+requires = ["scikit-build-core~=0.10.5", "nanobind>=2.1"]
 build-backend = "scikit_build_core.build"
 
 # https://packaging.python.org/en/latest/specifications/declaring-project-metadata/
@@ -88,6 +87,10 @@ test-command = "python -m unittest discover -v -s {project}/tests/"
 [tool.cibuildwheel.environment]
 SKBUILD_CMAKE_ARGS = '-DBUILD_GEMMI_PROGRAM=OFF;-DINSTALL_DEV_FILES=OFF;-DBUILD_SHARED_LIBS=OFF;-DFETCH_ZLIB_NG=ON'
 
+# Needed for full C++17 support on macOS
+[tool.cibuildwheel.macos.environment]
+MACOSX_DEPLOYMENT_TARGET = "10.14"
+
 # https://cibuildwheel.readthedocs.io/en/stable/faq/#macos-building-cpython-38-wheels-on-arm64
 [[tool.cibuildwheel.overrides]]
 select = "cp38-macosx_arm64"
diff --git a/python/align.cpp b/python/align.cpp
index cf5ce7aad..d666fb64e 100644
--- a/python/align.cpp
+++ b/python/align.cpp
@@ -4,86 +4,85 @@
 #include "gemmi/seqalign.hpp"  // for align_string_sequences
 
 #include "common.h"
-#include <pybind11/stl.h>
+#include <nanobind/stl/string.h>
+#include <nanobind/stl/vector.h>
 
-namespace py = pybind11;
 using namespace gemmi;
 
-
-void add_alignment(py::module& m) {
+void add_alignment(nb::module_& m) {
 
   // sequence alignment
-  py::class_<AlignmentResult>(m, "AlignmentResult")
-    .def_readonly("score", &AlignmentResult::score)
-    .def_readonly("match_count", &AlignmentResult::match_count)
-    .def_readonly("match_string", &AlignmentResult::match_string)
+  nb::class_<AlignmentResult>(m, "AlignmentResult")
+    .def_ro("score", &AlignmentResult::score)
+    .def_ro("match_count", &AlignmentResult::match_count)
+    .def_ro("match_string", &AlignmentResult::match_string)
     .def("cigar_str", &AlignmentResult::cigar_str)
     .def("calculate_identity", &AlignmentResult::calculate_identity,
-         py::arg("which")=0)
-    .def("add_gaps", &AlignmentResult::add_gaps, py::arg("s"), py::arg("which"))
+         nb::arg("which")=0)
+    .def("add_gaps", &AlignmentResult::add_gaps, nb::arg("s"), nb::arg("which"))
     .def("formatted", &AlignmentResult::formatted)
     ;
 
-  py::class_<AlignmentScoring>(m, "AlignmentScoring")
-    .def(py::init([](char what) {
+  nb::class_<AlignmentScoring>(m, "AlignmentScoring")
+    .def("__init__", [](AlignmentScoring* t, char what) {
           const AlignmentScoring* s = AlignmentScoring::simple();
           if (what == 'p')
             s = AlignmentScoring::partial_model();
           else if (what == 'b')
             s = AlignmentScoring::blosum62();
-          return new AlignmentScoring(*s);
-    }), py::arg("what")='s')
-    .def_readwrite("match", &AlignmentScoring::match)
-    .def_readwrite("mismatch", &AlignmentScoring::mismatch)
-    .def_readwrite("gapo", &AlignmentScoring::gapo)
-    .def_readwrite("gape", &AlignmentScoring::gape)
-    .def_readwrite("good_gapo", &AlignmentScoring::good_gapo)
-    .def_readwrite("bad_gapo", &AlignmentScoring::bad_gapo)
+          new(t) AlignmentScoring(*s);
+    }, nb::arg("what")='s')
+    .def_rw("match", &AlignmentScoring::match)
+    .def_rw("mismatch", &AlignmentScoring::mismatch)
+    .def_rw("gapo", &AlignmentScoring::gapo)
+    .def_rw("gape", &AlignmentScoring::gape)
+    .def_rw("good_gapo", &AlignmentScoring::good_gapo)
+    .def_rw("bad_gapo", &AlignmentScoring::bad_gapo)
     ;
 
   m.def("align_string_sequences", &align_string_sequences,
-        py::arg("query"), py::arg("target"), py::arg("target_gapo"),
-        py::arg("scoring")=nullptr);
+        nb::arg("query"), nb::arg("target"), nb::arg("target_gapo"),
+        nb::arg("scoring")=nb::none());
   m.def("align_sequence_to_polymer",
         [](const std::vector<std::string>& full_seq, const ResidueSpan& polymer,
            PolymerType polymer_type, AlignmentScoring* scoring) {
       return align_sequence_to_polymer(full_seq, polymer, polymer_type, scoring);
-  }, py::arg("full_seq"), py::arg("polymer"),
-     py::arg("polymer_type"), py::arg("scoring")=nullptr);
+  }, nb::arg("full_seq"), nb::arg("polymer"),
+     nb::arg("polymer_type"), nb::arg("scoring")=nb::none());
 
   // structure superposition
-  py::enum_<SupSelect>(m, "SupSelect")
+  nb::enum_<SupSelect>(m, "SupSelect")
     .value("CaP", SupSelect::CaP)
     .value("MainChain", SupSelect::MainChain)
     .value("All", SupSelect::All);
 
-  py::class_<SupResult>(m, "SupResult")
-    .def_readonly("rmsd", &SupResult::rmsd)
-    .def_readonly("count", &SupResult::count)
-    .def_readonly("center1", &SupResult::center1)
-    .def_readonly("center2", &SupResult::center2)
-    .def_readonly("transform", &SupResult::transform)
+  nb::class_<SupResult>(m, "SupResult")
+    .def_ro("rmsd", &SupResult::rmsd)
+    .def_ro("count", &SupResult::count)
+    .def_ro("center1", &SupResult::center1)
+    .def_ro("center2", &SupResult::center2)
+    .def_ro("transform", &SupResult::transform)
     ;
 
   m.def("calculate_current_rmsd",
         [](const ResidueSpan& fixed, const ResidueSpan& movable, PolymerType ptype,
            SupSelect sel, char altloc) {
           return calculate_current_rmsd(fixed, movable, ptype, sel, altloc);
-        }, py::arg("fixed"), py::arg("movable"), py::arg("ptype"), py::arg("sel"),
-           py::arg("altloc")='\0');
+        }, nb::arg("fixed"), nb::arg("movable"), nb::arg("ptype"), nb::arg("sel"),
+           nb::arg("altloc")='\0');
   m.def("calculate_superposition",
         [](const ResidueSpan& fixed, const ResidueSpan& movable, PolymerType ptype,
            SupSelect sel, int trim_cycles, double trim_cutoff, char altloc) {
           return calculate_superposition(fixed, movable, ptype, sel,
                                          trim_cycles, trim_cutoff, altloc);
-        }, py::arg("fixed"), py::arg("movable"), py::arg("ptype"), py::arg("sel"),
-           py::arg("trim_cycles")=0, py::arg("trim_cutoff")=2.0,
-           py::arg("altloc")='\0');
+        }, nb::arg("fixed"), nb::arg("movable"), nb::arg("ptype"), nb::arg("sel"),
+           nb::arg("trim_cycles")=0, nb::arg("trim_cutoff")=2.0,
+           nb::arg("altloc")='\0');
   m.def("calculate_superpositions_in_moving_window",
         [](const ResidueSpan& fixed, const ResidueSpan& movable, PolymerType ptype,
            double radius) {
           return calculate_superpositions_in_moving_window(fixed, movable, ptype, radius);
-        }, py::arg("fixed"), py::arg("movable"), py::arg("ptype"), py::arg("radius")=10.0);
+        }, nb::arg("fixed"), nb::arg("movable"), nb::arg("ptype"), nb::arg("radius")=10.0);
 
   m.def("superpose_positions",
         [](std::vector<Position> pos1, std::vector<Position> pos2,
@@ -94,13 +93,13 @@ void add_alignment(py::module& m) {
             fail("superpose_positions: weights must be empty or of the same length as pos1/pos2");
           return superpose_positions(pos1.data(), pos2.data(), pos1.size(),
                                      weight.empty() ? nullptr : weight.data());
-        }, py::arg("pos1"), py::arg("pos2"), py::arg("weight")=std::vector<int>{});
+        }, nb::arg("pos1"), nb::arg("pos2"), nb::arg("weight")=std::vector<int>{});
 }
 
-void add_assign_label_seq_id(py::class_<Structure>& structure) {
+void add_assign_label_seq_id(nb::class_<Structure>& structure) {
   structure
-    .def("assign_label_seq_id", &assign_label_seq_id, py::arg("force")=false)
+    .def("assign_label_seq_id", &assign_label_seq_id, nb::arg("force")=false)
     .def("clear_sequences", &clear_sequences)
-    .def("assign_best_sequences", &assign_best_sequences, py::arg("fasta_sequences"))
+    .def("assign_best_sequences", &assign_best_sequences, nb::arg("fasta_sequences"))
     ;
 }
diff --git a/python/array.h b/python/array.h
new file mode 100644
index 000000000..d5b1c8564
--- /dev/null
+++ b/python/array.h
@@ -0,0 +1,62 @@
+#pragma once
+#include <array>
+#include "common.h"
+#include <nanobind/ndarray.h>
+
+template<typename T>
+using cpu_array = nb::ndarray<T, nb::shape<-1>, nb::device::cpu>;
+template<typename T>
+using cpu_c_array = nb::ndarray<T, nb::shape<-1>, nb::device::cpu, nb::c_contig>;
+using cpu_miller_array = nb::ndarray<int, nb::shape<-1,3>, nb::device::cpu>;
+
+template<typename T>
+auto numpy_array_from_vector(std::vector<T>&& original_vec) {
+  using V = std::vector<T>;
+  auto v = new V(std::move(original_vec));
+  nb::capsule owner(v, [](void* p) noexcept { delete static_cast<V*>(p); });
+  return nb::ndarray<nb::numpy, T, nb::shape<-1>>(v->data(), {v->size()}, owner);
+}
+
+template<typename T, size_t N>
+auto py_array2d_from_vector(std::vector<std::array<T,N>>&& original_vec) {
+  using V = std::vector<std::array<T,N>>;
+  auto v = new V(std::move(original_vec));
+  nb::capsule owner(v, [](void* p) noexcept { delete static_cast<V*>(p); });
+  return nb::ndarray<nb::numpy, T, nb::shape<-1, N>>(v->data(), {v->size(), N}, owner);
+}
+
+// to be used with rv_policy::reference_internal
+template<typename T, typename S>
+auto vector_member_array(std::vector<S>& vec, T S::*ptr) {
+  constexpr int64_t stride = static_cast<int64_t>(sizeof(S) / sizeof(T));
+  static_assert(stride * sizeof(T) == sizeof(S),
+                "vector_member_array(): problem with stride");
+  return nb::ndarray<nb::numpy, T, nb::shape<-1>>(
+          &(vec.data()->*ptr),
+          {vec.size()},
+          nb::handle(),
+          {stride});
+}
+
+template<typename T>
+auto make_numpy_array(std::initializer_list<size_t> size,
+                      std::initializer_list<int64_t> strides={}) {
+  size_t total_size = 1;
+  for (size_t i : size)
+    total_size *= i;
+  T* c_array = new T[total_size];
+  nb::capsule owner(c_array, [](void* p) noexcept { delete [] static_cast<T*>(p); });
+  return nb::ndarray<nb::numpy, T>(c_array, size, owner, strides);
+}
+
+template<typename Ret, typename Obj, typename Func>
+auto miller_function(const Obj& obj, Func func, cpu_miller_array hkl) {
+  auto h = hkl.view();
+  size_t n = h.shape(0);
+  auto result = make_numpy_array<Ret>({n});
+  Ret* rptr = result.data();
+  for (size_t i = 0; i < h.shape(0); ++i)
+    rptr[i] = (obj.*func)({h(i, 0), h(i, 1), h(i, 2)});
+  return result;
+}
+
diff --git a/python/arrvec.h b/python/arrvec.h
deleted file mode 100644
index 42bdb18b1..000000000
--- a/python/arrvec.h
+++ /dev/null
@@ -1,9 +0,0 @@
-#pragma once
-#include <pybind11/numpy.h>
-
-template<typename T>
-pybind11::array_t<T> py_array_from_vector(std::vector<T>&& original_vec) {
-  auto v = new std::vector<T>(std::move(original_vec));
-  pybind11::capsule cap(v, [](void* p) { delete (std::vector<T>*) p; });
-  return pybind11::array_t<T>(v->size(), v->data(), cap);
-}
diff --git a/python/ccp4.cpp b/python/ccp4.cpp
index 9aa352580..3c1ab4c03 100644
--- a/python/ccp4.cpp
+++ b/python/ccp4.cpp
@@ -4,23 +4,23 @@
 #include "gemmi/util.hpp"  // for cat
 #include "gemmi/read_map.hpp"  // for read_ccp4_map, read_ccp4_mask
 #include "common.h"
-#include <pybind11/stl.h>
+#include <nanobind/stl/string.h>
+#include <nanobind/stl/array.h>  // for Ccp4Base::axis_positions
 
-namespace py = pybind11;
 using namespace gemmi;
 
 template<typename T>
-py::class_<Ccp4<T>, Ccp4Base> add_ccp4_common(py::module& m, const char* name) {
+auto add_ccp4_common(nb::module_& m, const char* name) {
   using Map = Ccp4<T>;
-  return py::class_<Map, Ccp4Base>(m, name)
-    .def(py::init<>())
-    .def_readwrite("grid", &Map::grid)
+  return nb::class_<Map, Ccp4Base>(m, name)
+    .def(nb::init<>())
+    .def_rw("grid", &Map::grid)
     .def("setup", &Map::setup,
-         py::arg("default_value"), py::arg("mode")=MapSetup::Full)
+         nb::arg("default_value"), nb::arg("mode")=MapSetup::Full)
     .def("update_ccp4_header", &Map::update_ccp4_header,
-         py::arg("mode")=-1, py::arg("update_stats")=true)
+         nb::arg("mode")=-1, nb::arg("update_stats")=true)
     .def("full_cell", &Map::full_cell)
-    .def("write_ccp4_map", &Map::write_ccp4_map, py::arg("filename"))
+    .def("write_ccp4_map", &Map::write_ccp4_map, nb::arg("filename"))
     .def("set_extent", &Map::set_extent)
     .def("__repr__", [=](const Map& self) {
         const SpaceGroup* sg = self.grid.spacegroup;
@@ -30,16 +30,16 @@ py::class_<Ccp4<T>, Ccp4Base> add_ccp4_common(py::module& m, const char* name) {
     });
 }
 
-void add_ccp4(py::module& m) {
-  py::enum_<MapSetup>(m, "MapSetup")
+void add_ccp4(nb::module_& m) {
+  nb::enum_<MapSetup>(m, "MapSetup")
     .value("Full", MapSetup::Full)
     .value("NoSymmetry", MapSetup::NoSymmetry)
     .value("ReorderOnly", MapSetup::ReorderOnly);
 
-  py::class_<Ccp4Base>(m, "Ccp4Base")
+  nb::class_<Ccp4Base>(m, "Ccp4Base")
     .def("header_i32", &Ccp4Base::header_i32)
     .def("header_float", &Ccp4Base::header_float)
-    .def("header_str", &Ccp4Base::header_str, py::arg("w"), py::arg("len")=80)
+    .def("header_str", &Ccp4Base::header_str, nb::arg("w"), nb::arg("len")=80)
     .def("set_header_i32", &Ccp4Base::set_header_i32)
     .def("set_header_float", &Ccp4Base::set_header_float)
     .def("set_header_str", &Ccp4Base::set_header_str)
@@ -52,9 +52,9 @@ void add_ccp4(py::module& m) {
   add_ccp4_common<float>(m, "Ccp4Map");
   add_ccp4_common<int8_t>(m, "Ccp4Mask");
   m.def("read_ccp4_map", &read_ccp4_map,
-        py::arg("path"), py::arg("setup")=false, py::return_value_policy::move,
+        nb::arg("path"), nb::arg("setup")=false, nb::rv_policy::move,
         "Reads a CCP4 file, mode 2 (floating-point data).");
   m.def("read_ccp4_mask", &read_ccp4_mask,
-        py::arg("path"), py::arg("setup")=false, py::return_value_policy::move,
+        nb::arg("path"), nb::arg("setup")=false, nb::rv_policy::move,
         "Reads a CCP4 file, mode 0 (int8_t data, usually 0/1 masks).");
 }
diff --git a/python/chemcomp.cpp b/python/chemcomp.cpp
index 0f88f04cf..05d0e1d8d 100644
--- a/python/chemcomp.cpp
+++ b/python/chemcomp.cpp
@@ -4,38 +4,38 @@
 #include "gemmi/to_chemcomp.hpp" // for add_chemcomp_to_block
 
 #include "common.h"
-#include <pybind11/stl.h>
-#include <pybind11/stl_bind.h>
+#include <nanobind/stl/bind_vector.h>
+#include <nanobind/stl/string.h>
+#include <nanobind/stl/vector.h>  // for find_shortest_path
 
-namespace py = pybind11;
 using namespace gemmi;
 
-PYBIND11_MAKE_OPAQUE(std::vector<Restraints::Bond>)
-PYBIND11_MAKE_OPAQUE(std::vector<Restraints::Angle>)
-PYBIND11_MAKE_OPAQUE(std::vector<Restraints::Torsion>)
-PYBIND11_MAKE_OPAQUE(std::vector<Restraints::Chirality>)
-PYBIND11_MAKE_OPAQUE(std::vector<Restraints::Plane>)
-PYBIND11_MAKE_OPAQUE(std::vector<ChemComp::Atom>)
+NB_MAKE_OPAQUE(std::vector<Restraints::Bond>)
+NB_MAKE_OPAQUE(std::vector<Restraints::Angle>)
+NB_MAKE_OPAQUE(std::vector<Restraints::Torsion>)
+NB_MAKE_OPAQUE(std::vector<Restraints::Chirality>)
+NB_MAKE_OPAQUE(std::vector<Restraints::Plane>)
+NB_MAKE_OPAQUE(std::vector<ChemComp::Atom>)
 
-void add_chemcomp(py::module& m) {
-  py::class_<ChemComp> chemcomp(m, "ChemComp");
-  py::class_<ChemComp::Atom> chemcompatom(chemcomp, "Atom");
+void add_chemcomp(nb::module_& m) {
+  nb::class_<ChemComp> chemcomp(m, "ChemComp");
+  nb::class_<ChemComp::Atom> chemcompatom(chemcomp, "Atom");
 
-  py::class_<Restraints> restraints(m, "Restraints");
-  py::class_<Restraints::Bond> restraintsbond(restraints, "Bond");
-  py::class_<Restraints::Angle> restraintsangle(restraints, "Angle");
-  py::class_<Restraints::Torsion> restraintstorsion(restraints, "Torsion");
-  py::class_<Restraints::Chirality> restraintschirality(restraints, "Chirality");
-  py::class_<Restraints::Plane> restraintsplane(restraints, "Plane");
+  nb::class_<Restraints> restraints(m, "Restraints");
+  nb::class_<Restraints::Bond> restraintsbond(restraints, "Bond");
+  nb::class_<Restraints::Angle> restraintsangle(restraints, "Angle");
+  nb::class_<Restraints::Torsion> restraintstorsion(restraints, "Torsion");
+  nb::class_<Restraints::Chirality> restraintschirality(restraints, "Chirality");
+  nb::class_<Restraints::Plane> restraintsplane(restraints, "Plane");
 
-  py::bind_vector<std::vector<Restraints::Bond>>(m, "RestraintsBonds");
-  py::bind_vector<std::vector<Restraints::Angle>>(m, "RestraintsAngles");
-  py::bind_vector<std::vector<Restraints::Torsion>>(m, "RestraintsTorsions");
-  py::bind_vector<std::vector<Restraints::Chirality>>(m, "RestraintsChirs");
-  py::bind_vector<std::vector<Restraints::Plane>>(m, "RestraintsPlanes");
-  py::bind_vector<std::vector<ChemComp::Atom>>(m, "ChemCompAtoms");
+  nb::bind_vector<std::vector<Restraints::Bond>, rv_ri>(m, "RestraintsBonds");
+  nb::bind_vector<std::vector<Restraints::Angle>, rv_ri>(m, "RestraintsAngles");
+  nb::bind_vector<std::vector<Restraints::Torsion>, rv_ri>(m, "RestraintsTorsions");
+  nb::bind_vector<std::vector<Restraints::Chirality>, rv_ri>(m, "RestraintsChirs");
+  nb::bind_vector<std::vector<Restraints::Plane>, rv_ri>(m, "RestraintsPlanes");
+  nb::bind_vector<std::vector<ChemComp::Atom>, rv_ri>(m, "ChemCompAtoms");
 
-  py::enum_<BondType>(m, "BondType")
+  nb::enum_<BondType>(m, "BondType")
     .value("Unspec", BondType::Unspec)
     .value("Single", BondType::Single)
     .value("Double", BondType::Double)
@@ -44,99 +44,99 @@ void add_chemcomp(py::module& m) {
     .value("Deloc", BondType::Deloc)
     .value("Metal", BondType::Metal);
 
-  py::enum_<ChiralityType>(m, "ChiralityType")
+  nb::enum_<ChiralityType>(m, "ChiralityType")
     .value("Positive", ChiralityType::Positive)
     .value("Negative", ChiralityType::Negative)
     .value("Both", ChiralityType::Both);
 
-  py::enum_<Restraints::DistanceOf>(restraints, "DistanceOf")
+  nb::enum_<Restraints::DistanceOf>(restraints, "DistanceOf")
     .value("ElectronCloud", Restraints::DistanceOf::ElectronCloud)
     .value("Nucleus", Restraints::DistanceOf::Nucleus);
 
 
-  py::class_<Restraints::AtomId>(restraints, "AtomId")
-    .def(py::init([](int comp, const std::string& atom) {
-          return new Restraints::AtomId{comp, atom};
-    }))
-    .def(py::init([](const std::string& atom) {
-          return new Restraints::AtomId{1, atom};
-    }))
-    .def_readwrite("comp", &Restraints::AtomId::comp)
-    .def_readwrite("atom", &Restraints::AtomId::atom)
+  nb::class_<Restraints::AtomId>(restraints, "AtomId")
+    .def("__init__", [](Restraints::AtomId* p, int comp, const std::string& atom) {
+        new(p) Restraints::AtomId{comp, atom};
+    })
+    .def("__init__", [](Restraints::AtomId* p, const std::string& atom) {
+        new(p) Restraints::AtomId{1, atom};
+    })
+    .def_rw("comp", &Restraints::AtomId::comp)
+    .def_rw("atom", &Restraints::AtomId::atom)
     .def("get_from",
          (Atom* (Restraints::AtomId::*)(Residue&, Residue*, char, char) const)
          &Restraints::AtomId::get_from,
-         py::arg("res1"), py::arg("res2"), py::arg("altloc1"), py::arg("altloc2"),
-         py::return_value_policy::reference)
+         nb::arg("res1"), nb::arg("res2"), nb::arg("altloc1"), nb::arg("altloc2"),
+         nb::rv_policy::reference)
     .def("__repr__", [](const Restraints::AtomId& self) {
         return cat("<gemmi.Restraints.AtomId ", self.comp, ' ', self.atom, '>');
     });
   restraintsbond
-    .def(py::init<>())
-    .def_readwrite("id1", &Restraints::Bond::id1)
-    .def_readwrite("id2", &Restraints::Bond::id2)
-    .def_readwrite("type", &Restraints::Bond::type)
-    .def_readwrite("aromatic", &Restraints::Bond::aromatic)
-    .def_readwrite("value", &Restraints::Bond::value)
-    .def_readwrite("esd", &Restraints::Bond::esd)
-    .def_readwrite("value_nucleus", &Restraints::Bond::value_nucleus)
-    .def_readwrite("esd_nucleus", &Restraints::Bond::esd_nucleus)
+    .def(nb::init<>())
+    .def_rw("id1", &Restraints::Bond::id1)
+    .def_rw("id2", &Restraints::Bond::id2)
+    .def_rw("type", &Restraints::Bond::type)
+    .def_rw("aromatic", &Restraints::Bond::aromatic)
+    .def_rw("value", &Restraints::Bond::value)
+    .def_rw("esd", &Restraints::Bond::esd)
+    .def_rw("value_nucleus", &Restraints::Bond::value_nucleus)
+    .def_rw("esd_nucleus", &Restraints::Bond::esd_nucleus)
     .def("lexicographic_str", &Restraints::Bond::lexicographic_str)
     .def("__repr__", [](const Restraints::Bond& self) {
         return "<gemmi.Restraints.Bond " + self.str() + ">";
     });
   restraintsangle
-    .def(py::init<>())
-    .def_readwrite("id1", &Restraints::Angle::id1)
-    .def_readwrite("id2", &Restraints::Angle::id2)
-    .def_readwrite("id3", &Restraints::Angle::id3)
-    .def_readwrite("value", &Restraints::Angle::value)
-    .def_readwrite("esd", &Restraints::Angle::esd)
+    .def(nb::init<>())
+    .def_rw("id1", &Restraints::Angle::id1)
+    .def_rw("id2", &Restraints::Angle::id2)
+    .def_rw("id3", &Restraints::Angle::id3)
+    .def_rw("value", &Restraints::Angle::value)
+    .def_rw("esd", &Restraints::Angle::esd)
     .def("__repr__", [](const Restraints::Angle& self) {
         return "<gemmi.Restraints.Angle " + self.str() + ">";
     });
   restraintstorsion
-    .def(py::init<>())
-    .def_readwrite("label", &Restraints::Torsion::label)
-    .def_readwrite("id1", &Restraints::Torsion::id1)
-    .def_readwrite("id2", &Restraints::Torsion::id2)
-    .def_readwrite("id3", &Restraints::Torsion::id3)
-    .def_readwrite("id4", &Restraints::Torsion::id4)
-    .def_readwrite("value", &Restraints::Torsion::value)
-    .def_readwrite("esd", &Restraints::Torsion::esd)
-    .def_readwrite("period", &Restraints::Torsion::period)
+    .def(nb::init<>())
+    .def_rw("label", &Restraints::Torsion::label)
+    .def_rw("id1", &Restraints::Torsion::id1)
+    .def_rw("id2", &Restraints::Torsion::id2)
+    .def_rw("id3", &Restraints::Torsion::id3)
+    .def_rw("id4", &Restraints::Torsion::id4)
+    .def_rw("value", &Restraints::Torsion::value)
+    .def_rw("esd", &Restraints::Torsion::esd)
+    .def_rw("period", &Restraints::Torsion::period)
     .def("__repr__", [](const Restraints::Torsion& self) {
         return "<gemmi.Restraints.Torsion " + self.str() + ">";
     });
   restraintschirality
-    .def(py::init<>())
-    .def_readwrite("id_ctr", &Restraints::Chirality::id_ctr)
-    .def_readwrite("id1", &Restraints::Chirality::id1)
-    .def_readwrite("id2", &Restraints::Chirality::id2)
-    .def_readwrite("id3", &Restraints::Chirality::id3)
-    .def_readwrite("sign", &Restraints::Chirality::sign)
+    .def(nb::init<>())
+    .def_rw("id_ctr", &Restraints::Chirality::id_ctr)
+    .def_rw("id1", &Restraints::Chirality::id1)
+    .def_rw("id2", &Restraints::Chirality::id2)
+    .def_rw("id3", &Restraints::Chirality::id3)
+    .def_rw("sign", &Restraints::Chirality::sign)
     .def("is_wrong", &Restraints::Chirality::is_wrong)
     .def("__repr__", [](const Restraints::Chirality& self) {
         return "<gemmi.Restraints.Chirality " + self.str() + ">";
     });
   restraintsplane
-    .def(py::init<>())
-    .def_readwrite("label", &Restraints::Plane::label)
-    .def_readwrite("ids", &Restraints::Plane::ids)
-    .def_readwrite("esd", &Restraints::Plane::esd)
+    .def(nb::init<>())
+    .def_rw("label", &Restraints::Plane::label)
+    .def_rw("ids", &Restraints::Plane::ids)
+    .def_rw("esd", &Restraints::Plane::esd)
     .def("__repr__", [](const Restraints::Plane& self) {
         return "<gemmi.Restraints.Plane " + self.str() + ">";
     });
   restraints
-    .def(py::init<>())
-    .def_readwrite("bonds", &Restraints::bonds)
-    .def_readwrite("angles", &Restraints::angles)
-    .def_readwrite("torsions", &Restraints::torsions)
-    .def_readwrite("chirs", &Restraints::chirs)
-    .def_readwrite("planes", &Restraints::planes)
+    .def(nb::init<>())
+    .def_rw("bonds", &Restraints::bonds)
+    .def_rw("angles", &Restraints::angles)
+    .def_rw("torsions", &Restraints::torsions)
+    .def_rw("chirs", &Restraints::chirs)
+    .def_rw("planes", &Restraints::planes)
     .def("empty", &Restraints::empty)
     .def("get_bond", &Restraints::get_bond,
-         py::return_value_policy::reference_internal)
+         nb::rv_policy::reference_internal)
     .def("get_bond", [](Restraints& self,
                         const std::string& a1, const std::string& a2)
                                                       -> Restraints::Bond& {
@@ -144,12 +144,12 @@ void add_chemcomp(py::module& m) {
             if (it == self.bonds.end())
               fail("Bond restraint not found: " + a1 + "-" + a2);
             return *it;
-         }, py::return_value_policy::reference_internal)
+         }, nb::rv_policy::reference_internal)
     .def("find_shortest_path", &Restraints::find_shortest_path)
     .def("chiral_abs_volume", &Restraints::chiral_abs_volume)
     ;
 
-  py::enum_<ChemComp::Group>(chemcomp, "Group")
+  nb::enum_<ChemComp::Group>(chemcomp, "Group")
       .value("Peptide",    ChemComp::Group::Peptide)
       .value("PPeptide",   ChemComp::Group::PPeptide)
       .value("MPeptide",   ChemComp::Group::MPeptide)
@@ -162,21 +162,21 @@ void add_chemcomp(py::module& m) {
       .value("NonPolymer", ChemComp::Group::NonPolymer)
       .value("Null",       ChemComp::Group::Null);
   chemcompatom
-    .def_readwrite("id", &ChemComp::Atom::id)
-    .def_readwrite("el", &ChemComp::Atom::el)
-    .def_readwrite("charge", &ChemComp::Atom::charge)
-    .def_readwrite("chem_type", &ChemComp::Atom::chem_type)
+    .def_rw("id", &ChemComp::Atom::id)
+    .def_rw("el", &ChemComp::Atom::el)
+    .def_rw("charge", &ChemComp::Atom::charge)
+    .def_rw("chem_type", &ChemComp::Atom::chem_type)
     .def("is_hydrogen", &ChemComp::Atom::is_hydrogen)
     ;
-  py::class_<ChemComp::Aliasing>(chemcomp, "Aliasing")
-    .def_readonly("group", &ChemComp::Aliasing::group)
+  nb::class_<ChemComp::Aliasing>(chemcomp, "Aliasing")
+    .def_ro("group", &ChemComp::Aliasing::group)
     .def("name_from_alias", &ChemComp::Aliasing::name_from_alias)
     ;
   chemcomp
-    .def_readwrite("name", &ChemComp::name)
-    .def_readwrite("group", &ChemComp::group)
-    .def_readonly("atoms", &ChemComp::atoms)
-    .def_readonly("rt", &ChemComp::rt)
+    .def_rw("name", &ChemComp::name)
+    .def_rw("group", &ChemComp::group)
+    .def_ro("atoms", &ChemComp::atoms)
+    .def_ro("rt", &ChemComp::rt)
     .def_static("read_group", &ChemComp::read_group)
     .def_static("group_str", &ChemComp::group_str)
     .def("set_group", &ChemComp::set_group)
@@ -184,7 +184,7 @@ void add_chemcomp(py::module& m) {
     .def("find_atom", [](ChemComp& self, const std::string& atom_id) {
         auto it = self.find_atom(atom_id);
         return it != self.atoms.end() ? &*it : nullptr;
-    }, py::return_value_policy::reference_internal)
+    }, nb::rv_policy::reference_internal)
     .def("remove_hydrogens", &ChemComp::remove_hydrogens)
     ;
   m.def("make_chemcomp_from_block", &make_chemcomp_from_block);
diff --git a/python/cif.cpp b/python/cif.cpp
index 667b4cba9..f9aa89f21 100644
--- a/python/cif.cpp
+++ b/python/cif.cpp
@@ -9,27 +9,37 @@
 #include "gemmi/read_cif.hpp"  // for read_cif_gz
 
 #include "common.h"
-#include <pybind11/stl.h>
+#include "make_iterator.h"
+#include <nanobind/stl/string.h>
+#include <nanobind/stl/vector.h>
+#include <nanobind/stl/pair.h>
 
-namespace py = pybind11;
 using namespace gemmi::cif;
 
-std::string pyobject_to_string(py::handle handle, bool raw) {
+std::string pyobject_to_string(nb::handle handle, bool raw) {
   PyObject* ptr = handle.ptr();
   if (ptr == Py_None) {
     return "?";
   } else if (ptr == Py_False) {
     return ".";
   } else if (ptr == Py_True) {
-    throw py::value_error("unexpected value True");
+    throw nb::value_error("unexpected value True");
   } else if (raw || PyFloat_Check(ptr) || PyLong_Check(ptr)) {
-    return py::str(handle);
+    return nb::str(handle).c_str();
   } else {
-    return gemmi::cif::quote(py::str(handle));
+    return gemmi::cif::quote(nb::str(handle).c_str());
   }
 }
 
-std::vector<std::string> quote_list(py::list items) {
+nb::object string_to_pyobject(const std::string& s, bool raw) {
+  if (raw)
+    return nb::cast(s);
+  if (is_null(s))
+    return nb::borrow(s[0] == '?' ? Py_None : Py_False);
+  return nb::cast(as_string(s));
+}
+
+std::vector<std::string> quote_list(nb::list items) {
   size_t size = items.size();
   std::vector<std::string> ret;
   ret.reserve(size);
@@ -43,28 +53,28 @@ T& add_to_vector(std::vector<T>& vec, const T& new_item, int pos) {
   if (pos < 0)
     pos = (int) vec.size();
   else if (pos > (int) vec.size())
-    throw py::index_error();
+    throw nb::index_error();
   vec.insert(vec.begin() + pos, new_item);
   return vec[pos];
 }
 
 // for delitem_slice
 namespace gemmi { namespace cif {
-void delitem_at_index(Table& t, py::ssize_t idx) { t.remove_row((int)idx); }
-void delitem_range(Table& t, py::ssize_t start, py::ssize_t end) {
+void delitem_at_index(Table& t, size_t idx) { t.remove_row((int)idx); }
+void delitem_range(Table& t, size_t start, size_t end) {
   t.remove_rows((int)start, (int)end);
 }
 } } // namespace gemmi::cif
 
-void add_cif(py::module& cif) {
-  py::class_<Block> cif_block(cif, "Block");
-  py::class_<Item> cif_item(cif, "Item");
-  py::class_<Loop> cif_loop(cif, "Loop");
-  py::class_<Column> cif_column(cif, "Column");
-  py::class_<Table> cif_table(cif, "Table");
-  py::class_<Table::Row> cif_table_row(cif_table, "Row");
+void add_cif(nb::module_& cif) {
+  nb::class_<Block> cif_block(cif, "Block");
+  nb::class_<Item> cif_item(cif, "Item");
+  nb::class_<Loop> cif_loop(cif, "Loop");
+  nb::class_<Column> cif_column(cif, "Column");
+  nb::class_<Table> cif_table(cif, "Table");
+  nb::class_<Table::Row> cif_table_row(cif_table, "Row");
 
-  py::enum_<Style>(cif, "Style")
+  nb::enum_<Style>(cif, "Style")
     .value("Simple", Style::Simple)
     .value("NoBlankLines", Style::NoBlankLines)
     .value("PreferPairs", Style::PreferPairs)
@@ -72,90 +82,89 @@ void add_cif(py::module& cif) {
     .value("Indent35", Style::Indent35)
     .value("Aligned", Style::Aligned)
     ;
-  py::class_<WriteOptions>(cif, "WriteOptions")
-    .def(py::init<>())
-    .def_readwrite("prefer_pairs", &WriteOptions::prefer_pairs)
-    .def_readwrite("compact", &WriteOptions::compact)
-    .def_readwrite("misuse_hash", &WriteOptions::misuse_hash)
-    .def_readwrite("align_pairs", &WriteOptions::align_pairs)
-    .def_readwrite("align_loops", &WriteOptions::align_loops)
+  nb::class_<WriteOptions>(cif, "WriteOptions")
+    .def(nb::init<>())
+    .def_rw("prefer_pairs", &WriteOptions::prefer_pairs)
+    .def_rw("compact", &WriteOptions::compact)
+    .def_rw("misuse_hash", &WriteOptions::misuse_hash)
+    .def_rw("align_pairs", &WriteOptions::align_pairs)
+    .def_rw("align_loops", &WriteOptions::align_loops)
     .def("__repr__", [](const WriteOptions &self) -> std::string {
         std::string str = self.str();
         if (str.empty())
           return "gemmi.cif.WriteOptions()";
         return gemmi::cat("<gemmi.cif.WriteOptions ", str, '>');
     });
-  py::class_<Document>(cif, "Document")
-    .def(py::init<>())
-    .def_readwrite("source", &Document::source)
+  nb::class_<Document>(cif, "Document")
+    .def(nb::init<>())
+    .def_rw("source", &Document::source)
     .def("__len__", [](const Document& d) { return d.blocks.size(); })
-    .def("__iter__", [](const Document& d) {
-        return py::make_iterator(d.blocks);
-    }, py::keep_alive<0, 1>())
+    .def("__iter__", [](Document& d) { return usual_iterator(d, d.blocks); },
+         nb::keep_alive<0, 1>())
     .def("__getitem__", [](Document& d, const std::string& name) -> Block& {
         Block* b = d.find_block(name);
         if (!b)
-          throw py::key_error("block '" + name + "' does not exist");
+          throw nb::key_error(gemmi::cat("block '", name, "' does not exist").c_str());
         return *b;
-    }, py::arg("name"), py::return_value_policy::reference_internal)
+    }, nb::arg("name"), nb::rv_policy::reference_internal)
     .def("__getitem__", [](Document& d, int index) -> Block& {
         return d.blocks[normalize_index(index, d.blocks)];
-    }, py::arg("index"), py::return_value_policy::reference_internal)
-    .def("__getitem__", [](Document &d, py::slice slice) -> py::list {
+    }, nb::arg("index"), nb::rv_policy::reference_internal)
+    .def("__getitem__", [](Document &d, nb::slice slice) -> nb::list {
         return getitem_slice(d.blocks, slice);
-    }, py::return_value_policy::reference_internal)
+    }, nb::rv_policy::reference_internal)
     .def("__contains__", [](Document& d, const std::string& name) -> bool {
         Block* b = d.find_block(name);
         return b != nullptr;
-    }, py::arg("name"))
+    }, nb::arg("name"))
     .def("__delitem__", [](Document &d, int index) {
         if (index < 0)
           index += (int) d.blocks.size();
         if (index < 0 || static_cast<size_t>(index) >= d.blocks.size())
-          throw py::index_error();
+          throw nb::index_error();
         d.blocks.erase(d.blocks.begin() + index);
-    }, py::arg("index"))
+    }, nb::arg("index"))
     .def("add_copied_block", [](Document& d, const Block& block, int pos) -> Block& {
         return add_to_vector(d.blocks, block, pos);
-    }, py::arg("block"), py::arg("pos")=-1,
-       py::return_value_policy::reference_internal)
+    }, nb::arg("block"), nb::arg("pos")=-1,
+       nb::rv_policy::reference_internal)
     .def("add_new_block", &Document::add_new_block,
-         py::arg("name"), py::arg("pos")=-1,
-         py::return_value_policy::reference_internal)
+         nb::arg("name"), nb::arg("pos")=-1,
+         nb::rv_policy::reference_internal)
     .def("clear", &Document::clear)
     .def("parse_string", &cif_parse_string)
     .def("parse_file", &cif_parse_file)
     .def("check_for_missing_values", &check_for_missing_values)
     .def("check_for_duplicates", &check_for_duplicates)
     .def("sole_block", (Block& (Document::*)()) &Document::sole_block,
-         py::return_value_policy::reference_internal,
+         nb::rv_policy::reference_internal,
          "Returns the only block if there is exactly one")
     .def("find_block",
          (Block* (Document::*)(const std::string&)) &Document::find_block,
-         py::arg("name"),
-         py::return_value_policy::reference_internal)
+         nb::arg("name"),
+         nb::rv_policy::reference_internal)
     .def("write_file",
          [](const Document& doc, const std::string& filename, WriteOptions opt) {
         gemmi::Ofstream os(filename);
         write_cif_to_stream(os.ref(), doc, opt);
-    }, py::arg("filename"), py::arg("options")=WriteOptions(),
+    }, nb::arg("filename"), nb::arg("options")=WriteOptions(),
     "Write data to a CIF file.")
     // deprecated
     .def("write_file", [](const Document& doc, const std::string& filename, Style s) {
         gemmi::Ofstream os(filename);
         write_cif_to_stream(os.ref(), doc, s);
-    }, py::arg("filename"), py::arg("style"))
+    }, nb::arg("filename"), nb::arg("style"))
     .def("as_string", [](const Document& d, WriteOptions opt) {
         std::ostringstream os;
         write_cif_to_stream(os, d, opt);
         return os.str();
-    }, py::arg("options")=WriteOptions(), "Returns a string in CIF format.")
+    }, nb::arg("options")=WriteOptions(), "Returns a string in CIF format.")
     // deprecated
     .def("as_string", [](const Document& d, Style s) {
         std::ostringstream os;
         write_cif_to_stream(os, d, s);
         return os.str();
-    }, py::arg("style"))
+    }, nb::arg("style"))
     .def("as_json", [](const Document& d, bool mmjson, bool lowercase_names) {
         std::ostringstream os;
         JsonWriter writer(os);
@@ -167,7 +176,7 @@ void add_cif(py::module& cif) {
         }
         writer.write_json(d);
         return os.str();
-    }, py::arg("mmjson")=false, py::arg("lowercase_names")=true,
+    }, nb::arg("mmjson")=false, nb::arg("lowercase_names")=true,
     "Returns JSON representation in a string.")
     .def("__repr__", [](const Document &d) {
         std::string s = "<gemmi.cif.Document with ";
@@ -183,77 +192,79 @@ void add_cif(py::module& cif) {
     });
 
   cif_block
-    .def(py::init<const std::string &>())
-    .def_readwrite("name", &Block::name)
-    .def("__iter__", [](Block& self) { return py::make_iterator(self.items); },
-         py::keep_alive<0, 1>())
+    .def(nb::init<const std::string &>())
+    .def_rw("name", &Block::name)
+    .def("__iter__", [](Block& self) { return usual_iterator(self, self.items); },
+         nb::keep_alive<0, 1>())
     .def("__getitem__", [](Block& self, int index) -> Item& {
         return self.items[normalize_index(index, self.items)];
-    }, py::arg("index"), py::return_value_policy::reference_internal)
-    .def("find_pair", [](const Block& self, const std::string& tag) -> py::object {
+    }, nb::arg("index"), nb::rv_policy::reference_internal)
+    .def("find_pair", [](const Block& self, const std::string& tag) -> nb::object {
         if (const Pair* p = self.find_pair(tag))
-          return py::make_tuple((*p)[0], (*p)[1]);
-        return py::none();
-     }, py::arg("tag"))
-    .def("find_pair_item", &Block::find_pair_item, py::arg("tag"),
-         py::return_value_policy::reference_internal)
-    .def("find_value", &Block::find_value, py::arg("tag"),
-         py::return_value_policy::reference)
-    .def("find_loop", &Block::find_loop, py::arg("tag"),
-         py::keep_alive<0, 1>())
-    .def("find_loop_item", &Block::find_loop_item, py::arg("tag"),
-         py::return_value_policy::reference_internal)
-    .def("find_values", &Block::find_values, py::arg("tag"),
-         py::keep_alive<0, 1>())
+          return nb::make_tuple((*p)[0], (*p)[1]);
+        return nb::none();
+     }, nb::arg("tag"))
+    .def("find_pair_item", &Block::find_pair_item, nb::arg("tag"),
+         nb::rv_policy::reference_internal)
+    .def("find_value", &Block::find_value, nb::arg("tag"),
+         nb::rv_policy::reference)
+    .def("find_loop", &Block::find_loop, nb::arg("tag"),
+         nb::keep_alive<0, 1>())
+    .def("find_loop_item", &Block::find_loop_item, nb::arg("tag"),
+         nb::rv_policy::reference_internal)
+    .def("find_values", &Block::find_values, nb::arg("tag"),
+         nb::keep_alive<0, 1>())
     .def("find", (Table (Block::*)(const std::string&,
             const std::vector<std::string>&)) &Block::find,
-         py::arg("prefix"), py::arg("tags"), py::keep_alive<0, 1>())
+         nb::arg("prefix"), nb::arg("tags"), nb::keep_alive<0, 1>())
     .def("find", (Table (Block::*)(const std::vector<std::string>&))
                  &Block::find,
-         py::arg("tags"), py::keep_alive<0, 1>())
+         nb::arg("tags"), nb::keep_alive<0, 1>())
     .def("find_or_add", &Block::find_or_add,
-         py::arg("prefix"), py::arg("tags"), py::keep_alive<0, 1>())
+         nb::arg("prefix"), nb::arg("tags"), nb::keep_alive<0, 1>())
     .def("add_item", [](Block& block, const Item& item, int pos) {
         return add_to_vector(block.items, item, pos);
-    }, py::arg("item"), py::arg("pos")=-1,
-       py::return_value_policy::reference_internal)
-    .def("find_frame", &Block::find_frame, py::arg("name"),
-         py::return_value_policy::reference_internal)
+    }, nb::arg("item"), nb::arg("pos")=-1,
+       nb::rv_policy::reference_internal)
+    .def("find_frame", &Block::find_frame, nb::arg("name"),
+         nb::rv_policy::reference_internal)
     .def("item_as_table", &Block::item_as_table)
-    .def("get_index", &Block::get_index, py::arg("tag"))
-    .def("set_pair", &Block::set_pair, py::arg("tag"), py::arg("value"))
+    .def("get_index", &Block::get_index, nb::arg("tag"))
+    .def("set_pair", &Block::set_pair, nb::arg("tag"), nb::arg("value"))
     .def("set_pairs",
-         [](Block &self, std::string prefix, py::dict data, bool raw) {
+         [](Block &self, std::string prefix, nb::dict data, bool raw) {
            ItemSpan span(self.items, prefix);
            for (auto item : data) {
-             std::string key = py::str(item.first);
+             std::string key = nb::str(item.first).c_str();
              std::string value = pyobject_to_string(item.second, raw);
              span.set_pair(prefix + key, value);
            }
-         }, py::arg("prefix"), py::arg("data"), py::arg("raw")=false)
-    .def("init_loop", &Block::init_loop, py::arg("prefix"), py::arg("tags"),
-         py::return_value_policy::reference_internal)
-    .def("move_item", &Block::move_item, py::arg("old_pos"), py::arg("new_pos"))
+         }, nb::arg("prefix"), nb::arg("data"), nb::arg("raw")=false)
+    .def("init_loop", &Block::init_loop, nb::arg("prefix"), nb::arg("tags"),
+         nb::rv_policy::reference_internal)
+    .def("move_item", &Block::move_item, nb::arg("old_pos"), nb::arg("new_pos"))
     .def("find_mmcif_category", &Block::find_mmcif_category,
-         py::arg("category"), py::keep_alive<0, 1>(),
+         nb::arg("category"), nb::keep_alive<0, 1>(),
          "Returns Table with all items in the category.")
     .def("get_mmcif_category_names", &Block::get_mmcif_category_names,
          "For mmCIF files only. Returns list of all category prefixes (_x.)")
     .def("init_mmcif_loop", &Block::init_mmcif_loop,
-         py::arg("cat"), py::arg("tags"),
-         py::return_value_policy::reference_internal)
+         nb::arg("cat"), nb::arg("tags"),
+         nb::rv_policy::reference_internal)
     .def("set_mmcif_category",
-         [](Block &self, std::string name, py::dict data, bool raw) {
+         [](Block &self, std::string name, nb::dict data, bool raw) {
            size_t w = data.size();
            std::vector<std::string> tags;
            tags.reserve(w);
-           std::vector<py::list> values;
+           std::vector<nb::list> values;
            values.reserve(w);
            for (auto item : data) {
-             tags.emplace_back(py::str(item.first));
-             values.emplace_back(item.second.cast<py::list>());
-             if (values.back().size() != values[0].size())
-               throw py::value_error("all columns must have equal length");
+             tags.emplace_back(nb::str(item.first).c_str());
+             // We could support all iterables as values, but it'd be confusing
+             // if strings/bytes were converted to sequences of letters.
+             nb::list& ref = values.emplace_back(nb::cast<nb::list>(item.second));
+             if (ref.size() != values[0].size())
+               throw nb::value_error("all columns must have equal length");
            }
            Loop& loop = self.init_mmcif_loop(std::move(name), std::move(tags));
            loop.values.resize(w != 0 ? w * values[0].size() : 0);
@@ -264,54 +275,49 @@ void add_cif(py::module& cif) {
                idx += w;
              }
            }
-         }, py::arg("name"), py::arg("data"), py::arg("raw")=false)
+         }, nb::arg("name"), nb::arg("data"), nb::arg("raw")=false)
     .def("get_mmcif_category",
          [](Block &self, std::string name, bool raw) {
            ensure_mmcif_category(name);
-           py::dict data;
+           nb::dict data;
            Table table = self.find_mmcif_category(name);
            int len = (int) table.length();
            for (const std::string& tag : table.tags()) {
              assert(tag.size() >= name.size());
              Column col = table.column((int)data.size());
-             py::list new_list(len);
+             // We could avoid reallocations with:
+             //  nb::list new_list = nb::steal<nb::list>(PyList_New(len));
+             // but then would need to use directly NB_LIST_SET_ITEM
+             // because new_list[i]=... doesn't check for null.
+             nb::list new_list;
              for (int i = 0; i != len; ++i)
-               if (raw) {
-                 new_list[i] = col[i];
-               } else if (is_null(col[i])) {
-                 if (col[i][0] == '?')
-                   new_list[i] = py::none().inc_ref();
-                 else
-                   new_list[i] = py::handle(Py_False).inc_ref();
-               } else {
-                 new_list[i] = col.str(i);
-               }
+               new_list.append(string_to_pyobject(col[i], raw));
              data[tag.c_str() + name.size()] = new_list;
            }
            return data;
-         }, py::arg("name"), py::arg("raw")=false)
+         }, nb::arg("name"), nb::arg("raw")=false)
     .def("write_file",
          [](const Block& self, const std::string& filename, WriteOptions opt) {
         gemmi::Ofstream os(filename);
         write_cif_block_to_stream(os.ref(), self, opt);
-    }, py::arg("filename"), py::arg("options")=WriteOptions(),
+    }, nb::arg("filename"), nb::arg("options")=WriteOptions(),
     "Write data to a CIF file.")
     // deprecated
     .def("write_file", [](const Block& self, const std::string& filename, Style s) {
         gemmi::Ofstream os(filename);
         write_cif_block_to_stream(os.ref(), self, s);
-    }, py::arg("filename"), py::arg("style"))
+    }, nb::arg("filename"), nb::arg("style"))
     .def("as_string", [](const Block& self, WriteOptions opt) {
         std::ostringstream os;
         write_cif_block_to_stream(os, self, opt);
         return os.str();
-    }, py::arg("options")=WriteOptions(), "Returns a string in CIF format.")
+    }, nb::arg("options")=WriteOptions(), "Returns a string in CIF format.")
     // deprecated
     .def("as_string", [](const Block& self, Style s) {
         std::ostringstream os;
         write_cif_block_to_stream(os, self, s);
         return os.str();
-    }, py::arg("style"))
+    }, nb::arg("style"))
     .def("__repr__", [](const Block &self) {
         return gemmi::cat("<gemmi.cif.Block ", self.name, '>');
     });
@@ -319,26 +325,26 @@ void add_cif(py::module& cif) {
 
   cif_item
     .def("erase", &Item::erase)
-    .def_readonly("line_number", &Item::line_number)
-    .def_property_readonly("pair", [](Item& self) -> py::object {
+    .def_ro("line_number", &Item::line_number)
+    .def_prop_ro("pair", [](Item& self) -> nb::object {
         if (self.type == ItemType::Pair)
-          return py::make_tuple(self.pair[0], self.pair[1]);
-        return py::none();
+          return nb::make_tuple(self.pair[0], self.pair[1]);
+        return nb::none();
     })
-    .def_property_readonly("loop", [](Item& self) {
+    .def_prop_ro("loop", [](Item& self) {
         return self.type == ItemType::Loop ? &self.loop : nullptr;
-    }, py::return_value_policy::reference_internal)
-    .def_property_readonly("frame", [](Item& self) {
+    }, nb::rv_policy::reference_internal)
+    .def_prop_ro("frame", [](Item& self) {
         return self.type == ItemType::Frame ? &self.frame : nullptr;
-    }, py::return_value_policy::reference_internal)
+    }, nb::rv_policy::reference_internal)
     ;
 
   cif_loop
-    .def(py::init<>())
+    .def(nb::init<>())
     .def("width", &Loop::width, "Returns number of columns")
     .def("length", &Loop::length, "Returns number of rows")
-    .def_readonly("tags", &Loop::tags)
-    .def_readonly("values", &Loop::values)
+    .def_ro("tags", &Loop::tags)
+    .def_ro("values", &Loop::values)
     .def("__getitem__", [](Loop &self, std::pair<int,int> idx) {
         return self.val(c_index(idx.first, self.length()),
                         c_index(idx.second, self.width()));
@@ -348,35 +354,35 @@ void add_cif(py::module& cif) {
                  c_index(idx.second, self.width())) = value;
     })
     .def("add_row", &Loop::add_row<std::vector<std::string>>,
-         py::arg("new_values"), py::arg("pos")=-1)
+         nb::arg("new_values"), nb::arg("pos")=-1)
     .def("add_columns", &Loop::add_columns,
-         py::arg("column_names"), py::arg("value"), py::arg("pos")=-1)
+         nb::arg("column_names"), nb::arg("value"), nb::arg("pos")=-1)
     .def("remove_column", &Loop::remove_column)
-    .def("set_all_values", &Loop::set_all_values, py::arg("columns"))
+    .def("set_all_values", &Loop::set_all_values, nb::arg("columns"))
     .def("__repr__", [](const Loop &self) {
         return gemmi::cat("<gemmi.cif.Loop ", self.length(), " x ", self.width(), '>');
     });
 
 
   cif_column
-    .def(py::init<>())
+    .def(nb::init<>())
     .def("get_loop", &Column::get_loop,
-         py::return_value_policy::reference_internal)
-    .def_property("tag",
+         nb::rv_policy::reference_internal)
+    .def_prop_rw("tag",
                   [](const Column& self) { return self.get_tag(); },
                   [](Column& self, const std::string& s) {
                       if (std::string* tag = self.get_tag())
                           *tag = s;
                   })
-    .def("__iter__", [](const Column& self) { return py::make_iterator(self); },
-         py::keep_alive<0, 1>())
+    .def("__iter__", [](Column& self) { return usual_iterator(self, self); },
+         nb::keep_alive<0, 1>())
     .def("__bool__", [](const Column &self) { return self.item() != nullptr; })
     .def("__len__", [](const Column &self) { return self.length(); })
     .def("__getitem__", (std::string& (Column::*)(int)) &Column::at)
     .def("__setitem__", [](Column &self, int idx, std::string value) {
         self.at(idx) = value;
     })
-    .def("str", &Column::str, py::arg("index"))
+    .def("str", &Column::str, nb::arg("index"))
     .def("erase", &Column::erase)
     .def("__repr__", [](const Column &self) {
         std::string s = "<gemmi.cif.Column ";
@@ -389,27 +395,27 @@ void add_cif(py::module& cif) {
 
   cif_table
     .def("width", &Table::width)
-    .def_readonly("prefix_length", &Table::prefix_length)
-    .def_property_readonly("loop", &Table::get_loop,
-                           py::return_value_policy::reference_internal)
+    .def_ro("prefix_length", &Table::prefix_length)
+    .def_prop_ro("loop", &Table::get_loop,
+                           nb::rv_policy::reference_internal)
     .def("get_prefix", &Table::get_prefix)
     .def("has_column", &Table::has_column)
-    .def("column", &Table::column, py::arg("n"), py::keep_alive<0, 1>())
-    .def("find_row", &Table::find_row, py::keep_alive<0, 1>())
-    .def("find_column", &Table::find_column, py::arg("tag"),
-         py::keep_alive<0, 1>())
+    .def("column", &Table::column, nb::arg("n"), nb::keep_alive<0, 1>())
+    .def("find_row", &Table::find_row, nb::keep_alive<0, 1>())
+    .def("find_column", &Table::find_column, nb::arg("tag"),
+         nb::keep_alive<0, 1>())
     .def("erase", &Table::erase)
     .def("ensure_loop", &Table::ensure_loop)
     .def("append_row", &Table::append_row<std::vector<std::string>>,
-         py::arg("new_values"))
-    .def("remove_row", &Table::remove_row, py::arg("row_index"))
-    .def("move_row", &Table::move_row, py::arg("old_pos"), py::arg("new_pos"))
-    .def_property_readonly("tags",
-            py::cpp_function(&Table::tags, py::keep_alive<0, 1>()))
+         nb::arg("new_values"))
+    .def("remove_row", &Table::remove_row, nb::arg("row_index"))
+    .def("move_row", &Table::move_row, nb::arg("old_pos"), nb::arg("new_pos"))
+    .def_prop_ro("tags", &Table::tags, nb::keep_alive<0, 1>())
     .def("__iter__", [](Table& self) {
-        return py::make_iterator(self, py::keep_alive<0, 1>());
-    }, py::keep_alive<0, 1>())
-    .def("__getitem__", &Table::at, py::keep_alive<0, 1>())
+        return nb::make_iterator(nb::type<Table>(), "iterator", self.begin(), self.end(),
+                                 nb::keep_alive<0, 1>());
+    }, nb::keep_alive<0, 1>())
+    .def("__getitem__", &Table::at, nb::keep_alive<0, 1>())
     .def("__delitem__", &Table::remove_row)
     .def("__delitem__", &delitem_slice<Table>)
     .def("__bool__", &Table::ok)
@@ -424,7 +430,7 @@ void add_cif(py::module& cif) {
     });
 
   cif_table_row
-    .def_readonly("row_index", &Table::Row::row_index)
+    .def_ro("row_index", &Table::Row::row_index)
     .def("str", &Table::Row::str)
     .def("__len__", &Table::Row::size)
     .def("__getitem__", (std::string& (Table::Row::*)(int)) &Table::Row::at)
@@ -439,11 +445,11 @@ void add_cif(py::module& cif) {
         self.value_at_unsafe(self.tab.find_column_position(tag)) = value;
     })
     .def("get", (std::string* (Table::Row::*)(int)) &Table::Row::ptr_at,
-         py::arg("index"), py::return_value_policy::reference_internal)
-    .def("has", &Table::Row::has, py::arg("index"))
-    .def("__iter__", [](const Table::Row& self) {
-        return py::make_iterator(self);
-    }, py::keep_alive<0, 1>())
+         nb::arg("index"), nb::rv_policy::reference_internal)
+    .def("has", &Table::Row::has, nb::arg("index"))
+    .def("__iter__", [](Table::Row& self) {
+        return usual_iterator(self, self);
+    }, nb::keep_alive<0, 1>())
     .def("__repr__", [](const Table::Row& self) {
         std::string items;
         for (int i = 0; (size_t)i != self.size(); ++i)
@@ -451,30 +457,28 @@ void add_cif(py::module& cif) {
         return "<gemmi.cif.Table.Row:" + items + ">";
     });
 
-  cif.def("quote", &quote, py::arg("string"));
+  cif.def("quote", &quote, nb::arg("string"));
   cif.def("quote_list", &quote_list);
 
-  py::class_<Ddl>(cif, "Ddl")
-    .def(py::init([](bool print_unknown_tags, bool use_regex, bool use_context,
-                     bool use_parents, bool use_mandatory, bool use_unique_keys) {
-          Ddl* ddl = new Ddl;
-          if (ddl) {
-            ddl->print_unknown_tags = print_unknown_tags;
-            ddl->use_regex = use_regex;
-            ddl->use_context = use_context;
-            ddl->use_parents = use_parents;
-            ddl->use_mandatory = use_mandatory;
-            ddl->use_unique_keys = use_unique_keys;
-          }
-          return ddl;
-    }), py::arg("print_unknown_tags")=true, py::arg("use_regex")=true,
-        py::arg("use_context")=true, py::arg("use_linked_groups")=true,
-        py::arg("use_mandatory")=true, py::arg("use_unique_keys")=true)
+  nb::class_<Ddl>(cif, "Ddl")
+    .def("__init__", [](Ddl* ddl, bool print_unknown_tags, bool use_regex,
+                        bool use_context, bool use_parents,
+                        bool use_mandatory, bool use_unique_keys) {
+          new(ddl) Ddl();
+          ddl->print_unknown_tags = print_unknown_tags;
+          ddl->use_regex = use_regex;
+          ddl->use_context = use_context;
+          ddl->use_parents = use_parents;
+          ddl->use_mandatory = use_mandatory;
+          ddl->use_unique_keys = use_unique_keys;
+    }, nb::arg("print_unknown_tags")=true, nb::arg("use_regex")=true,
+       nb::arg("use_context")=true, nb::arg("use_linked_groups")=true,
+       nb::arg("use_mandatory")=true, nb::arg("use_unique_keys")=true)
     .def("read_ddl_file", [](Ddl& self, const std::string& path) {
         std::ostringstream out;
         self.read_ddl(gemmi::read_cif_gz(path), out);
         return out.str();
-    }, py::arg("path"))
+    }, nb::arg("path"))
     .def("validate_cif", [](Ddl& self, const Document& doc) {
         std::ostringstream out;
         self.validate_cif(doc, out);
diff --git a/python/common.h b/python/common.h
index 51914e2b8..2e0a4d340 100644
--- a/python/common.h
+++ b/python/common.h
@@ -1,29 +1,52 @@
 
 #pragma once
-#include <pybind11/pybind11.h>
-
-void add_elem(pybind11::module& m); // elem.cpp
-void add_symmetry(pybind11::module& m); // sym.cpp
-void add_ccp4(pybind11::module& m); // ccp4.cpp
-void add_grid(pybind11::module& m); // grid.cpp
-void add_recgrid(pybind11::module& m); // recgrid.cpp
-void add_unitcell(pybind11::module& m); // unitcell.cpp
-void add_hkl(pybind11::module& m); // hkl.cpp
-void add_meta(pybind11::module& m); // meta.cpp
-void add_mol(pybind11::module& m); // mol.cpp
-void add_mtz(pybind11::module& m); // mtz.cpp
-void add_cif(pybind11::module& cif); // cif.cpp
-void add_cif_read(pybind11::module& cif); // read.cpp
-void add_read_structure(pybind11::module& m); // read.cpp
-void add_small(pybind11::module& m); // read.cpp
-void add_chemcomp(pybind11::module& m); // chemcomp.cpp
-void add_monlib(pybind11::module& m); // monlib.cpp
-void add_topo(pybind11::module& m); // topo.cpp
-void add_alignment(pybind11::module& m); // align.cpp
-void add_scaling(pybind11::module& m); // scaling.cpp
-void add_search(pybind11::module& m); // search.cpp
-void add_sf(pybind11::module& m); // sf.cpp
-void add_custom(pybind11::module& m); // custom.cpp
+
+#if defined(__clang__)
+  #pragma clang diagnostic push
+#elif defined(__GNUC__)
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wpedantic"
+#endif
+
+#include <nanobind/nanobind.h>
+
+#if defined(__clang__)
+  #pragma clang diagnostic pop
+#elif defined(__GNUC__)
+  #pragma GCC diagnostic pop
+#endif
+
+#if NB_VERSION_MAJOR < 2
+  #error Required nanobind version >= 2
+#endif
+
+#include <vector>
+
+namespace nb = nanobind;
+constexpr auto rv_ri = nb::rv_policy::reference_internal;
+
+void add_elem(nb::module_& m); // elem.cpp
+void add_symmetry(nb::module_& m); // sym.cpp
+void add_ccp4(nb::module_& m); // ccp4.cpp
+void add_grid(nb::module_& m); // grid.cpp
+void add_recgrid(nb::module_& m); // recgrid.cpp
+void add_unitcell(nb::module_& m); // unitcell.cpp
+void add_hkl(nb::module_& m); // hkl.cpp
+void add_meta(nb::module_& m); // meta.cpp
+void add_mol(nb::module_& m); // mol.cpp
+void add_mtz(nb::module_& m); // mtz.cpp
+void add_cif(nb::module_& cif); // cif.cpp
+void add_cif_read(nb::module_& cif); // read.cpp
+void add_read_structure(nb::module_& m); // read.cpp
+void add_small(nb::module_& m); // read.cpp
+void add_chemcomp(nb::module_& m); // chemcomp.cpp
+void add_monlib(nb::module_& m); // monlib.cpp
+void add_topo(nb::module_& m); // topo.cpp
+void add_alignment(nb::module_& m); // align.cpp
+void add_scaling(nb::module_& m); // scaling.cpp
+void add_search(nb::module_& m); // search.cpp
+void add_sf(nb::module_& m); // sf.cpp
+void add_custom(nb::module_& m); // custom.cpp
 
 // defined in write.cpp
 namespace gemmi {
@@ -31,9 +54,9 @@ namespace gemmi {
   namespace cif { struct Document; }
 }
 
-void add_write(pybind11::module& m, pybind11::class_<gemmi::Structure>& structure);
+void add_write(nb::module_& m, nb::class_<gemmi::Structure>& structure);
 // defined in align.cpp
-void add_assign_label_seq_id(pybind11::class_<gemmi::Structure>& structure);
+void add_assign_label_seq_id(nb::class_<gemmi::Structure>& structure);
 
 // defined in read.cpp
 void cif_parse_string(gemmi::cif::Document& doc, const std::string& data);
@@ -44,7 +67,7 @@ inline int c_index(int index, size_t size) {
   if (index < 0)
     index += (int) size;
   if ((size_t) index >= size)
-    throw pybind11::index_error();
+    throw nb::index_error();
   return index;
 }
 
@@ -52,38 +75,34 @@ template<typename T> int normalize_index(int index, const T& container) {
   return c_index(index, container.size());
 }
 
+// overloaded in cif.cpp
 template<typename Item>
-void delitem_at_index(std::vector<Item>& items, pybind11::ssize_t idx) {
+void delitem_at_index(std::vector<Item>& items, size_t idx) {
   items.erase(items.begin() + idx);
 }
 
+// overloaded in cif.cpp
 template<typename Item>
-void delitem_range(std::vector<Item>& items, pybind11::ssize_t start, pybind11::ssize_t end) {
+void delitem_range(std::vector<Item>& items, size_t start, size_t end) {
   items.erase(items.begin() + start, items.begin() + end);
 }
 
 template<typename Items>
-void delitem_slice(Items& items, const pybind11::slice& slice) {
-  namespace py = pybind11;
-  py::ssize_t start, stop, step, slength;
-  if (!slice.compute((py::ssize_t)items.size(), &start, &stop, &step, &slength))
-    throw py::error_already_set();
+void delitem_slice(Items& items, const nb::slice& slice) {
+  auto [start, stop, step, length] = slice.compute(items.size());
   if (step == 1) {
-    delitem_range(items, start, start + slength);
+    delitem_range(items, start, start + length);
   } else {
-    for (int i = 0; i < slength; ++i)
-      delitem_at_index(items, start + (step > 0 ? slength - 1 - i : i) * step);
+    for (size_t i = 0; i < length; ++i)
+      delitem_at_index(items, start + (step > 0 ? length - 1 - i : i) * step);
   }
 }
 
 template<typename Items>
-pybind11::list getitem_slice(Items& items, const pybind11::slice& slice) {
-  namespace py = pybind11;
-  py::ssize_t start, stop, step, slength;
-  if (!slice.compute((py::ssize_t)items.size(), &start, &stop, &step, &slength))
-    throw py::error_already_set();
-  py::list l;
-  for (py::ssize_t i = 0; i < slength; ++i)
-    l.append(py::cast(&items[start + i * step]));
+nb::list getitem_slice(Items& items, const nb::slice& slice) {
+  auto [start, stop, step, length] = slice.compute(items.size());
+  nb::list l;
+  for (size_t i = 0; i < length; ++i)
+    l.append(nb::cast(&items[start + i * step]));
   return l;
 }
diff --git a/python/custom.cpp b/python/custom.cpp
index 280b1ca4f..6414e0af4 100644
--- a/python/custom.cpp
+++ b/python/custom.cpp
@@ -1,9 +1,8 @@
 // An empty file that makes easier to add custom functions.
 //
 
-#include "common.h"  // it includes <pybind11/pybind11.h>
-namespace py = pybind11;
+#include "common.h"  // it includes <nanobind/nanobind.h>
 
-void add_custom(py::module& m) {
+void add_custom(nb::module_& m) {
   (void) m;
 }
diff --git a/python/elem.cpp b/python/elem.cpp
index d7dd9e70b..8356ae70a 100644
--- a/python/elem.cpp
+++ b/python/elem.cpp
@@ -1,17 +1,18 @@
 // Copyright 2020 Global Phasing Ltd.
 
 #include "common.h"
+#include <nanobind/operators.h>
+#include <nanobind/stl/array.h>
+#include <nanobind/stl/string.h>
+#include <nanobind/stl/vector.h>  // for expand_one_letter_sequence
+
 #include "gemmi/elem.hpp"
 #include "gemmi/resinfo.hpp"
 #include "gemmi/it92.hpp"
 #include "gemmi/c4322.hpp"
 #include "gemmi/neutron92.hpp"
 #include "gemmi/util.hpp"  // for cat
-#include <pybind11/stl.h>
-#include <pybind11/numpy.h>
-#include <pybind11/operators.h>
 
-namespace py = pybind11;
 using namespace gemmi;
 
 // Round coefficients.
@@ -23,77 +24,73 @@ double roc(float x) {
   return std::round(x * n) / n;
 }
 
-void add_elem(py::module& m) {
+void add_elem(nb::module_& m) {
   // it92.hpp
   using IT92 = gemmi::IT92<float>;
-  py::class_<IT92::Coef>(m, "IT92Coef")
-    .def_property_readonly("a", [](IT92::Coef& c) -> std::array<double,4> {
+  nb::class_<IT92::Coef>(m, "IT92Coef")
+    .def_prop_ro("a", [](IT92::Coef& c) -> std::array<double,4> {
         return {{ roc(c.a(0)), roc(c.a(1)), roc(c.a(2)), roc(c.a(3)) }};
     })
-    .def_property_readonly("b", [](IT92::Coef& c) -> std::array<double,4> {
+    .def_prop_ro("b", [](IT92::Coef& c) -> std::array<double,4> {
         return {{ roc(c.b(0)), roc(c.b(1)), roc(c.b(2)), roc(c.b(3)) }};
     })
-    .def_property_readonly("c", [](IT92::Coef& c) { return roc(c.c()); })
+    .def_prop_ro("c", [](IT92::Coef& c) { return roc(c.c()); })
     .def("get_coefs", [](const IT92::Coef &self) { return self.coefs; })
     .def("set_coefs", &IT92::Coef::set_coefs)
-    .def("calculate_sf", py::vectorize(&IT92::Coef::calculate_sf), py::arg("stol2"))
-    .def("calculate_density_iso",
-         [](const IT92::Coef &self, py::array_t<float> r2, float B) {
-             return py::vectorize([&self,B](float r2) {
-                 return self.calculate_density_iso(r2, B);
-             })(r2);
-    }, py::arg("r2"), py::arg("B"))
+    .def("calculate_sf", &IT92::Coef::calculate_sf, nb::arg("stol2"))
+    .def("calculate_density_iso", &IT92::Coef::calculate_density_iso,
+         nb::arg("r2"), nb::arg("B"))
     ;
   m.def("IT92_normalize", &IT92::normalize);
-  // can't define property for py::module_, and we don't expose IT92 as class
+  // can't define property for nb::module_, and we don't expose IT92 as class
   m.def("IT92_get_ignore_charge", []() { return IT92::ignore_charge; });
   m.def("IT92_set_ignore_charge", [](bool v) { IT92::ignore_charge = v; });
 
   // c4322.hpp
   using C4322 = gemmi::C4322<float>;
-  py::class_<C4322::Coef>(m, "C4322Coef")
-    .def_property_readonly("a", [](C4322::Coef& c) -> std::array<double,5> {
+  nb::class_<C4322::Coef>(m, "C4322Coef")
+    .def_prop_ro("a", [](C4322::Coef& c) -> std::array<double,5> {
         return {{ roc(c.a(0)), roc(c.a(1)), roc(c.a(2)), roc(c.a(3)), roc(c.a(4)) }};
     })
-    .def_property_readonly("b", [](C4322::Coef& c) -> std::array<double,5> {
+    .def_prop_ro("b", [](C4322::Coef& c) -> std::array<double,5> {
         return {{ roc(c.b(0)), roc(c.b(1)), roc(c.b(2)), roc(c.b(3)), roc(c.b(4)) }};
     })
     .def("get_coefs", [](const C4322::Coef &self) { return self.coefs; })
     .def("set_coefs", &C4322::Coef::set_coefs)
-    .def("calculate_sf", &C4322::Coef::calculate_sf, py::arg("stol2"))
+    .def("calculate_sf", &C4322::Coef::calculate_sf, nb::arg("stol2"))
     .def("calculate_density_iso", &C4322::Coef::calculate_density_iso,
-         py::arg("r2"), py::arg("B"))
+         nb::arg("r2"), nb::arg("B"))
     ;
 
   // neutron92.hpp
   using Neutron92 = gemmi::Neutron92<double>;
-  py::class_<Neutron92::Coef>(m, "Neutron92")
+  nb::class_<Neutron92::Coef>(m, "Neutron92")
     .def("get_coefs", [](const Neutron92::Coef &self) { return self.coefs; })
     // the same arguments as above - for consistency
-    .def("calculate_sf", &Neutron92::Coef::calculate_sf, py::arg("stol2"))
+    .def("calculate_sf", &Neutron92::Coef::calculate_sf, nb::arg("stol2"))
     .def("calculate_density_iso", &Neutron92::Coef::calculate_density_iso,
-         py::arg("r2"), py::arg("B"))
+         nb::arg("r2"), nb::arg("B"))
     ;
 
   // elem.hpp (w/ properties from it92.hpp, ...)
-  py::class_<Element>(m, "Element")
-    .def(py::init<const std::string &>())
-    .def(py::init<int>())
-    .def(py::self == py::self)
-    .def_property_readonly("name", &Element::name)
-    .def_property_readonly("weight", &Element::weight)
-    .def_property_readonly("covalent_r", &Element::covalent_r)
-    .def_property_readonly("vdw_r", &Element::vdw_r)
-    .def_property_readonly("atomic_number", &Element::atomic_number)
-    .def_property_readonly("is_hydrogen", &Element::is_hydrogen)
-    .def_property_readonly("is_metal", &Element::is_metal)
-    .def_property_readonly("it92", [](const Element& self) {
+  nb::class_<Element>(m, "Element")
+    .def(nb::init<const std::string &>())
+    .def(nb::init<int>())
+    .def(nb::self == nb::self)
+    .def_prop_ro("name", &Element::name)
+    .def_prop_ro("weight", &Element::weight)
+    .def_prop_ro("covalent_r", &Element::covalent_r)
+    .def_prop_ro("vdw_r", &Element::vdw_r)
+    .def_prop_ro("atomic_number", &Element::atomic_number)
+    .def_prop_ro("is_hydrogen", &Element::is_hydrogen)
+    .def_prop_ro("is_metal", &Element::is_metal)
+    .def_prop_ro("it92", [](const Element& self) {
         return IT92::has(self.elem) ? &IT92::get(self.elem, 0) : nullptr;
-    }, py::return_value_policy::reference)
-    .def_property_readonly("c4322", [](const Element& self) {
+    }, nb::rv_policy::reference)
+    .def_prop_ro("c4322", [](const Element& self) {
         return C4322::has(self.elem) ? &C4322::get(self.elem) : nullptr;
-    }, py::return_value_policy::reference)
-    .def_property_readonly("neutron92", [](const Element& self) {
+    }, nb::rv_policy::reference)
+    .def_prop_ro("neutron92", [](const Element& self) {
         return Neutron92::get(self.elem);  // a copy is created
     })
     .def("__hash__", [](const Element &self) { return self.ordinal(); })
@@ -103,10 +100,10 @@ void add_elem(py::module& m) {
 
   m.def("IT92_get_exact", [](gemmi::Element el, signed char charge) {
       return IT92::get_exact(el.elem, charge);
-  }, py::return_value_policy::reference);
+  }, nb::rv_policy::reference);
 
   // resinfo.hpp
-  py::enum_<ResidueKind>(m, "ResidueKind")
+  nb::enum_<ResidueKind>(m, "ResidueKind")
     .value("UNKNOWN", ResidueKind::UNKNOWN)
     .value("AA", ResidueKind::AA)
     .value("AAD", ResidueKind::AAD)
@@ -120,11 +117,11 @@ void add_elem(py::module& m) {
     .value("KET", ResidueKind::KET)
     .value("ELS", ResidueKind::ELS);
 
-  py::class_<ResidueInfo>(m, "ResidueInfo")
-    .def_readonly("kind", &ResidueInfo::kind)
-    .def_readonly("one_letter_code", &ResidueInfo::one_letter_code)
-    .def_readonly("hydrogen_count", &ResidueInfo::hydrogen_count)
-    .def_readonly("weight", &ResidueInfo::weight)
+  nb::class_<ResidueInfo>(m, "ResidueInfo")
+    .def_ro("kind", &ResidueInfo::kind)
+    .def_ro("one_letter_code", &ResidueInfo::one_letter_code)
+    .def_ro("hydrogen_count", &ResidueInfo::hydrogen_count)
+    .def_ro("weight", &ResidueInfo::weight)
     .def("found", &ResidueInfo::found)
     .def("is_standard", &ResidueInfo::is_standard)
     .def("fasta_code", &ResidueInfo::fasta_code)
@@ -132,7 +129,7 @@ void add_elem(py::module& m) {
     .def("is_nucleic_acid", &ResidueInfo::is_nucleic_acid)
     .def("is_amino_acid", &ResidueInfo::is_amino_acid);
 
-  m.def("find_tabulated_residue", &find_tabulated_residue, py::arg("name"),
+  m.def("find_tabulated_residue", &find_tabulated_residue, nb::arg("name"),
         "Find chemical component information in the internal table.");
   m.def("expand_one_letter", &expand_one_letter);
   m.def("expand_one_letter_sequence", &expand_one_letter_sequence);
diff --git a/python/gemmi.cpp b/python/gemmi.cpp
index 9f878d1a7..5bc0f27a1 100644
--- a/python/gemmi.cpp
+++ b/python/gemmi.cpp
@@ -11,151 +11,166 @@
 #include "gemmi/third_party/tao/pegtl/parse_error.hpp" // for parse_error
 
 #include "common.h"
-#include <pybind11/stl.h>
-#include <pybind11/numpy.h>    // for vectorize
-
-namespace py = pybind11;
+#include "array.h"
+#include <nanobind/make_iterator.h>
+#include <nanobind/stl/string.h>
+#include <nanobind/stl/vector.h>  // for calculate_sequence_weight
 
 namespace {
-template<typename T> int get_max_bin(const T& bins) {
+// returns max value in the array bin indices (which are of type int)
+template<typename T> size_t get_max_bin(const T& bins) {
   int max_bin = 0;
-  for (int i = 0; i < bins.shape(0); ++i) {
+  for (size_t i = 0; i < bins.shape(0); ++i) {
     if (bins(i) < 0)
-      throw py::value_error("bins argument must have no negative elements");
+      throw nb::value_error("bins argument must have no negative elements");
     max_bin = std::max(max_bin, bins(i));
   }
   if (max_bin > 1000000)
-    throw py::value_error("bin numbers must be smaller than million");
-  return max_bin;
+    throw nb::value_error("bin numbers must be smaller than million");
+  return (size_t) max_bin;
 }
+
+struct VectorizeFunc {
+  typedef double (*Func)(double);
+  Func func;
+  auto operator()(cpu_array<double> x) const {
+    auto x_ = x.view();
+    size_t len = x_.shape(0);
+    auto ret = make_numpy_array<double>({len});
+    double* retp = ret.data();
+    for (size_t i = 0; i < len; ++i)
+      retp[i] = func(x_(i));
+    return ret;
+  }
+};
 } // anonymous namespace
 
-void add_misc(py::module& m) {
-  py::class_<gemmi::CifWalk>(m, "CifWalk")
-    .def(py::init<const char*, char>(), py::arg("path"), py::arg("try_pdbid")='\0')
+void add_misc(nb::module_& m) {
+  nb::class_<gemmi::CifWalk>(m, "CifWalk")
+    .def(nb::init<const char*, char>(), nb::arg("path"), nb::arg("try_pdbid")='\0')
     .def("__iter__", [](gemmi::CifWalk& self) {
-        return py::make_iterator(self);
-    }, py::keep_alive<0, 1>());
-  py::class_<gemmi::CoorFileWalk>(m, "CoorFileWalk")
-    .def(py::init<const char*, char>(), py::arg("path"), py::arg("try_pdbid")='\0')
+        return nb::make_iterator(nb::type<gemmi::CifWalk>(), "iterator", self);
+    }, nb::keep_alive<0, 1>());
+  nb::class_<gemmi::CoorFileWalk>(m, "CoorFileWalk")
+    .def(nb::init<const char*, char>(), nb::arg("path"), nb::arg("try_pdbid")='\0')
     .def("__iter__", [](gemmi::CoorFileWalk& self) {
-        return py::make_iterator(self);
-    }, py::keep_alive<0, 1>());
+        return nb::make_iterator(nb::type<gemmi::CoorFileWalk>(), "iterator", self);
+    }, nb::keep_alive<0, 1>());
   m.def("is_pdb_code", &gemmi::is_pdb_code);
   m.def("expand_pdb_code_to_path", &gemmi::expand_pdb_code_to_path,
-        py::arg("code"), py::arg("filetype"), py::arg("throw_if_unset")=false);
+        nb::arg("code"), nb::arg("filetype"), nb::arg("throw_if_unset")=false);
   m.def("expand_if_pdb_code", &gemmi::expand_if_pdb_code,
-        py::arg("code"), py::arg("filetype")='M');
-  m.attr("hc") = py::float_(gemmi::hc());
-  m.def("bessel_i1_over_i0", py::vectorize(gemmi::bessel_i1_over_i0));
-  m.def("log_bessel_i0", py::vectorize(gemmi::log_bessel_i0));
-  m.def("log_cosh", py::vectorize(gemmi::log_cosh));
+        nb::arg("code"), nb::arg("filetype")='M');
+  m.attr("hc") = nb::float_(gemmi::hc());
+
+  m.def("bessel_i1_over_i0", VectorizeFunc{gemmi::bessel_i1_over_i0});
+  m.def("log_bessel_i0", VectorizeFunc{gemmi::log_bessel_i0});
+  m.def("log_cosh", VectorizeFunc{gemmi::log_cosh});
 
   // pirfasta.hpp
-  py::class_<gemmi::FastaSeq>(m, "FastaSeq")
-    .def_readonly("header", &gemmi::FastaSeq::header)
-    .def_readonly("seq", &gemmi::FastaSeq::seq)
+  nb::class_<gemmi::FastaSeq>(m, "FastaSeq")
+    .def_ro("header", &gemmi::FastaSeq::header)
+    .def_ro("seq", &gemmi::FastaSeq::seq)
     ;
   m.def("read_pir_or_fasta", &gemmi::read_pir_or_fasta);
 
   // seqtools.hpp
   m.def("calculate_sequence_weight", &gemmi::calculate_sequence_weight,
-        py::arg("sequence"), py::arg("unknown")=0.);
+        nb::arg("sequence"), nb::arg("unknown")=0.);
   m.def("one_letter_code", &gemmi::one_letter_code);
   m.def("pdbx_one_letter_code", &gemmi::pdbx_one_letter_code);
   m.def("sequence_kind", &gemmi::sequence_kind);
 
   // stats.hpp
-  py::class_<gemmi::Correlation>(m, "Correlation")
-    .def_readonly("n", &gemmi::Correlation::n)
+  nb::class_<gemmi::Correlation>(m, "Correlation")
+    .def_ro("n", &gemmi::Correlation::n)
     .def("coefficient", &gemmi::Correlation::coefficient)
     .def("mean_ratio", &gemmi::Correlation::mean_ratio)
     ;
 
   // utilities inspired by numpy.bincount()
-  m.def("binmean", [](py::array_t<int> bins, py::array_t<double> values) {
-      auto bins_ = bins.unchecked<1>();
-      auto values_ = values.unchecked<1>();
+  m.def("binmean", [](cpu_array<int> bins, cpu_array<double> values) {
+      auto bins_ = bins.view();
+      auto values_ = values.view();
       auto len = bins_.shape(0);
       if (len != values_.shape(0))
         throw std::domain_error("arrays have different lengths");
-      int ret_size = get_max_bin(bins_) + 1;
-      py::array_t<double> ret(ret_size);
-      double* retp = (double*) ret.request().ptr;
-      for (int i = 0; i != ret_size; ++i)
+      size_t ret_size = get_max_bin(bins_) + 1;
+      auto ret = make_numpy_array<double>({ret_size});
+      double* retp = ret.data();
+      for (size_t i = 0; i != ret_size; ++i)
         retp[i] = 0.;
       std::vector<int> counts(ret_size);
-      for (int i = 0; i != len; ++i)
+      for (size_t i = 0; i != len; ++i)
         if (!std::isnan(values_(i))) {
           int n = bins_(i);
           counts[n]++;
           retp[n] += values_(i);
         }
-      for (int i = 0; i != ret_size; ++i)
+      for (size_t i = 0; i != ret_size; ++i)
         retp[i] /= counts[i];
       return ret;
-  }, py::arg("nbins"), py::arg("values"));
+  }, nb::arg("nbins"), nb::arg("values"));
 
-  m.def("binrfactor", [](py::array_t<int> bins, py::array_t<double> obs,
-                         py::array_t<double> calc, bool riso) {
-      auto bins_ = bins.unchecked<1>();
-      auto obs_ = obs.unchecked<1>();
-      auto calc_ = calc.unchecked<1>();
+  m.def("binrfactor", [](cpu_array<int> bins, cpu_array<double> obs,
+                         cpu_array<double> calc, bool riso) {
+      auto bins_ = bins.view();
+      auto obs_ = obs.view();
+      auto calc_ = calc.view();
       auto len = bins_.shape(0);
       if (len != obs_.shape(0) || len != calc_.shape(0))
         throw std::domain_error("arrays have different lengths");
-      int ret_size = get_max_bin(bins_) + 1;
-      py::array_t<double> ret(ret_size);
-      double* retp = (double*) ret.request().ptr;
-      for (int i = 0; i != ret_size; ++i)
+      size_t ret_size = get_max_bin(bins_) + 1;
+      auto ret = make_numpy_array<double>({ret_size});
+      double* retp = ret.data();
+      for (size_t i = 0; i != ret_size; ++i)
         retp[i] = 0.;
       std::vector<double> sum_fobs(ret_size);
-      for (int i = 0; i != len; ++i)
+      for (size_t i = 0; i != len; ++i)
         if (!std::isnan(obs_(i)) && !std::isnan(calc_(i))) {
           int n = bins_(i);
           retp[n] += std::fabs(obs_(i) - calc_(i));
           sum_fobs[n] += riso ? (obs_(i) + calc_(i)) : obs_(i);
         }
-      for (int i = 0; i != ret_size; ++i)
+      for (size_t i = 0; i != ret_size; ++i)
         retp[i] /= (riso ? 0.5 * sum_fobs[i] : sum_fobs[i]);
       return ret;
-  }, py::arg("nbins"), py::arg("obs"), py::arg("calc"), py::arg("riso")=false);
+  }, nb::arg("nbins"), nb::arg("obs"), nb::arg("calc"), nb::arg("riso")=false);
 
-  m.def("bincorr", [](py::array_t<int> bins, py::array_t<double> obs,
-                                             py::array_t<double> calc) {
-      auto bins_ = bins.unchecked<1>();
-      auto obs_ = obs.unchecked<1>();
-      auto calc_ = calc.unchecked<1>();
+  m.def("bincorr", [](cpu_array<int> bins, cpu_array<double> obs, cpu_array<double> calc) {
+      auto bins_ = bins.view();
+      auto obs_ = obs.view();
+      auto calc_ = calc.view();
       auto len = bins_.shape(0);
       if (len != obs_.shape(0) || len != calc_.shape(0))
         throw std::domain_error("arrays have different lengths");
-      int ret_size = get_max_bin(bins_) + 1;
+      size_t ret_size = get_max_bin(bins_) + 1;
       std::vector<gemmi::Correlation> cor(ret_size);
-      for (int i = 0; i != len; ++i)
+      for (size_t i = 0; i != len; ++i)
         if (!std::isnan(obs_(i)) && !std::isnan(calc_(i)))
           cor[bins_(i)].add_point(obs_(i), calc_(i));
       return cor;
-  }, py::arg("nbins"), py::arg("obs"), py::arg("calc"));
+  }, nb::arg("nbins"), nb::arg("obs"), nb::arg("calc"));
 }
 
-PYBIND11_MODULE(gemmi, mg) {
+NB_MODULE(gemmi, mg) {
   mg.doc() = "Python bindings to GEMMI - a library used in macromolecular\n"
              "crystallography and related fields";
   mg.attr("__version__") = GEMMI_VERSION;
 
-  py::register_exception_translator([](std::exception_ptr p) {
+  nb::register_exception_translator([](const std::exception_ptr& p, void*) {
     try {
       if (p)
         std::rethrow_exception(p);
     } catch (const std::system_error &e) {
       const int errornum = e.code().value();
-      PyErr_SetObject(PyExc_IOError, py::make_tuple(errornum, e.what()).ptr());
+      PyErr_SetObject(PyExc_IOError, nb::make_tuple(errornum, e.what()).ptr());
     } catch (const tao::pegtl::parse_error &e) {
       PyErr_SetString(PyExc_ValueError, e.what());
     }
   });
 
-  py::module cif = mg.def_submodule("cif", "CIF file format");
+  nb::module_ cif = mg.def_submodule("cif", "CIF file format");
   add_cif(cif);
   add_symmetry(mg);
   add_unitcell(mg);
diff --git a/python/grid.cpp b/python/grid.cpp
index 0b8ecd03a..e3c858007 100644
--- a/python/grid.cpp
+++ b/python/grid.cpp
@@ -10,6 +10,15 @@ bool operator>(const std::complex<float>& a, const std::complex<float>& b) {
     return std::norm(a) > std::norm(b);
 }
 
+#include "common.h"
+#include "array.h"
+#include "make_iterator.h"
+#include <nanobind/ndarray.h>
+#include <nanobind/stl/array.h>
+#include <nanobind/stl/complex.h>
+#include <nanobind/stl/string.h>
+#include <nanobind/stl/vector.h>  // for find_blobs_by_flood_fill, ...
+
 #include "gemmi/grid.hpp"
 #include "gemmi/floodfill.hpp"  // for flood_fill_above
 #include "gemmi/solmask.hpp"  // for SolventMasker, mask_points_in_constant_radius
@@ -17,25 +26,19 @@ bool operator>(const std::complex<float>& a, const std::complex<float>& b) {
 #include "gemmi/asumask.hpp"  // for MaskedGrid
 #include "tostr.hpp"
 
-#include "common.h"
-#include <pybind11/complex.h>
-#include <pybind11/stl.h>
-#include <pybind11/numpy.h>
-
-namespace py = pybind11;
 using namespace gemmi;
 
 template<typename T>
-py::class_<GridBase<T>, GridMeta> add_grid_base(py::module& m, const char* name) {
+nb::class_<GridBase<T>, GridMeta> add_grid_base(nb::module_& m, const char* name) {
   using GrBase = GridBase<T>;
   using GrPoint = typename GridBase<T>::Point;
 
-  py::class_<GrBase, GridMeta> grid_base(m, name, py::buffer_protocol());
-  py::class_<GrPoint>(grid_base, "Point")
-    .def_readonly("u", &GrPoint::u)
-    .def_readonly("v", &GrPoint::v)
-    .def_readonly("w", &GrPoint::w)
-    .def_property("value",
+  nb::class_<GrBase, GridMeta> grid_base(m, name);
+  nb::class_<GrPoint>(grid_base, "Point")
+    .def_ro("u", &GrPoint::u)
+    .def_ro("v", &GrPoint::v)
+    .def_ro("w", &GrPoint::w)
+    .def_prop_rw("value",
                   [](const GrPoint& self) { return *self.value; },
                   [](GrPoint& self, T x) { *self.value = x; })
     .def("__repr__", [=](const GrPoint& self) {
@@ -43,120 +46,124 @@ py::class_<GridBase<T>, GridMeta> add_grid_base(py::module& m, const char* name)
                      self.w, ") -> ", +*self.value, '>');
     });
 
+  auto to_array = [](GrBase& g) {
+    // should we take AxisOrder into account here?
+    return nb::ndarray<nb::numpy, T>(g.data.data(),
+                                     {(size_t)g.nu, (size_t)g.nv, (size_t)g.nw},
+                                     nb::handle(),
+                                     {1, g.nu, g.nu * g.nv});
+  };
+
   grid_base
-    .def_buffer([](GrBase& g) {
-      return py::buffer_info(g.data.data(),
-                             {g.nu, g.nv, g.nw},       // dimensions
-                             {sizeof(T),               // strides
-                              sizeof(T) * g.nu,
-                              sizeof(T) * g.nu * g.nv});
-    })
-    .def_property_readonly("array", [](const GrBase& g) {
-      return py::array_t<T>({g.nu, g.nv, g.nw},
-                            {sizeof(T), sizeof(T) * g.nu, sizeof(T) * g.nu * g.nv},
-                            g.data.data(), py::cast(g));
-    }, py::return_value_policy::reference_internal)
+    .def_prop_ro("array", to_array, nb::rv_policy::reference_internal)
+    .def("__array__", to_array, nb::rv_policy::reference_internal)
     .def("point_to_index", &GrBase::point_to_index)
     .def("index_to_point", &GrBase::index_to_point)
-    .def("fill", &GrBase::fill, py::arg("value"))
+    .def("fill", &GrBase::fill, nb::arg("value"))
     .def("sum", &GrBase::sum)
-    .def("__iter__", [](GrBase& self) { return py::make_iterator(self); },
-         py::keep_alive<0, 1>())
+    .def("__iter__", [](GrBase& self) {
+        return usual_iterator(self, self);
+    }, nb::keep_alive<0, 1>())
     ;
   return grid_base;
 }
 
 template<typename T>
-py::class_<Grid<T>, GridBase<T>> add_grid_common(py::module& m, const std::string& name) {
+nb::class_<Grid<T>, GridBase<T>> add_grid_common(nb::module_& m, const std::string& name) {
   using Gr = Grid<T>;
   using GrPoint = typename GridBase<T>::Point;
   using Masked = MaskedGrid<T>;
-  py::class_<Gr, GridBase<T>> grid(m, name.c_str());
-  py::class_<Masked> masked_grid (m, ("Masked" + name).c_str());
+  nb::class_<Gr, GridBase<T>> grid(m, name.c_str());
+  nb::class_<Masked> masked_grid (m, ("Masked" + name).c_str());
 
   grid
-    .def(py::init<>())
-    .def(py::init([](int nx, int ny, int nz) {
-      Gr* grid = new Gr();
+    .def(nb::init<>())
+    .def("__init__", [](Gr* grid, int nx, int ny, int nz) {
+      new(grid) Gr();
       grid->set_size(nx, ny, nz);
-      return grid;
-    }), py::arg("nx"), py::arg("ny"), py::arg("nz"))
-    .def(py::init([](py::array_t<T> arr, const UnitCell *cell, const SpaceGroup* sg) {
-      auto r = arr.template unchecked<3>();
-      Gr* grid = new Gr();
+    }, nb::arg("nx"), nb::arg("ny"), nb::arg("nz"))
+    .def("__init__", [](Gr* grid, nb::ndarray<nb::numpy, T, nb::ndim<3>> arr,
+                        const UnitCell *cell, const SpaceGroup* sg) {
+      new(grid) Gr();
+      auto r = arr.view();
       grid->set_size((int)r.shape(0), (int)r.shape(1), (int)r.shape(2));
-      for (int k = 0; k < r.shape(2); ++k)
-        for (int j = 0; j < r.shape(1); ++j)
-          for (int i = 0; i < r.shape(0); ++i)
+      for (size_t k = 0; k < r.shape(2); ++k)
+        for (size_t j = 0; j < r.shape(1); ++j)
+          for (size_t i = 0; i < r.shape(0); ++i)
             grid->data[grid->index_q(i, j, k)] = r(i, j, k);
       if (cell)
         grid->set_unit_cell(*cell);
       if (sg)
         grid->spacegroup = sg;
-      return grid;
-    }), py::arg().noconvert(), py::arg("cell")=nullptr, py::arg("spacegroup")=nullptr)
-    .def_property_readonly("spacing", [](const Gr& self) {
-        return py::make_tuple(self.spacing[0], self.spacing[1], self.spacing[2]);
+    }, nb::arg().noconvert(), nb::arg("cell")=nb::none(), nb::arg("spacegroup")=nb::none())
+    .def_prop_ro("spacing", [](const Gr& self) {
+        return nb::make_tuple(self.spacing[0], self.spacing[1], self.spacing[2]);
     })
     .def("set_size", &Gr::set_size)
     .def("set_size_from_spacing", &Gr::set_size_from_spacing,
-         py::arg("spacing"), py::arg("rounding"))
+         nb::arg("spacing"), nb::arg("rounding"))
     .def("get_value", &Gr::get_value)
     .def("set_value", &Gr::set_value)
     .def("get_point", &Gr::get_point)
     .def("get_nearest_point", (GrPoint (Gr::*)(const Position&)) &Gr::get_nearest_point)
     .def("point_to_fractional", &Gr::point_to_fractional)
     .def("point_to_position", &Gr::point_to_position)
-    .def("change_values", &Gr::change_values, py::arg("old_value"), py::arg("new_value"))
+    .def("change_values", &Gr::change_values, nb::arg("old_value"), nb::arg("new_value"))
     .def("copy_metadata_from", &Gr::copy_metadata_from)
     .def("setup_from", &Gr::template setup_from<Structure>,
-         py::arg("st"), py::arg("spacing")=0.)
+         nb::arg("st"), nb::arg("spacing")=0.)
     .def("set_unit_cell", (void (Gr::*)(const UnitCell&)) &Gr::set_unit_cell)
     .def("set_points_around", &Gr::set_points_around,
-         py::arg("position"), py::arg("radius"), py::arg("value"), py::arg("use_pbc")=true)
+         nb::arg("position"), nb::arg("radius"), nb::arg("value"), nb::arg("use_pbc")=true)
     .def("symmetrize_min", &Gr::symmetrize_min)
     .def("symmetrize_max", &Gr::symmetrize_max)
     .def("symmetrize_abs_max", &Gr::symmetrize_abs_max)
     .def("symmetrize_sum", &Gr::symmetrize_sum)
-    .def("resample_to", &Gr::resample_to, py::arg("dest"), py::arg("order"))
-    .def("masked_asu", &masked_asu<T>, py::keep_alive<0, 1>())
+    .def("resample_to", &Gr::resample_to, nb::arg("dest"), nb::arg("order"))
+    .def("masked_asu", &masked_asu<T>, nb::keep_alive<0, 1>())
     .def("mask_points_in_constant_radius", &mask_points_in_constant_radius<T>,
-         py::arg("model"), py::arg("radius"), py::arg("value"),
-         py::arg("ignore_hydrogen")=false, py::arg("ignore_zero_occupancy_atoms")=false)
+         nb::arg("model"), nb::arg("radius"), nb::arg("value"),
+         nb::arg("ignore_hydrogen")=false, nb::arg("ignore_zero_occupancy_atoms")=false)
     .def("get_subarray",
          [](const Gr& self, std::array<int,3> start, std::array<int,3> shape) {
-        py::array_t<T> arr({shape[0], shape[1], shape[2]},
-                           {sizeof(T), sizeof(T)*shape[0], sizeof(T)*shape[0]*shape[1]});
-        self.get_subarray((T*) arr.request().ptr, start, shape);
+        auto arr = make_numpy_array<T>(
+            {(size_t)shape[0], (size_t)shape[1], (size_t)shape[2]},
+            {1, int64_t(shape[0]), int64_t(shape[0]*shape[1])});
+        self.get_subarray(arr.data(), start, shape);
         return arr;
-    }, py::arg("start"), py::arg("shape"))
+    }, nb::arg("start"), nb::arg("shape"))
     .def("set_subarray",
-         [](Gr& self, py::array_t<T, py::array::f_style | py::array::forcecast> arr,
+         [](Gr& self,
+            nb::ndarray<T, nb::ndim<3>, nb::f_contig, nb::device::cpu> arr,
             std::array<int,3> start) {
-        self.set_subarray((T*) arr.request().ptr, start,
+        self.set_subarray(arr.data(), start,
                           {(int)arr.shape(0), (int)arr.shape(1), (int)arr.shape(2)});
-    }, py::arg("arr"), py::arg("start"))
+    }, nb::arg("arr"), nb::arg("start"))
     .def("clone", [](const Gr& self) { return new Gr(self); })
     .def("__repr__", [=](const Gr& self) {
         return tostr("<gemmi.", name, '(', self.nu, ", ", self.nv, ", ", self.nw, ")>");
     });
 
   masked_grid
-    .def_readonly("grid", &Masked::grid, py::return_value_policy::reference)
-    .def_property_readonly("mask_array", [](const Masked& self) {
+    .def_ro("grid", &Masked::grid, nb::rv_policy::reference)
+    .def_prop_ro("mask_array", [](Masked& self) {
       const Gr& gr = *self.grid;
-      py::array::ShapeContainer shape({gr.nu, gr.nv, gr.nw});
-      py::array::StridesContainer strides({gr.nv * gr.nw, gr.nw, 1});
-      return py::array_t<std::int8_t>(shape, strides, self.mask.data(), py::cast(self));
-    }, py::return_value_policy::reference_internal)
-    .def("__iter__", [](Masked& self) { return py::make_iterator(self); },
-         py::keep_alive<0, 1>())
+      // cf. to_array() above
+      return nb::ndarray<nb::numpy, std::int8_t>(
+          self.mask.data(),
+          {(size_t)gr.nu, (size_t)gr.nv, (size_t)gr.nw},
+          nb::handle(),
+          {int64_t(gr.nv * gr.nw), int64_t(gr.nw), 1});
+    }, nb::rv_policy::reference_internal)
+    .def("__iter__", [](Masked& self) {
+        return usual_iterator(self, self);
+    }, nb::keep_alive<0, 1>())
     ;
     return grid;
 }
 
 template<typename T>
-void add_grid_interpolation(py::class_<Grid<T>, GridBase<T>>& grid) {
+void add_grid_interpolation(nb::class_<Grid<T>, GridBase<T>>& grid) {
   using Gr = Grid<T>;
   grid
     .def("interpolate_value",
@@ -165,16 +172,17 @@ void add_grid_interpolation(py::class_<Grid<T>, GridBase<T>>& grid) {
          (T (Gr::*)(const Position&) const) &Gr::interpolate_value)
     // TODO: find a better name for this func, perhaps interpolate_array?
     .def("interpolate_values",
-         [](const Gr& self, py::array_t<T> arr, const Transform& tr, int order) {
-        auto r = arr.template mutable_unchecked<3>();
-        for (int i = 0; i < r.shape(0); ++i)
-          for (int j = 0; j < r.shape(1); ++j)
-            for (int k = 0; k < r.shape(2); ++k) {
+         [](const Gr& self, nb::ndarray<nb::numpy, T, nb::ndim<3>> arr,
+            const Transform& tr, int order) {
+        auto r = arr.view();
+        for (size_t i = 0; i < r.shape(0); ++i)
+          for (size_t j = 0; j < r.shape(1); ++j)
+            for (size_t k = 0; k < r.shape(2); ++k) {
               Position pos(tr.apply(Vec3(i, j, k)));
               Fractional fpos = self.unit_cell.fractionalize(pos);
               r(i, j, k) = self.interpolate(fpos, order);
             }
-    }, py::arg().noconvert(), py::arg(), py::arg("order")=2)
+    }, nb::arg().noconvert(), nb::arg(), nb::arg("order")=2)
     .def("tricubic_interpolation",
          (double (Gr::*)(const Fractional&) const) &Gr::tricubic_interpolation)
     .def("tricubic_interpolation",
@@ -185,29 +193,29 @@ void add_grid_interpolation(py::class_<Grid<T>, GridBase<T>>& grid) {
     ;
 }
 
-void add_grid(py::module& m) {
-  py::enum_<AxisOrder>(m, "AxisOrder")
+void add_grid(nb::module_& m) {
+  nb::enum_<AxisOrder>(m, "AxisOrder")
     .value("Unknown", AxisOrder::Unknown)
     .value("XYZ", AxisOrder::XYZ)
     .value("ZYX", AxisOrder::ZYX);
 
-  py::enum_<GridSizeRounding>(m, "GridSizeRounding")
+  nb::enum_<GridSizeRounding>(m, "GridSizeRounding")
     .value("Nearest", GridSizeRounding::Nearest)
     .value("Up", GridSizeRounding::Up)
     .value("Down", GridSizeRounding::Down);
 
-  py::class_<GridMeta>(m, "GridMeta")
-    .def_readwrite("spacegroup", &GridMeta::spacegroup)
-    .def_readwrite("unit_cell", &GridMeta::unit_cell)
-    .def_readonly("nu", &GridMeta::nu, "size in the first (fastest-changing) dim")
-    .def_readonly("nv", &GridMeta::nv, "size in the second dimension")
-    .def_readonly("nw", &GridMeta::nw, "size in the third (slowest-changing) dim")
-    .def_readonly("axis_order", &GridMeta::axis_order)
-    .def_property_readonly("point_count", &GridMeta::point_count)
+  nb::class_<GridMeta>(m, "GridMeta")
+    .def_rw("spacegroup", &GridMeta::spacegroup)
+    .def_rw("unit_cell", &GridMeta::unit_cell)
+    .def_ro("nu", &GridMeta::nu, "size in the first (fastest-changing) dim")
+    .def_ro("nv", &GridMeta::nv, "size in the second dimension")
+    .def_ro("nw", &GridMeta::nw, "size in the third (slowest-changing) dim")
+    .def_ro("axis_order", &GridMeta::axis_order)
+    .def_prop_ro("point_count", &GridMeta::point_count)
     .def("get_position", &GridMeta::get_position)
     .def("get_fractional", &GridMeta::get_fractional)
-    .def_property_readonly("shape", [](const GridMeta& self) {
-      return py::make_tuple(self.nu, self.nv, self.nw);
+    .def_prop_ro("shape", [](const GridMeta& self) {
+      return nb::make_tuple(self.nu, self.nv, self.nw);
     });
 
   add_grid_base<int8_t>(m, "Int8GridBase")
@@ -227,41 +235,41 @@ void add_grid(py::module& m) {
   add_grid_base<std::complex<float>>(m, "ComplexGridBase");
 
   // from solmask.hpp
-  py::enum_<AtomicRadiiSet>(m, "AtomicRadiiSet")
+  nb::enum_<AtomicRadiiSet>(m, "AtomicRadiiSet")
     .value("VanDerWaals", AtomicRadiiSet::VanDerWaals)
     .value("Cctbx", AtomicRadiiSet::Cctbx)
     .value("Refmac", AtomicRadiiSet::Refmac)
     .value("Constant", AtomicRadiiSet::Constant);
-  py::class_<SolventMasker>(m, "SolventMasker")
-    .def(py::init<AtomicRadiiSet, double>(),
-         py::arg("choice"), py::arg("constant_r")=0.)
-    .def_readwrite("atomic_radii_set", &SolventMasker::atomic_radii_set)
-    .def_readwrite("rprobe", &SolventMasker::rprobe)
-    .def_readwrite("rshrink", &SolventMasker::rshrink)
-    .def_readwrite("island_min_volume", &SolventMasker::island_min_volume)
-    .def_readwrite("constant_r", &SolventMasker::constant_r)
-    .def_readwrite("ignore_hydrogen", &SolventMasker::ignore_hydrogen)
-    .def_readwrite("ignore_zero_occupancy_atoms", &SolventMasker::ignore_zero_occupancy_atoms)
+  nb::class_<SolventMasker>(m, "SolventMasker")
+    .def(nb::init<AtomicRadiiSet, double>(),
+         nb::arg("choice"), nb::arg("constant_r")=0.)
+    .def_rw("atomic_radii_set", &SolventMasker::atomic_radii_set)
+    .def_rw("rprobe", &SolventMasker::rprobe)
+    .def_rw("rshrink", &SolventMasker::rshrink)
+    .def_rw("island_min_volume", &SolventMasker::island_min_volume)
+    .def_rw("constant_r", &SolventMasker::constant_r)
+    .def_rw("ignore_hydrogen", &SolventMasker::ignore_hydrogen)
+    .def_rw("ignore_zero_occupancy_atoms", &SolventMasker::ignore_zero_occupancy_atoms)
     .def("set_radii", &SolventMasker::set_radii,
-         py::arg("choice"), py::arg("constant_r")=0.)
+         nb::arg("choice"), nb::arg("constant_r")=0.)
     .def("put_mask_on_int8_grid", &SolventMasker::put_mask_on_grid<int8_t>)
     .def("put_mask_on_float_grid", &SolventMasker::put_mask_on_grid<float>)
     .def("set_to_zero", &SolventMasker::set_to_zero)
     ;
   m.def("interpolate_grid", &interpolate_grid<float>,
-        py::arg("dest"), py::arg("src"), py::arg("tr"), py::arg("order")=2);
+        nb::arg("dest"), nb::arg("src"), nb::arg("tr"), nb::arg("order")=2);
   m.def("interpolate_grid_of_aligned_model2", &interpolate_grid_of_aligned_model2<float>,
-        py::arg("dest"), py::arg("src"), py::arg("tr"),
-        py::arg("dest_model"), py::arg("radius"), py::arg("order")=2);
+        nb::arg("dest"), nb::arg("src"), nb::arg("tr"),
+        nb::arg("dest_model"), nb::arg("radius"), nb::arg("order")=2);
 
 
   // from blob.hpp
-  py::class_<Blob>(m, "Blob")
-    .def_readonly("volume", &Blob::volume)
-    .def_readonly("score", &Blob::score)
-    .def_readonly("peak_value", &Blob::peak_value)
-    .def_readonly("centroid", &Blob::centroid)
-    .def_readonly("peak_pos", &Blob::peak_pos)
+  nb::class_<Blob>(m, "Blob")
+    .def_ro("volume", &Blob::volume)
+    .def_ro("score", &Blob::score)
+    .def_ro("peak_value", &Blob::peak_value)
+    .def_ro("centroid", &Blob::centroid)
+    .def_ro("peak_pos", &Blob::peak_pos)
     ;
   m.def("find_blobs_by_flood_fill",
         [](const Grid<float>& grid, double cutoff, double min_volume,
@@ -272,17 +280,17 @@ void add_grid(py::module& m) {
        crit.min_score = min_score;
        crit.min_peak = min_peak;
        return find_blobs_by_flood_fill(grid, crit, negate);
-    }, py::arg("grid"), py::arg("cutoff"), py::arg("min_volume")=10.,
-       py::arg("min_score")=15., py::arg("min_peak")=0., py::arg("negate")=false);
+    }, nb::arg("grid"), nb::arg("cutoff"), nb::arg("min_volume")=10.,
+       nb::arg("min_score")=15., nb::arg("min_peak")=0., nb::arg("negate")=false);
 
   // from floodfill.hpp
   m.def("flood_fill_above", &flood_fill_above,
-        py::arg("grid"), py::arg("seeds"), py::arg("threshold"), py::arg("negate")=false);
+        nb::arg("grid"), nb::arg("seeds"), nb::arg("threshold"), nb::arg("negate")=false);
 
   // from asumask.hpp
-  py::class_<AsuBrick>(m, "AsuBrick")
-    .def_readonly("size", &AsuBrick::size)
-    .def_readonly("incl", &AsuBrick::incl)
+  nb::class_<AsuBrick>(m, "AsuBrick")
+    .def_ro("size", &AsuBrick::size)
+    .def_ro("incl", &AsuBrick::incl)
     .def("get_extent", &AsuBrick::get_extent)
     .def("str", &AsuBrick::str)
     ;
diff --git a/python/hkl.cpp b/python/hkl.cpp
index 4df7ec0d7..a4fe27f5c 100644
--- a/python/hkl.cpp
+++ b/python/hkl.cpp
@@ -1,5 +1,13 @@
 // Copyright 2019 Global Phasing Ltd.
 
+#include "common.h"
+#include "array.h"  // numpy_array_from_vector
+#include <nanobind/stl/array.h>
+#include <nanobind/stl/bind_vector.h>
+#include <nanobind/stl/string.h>
+#include <nanobind/stl/vector.h>
+#include <nanobind/ndarray.h>
+
 #include "gemmi/unitcell.hpp"
 #include "gemmi/refln.hpp"
 #include "gemmi/fourier.hpp"  // for get_size_for_hkl, get_f_phi_on_grid, ...
@@ -12,16 +20,9 @@
 #include "gemmi/binner.hpp"   // for Binner
 #include "gemmi/ecalc.hpp"    // for calculate_amplitude_normalizers
 
-#include "common.h"
-#include "arrvec.h"  // py_array_from_vector
-#include <pybind11/stl.h>
-#include <pybind11/stl_bind.h>
-#include <pybind11/numpy.h>
-
-namespace py = pybind11;
 using namespace gemmi;
 
-PYBIND11_MAKE_OPAQUE(std::vector<ReflnBlock>)
+NB_MAKE_OPAQUE(std::vector<ReflnBlock>)
 
 namespace gemmi {
   // operator<< is used by stl_bind for vector's __repr__
@@ -36,44 +37,43 @@ namespace gemmi {
   }
 }
 
-void add_hkl(py::module& m) {
-  py::class_<ReflnBlock> pyReflnBlock(m, "ReflnBlock");
-  py::bind_vector<std::vector<ReflnBlock>>(m, "ReflnBlocks");
-
+void add_hkl(nb::module_& m) {
+  nb::class_<ReflnBlock> pyReflnBlock(m, "ReflnBlock");
+  nb::bind_vector<std::vector<ReflnBlock>, rv_ri>(m, "ReflnBlocks");
   pyReflnBlock
-    .def_readonly("block", &ReflnBlock::block)
-    .def_readonly("entry_id", &ReflnBlock::entry_id)
-    .def_readonly("cell", &ReflnBlock::cell)
-    .def_readonly("spacegroup", &ReflnBlock::spacegroup)
-    .def_readonly("wavelength", &ReflnBlock::wavelength)
-    .def_readonly("default_loop", &ReflnBlock::default_loop)
+    .def_ro("block", &ReflnBlock::block)
+    .def_ro("entry_id", &ReflnBlock::entry_id)
+    .def_ro("cell", &ReflnBlock::cell)
+    .def_ro("spacegroup", &ReflnBlock::spacegroup)
+    .def_ro("wavelength", &ReflnBlock::wavelength)
+    .def_ro("default_loop", &ReflnBlock::default_loop)
     .def("column_labels", &ReflnBlock::column_labels)
     .def("make_int_array",
          [](ReflnBlock& self, const std::string& tag, int null) {
-           return py_array_from_vector(self.make_vector(tag, null));
-    }, py::arg("tag"), py::arg("null"))
+           return numpy_array_from_vector(self.make_vector(tag, null));
+    }, nb::arg("tag"), nb::arg("null"))
     .def("make_float_array",
          [](ReflnBlock& self, const std::string& tag, double null) {
-           return py_array_from_vector(self.make_vector(tag, null));
-    }, py::arg("tag"), py::arg("null")=NAN)
+           return numpy_array_from_vector(self.make_vector(tag, null));
+    }, nb::arg("tag"), nb::arg("null")=NAN)
     .def("make_miller_array", [](ReflnBlock& self) {
-        return py::array_t<int>(py::cast(self.make_miller_vector()));
+        return py_array2d_from_vector(self.make_miller_vector());
     })
     .def("make_1_d2_array", [](ReflnBlock& self) {
-        return py_array_from_vector(self.make_1_d2_vector());
+        return numpy_array_from_vector(self.make_1_d2_vector());
     })
     .def("make_d_array", [](ReflnBlock& self) {
-        return py_array_from_vector(self.make_d_vector());
+        return numpy_array_from_vector(self.make_d_vector());
     })
     .def("get_size_for_hkl",
          [](const ReflnBlock& self,
             std::array<int,3> min_size, double sample_rate) {
           return get_size_for_hkl(ReflnDataProxy(self), min_size, sample_rate);
-    }, py::arg("min_size")=std::array<int,3>{{0,0,0}},
-       py::arg("sample_rate")=0.)
+    }, nb::arg("min_size")=std::array<int,3>{{0,0,0}},
+       nb::arg("sample_rate")=0.)
     .def("data_fits_into", [](const ReflnBlock& self, std::array<int,3> size) {
         return data_fits_into(ReflnDataProxy(self), size);
-    }, py::arg("size"))
+    }, nb::arg("size"))
     .def("get_f_phi_on_grid", [](const ReflnBlock& self,
                                  const std::string& f_col,
                                  const std::string& phi_col,
@@ -83,8 +83,8 @@ void add_hkl(py::module& m) {
         size_t phi_idx = self.get_column_index(phi_col);
         FPhiProxy<ReflnDataProxy> fphi(ReflnDataProxy{self}, f_idx, phi_idx);
         return get_f_phi_on_grid<float>(fphi, size, half_l, order);
-    }, py::arg("f"), py::arg("phi"), py::arg("size"),
-       py::arg("half_l")=false, py::arg("order")=AxisOrder::XYZ)
+    }, nb::arg("f"), nb::arg("phi"), nb::arg("size"),
+       nb::arg("half_l")=false, nb::arg("order")=AxisOrder::XYZ)
     .def("get_value_on_grid", [](const ReflnBlock& self,
                                  const std::string& column,
                                  std::array<int, 3> size,
@@ -92,8 +92,8 @@ void add_hkl(py::module& m) {
         size_t col_idx = self.get_column_index(column);
         return get_value_on_grid<float>(ReflnDataProxy(self), col_idx,
                                         size, half_l, order);
-    }, py::arg("column"), py::arg("size"), py::arg("half_l")=false,
-       py::arg("order")=AxisOrder::XYZ)
+    }, nb::arg("column"), nb::arg("size"), nb::arg("half_l")=false,
+       nb::arg("order")=AxisOrder::XYZ)
     .def("transform_f_phi_to_map", [](const ReflnBlock& self,
                                       const std::string& f_col,
                                       const std::string& phi_col,
@@ -106,25 +106,25 @@ void add_hkl(py::module& m) {
         FPhiProxy<ReflnDataProxy> fphi(ReflnDataProxy{self}, f_idx, phi_idx);
         return transform_f_phi_to_map2<float>(fphi, min_size, sample_rate,
                                               exact_size, order);
-    }, py::arg("f"), py::arg("phi"),
-       py::arg("min_size")=std::array<int,3>{{0,0,0}},
-       py::arg("exact_size")=std::array<int,3>{{0,0,0}},
-       py::arg("sample_rate")=0.,
-       py::arg("order")=AxisOrder::XYZ)
+    }, nb::arg("f"), nb::arg("phi"),
+       nb::arg("min_size")=std::array<int,3>{{0,0,0}},
+       nb::arg("exact_size")=std::array<int,3>{{0,0,0}},
+       nb::arg("sample_rate")=0.,
+       nb::arg("order")=AxisOrder::XYZ)
     .def("get_float", &make_asu_data<float, ReflnBlock>,
-         py::arg("col"), py::arg("as_is")=false)
+         nb::arg("col"), nb::arg("as_is")=false)
     .def("get_int", &make_asu_data<int, ReflnBlock>,
-         py::arg("col"), py::arg("as_is")=false)
+         nb::arg("col"), nb::arg("as_is")=false)
     .def("get_f_phi", [](const ReflnBlock& self, const std::string& f_col,
                                                  const std::string& phi_col,
                                                  bool as_is) {
         return make_asu_data<std::complex<float>, 2>(self, {f_col, phi_col}, as_is);
-    }, py::arg("f"), py::arg("phi"), py::arg("as_is")=false)
+    }, nb::arg("f"), nb::arg("phi"), nb::arg("as_is")=false)
     .def("get_value_sigma", [](const ReflnBlock& self, const std::string& f_col,
                                                        const std::string& sigma_col,
                                                        bool as_is) {
         return make_asu_data<ValueSigma<float>, 2>(self, {f_col, sigma_col}, as_is);
-    }, py::arg("f"), py::arg("sigma"), py::arg("as_is")=false)
+    }, nb::arg("f"), nb::arg("sigma"), nb::arg("as_is")=false)
     .def("is_unmerged", &ReflnBlock::is_unmerged)
     .def("use_unmerged", &ReflnBlock::use_unmerged)
     .def("__bool__", [](const ReflnBlock& self) { return self.ok(); })
@@ -132,55 +132,54 @@ void add_hkl(py::module& m) {
     ;
   m.def("as_refln_blocks",
         [](cif::Document& d) { return as_refln_blocks(std::move(d.blocks)); });
-  m.def("hkl_cif_as_refln_block", &hkl_cif_as_refln_block, py::arg("block"));
+  m.def("hkl_cif_as_refln_block", &hkl_cif_as_refln_block, nb::arg("block"));
   m.def("transform_f_phi_grid_to_map", [](FPhiGrid<float> grid) {
           return transform_f_phi_grid_to_map<float>(std::move(grid));
-        }, py::arg("grid"));
+        }, nb::arg("grid"));
   m.def("transform_map_to_f_phi", &transform_map_to_f_phi<float>,
-        py::arg("map"), py::arg("half_l")=false, py::arg("use_scale")=true);
+        nb::arg("map"), nb::arg("half_l")=false, nb::arg("use_scale")=true);
   m.def("cromer_liberman", [](int z, double energy) {
-          std::pair<double, double> r;
-          r.first = cromer_liberman(z, energy, &r.second);
-          return r;
-        }, py::arg("z"), py::arg("energy"));
+      std::pair<double, double> r;
+      r.first = cromer_liberman(z, energy, &r.second);
+      return r;
+  }, nb::arg("z"), nb::arg("energy"));
   m.def("count_reflections", &count_reflections,
-        py::arg("cell"), py::arg("spacegroup"), py::arg("dmin"),
-        py::arg("dmax")=0., py::arg("unique")=true);
+        nb::arg("cell"), nb::arg("spacegroup"), nb::arg("dmin"),
+        nb::arg("dmax")=0., nb::arg("unique")=true);
   m.def("make_miller_array", [](const UnitCell& cell, const SpaceGroup* sg,
                                 double dmin, double dmax, bool unique) {
-          return py::array_t<int>(py::cast(
-                      gemmi::make_miller_vector(cell, sg, dmin, dmax, unique)));
-        }, py::arg("cell"), py::arg("spacegroup"), py::arg("dmin"),
-           py::arg("dmax")=0., py::arg("unique")=true);
+      return py_array2d_from_vector(gemmi::make_miller_vector(cell, sg, dmin, dmax, unique));
+  }, nb::arg("cell"), nb::arg("spacegroup"), nb::arg("dmin"),
+     nb::arg("dmax")=0., nb::arg("unique")=true);
 
-  py::class_<CifToMtz>(m, "CifToMtz")
-    .def(py::init<>())
-    .def_readwrite("title", &CifToMtz::title)
-    .def_readwrite("history", &CifToMtz::history)
-    .def_readwrite("spec_lines", &CifToMtz::spec_lines)
+  nb::class_<CifToMtz>(m, "CifToMtz")
+    .def(nb::init<>())
+    .def_rw("title", &CifToMtz::title)
+    .def_rw("history", &CifToMtz::history)
+    .def_rw("spec_lines", &CifToMtz::spec_lines)
     .def("convert_block_to_mtz", [](const CifToMtz& self, const ReflnBlock& rb) {
         std::ostringstream out;
         return new Mtz(self.convert_block_to_mtz(rb, out));
     })
     ;
 
-  py::class_<MtzToCif>(m, "MtzToCif")
-    .def(py::init<>())
-    .def_readwrite("spec_lines", &MtzToCif::spec_lines)
-    .def_readwrite("with_comments", &MtzToCif::with_comments)
-    .def_readwrite("with_history", &MtzToCif::with_history)
-    .def_readwrite("skip_empty", &MtzToCif::skip_empty)
-    .def_readwrite("skip_negative_sigi", &MtzToCif::skip_negative_sigi)
-    .def_readwrite("wavelength", &MtzToCif::wavelength)
-    .def_readwrite("free_flag_value", &MtzToCif::free_flag_value)
+  nb::class_<MtzToCif>(m, "MtzToCif")
+    .def(nb::init<>())
+    .def_rw("spec_lines", &MtzToCif::spec_lines)
+    .def_rw("with_comments", &MtzToCif::with_comments)
+    .def_rw("with_history", &MtzToCif::with_history)
+    .def_rw("skip_empty", &MtzToCif::skip_empty)
+    .def_rw("skip_negative_sigi", &MtzToCif::skip_negative_sigi)
+    .def_rw("wavelength", &MtzToCif::wavelength)
+    .def_rw("free_flag_value", &MtzToCif::free_flag_value)
     .def("write_cif_to_string", [](MtzToCif& self, const Mtz& mtz, const Mtz* mtz2) {
         std::ostringstream out;
         self.write_cif(mtz, mtz2, nullptr, out);
         return out.str();
-    }, py::arg("mtz"), py::arg("mtz2")=nullptr)
+    }, nb::arg("mtz"), nb::arg("mtz2")=nb::none())
     ;
 
-  py::enum_<DataType>(m, "DataType")
+  nb::enum_<DataType>(m, "DataType")
     .value("Unknown", DataType::Unknown)
     .value("Unmerged", DataType::Unmerged)
     .value("Mean", DataType::Mean)
@@ -193,144 +192,128 @@ void add_hkl(py::module& m) {
       return check_data_type_under_symmetry(MtzDataProxy{data});
   });
 
-  py::class_<Intensities>(m, "Intensities")
-    .def(py::init<>())
-    .def_readwrite("spacegroup", &Intensities::spacegroup)
-    .def_readwrite("unit_cell", &Intensities::unit_cell)
-    .def_readwrite("type", &Intensities::type)
+  nb::class_<Intensities>(m, "Intensities")
+    .def(nb::init<>())
+    .def_rw("spacegroup", &Intensities::spacegroup)
+    .def_rw("unit_cell", &Intensities::unit_cell)
+    .def_rw("type", &Intensities::type)
     .def("resolution_range", &Intensities::resolution_range)
     .def("remove_systematic_absences", &Intensities::remove_systematic_absences)
-    .def("merge_in_place", &Intensities::merge_in_place, py::arg("itype"))
-    .def("read_mtz", &Intensities::read_mtz, py::arg("mtz"), py::arg("type"))
+    .def("merge_in_place", &Intensities::merge_in_place, nb::arg("itype"))
+    .def("read_mtz", &Intensities::read_mtz, nb::arg("mtz"), nb::arg("type"))
     .def("prepare_merged_mtz", &Intensities::prepare_merged_mtz,
-         py::arg("with_nobs"))
-    .def_property_readonly("miller_array", [](const Intensities& self) {
-      const Intensities::Refl* data = self.data.data();
-      py::array::ShapeContainer shape({(py::ssize_t)self.data.size(), 3});
-      py::array::StridesContainer strides({(const char*)(data+1) - (const char*)data,
-                                           sizeof(int)});
-      return py::array_t<int>(shape, strides, &data->hkl[0], py::cast(self));
-    }, py::return_value_policy::reference_internal)
-    .def_property_readonly("value_array", [](const Intensities& self) {
-      const Intensities::Refl* data = self.data.data();
-      py::ssize_t stride = (const char*)(data+1) - (const char*)data;
-      return py::array_t<double>({(py::ssize_t)self.data.size()}, {stride},
-                                 &data->value, py::cast(self));
-    }, py::return_value_policy::reference_internal)
-    .def_property_readonly("sigma_array", [](const Intensities& self) {
-      const Intensities::Refl* data = self.data.data();
-      py::ssize_t stride = (const char*)(data+1) - (const char*)data;
-      return py::array_t<double>({(py::ssize_t)self.data.size()}, {stride},
-                                 &data->sigma, py::cast(self));
-    }, py::return_value_policy::reference_internal)
-    .def_property_readonly("nobs_array", [](const Intensities& self) {
-      const Intensities::Refl* data = self.data.data();
-      py::ssize_t stride = (const char*)(data+1) - (const char*)data;
-      return py::array_t<short>({(py::ssize_t)self.data.size()}, {stride},
-                                &data->nobs, py::cast(self));
-    }, py::return_value_policy::reference_internal)
-    .def_property_readonly("isign_array", [](const Intensities& self) {
-      const Intensities::Refl* data = self.data.data();
-      py::ssize_t stride = (const char*)(data+1) - (const char*)data;
-      return py::array_t<short>({(py::ssize_t)self.data.size()}, {stride},
-                                &data->isign, py::cast(self));
-    }, py::return_value_policy::reference_internal)
-    .def("set_data", [](Intensities& self, const UnitCell& unit_cell,
-                        const SpaceGroup* sg, py::array_t<int> hkl,
-                        py::array_t<double> values, py::array_t<double> sigmas) {
-      auto h = hkl.unchecked<2>();
-      if (h.shape(1) != 3)
-        throw std::domain_error("the hkl array must have size N x 3");
-      auto v = values.template unchecked<1>();
-      auto s = sigmas.template unchecked<1>();
+         nb::arg("with_nobs"))
+    .def_prop_ro("miller_array", [](Intensities& self) {
+      int64_t stride = static_cast<int64_t>(sizeof(Intensities::Refl) / sizeof(int));
+      return nb::ndarray<nb::numpy, int, nb::shape<-1,3>>(
+          &self.data.data()->hkl[0], {self.data.size(), 3},
+          nb::handle(), {stride, 1});
+    }, nb::rv_policy::reference_internal)
+    .def_prop_ro("value_array", [](Intensities& self) {
+      return vector_member_array(self.data, &Intensities::Refl::value);
+      //const Intensities::Refl* data = self.data.data();
+      //nb::ssize_t stride = (const char*)(data+1) - (const char*)data;
+      //return nb::array_t<double>({(nb::ssize_t)self.data.size()}, {stride},
+      //                           &data->value, nb::cast(self));
+    }, nb::rv_policy::reference_internal)
+    .def_prop_ro("sigma_array", [](Intensities& self) {
+      return vector_member_array(self.data, &Intensities::Refl::sigma);
+    }, nb::rv_policy::reference_internal)
+    .def_prop_ro("nobs_array", [](Intensities& self) {
+      return vector_member_array(self.data, &Intensities::Refl::nobs);
+    }, nb::rv_policy::reference_internal)
+    .def_prop_ro("isign_array", [](Intensities& self) {
+      return vector_member_array(self.data, &Intensities::Refl::isign);
+    }, nb::rv_policy::reference_internal)
+    .def("set_data", [](Intensities& self,
+                        const UnitCell& unit_cell,
+                        const SpaceGroup* sg,
+                        cpu_miller_array hkl,
+                        cpu_array<double> values,
+                        cpu_array<double> sigmas) {
+      auto h = hkl.view();
+      auto v = values.view();
+      auto s = sigmas.view();
       if (h.shape(0) != v.shape(0) || h.shape(0) != s.shape(0))
         throw std::domain_error("arrays have different lengths");
-
       self.unit_cell = unit_cell;
       self.spacegroup = sg;
+      self.data.clear();
       self.data.reserve(h.shape(0));
-      for (py::ssize_t i = 0; i < h.shape(0); ++i)
+      for (size_t i = 0; i < h.shape(0); ++i)
         if (!std::isnan(v(i)) && s(i) > 0)
           self.data.push_back({{{h(i, 0), h(i, 1), h(i, 2)}}, 1, 0, v(i), s(i)});
 
       self.switch_to_asu_indices();
       self.type = DataType::Unmerged;
-    }, py::arg("cell"), py::arg("sg").none(false),
-       py::arg("miller_array"), py::arg("value_array"), py::arg("sigma_array"))
+    }, nb::arg("cell"), nb::arg("sg").none(false),
+       nb::arg("miller_array"), nb::arg("value_array"), nb::arg("sigma_array"))
     ;
 
-  py::class_<Binner> binner(m, "Binner");
-  py::enum_<Binner::Method>(binner, "Method")
+  nb::class_<Binner> binner(m, "Binner");
+  nb::enum_<Binner::Method>(binner, "Method")
       .value("EqualCount", Binner::Method::EqualCount)
       .value("Dstar", Binner::Method::Dstar)
       .value("Dstar2", Binner::Method::Dstar2)
       .value("Dstar3", Binner::Method::Dstar3)
       ;
   binner
-    .def(py::init<>())
+    .def(nb::init<>())
     .def("setup", [](Binner& self, int nbins, Binner::Method method,
                      const Mtz& mtz, const UnitCell* cell) {
         self.setup(nbins, method, MtzDataProxy{mtz}, cell);
-    }, py::arg("nbins"), py::arg("method"), py::arg("mtz"), py::arg("cell")=nullptr)
+    }, nb::arg("nbins"), nb::arg("method"), nb::arg("mtz"), nb::arg("cell")=nb::none())
     .def("setup", [](Binner& self, int nbins, Binner::Method method,
                      const ReflnBlock& r, const UnitCell* cell) {
         self.setup(nbins, method, ReflnDataProxy(r), cell);
-    }, py::arg("nbins"), py::arg("method"), py::arg("r"), py::arg("cell")=nullptr)
+    }, nb::arg("nbins"), nb::arg("method"), nb::arg("r"), nb::arg("cell")=nb::none())
     .def("setup", [](Binner& self, int nbins, Binner::Method method,
-                     py::array_t<int> hkl, const UnitCell* cell) {
-        auto h = hkl.unchecked<2>();
-        if (h.shape(1) != 3)
-          throw std::domain_error("the hkl array must have size N x 3");
+                     cpu_miller_array hkl, const UnitCell* cell) {
+        auto h = hkl.view();
         std::vector<double> inv_d2(h.shape(0));
         if (cell)
           for (size_t i = 0; i < inv_d2.size(); ++i)
             inv_d2[i] = cell->calculate_1_d2_double(h(i, 0), h(i, 1), h(i, 2));
         self.setup_from_1_d2(nbins, method, std::move(inv_d2), cell);
-    }, py::arg("nbins"), py::arg("method"), py::arg("hkl"), py::arg("cell"))
+    }, nb::arg("nbins"), nb::arg("method"), nb::arg("hkl"), nb::arg("cell"))
     .def("setup_from_1_d2", [](Binner& self, int nbins, Binner::Method method,
-                               py::array_t<double> inv_d2, const UnitCell* cell) {
-        double* ptr = (double*) inv_d2.request().ptr;
+                               cpu_c_array<double> inv_d2, const UnitCell* cell) {
+        double* ptr = inv_d2.data();
         auto len = inv_d2.shape(0);
         self.setup_from_1_d2(nbins, method, std::vector<double>(ptr, ptr+len), cell);
-    }, py::arg("nbins"), py::arg("method"), py::arg("inv_d2"), py::arg("cell"))
+    }, nb::arg("nbins"), nb::arg("method"), nb::arg("inv_d2"), nb::arg("cell"))
     .def("get_bin", &Binner::get_bin)
     .def("get_bins", [](Binner& self, const Mtz& mtz) {
-        return py_array_from_vector(self.get_bins(MtzDataProxy{mtz}));
+        return numpy_array_from_vector(self.get_bins(MtzDataProxy{mtz}));
     })
     .def("get_bins", [](Binner& self, const ReflnBlock& r) {
-        return py_array_from_vector(self.get_bins(ReflnDataProxy(r)));
+        return numpy_array_from_vector(self.get_bins(ReflnDataProxy(r)));
     })
-    .def("get_bins", [](Binner& self, py::array_t<int> hkl) {
-        self.ensure_limits_are_set();
-        auto h = hkl.unchecked<2>();
-        if (h.shape(1) != 3)
-          throw std::domain_error("the hkl array must have size N x 3");
-        auto len = h.shape(0);
-        int hint = 0;
-        py::array_t<int> arr(len);
-        int* ptr = (int*) arr.request().ptr;
-        for (int i = 0; i < len; ++i)
-          ptr[i] = self.get_bin_hinted({{h(i, 0), h(i, 1), h(i, 2)}}, hint);
-        return arr;
+    .def("get_bins", [](Binner& self, cpu_miller_array hkl) {
+        if (hkl.stride(1) != 1 || hkl.stride(0) < 3)
+          throw std::domain_error("hkl array must be contiguous");
+        struct {  // cf. MtzDataProxy
+          size_t size_;
+          size_t stride_;
+          int* data_;
+          size_t size() const noexcept { return size_; }
+          size_t stride() const noexcept { return stride_; }
+          Miller get_hkl(size_t offset) const noexcept {
+            return {data_[offset], data_[offset+1], data_[offset+2]};
+          }
+        } proxy{hkl.size(), (size_t) hkl.stride(0), hkl.data()};
+        return numpy_array_from_vector(self.get_bins(proxy));
     })
-    .def("get_bins_from_1_d2", [](Binner& self, py::array_t<double> inv_d2) {
-        self.ensure_limits_are_set();
-        auto v = inv_d2.unchecked<1>();
-        auto len = v.shape(0);
-        int hint = 0;
-        py::array_t<int> arr(len);
-        int* ptr = (int*) arr.request().ptr;
-        for (int i = 0; i < len; ++i)
-          ptr[i] = self.get_bin_from_1_d2_hinted(v(i), hint);
-        return arr;
+    .def("get_bins_from_1_d2", [](Binner& self, cpu_c_array<double> inv_d2) {
+        return numpy_array_from_vector(self.get_bins_from_1_d2(inv_d2.data(), inv_d2.shape(0)));
     })
     .def("dmin_of_bin", &Binner::dmin_of_bin)
     .def("dmax_of_bin", &Binner::dmax_of_bin)
-    .def_property_readonly("size", &Binner::size)
-    .def_readonly("limits", &Binner::limits)
-    .def_readwrite("cell", &Binner::cell)
-    .def_readonly("min_1_d2", &Binner::min_1_d2)
-    .def_readonly("max_1_d2", &Binner::max_1_d2)
+    .def_prop_ro("size", &Binner::size)
+    .def_ro("limits", &Binner::limits)
+    .def_rw("cell", &Binner::cell)
+    .def_ro("min_1_d2", &Binner::min_1_d2)
+    .def_ro("max_1_d2", &Binner::max_1_d2)
     ;
 
   m.def("combine_correlations", &combine_correlations);
@@ -338,32 +321,19 @@ void add_hkl(py::module& m) {
   m.def("calculate_amplitude_normalizers",
         [](const Mtz& mtz, const std::string& f_col, const Binner& binner) {
       const Mtz::Column& f = mtz.get_column_with_label(f_col);
-      return py_array_from_vector(
+      return numpy_array_from_vector(
           calculate_amplitude_normalizers(MtzDataProxy{mtz}, f.idx, binner));
   });
 
-  py::class_<HklMatch>(m, "HklMatch")
-    .def(py::init([](py::array_t<int, py::array::c_style> hkl,
-                     py::array_t<int, py::array::c_style> ref) {
-        auto hkl_ = hkl.unchecked<2>();
-        if (hkl_.shape(1) != 3)
-          throw std::domain_error("the hkl array must have size N x 3");
-        auto ref_ = ref.unchecked<2>();
-        if (ref_.shape(1) != 3)
-          throw std::domain_error("the ref array must have size N x 3");
-        return new HklMatch((Miller*)hkl.request().ptr, hkl.shape(0),
-                            (Miller*)ref.request().ptr, ref.shape(0));
-    }), py::arg("hkl"), py::arg("ref"))
-    .def("aligned", [](HklMatch& self, py::array_t<double> vec) {
-        auto v = vec.unchecked<1>();
-        if (v.shape(0) != (py::ssize_t) self.hkl_size)
-          fail("HklMatch.aligned(): wrong data, size differs");
-        py::array_t<double> result(self.pos.size());
-        double* ptr = (double*) result.request().ptr;
-        for (size_t i = 0; i != self.pos.size(); ++i)
-          ptr[i] = self.pos[i] >= 0 ? v(self.pos[i]) : NAN;
-        return result;
+  nb::class_<HklMatch>(m, "HklMatch")
+    .def("__init__", [](HklMatch* p, cpu_miller_array hkl, cpu_miller_array ref) {
+        static_assert(sizeof(Miller) == 3 * sizeof(int), "sizeof(Miller) problem");
+        new(p) HklMatch(static_cast<Miller*>((void*)hkl.data()), hkl.shape(0),
+                        static_cast<Miller*>((void*)ref.data()), ref.shape(0));
+    }, nb::arg("hkl"), nb::arg("ref"))
+    .def("aligned", [](HklMatch& self, cpu_c_array<double> vec) {
+        return numpy_array_from_vector(self.aligned_(vec.data(), vec.size(), (double)NAN));
     })
-    .def_readonly("pos", &HklMatch::pos)
+    .def_ro("pos", &HklMatch::pos)
     ;
 }
diff --git a/python/make_iterator.h b/python/make_iterator.h
new file mode 100644
index 000000000..b54a28a1a
--- /dev/null
+++ b/python/make_iterator.h
@@ -0,0 +1,9 @@
+#include <nanobind/make_iterator.h>
+
+// This wrapper simplifies the call to nb::make_iterator (by assuming
+// the name "iterator") and changes the default rv_policy to what it was
+// in pybind11 and nanobind<2.0.
+template<nb::rv_policy Policy = nb::rv_policy::reference_internal, typename S, typename T>
+auto usual_iterator(const S&, T& value) {
+  return nb::make_iterator<Policy>(nb::type<S>(), "iterator", value);
+}
diff --git a/python/meta.cpp b/python/meta.cpp
index 58e29bcf3..47fcfdd58 100644
--- a/python/meta.cpp
+++ b/python/meta.cpp
@@ -1,8 +1,10 @@
 // Copyright 2017 Global Phasing Ltd.
 
 #include "common.h"
-#include <pybind11/stl.h>
-#include <pybind11/stl_bind.h>
+#include <nanobind/operators.h>
+#include <nanobind/stl/bind_vector.h>
+#include <nanobind/stl/string.h>
+#include <nanobind/stl/vector.h>
 #include <ostream>
 
 #include "gemmi/seqid.hpp"
@@ -11,7 +13,6 @@
 #include "tostr.hpp"
 #include "meta.h"
 
-namespace py = pybind11;
 using namespace gemmi;
 
 namespace gemmi {
@@ -26,117 +27,85 @@ namespace gemmi {
   }
 }
 
-void add_meta(py::module& m) {
+void add_meta(nb::module_& m) {
 
   // seqid.hpp
 
-  py::class_<SeqId>(m, "SeqId")
-    .def(py::init<int, char>())
-    .def(py::init<const std::string&>())
-    .def_readwrite("num", &SeqId::num)
-    .def_readwrite("icode", &SeqId::icode)
+  nb::class_<SeqId>(m, "SeqId")
+    .def(nb::init<int, char>())
+    .def(nb::init<const std::string&>())
+    .def_rw("num", &SeqId::num, nb::arg().none())
+    .def_rw("icode", &SeqId::icode)
     .def("__str__", &SeqId::str)
     .def("__repr__", [](const SeqId& self) {
         return "<gemmi.SeqId " + self.str() + ">";
     })
-    .def(py::self == py::self)
-    .def(py::self < py::self)
-    .def(py::pickle(
-        [](const SeqId &self) {
-            return py::make_tuple(self.num, self.icode);
-        },
-        [](py::tuple t) {
-            if (t.size() != 2)
-                throw std::runtime_error("invalid tuple size");
-            return SeqId(t[0].cast<int>(), t[1].cast<char>());
-        }
-    ))
+    .def(nb::self == nb::self)
+    .def(nb::self < nb::self)
     .def("__hash__", [](const SeqId& self) {
-        return py::hash(py::make_tuple(self.num, self.icode));
-    });
+        // TODO: implement in hash<gemmi::SeqId> in seqid.hpp?
+        return nb::hash(nb::make_tuple(*self.num, self.icode));
+    })
+    ;
 
-  py::class_<ResidueId>(m, "ResidueId")
-    .def(py::init<>())
-    .def_readwrite("name", &ResidueId::name)
-    .def_readwrite("seqid", &ResidueId::seqid)
-    .def_readwrite("segment", &ResidueId::segment)
+  nb::class_<ResidueId>(m, "ResidueId")
+    .def(nb::init<>())
+    .def_rw("name", &ResidueId::name)
+    .def_rw("seqid", &ResidueId::seqid)
+    .def_rw("segment", &ResidueId::segment)
     .def("__str__", &ResidueId::str)
     .def("__repr__", [](const ResidueId& self) {
         return "<gemmi.ResidueId " + self.str() + ">";
     })
-    .def(py::self == py::self)
-    .def(py::pickle(
-        [](const ResidueId &self) {
-            return py::make_tuple(self.seqid, self.segment, self.name);
-        },
-        [](py::tuple t) {
-            if (t.size() != 3)
-                throw std::runtime_error("invalid tuple size");
-            ResidueId r;
-            r.seqid = t[0].cast<SeqId>();
-            r.segment = t[1].cast<std::string>();
-            r.name = t[2].cast<std::string>();
-            return r;
-        }
-    ));
-
+    .def(nb::self == nb::self)
+    ;
 
-  py::class_<AtomAddress>(m, "AtomAddress")
-    .def(py::init<>())
-    .def(py::init<const std::string&, const SeqId&, const std::string&,
+  nb::class_<AtomAddress>(m, "AtomAddress")
+    .def(nb::init<>())
+    .def(nb::init<const std::string&, const SeqId&, const std::string&,
                   const std::string&, char>(),
-         py::arg("chain"), py::arg("seqid"), py::arg("resname"),
-         py::arg("atom"), py::arg("altloc")='\0')
-    .def_readwrite("chain_name", &AtomAddress::chain_name)
-    .def_readwrite("res_id", &AtomAddress::res_id)
-    .def_readwrite("atom_name", &AtomAddress::atom_name)
-    .def_readwrite("altloc", &AtomAddress::altloc)
+         nb::arg("chain"), nb::arg("seqid"), nb::arg("resname"),
+         nb::arg("atom"), nb::arg("altloc")='\0')
+    .def_rw("chain_name", &AtomAddress::chain_name)
+    .def_rw("res_id", &AtomAddress::res_id)
+    .def_rw("atom_name", &AtomAddress::atom_name)
+    .def_rw("altloc", &AtomAddress::altloc)
     .def("__str__", &AtomAddress::str)
     .def("__repr__", [](const AtomAddress& self) {
         return cat("<gemmi.AtomAddress ", self.str(), '>');
     })
-    .def(py::self == py::self)
-    .def(py::pickle(
-        [](const AtomAddress &self) {
-            return py::make_tuple(self.chain_name, self.res_id, self.atom_name, self.altloc);
-        },
-        [](py::tuple t) {
-            if (t.size() != 4)
-                throw std::runtime_error("invalid tuple size");
-            return AtomAddress(t[0].cast<std::string>(), t[1].cast<ResidueId>(),
-                               t[2].cast<std::string>(), t[3].cast<char>());
-        }
-    ));
+    .def(nb::self == nb::self)
+    ;
+
   // metadata.hpp
 
-  py::class_<NcsOp>(m, "NcsOp")
-    .def(py::init<>())
-    .def(py::init([](const Transform& tr, const std::string& id, bool given) {
-      NcsOp* op = new NcsOp();
+  nb::class_<NcsOp>(m, "NcsOp")
+    .def(nb::init<>())
+    .def("__init__", [](NcsOp* op, const Transform& tr, const std::string& id, bool given) {
+      new(op) NcsOp;
       op->tr = tr;
       op->id = id;
       op->given = given;
-      return op;
-    }), py::arg("tr"), py::arg("id")="", py::arg("given")=false)
-    .def_readwrite("id", &NcsOp::id)
-    .def_readwrite("given", &NcsOp::given)
-    .def_readonly("tr", &NcsOp::tr)
+    }, nb::arg("tr"), nb::arg("id")="", nb::arg("given")=false)
+    .def_rw("id", &NcsOp::id)
+    .def_rw("given", &NcsOp::given)
+    .def_ro("tr", &NcsOp::tr)
     .def("apply", &NcsOp::apply)
     .def("__repr__", [](const NcsOp& self) {
         return tostr("<gemmi.NcsOp ", self.id,
                      " |shift|=", self.tr.vec.length(),
                      (self.given ? " (" : " (not "), "given)>");
     });
-  py::bind_vector<std::vector<NcsOp>>(m, "NcsOpList");
+  nb::bind_vector<std::vector<NcsOp>, rv_ri>(m, "NcsOpList");
 
-  py::enum_<EntityType>(m, "EntityType")
+  nb::enum_<EntityType>(m, "EntityType")
     .value("Unknown", EntityType::Unknown)
     .value("Polymer", EntityType::Polymer)
     .value("NonPolymer", EntityType::NonPolymer)
     .value("Branched", EntityType::Branched)
     .value("Water", EntityType::Water);
 
-  py::enum_<PolymerType>(m, "PolymerType")
+  nb::enum_<PolymerType>(m, "PolymerType")
     .value("PeptideL", PolymerType::PeptideL)
     .value("PeptideD", PolymerType::PeptideD)
     .value("Dna", PolymerType::Dna)
@@ -149,60 +118,60 @@ void add_meta(py::module& m) {
     .value("Other", PolymerType::Other)
     .value("Unknown", PolymerType::Unknown);
 
-  py::class_<Entity>(m, "Entity")
-    .def(py::init<std::string>())
-    .def_readwrite("name", &Entity::name)
-    .def_readwrite("subchains", &Entity::subchains)
-    .def_readwrite("entity_type", &Entity::entity_type)
-    .def_readwrite("polymer_type", &Entity::polymer_type)
-    .def_readwrite("sifts_unp_acc", &Entity::sifts_unp_acc)
-    .def_readwrite("full_sequence", &Entity::full_sequence)
+  nb::class_<Entity>(m, "Entity")
+    .def(nb::init<std::string>())
+    .def_rw("name", &Entity::name)
+    .def_rw("subchains", &Entity::subchains)
+    .def_rw("entity_type", &Entity::entity_type)
+    .def_rw("polymer_type", &Entity::polymer_type)
+    .def_rw("sifts_unp_acc", &Entity::sifts_unp_acc)
+    .def_rw("full_sequence", &Entity::full_sequence)
     .def_static("first_mon", &Entity::first_mon)
     .def("__repr__", [](const Entity& self) { return tostr(self); });
-  py::bind_vector<std::vector<Entity>>(m, "EntityList");
+  nb::bind_vector<std::vector<Entity>, rv_ri>(m, "EntityList");
 
-  py::enum_<Connection::Type>(m, "ConnectionType")
+  nb::enum_<Connection::Type>(m, "ConnectionType")
     .value("Covale", Connection::Type::Covale)
     .value("Disulf", Connection::Type::Disulf)
     .value("Hydrog", Connection::Type::Hydrog)
     .value("MetalC", Connection::Type::MetalC)
     .value("Unknown", Connection::Type::Unknown);
 
-  py::class_<Connection>(m, "Connection")
-    .def(py::init<>())
-    .def_readwrite("name", &Connection::name)
-    .def_readwrite("link_id", &Connection::link_id)
-    .def_readwrite("type", &Connection::type)
-    .def_readwrite("asu", &Connection::asu)
-    .def_readwrite("partner1", &Connection::partner1)
-    .def_readwrite("partner2", &Connection::partner2)
-    .def_readwrite("reported_distance", &Connection::reported_distance)
+  nb::class_<Connection>(m, "Connection")
+    .def(nb::init<>())
+    .def_rw("name", &Connection::name)
+    .def_rw("link_id", &Connection::link_id)
+    .def_rw("type", &Connection::type)
+    .def_rw("asu", &Connection::asu)
+    .def_rw("partner1", &Connection::partner1)
+    .def_rw("partner2", &Connection::partner2)
+    .def_rw("reported_distance", &Connection::reported_distance)
     .def("__repr__", [](const Connection& self) {
         return cat("<gemmi.Connection ", self.name, "  ",
                    self.partner1.str(), " - ", self.partner2.str(), '>');
     });
-  py::bind_vector<std::vector<Connection>>(m, "ConnectionList");
+  nb::bind_vector<std::vector<Connection>, rv_ri>(m, "ConnectionList");
 
-  py::class_<CisPep>(m, "CisPep")
-    .def(py::init<>())
-    .def_readwrite("partner_c", &CisPep::partner_c)
-    .def_readwrite("partner_n", &CisPep::partner_n)
-    .def_readwrite("model_str", &CisPep::model_str)
-    .def_readwrite("only_altloc", &CisPep::only_altloc)
-    .def_readwrite("reported_angle", &CisPep::reported_angle)
+  nb::class_<CisPep>(m, "CisPep")
+    .def(nb::init<>())
+    .def_rw("partner_c", &CisPep::partner_c)
+    .def_rw("partner_n", &CisPep::partner_n)
+    .def_rw("model_str", &CisPep::model_str)
+    .def_rw("only_altloc", &CisPep::only_altloc)
+    .def_rw("reported_angle", &CisPep::reported_angle)
     ;
 
-  py::class_<ModRes>(m, "ModRes")
-    .def(py::init<>())
-    .def_readwrite("chain_name", &ModRes::chain_name)
-    .def_readwrite("res_id", &ModRes::res_id)
-    .def_readwrite("parent_comp_id", &ModRes::parent_comp_id)
-    .def_readwrite("mod_id", &ModRes::mod_id)
-    .def_readwrite("details", &ModRes::details)
+  nb::class_<ModRes>(m, "ModRes")
+    .def(nb::init<>())
+    .def_rw("chain_name", &ModRes::chain_name)
+    .def_rw("res_id", &ModRes::res_id)
+    .def_rw("parent_comp_id", &ModRes::parent_comp_id)
+    .def_rw("mod_id", &ModRes::mod_id)
+    .def_rw("details", &ModRes::details)
     ;
 
-  py::class_<Helix> helix(m, "Helix");
-  py::enum_<Helix::HelixClass>(helix, "HelixClass")
+  nb::class_<Helix> helix(m, "Helix");
+  nb::enum_<Helix::HelixClass>(helix, "HelixClass")
     .value("UnknownHelix", Helix::HelixClass::UnknownHelix)
     .value("RAlpha", Helix::HelixClass::RAlpha)
     .value("ROmega", Helix::HelixClass::ROmega)
@@ -216,67 +185,67 @@ void add_meta(py::module& m) {
     .value("HelixPolyProlineNone", Helix::HelixClass::HelixPolyProlineNone);
 
   helix
-    .def(py::init<>())
-    .def_readwrite("start", &Helix::start)
-    .def_readwrite("end", &Helix::end)
-    .def_readwrite("pdb_helix_class", &Helix::pdb_helix_class)
-    .def_readwrite("length", &Helix::length);
-  py::bind_vector<std::vector<Helix>>(m, "HelixList");
+    .def(nb::init<>())
+    .def_rw("start", &Helix::start)
+    .def_rw("end", &Helix::end)
+    .def_rw("pdb_helix_class", &Helix::pdb_helix_class)
+    .def_rw("length", &Helix::length);
+  nb::bind_vector<std::vector<Helix>, rv_ri>(m, "HelixList");
 
-  py::class_<Sheet> sheet(m, "Sheet");
-  py::class_<Sheet::Strand>(sheet, "Strand")
-    .def(py::init<>())
-    .def_readwrite("start", &Sheet::Strand::start)
-    .def_readwrite("end", &Sheet::Strand::end)
-    .def_readwrite("hbond_atom2", &Sheet::Strand::hbond_atom2)
-    .def_readwrite("hbond_atom1", &Sheet::Strand::hbond_atom1)
-    .def_readwrite("sense", &Sheet::Strand::sense)
-    .def_readwrite("name", &Sheet::Strand::name);
-  py::bind_vector<std::vector<Sheet::Strand>>(sheet, "StrandList");
+  nb::class_<Sheet> sheet(m, "Sheet");
+  nb::class_<Sheet::Strand>(sheet, "Strand")
+    .def(nb::init<>())
+    .def_rw("start", &Sheet::Strand::start)
+    .def_rw("end", &Sheet::Strand::end)
+    .def_rw("hbond_atom2", &Sheet::Strand::hbond_atom2)
+    .def_rw("hbond_atom1", &Sheet::Strand::hbond_atom1)
+    .def_rw("sense", &Sheet::Strand::sense)
+    .def_rw("name", &Sheet::Strand::name);
+  nb::bind_vector<std::vector<Sheet::Strand>, rv_ri>(sheet, "StrandList");
 
   sheet
-    .def(py::init<std::string>())
-    .def_readwrite("name", &Sheet::name)
-    .def_readwrite("strands", &Sheet::strands);
-  py::bind_vector<std::vector<Sheet>>(m, "SheetList");
+    .def(nb::init<std::string>())
+    .def_rw("name", &Sheet::name)
+    .def_rw("strands", &Sheet::strands);
+  nb::bind_vector<std::vector<Sheet>, rv_ri>(m, "SheetList");
 
-  py::class_<Assembly> assembly(m, "Assembly");
-  py::class_<Assembly::Operator>(assembly, "Operator")
-    .def(py::init<>())
-    .def_readwrite("name", &Assembly::Operator::name)
-    .def_readwrite("type", &Assembly::Operator::type)
-    .def_readwrite("transform", &Assembly::Operator::transform);
-  py::bind_vector<std::vector<Assembly::Operator>>(assembly, "OperatorList");
+  nb::class_<Assembly> assembly(m, "Assembly");
+  nb::class_<Assembly::Operator>(assembly, "Operator")
+    .def(nb::init<>())
+    .def_rw("name", &Assembly::Operator::name)
+    .def_rw("type", &Assembly::Operator::type)
+    .def_rw("transform", &Assembly::Operator::transform);
+  nb::bind_vector<std::vector<Assembly::Operator>, rv_ri>(assembly, "OperatorList");
 
-  py::class_<Assembly::Gen>(assembly, "Gen")
-    .def(py::init<>())
-    .def_readwrite("chains", &Assembly::Gen::chains)
-    .def_readwrite("subchains", &Assembly::Gen::subchains)
-    .def_readonly("operators", &Assembly::Gen::operators);
-  py::bind_vector<std::vector<Assembly::Gen>>(assembly, "GenList");
+  nb::class_<Assembly::Gen>(assembly, "Gen")
+    .def(nb::init<>())
+    .def_rw("chains", &Assembly::Gen::chains)
+    .def_rw("subchains", &Assembly::Gen::subchains)
+    .def_ro("operators", &Assembly::Gen::operators);
+  nb::bind_vector<std::vector<Assembly::Gen>, rv_ri>(assembly, "GenList");
 
-  py::enum_<Assembly::SpecialKind>(m, "AssemblySpecialKind")
+  nb::enum_<Assembly::SpecialKind>(m, "AssemblySpecialKind")
     .value("NA", Assembly::SpecialKind::NA)
     .value("CompleteIcosahedral", Assembly::SpecialKind::CompleteIcosahedral)
     .value("RepresentativeHelical", Assembly::SpecialKind::RepresentativeHelical)
     .value("CompletePoint", Assembly::SpecialKind::CompletePoint);
 
   assembly
-    .def(py::init<const std::string&>())
-    .def_readwrite("name", &Assembly::name)
-    .def_readwrite("author_determined", &Assembly::author_determined)
-    .def_readwrite("software_determined", &Assembly::software_determined)
-    .def_readwrite("oligomeric_details", &Assembly::oligomeric_details)
-    .def_readonly("generators", &Assembly::generators)
-    .def_readwrite("special_kind", &Assembly::special_kind)
+    .def(nb::init<const std::string&>())
+    .def_rw("name", &Assembly::name)
+    .def_rw("author_determined", &Assembly::author_determined)
+    .def_rw("software_determined", &Assembly::software_determined)
+    .def_rw("oligomeric_details", &Assembly::oligomeric_details)
+    .def_ro("generators", &Assembly::generators)
+    .def_rw("special_kind", &Assembly::special_kind)
     .def("__repr__", [](const Assembly& self) {
         return cat("<gemmi.Assembly ", self.name, ">");
     });
     ;
-  py::bind_vector<std::vector<Assembly>>(m, "AssemblyList");
+  nb::bind_vector<std::vector<Assembly>, rv_ri>(m, "AssemblyList");
 
-  py::class_<SoftwareItem> softitem(m, "SoftwareItem");
-  py::enum_<SoftwareItem::Classification>(softitem, "Classification")
+  nb::class_<SoftwareItem> softitem(m, "SoftwareItem");
+  nb::enum_<SoftwareItem::Classification>(softitem, "Classification")
     .value("DataCollection", SoftwareItem::Classification::DataCollection)
     .value("DataExtraction", SoftwareItem::Classification::DataExtraction)
     .value("DataProcessing", SoftwareItem::Classification::DataProcessing)
@@ -288,124 +257,124 @@ void add_meta(py::module& m) {
     .value("Unspecified", SoftwareItem::Classification::Unspecified)
     ;
   softitem
-    .def(py::init<>())
-    .def_readwrite("name", &SoftwareItem::name)
-    .def_readwrite("version", &SoftwareItem::version)
-    .def_readwrite("date", &SoftwareItem::date)
-    .def_readwrite("classification", &SoftwareItem::classification)
-    .def_readwrite("contact_author", &SoftwareItem::contact_author)
-    .def_readwrite("contact_author_email", &SoftwareItem::contact_author_email)
+    .def(nb::init<>())
+    .def_rw("name", &SoftwareItem::name)
+    .def_rw("version", &SoftwareItem::version)
+    .def_rw("date", &SoftwareItem::date)
+    .def_rw("classification", &SoftwareItem::classification)
+    .def_rw("contact_author", &SoftwareItem::contact_author)
+    .def_rw("contact_author_email", &SoftwareItem::contact_author_email)
     ;
-  py::class_<ReflectionsInfo>(m, "ReflectionsInfo")
-    .def(py::init<>())
-    .def_readwrite("resolution_high", &ReflectionsInfo::resolution_high)
-    .def_readwrite("resolution_low", &ReflectionsInfo::resolution_low)
-    .def_readwrite("completeness", &ReflectionsInfo::completeness)
-    .def_readwrite("redundancy", &ReflectionsInfo::redundancy)
-    .def_readwrite("r_merge", &ReflectionsInfo::r_merge)
-    .def_readwrite("r_sym", &ReflectionsInfo::r_sym)
-    .def_readwrite("mean_I_over_sigma", &ReflectionsInfo::mean_I_over_sigma)
+  nb::class_<ReflectionsInfo>(m, "ReflectionsInfo")
+    .def(nb::init<>())
+    .def_rw("resolution_high", &ReflectionsInfo::resolution_high)
+    .def_rw("resolution_low", &ReflectionsInfo::resolution_low)
+    .def_rw("completeness", &ReflectionsInfo::completeness)
+    .def_rw("redundancy", &ReflectionsInfo::redundancy)
+    .def_rw("r_merge", &ReflectionsInfo::r_merge)
+    .def_rw("r_sym", &ReflectionsInfo::r_sym)
+    .def_rw("mean_I_over_sigma", &ReflectionsInfo::mean_I_over_sigma)
     ;
-  py::class_<ExperimentInfo>(m, "ExperimentInfo")
-    .def(py::init<>())
-    .def_readwrite("method", &ExperimentInfo::method)
-    .def_readwrite("number_of_crystals", &ExperimentInfo::number_of_crystals)
-    .def_readwrite("unique_reflections", &ExperimentInfo::unique_reflections)
-    .def_readwrite("reflections", &ExperimentInfo::reflections)
-    .def_readwrite("b_wilson", &ExperimentInfo::b_wilson)
-    .def_readwrite("shells", &ExperimentInfo::shells)
-    .def_readwrite("diffraction_ids", &ExperimentInfo::diffraction_ids)
+  nb::class_<ExperimentInfo>(m, "ExperimentInfo")
+    .def(nb::init<>())
+    .def_rw("method", &ExperimentInfo::method)
+    .def_rw("number_of_crystals", &ExperimentInfo::number_of_crystals)
+    .def_rw("unique_reflections", &ExperimentInfo::unique_reflections)
+    .def_rw("reflections", &ExperimentInfo::reflections)
+    .def_rw("b_wilson", &ExperimentInfo::b_wilson)
+    .def_rw("shells", &ExperimentInfo::shells)
+    .def_rw("diffraction_ids", &ExperimentInfo::diffraction_ids)
     ;
-  py::class_<DiffractionInfo>(m, "DiffractionInfo")
-    .def(py::init<>())
-    .def_readwrite("id", &DiffractionInfo::id)
-    .def_readwrite("temperature", &DiffractionInfo::temperature)
-    .def_readwrite("source", &DiffractionInfo::source)
-    .def_readwrite("source_type", &DiffractionInfo::source_type)
-    .def_readwrite("synchrotron", &DiffractionInfo::synchrotron)
-    .def_readwrite("beamline", &DiffractionInfo::beamline)
-    .def_readwrite("wavelengths", &DiffractionInfo::wavelengths)
-    .def_readwrite("scattering_type", &DiffractionInfo::scattering_type)
-    .def_readwrite("mono_or_laue", &DiffractionInfo::mono_or_laue)
-    .def_readwrite("monochromator", &DiffractionInfo::monochromator)
-    .def_readwrite("collection_date", &DiffractionInfo::collection_date)
-    .def_readwrite("optics", &DiffractionInfo::optics)
-    .def_readwrite("detector", &DiffractionInfo::detector)
-    .def_readwrite("detector_make", &DiffractionInfo::detector_make)
+  nb::class_<DiffractionInfo>(m, "DiffractionInfo")
+    .def(nb::init<>())
+    .def_rw("id", &DiffractionInfo::id)
+    .def_rw("temperature", &DiffractionInfo::temperature)
+    .def_rw("source", &DiffractionInfo::source)
+    .def_rw("source_type", &DiffractionInfo::source_type)
+    .def_rw("synchrotron", &DiffractionInfo::synchrotron)
+    .def_rw("beamline", &DiffractionInfo::beamline)
+    .def_rw("wavelengths", &DiffractionInfo::wavelengths)
+    .def_rw("scattering_type", &DiffractionInfo::scattering_type)
+    .def_rw("mono_or_laue", &DiffractionInfo::mono_or_laue)
+    .def_rw("monochromator", &DiffractionInfo::monochromator)
+    .def_rw("collection_date", &DiffractionInfo::collection_date)
+    .def_rw("optics", &DiffractionInfo::optics)
+    .def_rw("detector", &DiffractionInfo::detector)
+    .def_rw("detector_make", &DiffractionInfo::detector_make)
     ;
-  py::class_<CrystalInfo>(m, "CrystalInfo")
-    .def(py::init<>())
-    .def_readwrite("id", &CrystalInfo::id)
-    .def_readwrite("description", &CrystalInfo::description)
-    .def_readwrite("ph", &CrystalInfo::ph)
-    .def_readwrite("ph_range", &CrystalInfo::ph_range)
-    .def_readwrite("diffractions", &CrystalInfo::diffractions)
+  nb::class_<CrystalInfo>(m, "CrystalInfo")
+    .def(nb::init<>())
+    .def_rw("id", &CrystalInfo::id)
+    .def_rw("description", &CrystalInfo::description)
+    .def_rw("ph", &CrystalInfo::ph)
+    .def_rw("ph_range", &CrystalInfo::ph_range)
+    .def_rw("diffractions", &CrystalInfo::diffractions)
     ;
-  py::class_<TlsGroup> tlsgroup(m, "TlsGroup");
-  py::class_<TlsGroup::Selection>(tlsgroup, "Selection")
-    .def(py::init<>())
-    .def_readwrite("chain", &TlsGroup::Selection::chain)
-    .def_readwrite("res_begin", &TlsGroup::Selection::res_begin)
-    .def_readwrite("res_end", &TlsGroup::Selection::res_end)
-    .def_readwrite("details", &TlsGroup::Selection::details)
+  nb::class_<TlsGroup> tlsgroup(m, "TlsGroup");
+  nb::class_<TlsGroup::Selection>(tlsgroup, "Selection")
+    .def(nb::init<>())
+    .def_rw("chain", &TlsGroup::Selection::chain)
+    .def_rw("res_begin", &TlsGroup::Selection::res_begin)
+    .def_rw("res_end", &TlsGroup::Selection::res_end)
+    .def_rw("details", &TlsGroup::Selection::details)
     ;
   tlsgroup
-    .def(py::init<>())
-    .def_readwrite("id", &TlsGroup::id)
-    .def_readwrite("selections", &TlsGroup::selections)
-    .def_readwrite("origin", &TlsGroup::origin)
-    .def_readwrite("T", &TlsGroup::T)
-    .def_readwrite("L", &TlsGroup::L)
-    .def_readwrite("S", &TlsGroup::S)
+    .def(nb::init<>())
+    .def_rw("id", &TlsGroup::id)
+    .def_rw("selections", &TlsGroup::selections)
+    .def_rw("origin", &TlsGroup::origin)
+    .def_rw("T", &TlsGroup::T)
+    .def_rw("L", &TlsGroup::L)
+    .def_rw("S", &TlsGroup::S)
     ;
-  py::class_<BasicRefinementInfo>(m, "BasicRefinementInfo")
-    .def(py::init<>())
-    .def_readwrite("resolution_high", &BasicRefinementInfo::resolution_high)
-    .def_readwrite("resolution_low", &BasicRefinementInfo::resolution_low)
-    .def_readwrite("completeness", &BasicRefinementInfo::completeness)
-    .def_readwrite("reflection_count", &BasicRefinementInfo::reflection_count)
-    .def_readwrite("rfree_set_count", &BasicRefinementInfo::rfree_set_count)
-    .def_readwrite("r_all", &BasicRefinementInfo::r_all)
-    .def_readwrite("r_work", &BasicRefinementInfo::r_work)
-    .def_readwrite("r_free", &BasicRefinementInfo::r_free)
+  nb::class_<BasicRefinementInfo>(m, "BasicRefinementInfo")
+    .def(nb::init<>())
+    .def_rw("resolution_high", &BasicRefinementInfo::resolution_high)
+    .def_rw("resolution_low", &BasicRefinementInfo::resolution_low)
+    .def_rw("completeness", &BasicRefinementInfo::completeness)
+    .def_rw("reflection_count", &BasicRefinementInfo::reflection_count)
+    .def_rw("rfree_set_count", &BasicRefinementInfo::rfree_set_count)
+    .def_rw("r_all", &BasicRefinementInfo::r_all)
+    .def_rw("r_work", &BasicRefinementInfo::r_work)
+    .def_rw("r_free", &BasicRefinementInfo::r_free)
     ;
-  py::class_<RefinementInfo, BasicRefinementInfo> refinfo(m, "RefinementInfo");
-  py::class_<RefinementInfo::Restr>(refinfo, "Restr")
-    .def(py::init<const std::string&>())
-    .def_readwrite("name", &RefinementInfo::Restr::name)
-    .def_readwrite("count", &RefinementInfo::Restr::count)
-    .def_readwrite("weight", &RefinementInfo::Restr::weight)
-    .def_readwrite("function", &RefinementInfo::Restr::function)
-    .def_readwrite("dev_ideal", &RefinementInfo::Restr::dev_ideal)
+  nb::class_<RefinementInfo, BasicRefinementInfo> refinfo(m, "RefinementInfo");
+  nb::class_<RefinementInfo::Restr>(refinfo, "Restr")
+    .def(nb::init<const std::string&>())
+    .def_rw("name", &RefinementInfo::Restr::name)
+    .def_rw("count", &RefinementInfo::Restr::count)
+    .def_rw("weight", &RefinementInfo::Restr::weight)
+    .def_rw("function", &RefinementInfo::Restr::function)
+    .def_rw("dev_ideal", &RefinementInfo::Restr::dev_ideal)
     ;
   refinfo
-    .def(py::init<>())
-    .def_readwrite("id", &RefinementInfo::id)
-    .def_readwrite("cross_validation_method", &RefinementInfo::cross_validation_method)
-    .def_readwrite("rfree_selection_method", &RefinementInfo::rfree_selection_method)
-    .def_readwrite("bin_count", &RefinementInfo::bin_count)
-    .def_readwrite("bins", &RefinementInfo::bins)
-    .def_readwrite("mean_b", &RefinementInfo::mean_b)
-    .def_readwrite("aniso_b", &RefinementInfo::aniso_b)
-    .def_readwrite("luzzati_error", &RefinementInfo::luzzati_error)
-    .def_readwrite("dpi_blow_r", &RefinementInfo::dpi_blow_r)
-    .def_readwrite("dpi_blow_rfree", &RefinementInfo::dpi_blow_rfree)
-    .def_readwrite("dpi_cruickshank_r", &RefinementInfo::dpi_cruickshank_r)
-    .def_readwrite("dpi_cruickshank_rfree", &RefinementInfo::dpi_cruickshank_rfree)
-    .def_readwrite("cc_fo_fc", &RefinementInfo::cc_fo_fc)
-    .def_readwrite("cc_fo_fc_free", &RefinementInfo::cc_fo_fc_free)
-    .def_readwrite("restr_stats", &RefinementInfo::restr_stats)
-    .def_readwrite("tls_groups", &RefinementInfo::tls_groups)
-    .def_readwrite("remarks", &RefinementInfo::remarks)
+    .def(nb::init<>())
+    .def_rw("id", &RefinementInfo::id)
+    .def_rw("cross_validation_method", &RefinementInfo::cross_validation_method)
+    .def_rw("rfree_selection_method", &RefinementInfo::rfree_selection_method)
+    .def_rw("bin_count", &RefinementInfo::bin_count)
+    .def_rw("bins", &RefinementInfo::bins)
+    .def_rw("mean_b", &RefinementInfo::mean_b)
+    .def_rw("aniso_b", &RefinementInfo::aniso_b)
+    .def_rw("luzzati_error", &RefinementInfo::luzzati_error)
+    .def_rw("dpi_blow_r", &RefinementInfo::dpi_blow_r)
+    .def_rw("dpi_blow_rfree", &RefinementInfo::dpi_blow_rfree)
+    .def_rw("dpi_cruickshank_r", &RefinementInfo::dpi_cruickshank_r)
+    .def_rw("dpi_cruickshank_rfree", &RefinementInfo::dpi_cruickshank_rfree)
+    .def_rw("cc_fo_fc", &RefinementInfo::cc_fo_fc)
+    .def_rw("cc_fo_fc_free", &RefinementInfo::cc_fo_fc_free)
+    .def_rw("restr_stats", &RefinementInfo::restr_stats)
+    .def_rw("tls_groups", &RefinementInfo::tls_groups)
+    .def_rw("remarks", &RefinementInfo::remarks)
     ;
-  py::class_<Metadata>(m, "Metadata")
-    .def_readwrite("authors", &Metadata::authors)
-    //.def_readwrite("experiments", &Metadata::experiments)
-    //.def_readwrite("crystals", &Metadata::crystals)
-    .def_readwrite("refinement", &Metadata::refinement)
-    .def_readwrite("software", &Metadata::software)
-    //.def_readwrite("solved_by", &Metadata::solved_by)
-    //.def_readwrite("starting_model", &Metadata::starting_model)
-    //.def_readwrite("remark_300_detail", &Metadata::remark_300_detail)
+  nb::class_<Metadata>(m, "Metadata")
+    .def_rw("authors", &Metadata::authors)
+    //.def_rw("experiments", &Metadata::experiments)
+    //.def_rw("crystals", &Metadata::crystals)
+    .def_rw("refinement", &Metadata::refinement)
+    .def_rw("software", &Metadata::software)
+    //.def_rw("solved_by", &Metadata::solved_by)
+    //.def_rw("starting_model", &Metadata::starting_model)
+    //.def_rw("remark_300_detail", &Metadata::remark_300_detail)
     ;
 }
diff --git a/python/meta.h b/python/meta.h
index 2ecec0be5..b4bbf156e 100644
--- a/python/meta.h
+++ b/python/meta.h
@@ -3,18 +3,38 @@ namespace gemmi {
   std::ostream& operator<< (std::ostream& os, const Entity& ent);
 }
 
-namespace pybind11 { namespace detail {
-  template<> struct type_caster<gemmi::SeqId::OptionalNum>
-    : optional_caster<gemmi::SeqId::OptionalNum> {};
-}} // namespace pybind11::detail
+namespace nanobind { namespace detail {
+  template<> struct type_caster<gemmi::SeqId::OptionalNum> {
+    NB_TYPE_CASTER(gemmi::SeqId::OptionalNum, optional_name(const_name("int")))
+    using Caster =  make_caster<int>;
 
-PYBIND11_MAKE_OPAQUE(std::vector<gemmi::Helix>)
-PYBIND11_MAKE_OPAQUE(std::vector<gemmi::Sheet>)
-PYBIND11_MAKE_OPAQUE(std::vector<gemmi::Sheet::Strand>)
-PYBIND11_MAKE_OPAQUE(std::vector<gemmi::Assembly::Gen>)
-PYBIND11_MAKE_OPAQUE(std::vector<gemmi::Assembly::Operator>)
-PYBIND11_MAKE_OPAQUE(std::vector<gemmi::Assembly>)
+    bool from_python(handle src, uint8_t flags, cleanup_list* cleanup) noexcept {
+      if (src.is_none()) {
+        value = Value();
+        return true;
+      }
+      Caster caster;
+      if (!caster.from_python(src, flags_for_local_caster<int>(flags), cleanup))
+        return false;
+      value = caster.operator cast_t<int>();
+      return true;
+    }
 
-PYBIND11_MAKE_OPAQUE(std::vector<gemmi::Connection>)
-PYBIND11_MAKE_OPAQUE(std::vector<gemmi::NcsOp>)
-PYBIND11_MAKE_OPAQUE(std::vector<gemmi::Entity>)
+    static handle from_cpp(Value value, rv_policy policy, cleanup_list *cleanup) noexcept {
+      if (!value)
+        return none().release();
+      return Caster::from_cpp(*value, policy, cleanup);
+    }
+  };
+}} // namespace nanobind::detail
+
+NB_MAKE_OPAQUE(std::vector<gemmi::Helix>)
+NB_MAKE_OPAQUE(std::vector<gemmi::Sheet>)
+NB_MAKE_OPAQUE(std::vector<gemmi::Sheet::Strand>)
+NB_MAKE_OPAQUE(std::vector<gemmi::Assembly::Gen>)
+NB_MAKE_OPAQUE(std::vector<gemmi::Assembly::Operator>)
+NB_MAKE_OPAQUE(std::vector<gemmi::Assembly>)
+
+NB_MAKE_OPAQUE(std::vector<gemmi::Connection>)
+NB_MAKE_OPAQUE(std::vector<gemmi::NcsOp>)
+NB_MAKE_OPAQUE(std::vector<gemmi::Entity>)
diff --git a/python/miller_a.h b/python/miller_a.h
deleted file mode 100644
index 1f0b76cb9..000000000
--- a/python/miller_a.h
+++ /dev/null
@@ -1,16 +0,0 @@
-
-#include <pybind11/numpy.h>
-
-template<typename Ret, typename Obj, typename Func>
-pybind11::array_t<Ret>
-miller_function(const Obj& obj, Func func, pybind11::array_t<int> hkl) {
-  auto h = hkl.unchecked<2>();
-  if (h.shape(1) != 3)
-    throw std::domain_error("error: the size of the second dimension != 3");
-  auto result = pybind11::array_t<Ret>(h.shape(0));
-  pybind11::buffer_info rbuf = result.request();
-  Ret* rptr = (Ret*) rbuf.ptr;
-  for (pybind11::ssize_t i = 0; i < h.shape(0); ++i)
-    rptr[i] = (obj.*func)({{h(i, 0), h(i, 1), h(i, 2)}});
-  return result;
-}
diff --git a/python/mol.cpp b/python/mol.cpp
index 983cb27d4..2c0398a92 100644
--- a/python/mol.cpp
+++ b/python/mol.cpp
@@ -9,15 +9,18 @@
 #include "gemmi/sprintf.hpp"    // for snprintf_z
 
 #include "common.h"
-#include <pybind11/stl.h>
-#include <pybind11/stl_bind.h>
+#include "serial.h"  // for getstate, setstate
+#include "make_iterator.h"
+#include <nanobind/stl/bind_map.h>
+#include <nanobind/stl/array.h>  // for calculate_phi_psi, find_best_plane, ...
+#include <nanobind/stl/string.h>
+#include <nanobind/stl/vector.h>
 #include "meta.h"
 
-namespace py = pybind11;
 using namespace gemmi;
 
 using info_map_type = std::map<std::string, std::string>;
-PYBIND11_MAKE_OPAQUE(info_map_type)
+NB_MAKE_OPAQUE(info_map_type)
 
 template<typename T, typename C>
 C& add_item(T& container, C child, int pos) {
@@ -46,23 +49,23 @@ template<typename P> void remove_child(P& parent, int index) {
   children.erase(children.begin() + normalize_index(index, children));
 }
 
-template<typename P> void remove_children(P& parent, py::slice slice) {
+template<typename P> void remove_children(P& parent, nb::slice slice) {
   delitem_slice(parent.children(), slice);
 }
 
-void add_mol(py::module& m) {
+void add_mol(nb::module_& m) {
 
   // "Forward declaration" of python classes to avoid
   // C++ signatures in docstrings
-  py::class_<Atom> pyAtom(m, "Atom");
-  py::class_<Residue, ResidueId> pyResidue(m, "Residue");
-  py::class_<Chain> pyChain(m, "Chain");
-  py::class_<Model> pyModel(m, "Model");
-  py::class_<ResidueSpan> pyResidueSpan(m, "ResidueSpan");
-  py::class_<ResidueGroup, ResidueSpan> pyResidueGroup(m, "ResidueGroup");
-  py::class_<Selection> pySelection(m, "Selection");
-
-  py::enum_<HowToNameCopiedChain>(m, "HowToNameCopiedChain")
+  nb::class_<Atom> pyAtom(m, "Atom");
+  nb::class_<Residue, ResidueId> pyResidue(m, "Residue");
+  nb::class_<Chain> pyChain(m, "Chain");
+  nb::class_<Model> pyModel(m, "Model");
+  nb::class_<ResidueSpan> pyResidueSpan(m, "ResidueSpan");
+  nb::class_<ResidueGroup, ResidueSpan> pyResidueGroup(m, "ResidueGroup");
+  nb::class_<Selection> pySelection(m, "Selection");
+
+  nb::enum_<HowToNameCopiedChain>(m, "HowToNameCopiedChain")
     .value("Short", HowToNameCopiedChain::Short)
     .value("AddNumber", HowToNameCopiedChain::AddNumber)
     .value("Dup", HowToNameCopiedChain::Dup)
@@ -70,7 +73,7 @@ void add_mol(py::module& m) {
 
   m.def("make_address", &make_address);
 
-  py::enum_<CoorFormat>(m, "CoorFormat")
+  nb::enum_<CoorFormat>(m, "CoorFormat")
     .value("Unknown", CoorFormat::Unknown)
     .value("Detect", CoorFormat::Detect)
     .value("Pdb", CoorFormat::Pdb)
@@ -78,12 +81,12 @@ void add_mol(py::module& m) {
     .value("Mmjson", CoorFormat::Mmjson)
     .value("ChemComp", CoorFormat::ChemComp);
 
-  py::bind_map<info_map_type>(m, "InfoMap");
+  nb::bind_map<info_map_type>(m, "InfoMap");
 
-  py::class_<CRA>(m, "CRA")
-    .def_readonly("chain", &CRA::chain)
-    .def_readonly("residue", &CRA::residue)
-    .def_readonly("atom", &CRA::atom)
+  nb::class_<CRA>(m, "CRA")
+    .def_ro("chain", &CRA::chain)
+    .def_ro("residue", &CRA::residue)
+    .def_ro("atom", &CRA::atom)
     .def("atom_matches", [](const CRA& self, const AtomAddress& addr) {
         return atom_matches(self, addr);
     })
@@ -92,87 +95,86 @@ void add_mol(py::module& m) {
         return cat("<gemmi.CRA ", atom_str(self), '>');
     });
 
-  py::class_<CraProxy>(m, "CraGenerator")
-    .def("__iter__", [](CraProxy& self) { return py::make_iterator(self); },
-         py::keep_alive<0, 1>());
+  nb::class_<CraProxy>(m, "CraGenerator")
+    .def("__iter__", [](CraProxy& self) { return usual_iterator(self, self); },
+         nb::keep_alive<0, 1>());
 
-  py::class_<Structure> structure(m, "Structure");
+  nb::class_<Structure> structure(m, "Structure");
   structure
-    .def(py::init<>())
-    .def_readwrite("name", &Structure::name)
-    .def_readwrite("cell", &Structure::cell)
-    .def_readwrite("spacegroup_hm", &Structure::spacegroup_hm)
-    .def_readwrite("ncs", &Structure::ncs)
-    .def_readwrite("resolution", &Structure::resolution)
-    .def_readwrite("input_format", &Structure::input_format)
-    .def_readwrite("entities", &Structure::entities)
-    .def_readwrite("connections", &Structure::connections)
-    .def_readwrite("cispeps", &Structure::cispeps)
-    .def_readwrite("mod_residues", &Structure::mod_residues)
-    .def_readwrite("helices", &Structure::helices)
-    .def_readwrite("sheets", &Structure::sheets)
-    .def_readwrite("assemblies", &Structure::assemblies)
-    .def_readwrite("meta", &Structure::meta)
-    .def_readwrite("has_d_fraction", &Structure::has_d_fraction)
-    .def_readwrite("has_origx", &Structure::has_origx)
-    .def_readonly("origx", &Structure::origx)
-    .def_readwrite("info", &Structure::info)
-    .def_readwrite("raw_remarks", &Structure::raw_remarks)
-    .def("find_spacegroup", &Structure::find_spacegroup, py::return_value_policy::reference)
+    .def(nb::init<>())
+    .def_rw("name", &Structure::name)
+    .def_rw("cell", &Structure::cell)
+    .def_rw("spacegroup_hm", &Structure::spacegroup_hm)
+    .def_rw("ncs", &Structure::ncs)
+    .def_rw("resolution", &Structure::resolution)
+    .def_rw("input_format", &Structure::input_format)
+    .def_rw("entities", &Structure::entities)
+    .def_rw("connections", &Structure::connections)
+    .def_rw("cispeps", &Structure::cispeps)
+    .def_rw("mod_residues", &Structure::mod_residues)
+    .def_rw("helices", &Structure::helices)
+    .def_rw("sheets", &Structure::sheets)
+    .def_rw("assemblies", &Structure::assemblies)
+    .def_rw("meta", &Structure::meta)
+    .def_rw("has_d_fraction", &Structure::has_d_fraction)
+    .def_rw("has_origx", &Structure::has_origx)
+    .def_ro("origx", &Structure::origx)
+    .def_rw("info", &Structure::info)
+    .def_rw("raw_remarks", &Structure::raw_remarks)
+    .def("find_spacegroup", &Structure::find_spacegroup, nb::rv_policy::reference)
     .def("get_entity",
          (Entity* (Structure::*)(const std::string&)) &Structure::get_entity,
-         py::arg("subchain"), py::return_value_policy::reference_internal)
+         nb::arg("subchain"), nb::rv_policy::reference_internal)
     .def("get_entity_of", [](Structure& st, ResidueSpan& span) {
         return st.get_entity_of(span);
-    }, py::arg("subchain"), py::return_value_policy::reference_internal)
+    }, nb::arg("subchain"), nb::rv_policy::reference_internal)
     .def("__len__", [](const Structure& st) { return st.models.size(); })
-    .def("__iter__", [](const Structure& st) {
-        return py::make_iterator(st.models);
-    }, py::keep_alive<0, 1>())
-    .def("__getitem__", &get_child<Structure, Model>, py::arg("index"),
-         py::return_value_policy::reference_internal)
+    .def("__iter__", [](Structure& st) { return usual_iterator(st, st.models); },
+         nb::keep_alive<0, 1>())
+    .def("__getitem__", &get_child<Structure, Model>, nb::arg("index"),
+         nb::rv_policy::reference_internal)
     .def("__getitem__", [](Structure& st, const std::string& name) -> Model& {
         return *impl::find_iter(st.models, name);
-    }, py::arg("name"), py::return_value_policy::reference_internal)
-    .def("__delitem__", &remove_child<Structure>, py::arg("index"))
+    }, nb::arg("name"), nb::rv_policy::reference_internal)
+    .def("__delitem__", &remove_child<Structure>, nb::arg("index"))
     .def("__delitem__", &remove_children<Structure>)
-    .def("__delitem__", &Structure::remove_model, py::arg("name"))
+    .def("__delitem__", &Structure::remove_model, nb::arg("name"))
     .def("__setitem__", &set_child<Structure, Model>)
     .def("find_connection_by_cra", [](Structure& st, CRA cra1, CRA cra2, bool ignore_segment) {
         return st.find_connection_by_cra(cra1, cra2, ignore_segment);
-    }, py::arg("cra1"), py::arg("cra2"), py::arg("ignore_segment")=false,
-       py::return_value_policy::reference_internal)
+    }, nb::arg("cra1"), nb::arg("cra2"), nb::arg("ignore_segment")=false,
+       nb::rv_policy::reference_internal)
     .def("find_connection", &Structure::find_connection,
-         py::arg("partner1"), py::arg("partner2"),
-         py::return_value_policy::reference_internal)
+         nb::arg("partner1"), nb::arg("partner2"),
+         nb::rv_policy::reference_internal)
     .def("find_or_add_model", &Structure::find_or_add_model,
-         py::arg("name"), py::return_value_policy::reference_internal)
+         nb::arg("name"), nb::rv_policy::reference_internal)
     .def("add_model", add_child<Structure, Model>,
-         py::arg("model"), py::arg("pos")=-1,
-         py::return_value_policy::reference_internal)
+         nb::arg("model"), nb::arg("pos")=-1,
+         nb::rv_policy::reference_internal)
     .def("renumber_models", &Structure::renumber_models)
     .def("merge_chain_parts", &Structure::merge_chain_parts,
-         py::arg("min_sep")=0)
+         nb::arg("min_sep")=0)
     .def("remove_empty_chains", &Structure::remove_empty_chains)
     .def("setup_cell_images", &Structure::setup_cell_images)
     .def("add_entity_types", (void (*)(Structure&, bool)) &add_entity_types,
-         py::arg("overwrite")=false)
+         nb::arg("overwrite")=false)
     .def("add_entity_ids", &add_entity_ids,
-         py::arg("overwrite")=false)
+         nb::arg("overwrite")=false)
     .def("add_conect", &Structure::add_conect,
-         py::arg("serial1"), py::arg("serial2"), py::arg("order"))
+         nb::arg("serial1"), nb::arg("serial2"), nb::arg("order"))
     .def("clear_conect", [](Structure& self) { self.conect_map.clear(); })
     .def("assign_subchains", &assign_subchains,
-         py::arg("force")=false, py::arg("fail_if_unknown")=true)
+         nb::arg("force")=false, nb::arg("fail_if_unknown")=true)
     .def("ensure_entities", &ensure_entities)
     .def("deduplicate_entities", &deduplicate_entities)
     .def("setup_entities", &setup_entities)
-    .def("assign_het_flags", assign_het_flags<Structure>, py::arg("flag")='R')
+    .def("assign_het_flags", assign_het_flags<Structure>, nb::arg("flag")='R')
     .def("remove_waters", remove_waters<Structure>)
     .def("remove_ligands_and_waters", remove_ligands_and_waters<Structure>)
     .def("shorten_ccd_codes", &shorten_ccd_codes)
     .def("restore_full_ccd_codes", &restore_full_ccd_codes)
-    .def_readwrite("shortened_ccd_codes", &Structure::shortened_ccd_codes)
+    .def_rw("shortened_ccd_codes", &Structure::shortened_ccd_codes)
 
     // modify.hpp
     .def("remove_alternative_conformations",
@@ -181,24 +183,26 @@ void add_mol(py::module& m) {
     .def("store_deuterium_as_fraction", &store_deuterium_as_fraction)
     .def("standardize_crystal_frame", &standardize_crystal_frame)
     .def("assign_serial_numbers", (void (*)(Structure&, bool)) &assign_serial_numbers,
-         py::arg("numbered_ter")=false)
+         nb::arg("numbered_ter")=false)
     .def("rename_chain", &rename_chain)
     .def("rename_residues", &rename_residues)
     // assembly.hpp
     .def("shorten_chain_names", &shorten_chain_names)
-    .def("expand_ncs", &expand_ncs, py::arg("how"), py::arg("merge_dist")=0.2)
+    .def("expand_ncs", &expand_ncs, nb::arg("how"), nb::arg("merge_dist")=0.2)
     .def("transform_to_assembly",
          [](Structure& st, const std::string& assembly_name, HowToNameCopiedChain how,
             bool keep_spacegroup, double merge_dist) {
         return transform_to_assembly(st, assembly_name, how, nullptr,
                                      keep_spacegroup, merge_dist);
-    }, py::arg("assembly_name"), py::arg("how"), py::arg("keep_spacegroup")=false,
-       py::arg("merge_dist")=0.2)
+    }, nb::arg("assembly_name"), nb::arg("how"), nb::arg("keep_spacegroup")=false,
+       nb::arg("merge_dist")=0.2)
     // calculate.hpp
-    .def("calculate_box", &calculate_box, py::arg("margin")=0.)
-    .def("calculate_fractional_box", &calculate_fractional_box, py::arg("margin")=0.)
+    .def("calculate_box", &calculate_box, nb::arg("margin")=0.)
+    .def("calculate_fractional_box", &calculate_fractional_box, nb::arg("margin")=0.)
 
     .def("clone", [](const Structure& self) { return new Structure(self); })
+    .def("__getstate__", &getstate<Structure>)
+    .def("__setstate__", &setstate<Structure>)
     .def("__repr__", [](const Structure& self) {
         return cat("<gemmi.Structure ", self.name, " with ",
                    self.models.size(), " model(s)>");
@@ -207,138 +211,138 @@ void add_mol(py::module& m) {
     add_write(m, structure);
 
   pyModel
-    .def(py::init<std::string>())
-    .def_readwrite("name", &Model::name)
+    .def(nb::init<std::string>())
+    .def_rw("name", &Model::name)
     .def("__len__", [](const Model& self) { return self.chains.size(); })
-    .def("__iter__", [](Model& self) {
-        return py::make_iterator(self.chains);
-    }, py::keep_alive<0, 1>())
-    .def("__getitem__", &get_child<Model, Chain>, py::arg("index"),
-         py::return_value_policy::reference_internal)
+    .def("__iter__", [](Model& self) { return usual_iterator(self, self.chains); },
+         nb::keep_alive<0, 1>())
+    .def("__getitem__", &get_child<Model, Chain>, nb::arg("index"),
+         nb::rv_policy::reference_internal)
     .def("__getitem__", [](Model& self, const std::string& name) -> Chain& {
         return *impl::find_iter(self.chains, name);
-    }, py::arg("name"), py::return_value_policy::reference_internal)
-    .def("all", (CraProxy (Model::*)()) &Model::all, py::keep_alive<0, 1>())
+    }, nb::arg("name"), nb::rv_policy::reference_internal)
+    .def("all", (CraProxy (Model::*)()) &Model::all, nb::keep_alive<0, 1>())
     .def("get_subchain",
          (ResidueSpan (Model::*)(const std::string&)) &Model::get_subchain,
-         py::arg("name"), py::return_value_policy::reference_internal)
+         nb::arg("name"), nb::rv_policy::reference_internal)
     .def("subchains", (std::vector<ResidueSpan> (Model::*)()) &Model::subchains,
-         py::return_value_policy::reference_internal)
+         nb::rv_policy::reference_internal)
     .def("find_residue_group", &Model::find_residue_group,
-         py::arg("chain"), py::arg("seqid"),
-         py::keep_alive<0, 1>())
+         nb::arg("chain"), nb::arg("seqid"),
+         nb::keep_alive<0, 1>())
     .def("sole_residue", &Model::sole_residue,
-         py::arg("chain"), py::arg("seqid"),
-         py::return_value_policy::reference_internal)
+         nb::arg("chain"), nb::arg("seqid"),
+         nb::rv_policy::reference_internal)
     .def("get_all_residue_names", &Model::get_all_residue_names)
     .def("find_cra", (CRA (Model::*)(const AtomAddress&, bool)) &Model::find_cra,
-         py::arg(), py::arg("ignore_segment")=false)
+         nb::arg(), nb::arg("ignore_segment")=false)
     .def("find_chain",
          (Chain* (Model::*)(const std::string&))&Model::find_chain,
-         py::arg("name"), py::return_value_policy::reference_internal)
+         nb::arg("name"), nb::rv_policy::reference_internal)
     .def("find_last_chain", &Model::find_last_chain,
-         py::arg("name"), py::return_value_policy::reference_internal)
+         nb::arg("name"), nb::rv_policy::reference_internal)
     .def("add_chain",
          [](Model& self, const Chain& chain, int pos, bool unique_name) -> Chain& {
            Chain& ref = add_child<Model, Chain>(self, chain, pos);
            if (unique_name)
              ensure_unique_chain_name(self, ref);
            return ref;
-    }, py::arg("chain"), py::arg("pos")=-1, py::arg("unique_name")=false,
-       py::return_value_policy::reference_internal)
+    }, nb::arg("chain"), nb::arg("pos")=-1, nb::arg("unique_name")=false,
+       nb::rv_policy::reference_internal)
     // for compatibility with older gemmi version
     .def("add_chain", [](Model& self, const std::string& name) -> Chain& {
         self.chains.emplace_back(name);
         return self.chains.back();
-     }, py::arg("name"), py::return_value_policy::reference_internal)
+     }, nb::arg("name"), nb::rv_policy::reference_internal)
     .def("get_cra", &Model::get_cra)
     .def("get_parent_of", &Model::get_parent_of,
-         py::return_value_policy::reference_internal)
-    .def("remove_chain", &Model::remove_chain, py::arg("name"))
-    .def("__delitem__", &Model::remove_chain, py::arg("name"))
-    .def("__delitem__", remove_child<Model>, py::arg("index"))
+         nb::rv_policy::reference_internal)
+    .def("remove_chain", &Model::remove_chain, nb::arg("name"))
+    .def("__delitem__", &Model::remove_chain, nb::arg("name"))
+    .def("__delitem__", remove_child<Model>, nb::arg("index"))
     .def("__delitem__", remove_children<Model>)
     .def("remove_alternative_conformations", remove_alternative_conformations<Model>)
     .def("remove_hydrogens", remove_hydrogens<Model>)
     .def("remove_waters", remove_waters<Model>)
     .def("remove_ligands_and_waters", remove_ligands_and_waters<Model>)
     .def("has_hydrogen", &has_hydrogen<Model>)
-    .def("count_atom_sites", &count_atom_sites<Model>, py::arg("sel")=nullptr)
+    .def("count_atom_sites", &count_atom_sites<Model>, nb::arg("sel")=nb::none())
     // deprecated, use has_hydrogen() or count_atom_sites(Selection('[H,D]'))
     .def("count_hydrogen_sites", &count_hydrogen_sites<Model>)
-    .def("count_occupancies", &count_occupancies<Model>, py::arg("sel")=nullptr)
+    .def("count_occupancies", &count_occupancies<Model>, nb::arg("sel")=nb::none())
     .def("calculate_mass", &calculate_mass<Model>)
     .def("calculate_center_of_mass", [](const Model& self) {
         return calculate_center_of_mass(self).get();
     })
     .def("calculate_b_iso_range", &calculate_b_iso_range<Model>)
     .def("calculate_b_aniso_range", &calculate_b_aniso_range)
-    .def("transform_pos_and_adp", transform_pos_and_adp<Model>, py::arg("tr"))
+    .def("transform_pos_and_adp", transform_pos_and_adp<Model>, nb::arg("tr"))
     .def("split_chains_by_segments", &split_chains_by_segments)
     .def("clone", [](const Model& self) { return new Model(self); })
+    .def("__getstate__", &getstate<Model>)
+    .def("__setstate__", &setstate<Model>)
     .def("__repr__", [](const Model& self) {
         return cat("<gemmi.Model ", self.name, " with ", self.chains.size(), " chain(s)>");
     });
 
-  py::class_<UniqProxy<Residue>>(m, "FirstConformerRes")
+  nb::class_<UniqProxy<Residue>>(m, "FirstConformerRes")
     .def("__iter__", [](UniqProxy<Residue>& self) {
-        return py::make_iterator(self);
-    }, py::keep_alive<0, 1>());
+        return usual_iterator(self, self);
+    }, nb::keep_alive<0, 1>());
 
-  py::class_<UniqProxy<Residue, ResidueSpan>>(m, "FirstConformerResSpan")
+  nb::class_<UniqProxy<Residue, ResidueSpan>>(m, "FirstConformerResSpan")
     .def("__iter__", [](UniqProxy<Residue, ResidueSpan>& self) {
-        return py::make_iterator(self);
-    }, py::keep_alive<0, 1>());
+        return usual_iterator(self, self);
+    }, nb::keep_alive<0, 1>());
 
-  py::class_<UniqProxy<Atom>>(m, "FirstConformerAtoms")
+  nb::class_<UniqProxy<Atom>>(m, "FirstConformerAtoms")
     .def("__iter__", [](UniqProxy<Atom>& self) {
-        return py::make_iterator(self);
-    }, py::keep_alive<0, 1>());
+        return usual_iterator(self, self);
+    }, nb::keep_alive<0, 1>());
 
-  py::class_<ResidueSpan::GroupingProxy>(m, "ResidueSpanGroups")
+  nb::class_<ResidueSpan::GroupingProxy>(m, "ResidueSpanGroups")
     .def("__iter__", [](ResidueSpan::GroupingProxy& self) {
-        return py::make_iterator(self);
-    }, py::keep_alive<0, 1>());
+        return usual_iterator(self, self);
+    }, nb::keep_alive<0, 1>());
 
   pyChain
-    .def(py::init<std::string>())
-    .def_readwrite("name", &Chain::name)
+    .def(nb::init<std::string>())
+    .def_rw("name", &Chain::name)
     .def("__len__", [](const Chain& ch) { return ch.residues.size(); })
-    .def("__iter__", [](const Chain& ch) {
-        return py::make_iterator(ch.residues);
-    }, py::keep_alive<0, 1>())
+    .def("__iter__", [](Chain& ch) { return usual_iterator(ch, ch.residues); },
+         nb::keep_alive<0, 1>())
     .def("__getitem__", [](Chain& ch, const std::string& seqid) {
         return ch.find_residue_group(SeqId(seqid));
-    }, py::arg("pdb_seqid"), py::keep_alive<0, 1>())
-    .def("__getitem__", &get_child<Chain, Residue>, py::arg("index"),
-         py::return_value_policy::reference_internal)
-    .def("__getitem__", [](Chain &ch, py::slice slice) -> py::list {
+    }, nb::arg("pdb_seqid"), nb::keep_alive<0, 1>())
+    .def("__getitem__", &get_child<Chain, Residue>, nb::arg("index"),
+         nb::rv_policy::reference_internal)
+    .def("__getitem__", [](Chain &ch, nb::slice slice) -> nb::list {
         return getitem_slice(ch.residues, slice);
-    }, py::return_value_policy::reference_internal)
-    .def("__delitem__", remove_child<Chain>, py::arg("index"))
+    }, nb::rv_policy::reference_internal)
+    .def("__delitem__", remove_child<Chain>, nb::arg("index"))
     .def("__delitem__", remove_children<Chain>)
     .def("add_residue", add_child<Chain, Residue>,
-         py::arg("residue"), py::arg("pos")=-1,
-         py::return_value_policy::reference_internal)
+         nb::arg("residue"), nb::arg("pos")=-1,
+         nb::rv_policy::reference_internal)
     .def("subchains", (std::vector<ResidueSpan> (Chain::*)()) &Chain::subchains)
     .def("whole", (ResidueSpan (Chain::*)()) &Chain::whole,
-         py::keep_alive<0, 1>())
+         nb::keep_alive<0, 1>())
     .def("get_polymer", (ResidueSpan (Chain::*)()) &Chain::get_polymer,
-         py::keep_alive<0, 1>())
+         nb::keep_alive<0, 1>())
     .def("get_ligands", (ResidueSpan (Chain::*)()) &Chain::get_ligands,
-         py::keep_alive<0, 1>())
+         nb::keep_alive<0, 1>())
     .def("get_waters", (ResidueSpan (Chain::*)()) &Chain::get_waters,
-         py::keep_alive<0, 1>())
+         nb::keep_alive<0, 1>())
     .def("get_subchain", (ResidueSpan (Chain::*)(const std::string&)) &Chain::get_subchain,
-         py::keep_alive<0, 1>())
+         nb::keep_alive<0, 1>())
     .def("previous_residue", &Chain::previous_residue,
-         py::return_value_policy::reference_internal)
+         nb::rv_policy::reference_internal)
     .def("next_residue", &Chain::next_residue,
-         py::return_value_policy::reference_internal)
+         nb::rv_policy::reference_internal)
     .def("append_residues", &Chain::append_residues,
-         py::arg("new_residues"), py::arg("min_sep")=0)
-    .def("count_atom_sites", &count_atom_sites<Chain>, py::arg("sel")=nullptr)
-    .def("count_occupancies", &count_occupancies<Chain>, py::arg("sel")=nullptr)
+         nb::arg("new_residues"), nb::arg("min_sep")=0)
+    .def("count_atom_sites", &count_atom_sites<Chain>, nb::arg("sel")=nb::none())
+    .def("count_occupancies", &count_occupancies<Chain>, nb::arg("sel")=nb::none())
     .def("calculate_mass", &calculate_mass<Chain>)
     .def("calculate_center_of_mass", [](const Chain& self) {
           return calculate_center_of_mass(self).get();
@@ -346,34 +350,36 @@ void add_mol(py::module& m) {
     .def("trim_to_alanine", (void (*)(Chain&)) &trim_to_alanine)
     .def("first_conformer",
          (UniqProxy<Residue> (Chain::*)()) &Chain::first_conformer,
-         py::keep_alive<0, 1>())
+         nb::keep_alive<0, 1>())
     .def("clone", [](const Chain& self) { return new Chain(self); })
+    .def("__getstate__", &getstate<Chain>)
+    .def("__setstate__", &setstate<Chain>)
     .def("__repr__", [](const Chain& self) {
         return cat("<gemmi.Chain ", self.name, " with ", self.residues.size(), " res>");
     });
 
   pyResidueSpan
     .def("__len__", &ResidueSpan::size)
-    .def("__iter__", [](ResidueSpan& g) { return py::make_iterator(g); },
-         py::keep_alive<0, 1>())
+    .def("__iter__", [](ResidueSpan& g) { return usual_iterator(g, g); },
+         nb::keep_alive<0, 1>())
     .def("__bool__", [](const ResidueSpan &g) -> bool { return !g.empty(); })
     .def("__getitem__", [](ResidueSpan& g, int index) -> Residue& {
         return g[normalize_index(index, g)];
-    }, py::arg("index"), py::return_value_policy::reference_internal)
+    }, nb::arg("index"), nb::rv_policy::reference_internal)
     .def("__getitem__", [](ResidueSpan& self, const std::string& seqid) {
         return self.find_residue_group(SeqId(seqid));
-    }, py::arg("pdb_seqid"), py::keep_alive<0, 1>())
+    }, nb::arg("pdb_seqid"), nb::keep_alive<0, 1>())
     .def("__delitem__", [](ResidueSpan& self, int index) {
         self.erase(self.begin() + normalize_index(index, self));
-    }, py::arg("index"))
+    }, nb::arg("index"))
     .def("add_residue", add_item<ResidueSpan, Residue>,
-         py::arg("residue"), py::arg("pos")=-1,
-         py::return_value_policy::reference_internal)
+         nb::arg("residue"), nb::arg("pos")=-1,
+         nb::rv_policy::reference_internal)
     .def("first_conformer",
          (UniqProxy<Residue, ResidueSpan> (ResidueSpan::*)())
                                                 &ResidueSpan::first_conformer,
-         py::keep_alive<0, 1>())
-    .def("residue_groups", &ResidueSpan::residue_groups, py::keep_alive<0, 1>())
+         nb::keep_alive<0, 1>())
+    .def("residue_groups", &ResidueSpan::residue_groups, nb::keep_alive<0, 1>())
     .def("length", &ResidueSpan::length)
     .def("subchain_id", &ResidueSpan::subchain_id)
     .def("extract_sequence", &ResidueSpan::extract_sequence)
@@ -409,41 +415,41 @@ void add_mol(py::module& m) {
     // need to duplicate it so it is visible
     .def("__getitem__", [](ResidueGroup& g, int index) -> Residue& {
         return g[normalize_index(index, g)];
-    }, py::arg("index"), py::return_value_policy::reference_internal)
+    }, nb::arg("index"), nb::rv_policy::reference_internal)
     .def("__getitem__", &ResidueGroup::by_resname,
-         py::arg("name"), py::return_value_policy::reference_internal)
-    .def("__delitem__", &ResidueGroup::remove_residue, py::arg("name"))
+         nb::arg("name"), nb::rv_policy::reference_internal)
+    .def("__delitem__", &ResidueGroup::remove_residue, nb::arg("name"))
     .def("__repr__", [](const ResidueGroup& self) {
         return "<gemmi.ResidueGroup [" +
                join_str(self, ' ', [](const Residue& r) { return r.str(); }) +
                "]>";
     });
 
-  py::class_<AtomGroup>(m, "AtomGroup")
+  nb::class_<AtomGroup>(m, "AtomGroup")
     .def("__len__", &AtomGroup::size)
-    .def("__iter__", [](AtomGroup& g) { return py::make_iterator(g); },
-         py::keep_alive<0, 1>())
+    .def("__iter__", [](AtomGroup& g) { return usual_iterator(g, g); },
+         nb::keep_alive<0, 1>())
     .def("__bool__", [](const AtomGroup &g) -> bool { return !g.empty(); })
     .def("__getitem__", [](AtomGroup& g, int index) -> Atom& {
         return g[normalize_index(index, g)];
-    }, py::arg("index"), py::return_value_policy::reference_internal)
+    }, nb::arg("index"), nb::rv_policy::reference_internal)
     .def("__getitem__", &AtomGroup::by_altloc,
-         py::arg("altloc"), py::return_value_policy::reference_internal)
+         nb::arg("altloc"), nb::rv_policy::reference_internal)
     .def("name", &AtomGroup::name)
     .def("__repr__", [](const AtomGroup& self) {
         return cat("<gemmi.AtomGroup ", self.name(), ", sites: ", self.size(), '>');
     });
 
   pyResidue
-    .def(py::init<>())
-    .def_readwrite("subchain", &Residue::subchain)
-    .def_readwrite("entity_id", &Residue::entity_id)
-    .def_readwrite("label_seq", &Residue::label_seq)
-    .def_readwrite("entity_type", &Residue::entity_type)
-    .def_readwrite("het_flag", &Residue::het_flag)
-    .def_readwrite("flag", &Residue::flag)
-    .def_property_readonly("sifts_unp", [](const Residue& self) {
-        return py::make_tuple(self.sifts_unp.res,
+    .def(nb::init<>())
+    .def_rw("subchain", &Residue::subchain)
+    .def_rw("entity_id", &Residue::entity_id)
+    .def_rw("label_seq", &Residue::label_seq, nb::arg().none())
+    .def_rw("entity_type", &Residue::entity_type)
+    .def_rw("het_flag", &Residue::het_flag)
+    .def_rw("flag", &Residue::flag)
+    .def_prop_ro("sifts_unp", [](const Residue& self) {
+        return nb::make_tuple(self.sifts_unp.res,
                               self.sifts_unp.acc_index,
                               self.sifts_unp.num);
     })
@@ -451,42 +457,44 @@ void add_mol(py::module& m) {
     .def("__contains__", [](const Residue& res, const std::string& name) {
         return res.find_atom(name, '*') != nullptr;
     })
-    .def("__iter__", [](const Residue& res) {
-        return py::make_iterator(res.atoms);
-    }, py::keep_alive<0, 1>())
-    .def("__getitem__", &get_child<Residue, Atom>, py::arg("index"),
-         py::return_value_policy::reference_internal)
+    .def("__iter__", [](Residue& res) {
+        return usual_iterator(res, res.atoms);
+    }, nb::keep_alive<0, 1>())
+    .def("__getitem__", &get_child<Residue, Atom>, nb::arg("index"),
+         nb::rv_policy::reference_internal)
     .def("__getitem__", &Residue::get,
-         py::arg("name"), py::return_value_policy::reference_internal)
-    .def("__delitem__", remove_child<Residue>, py::arg("index"))
+         nb::arg("name"), nb::rv_policy::reference_internal)
+    .def("__delitem__", remove_child<Residue>, nb::arg("index"))
     .def("__delitem__", remove_children<Residue>)
     .def("find_atom", [](Residue& self, const std::string& name, char altloc, Element el) {
            return self.find_atom(name, altloc, el);
-         }, py::arg("name"), py::arg("altloc"), py::arg("el")=Element(El::X),
-            py::return_value_policy::reference_internal)
+         }, nb::arg("name"), nb::arg("altloc"), nb::arg("el")=Element(El::X),
+            nb::rv_policy::reference_internal)
     .def("remove_atom",
          [](Residue& self, const std::string& name, char altloc, Element el) {
            self.atoms.erase(self.find_atom_iter(name, altloc, el));
-    }, py::arg("name"), py::arg("altloc"), py::arg("el")=Element(El::X))
+    }, nb::arg("name"), nb::arg("altloc"), nb::arg("el")=Element(El::X))
     .def("add_atom", add_child<Residue, Atom>,
-         py::arg("atom"), py::arg("pos")=-1,
-         py::return_value_policy::reference_internal)
+         nb::arg("atom"), nb::arg("pos")=-1,
+         nb::rv_policy::reference_internal)
     .def("first_conformer",
          (UniqProxy<Atom> (Residue::*)()) &Residue::first_conformer,
-         py::keep_alive<0, 1>())
+         nb::keep_alive<0, 1>())
     .def("sole_atom", &Residue::sole_atom)
-    .def("get_ca", &Residue::get_ca, py::return_value_policy::reference_internal)
-    .def("get_p", &Residue::get_p, py::return_value_policy::reference_internal)
+    .def("get_ca", &Residue::get_ca, nb::rv_policy::reference_internal)
+    .def("get_p", &Residue::get_p, nb::rv_policy::reference_internal)
     .def("is_water", &Residue::is_water)
     .def("remove_hydrogens", &remove_hydrogens<Residue>)
     .def("trim_to_alanine", (bool (*)(Residue&)) &trim_to_alanine)
     .def("recommended_het_flag", &recommended_het_flag)
     .def("clone", [](const Residue& self) { return new Residue(self); })
+    .def("__getstate__", &getstate<Residue>)
+    .def("__setstate__", &setstate<Residue>)
     .def("__repr__", [](const Residue& self) {
         return cat("<gemmi.Residue ", self.str(), " with ", self.atoms.size(), " atoms>");
     });
 
-  py::enum_<CalcFlag>(m, "CalcFlag")
+  nb::enum_<CalcFlag>(m, "CalcFlag")
     .value("NotSet", CalcFlag::NotSet)
     .value("NoHydrogen", CalcFlag::NoHydrogen)
     .value("Determined", CalcFlag::Determined)
@@ -494,25 +502,27 @@ void add_mol(py::module& m) {
     .value("Dummy", CalcFlag::Dummy);
 
   pyAtom
-    .def(py::init<>())
-    .def_readwrite("name", &Atom::name)
-    .def_readwrite("altloc", &Atom::altloc)
-    .def_readwrite("charge", &Atom::charge)
-    .def_readwrite("element", &Atom::element)
-    .def_readwrite("pos", &Atom::pos)
-    .def_readwrite("occ", &Atom::occ)
-    .def_readwrite("b_iso", &Atom::b_iso)
-    .def_readwrite("aniso", &Atom::aniso)
-    .def_readwrite("serial", &Atom::serial)
-    .def_readwrite("fraction", &Atom::fraction)
-    .def_readwrite("calc_flag", &Atom::calc_flag)
-    .def_readwrite("flag", &Atom::flag)
-    .def_readwrite("tls_group_id", &Atom::tls_group_id)
+    .def(nb::init<>())
+    .def_rw("name", &Atom::name)
+    .def_rw("altloc", &Atom::altloc)
+    .def_rw("charge", &Atom::charge)
+    .def_rw("element", &Atom::element)
+    .def_rw("pos", &Atom::pos)
+    .def_rw("occ", &Atom::occ)
+    .def_rw("b_iso", &Atom::b_iso)
+    .def_rw("aniso", &Atom::aniso)
+    .def_rw("serial", &Atom::serial)
+    .def_rw("fraction", &Atom::fraction)
+    .def_rw("calc_flag", &Atom::calc_flag)
+    .def_rw("flag", &Atom::flag)
+    .def_rw("tls_group_id", &Atom::tls_group_id)
     .def("is_hydrogen", &Atom::is_hydrogen)
     .def("has_altloc", &Atom::has_altloc)
     .def("b_eq", &Atom::b_eq)
     .def("padded_name", &Atom::padded_name)
     .def("clone", [](const Atom& self) { return new Atom(self); })
+    .def("__getstate__", &getstate<Atom>)
+    .def("__setstate__", &setstate<Atom>)
     .def("__repr__", [](const Atom& self) {
         std::string r = "<gemmi.Atom " + self.name;
         if (self.altloc) {
@@ -531,13 +541,13 @@ void add_mol(py::module& m) {
   m.def("calculate_dihedral", &calculate_dihedral,
         "Input: four points. Output: dihedral angle in radians.");
   m.def("calculate_omega", &calculate_omega,
-        py::arg("residue"), py::arg("next_residue"));
+        nb::arg("residue"), nb::arg("next_residue"));
   m.def("calculate_phi_psi", &calculate_phi_psi,
-        py::arg("prev_residue"), py::arg("residue"), py::arg("next_residue"));
+        nb::arg("prev_residue").none(), nb::arg("residue"), nb::arg("next_residue").none());
   m.def("find_best_plane", &find_best_plane,
-        py::arg("atoms"));
+        nb::arg("atoms"));
   m.def("get_distance_from_plane", &get_distance_from_plane,
-        py::arg("pos"), py::arg("coeff"));
+        nb::arg("pos"), nb::arg("coeff"));
   m.def("parse_triplet_as_ftransform", &parse_triplet_as_ftransform);
   m.def("make_assembly", [](const Assembly& assembly, const Model& model,
                             HowToNameCopiedChain how) {
@@ -545,26 +555,26 @@ void add_mol(py::module& m) {
   });
   m.def("expand_ncs_model", &expand_ncs_model);
   m.def("merge_atoms_in_expanded_model", &merge_atoms_in_expanded_model,
-        py::arg("model"), py::arg("cell"), py::arg("max_dist")=0.2,
-        py::arg("compare_serial")=true);
+        nb::arg("model"), nb::arg("cell"), nb::arg("max_dist")=0.2,
+        nb::arg("compare_serial")=true);
 
   // select.hpp
-  py::class_<FilterProxy<Selection, Model>> pySelectionModelsProxy(m, "SelectionModelsProxy");
-  py::class_<FilterProxy<Selection, Chain>> pySelectionChainsProxy(m, "SelectionChainsProxy");
-  py::class_<FilterProxy<Selection, Residue>> pySelectionResiduesProxy(m, "SelectionResiduesProxy");
-  py::class_<FilterProxy<Selection, Atom>> pySelectionAtomsProxy(m, "SelectionAtomsProxy");
+  nb::class_<FilterProxy<Selection, Model>> pySelectionModelsProxy(m, "SelectionModelsProxy");
+  nb::class_<FilterProxy<Selection, Chain>> pySelectionChainsProxy(m, "SelectionChainsProxy");
+  nb::class_<FilterProxy<Selection, Residue>> pySelectionResiduesProxy(m, "SelectionResiduesProxy");
+  nb::class_<FilterProxy<Selection, Atom>> pySelectionAtomsProxy(m, "SelectionAtomsProxy");
 
   pySelection
-    .def(py::init<>())
-    .def(py::init<const std::string&>())
+    .def(nb::init<>())
+    .def(nb::init<const std::string&>())
     .def("models", &Selection::models)
     .def("chains", &Selection::chains)
     .def("residues", &Selection::residues)
     .def("atoms", &Selection::atoms)
     .def("first_in_model", &Selection::first_in_model,
-         py::keep_alive<1, 2>())
-    .def("first", &Selection::first, py::return_value_policy::reference,
-         py::keep_alive<1, 2>())
+         nb::keep_alive<1, 2>())
+    .def("first", &Selection::first, nb::rv_policy::reference,
+         nb::keep_alive<1, 2>())
     .def("str", &Selection::str)
     .def("set_residue_flags", &Selection::set_residue_flags)
     .def("set_atom_flags", &Selection::set_atom_flags)
@@ -580,21 +590,21 @@ void add_mol(py::module& m) {
 
   pySelectionModelsProxy
     .def("__iter__", [](FilterProxy<Selection, Model>& self) {
-        return py::make_iterator(self);
-    }, py::keep_alive<0, 1>());
+        return usual_iterator(self, self);
+    }, nb::keep_alive<0, 1>());
 
   pySelectionChainsProxy
     .def("__iter__", [](FilterProxy<Selection, Chain>& self) {
-        return py::make_iterator(self);
-    }, py::keep_alive<0, 1>());
+        return usual_iterator(self, self);
+    }, nb::keep_alive<0, 1>());
 
   pySelectionResiduesProxy
     .def("__iter__", [](FilterProxy<Selection, Residue>& self) {
-        return py::make_iterator(self);
-    }, py::keep_alive<0, 1>());
+        return usual_iterator(self, self);
+    }, nb::keep_alive<0, 1>());
 
   pySelectionAtomsProxy
     .def("__iter__", [](FilterProxy<Selection, Atom>& self) {
-        return py::make_iterator(self);
-    }, py::keep_alive<0, 1>());
+        return usual_iterator(self, self);
+    }, nb::keep_alive<0, 1>());
 }
diff --git a/python/monlib.cpp b/python/monlib.cpp
index 7060a1792..974220c79 100644
--- a/python/monlib.cpp
+++ b/python/monlib.cpp
@@ -4,87 +4,88 @@
 #include "gemmi/read_cif.hpp"  // for read_cif_gz
 
 #include "common.h"
-#include <pybind11/stl.h>
-#include <pybind11/stl_bind.h>
+#include <nanobind/stl/bind_map.h>
+#include <nanobind/stl/string.h>
+#include <nanobind/stl/tuple.h>  // for MonLib::match_link
+#include <nanobind/stl/vector.h>
 
-namespace py = pybind11;
 using namespace gemmi;
 
 using monomers_type = std::map<std::string, ChemComp>;
 using links_type = std::map<std::string, ChemLink>;
 using modifications_type = std::map<std::string, ChemMod>;
-PYBIND11_MAKE_OPAQUE(monomers_type)
-PYBIND11_MAKE_OPAQUE(links_type)
-PYBIND11_MAKE_OPAQUE(modifications_type)
+NB_MAKE_OPAQUE(monomers_type)
+NB_MAKE_OPAQUE(links_type)
+NB_MAKE_OPAQUE(modifications_type)
 
-void add_monlib(py::module& m) {
-  py::class_<ChemMod> chemmod(m, "ChemMod");
-  py::class_<ChemLink> chemlink(m, "ChemLink");
+void add_monlib(nb::module_& m) {
+  nb::class_<ChemMod> chemmod(m, "ChemMod");
+  nb::class_<ChemLink> chemlink(m, "ChemLink");
 
-  py::bind_map<monomers_type>(m, "ChemCompMap");
-  py::bind_map<links_type>(m, "ChemLinkMap");
-  py::bind_map<modifications_type>(m, "ChemModMap");
+  nb::bind_map<monomers_type>(m, "ChemCompMap");
+  nb::bind_map<links_type>(m, "ChemLinkMap");
+  nb::bind_map<modifications_type>(m, "ChemModMap");
 
-  py::class_<ChemLink::Side>(chemlink, "Side")
-    .def(py::init<>())
-    .def_readwrite("comp", &ChemLink::Side::comp)
-    .def_readwrite("mod", &ChemLink::Side::mod)
-    .def_readwrite("group", &ChemLink::Side::group)
+  nb::class_<ChemLink::Side>(chemlink, "Side")
+    .def(nb::init<>())
+    .def_rw("comp", &ChemLink::Side::comp)
+    .def_rw("mod", &ChemLink::Side::mod)
+    .def_rw("group", &ChemLink::Side::group)
     .def("__repr__", [](const ChemLink::Side& self) {
         return "<gemmi.ChemLink.Side " + self.comp + "/" +
                ChemComp::group_str(self.group) + ">";
     });
 
-  py::class_<ChemMod::AtomMod>(chemmod, "AtomMod")
-    .def_readwrite("func", &ChemMod::AtomMod::func)
-    .def_readwrite("old_id", &ChemMod::AtomMod::old_id)
-    .def_readwrite("new_id", &ChemMod::AtomMod::new_id)
-    .def_readwrite("el", &ChemMod::AtomMod::el)
-    .def_readwrite("charge", &ChemMod::AtomMod::charge)
-    .def_readwrite("chem_type", &ChemMod::AtomMod::chem_type)
+  nb::class_<ChemMod::AtomMod>(chemmod, "AtomMod")
+    .def_rw("func", &ChemMod::AtomMod::func)
+    .def_rw("old_id", &ChemMod::AtomMod::old_id)
+    .def_rw("new_id", &ChemMod::AtomMod::new_id)
+    .def_rw("el", &ChemMod::AtomMod::el)
+    .def_rw("charge", &ChemMod::AtomMod::charge)
+    .def_rw("chem_type", &ChemMod::AtomMod::chem_type)
   ;
   chemlink
-    .def(py::init<>())
-    .def_readwrite("id", &ChemLink::id)
-    .def_readwrite("name", &ChemLink::name)
-    .def_readwrite("side1", &ChemLink::side1)
-    .def_readwrite("side2", &ChemLink::side2)
-    .def_readwrite("rt", &ChemLink::rt)
+    .def(nb::init<>())
+    .def_rw("id", &ChemLink::id)
+    .def_rw("name", &ChemLink::name)
+    .def_rw("side1", &ChemLink::side1)
+    .def_rw("side2", &ChemLink::side2)
+    .def_rw("rt", &ChemLink::rt)
     .def("__repr__", [](const ChemLink& self) {
         return "<gemmi.ChemLink " + self.id + ">";
     });
 
   chemmod
-    .def(py::init<>())
-    .def_readwrite("id", &ChemMod::id)
-    .def_readwrite("name", &ChemMod::name)
-    .def_readwrite("comp_id", &ChemMod::comp_id)
-    .def_readwrite("group_id", &ChemMod::group_id)
-    .def_readwrite("atom_mods", &ChemMod::atom_mods)
-    .def_readwrite("rt", &ChemMod::rt)
+    .def(nb::init<>())
+    .def_rw("id", &ChemMod::id)
+    .def_rw("name", &ChemMod::name)
+    .def_rw("comp_id", &ChemMod::comp_id)
+    .def_rw("group_id", &ChemMod::group_id)
+    .def_rw("atom_mods", &ChemMod::atom_mods)
+    .def_rw("rt", &ChemMod::rt)
     .def("__repr__", [](const ChemMod& self) {
         return "<gemmi.ChemMod " + self.id + ">";
     });
 
-  py::class_<EnerLib>(m, "EnerLib");
-  py::class_<MonLib>(m, "MonLib")
-    .def(py::init<>())
-    .def_property("monomer_dir",
+  nb::class_<EnerLib>(m, "EnerLib");
+  nb::class_<MonLib>(m, "MonLib")
+    .def(nb::init<>())
+    .def_prop_rw("monomer_dir",
                   [](const MonLib& self) { return self.monomer_dir; },
                   &MonLib::set_monomer_dir)
-    .def_readonly("ener_lib", &MonLib::ener_lib)
-    .def_readonly("monomers", &MonLib::monomers)
-    .def_readonly("links", &MonLib::links)
-    .def_readonly("modifications", &MonLib::modifications)
-    .def("get_link", &MonLib::get_link, py::arg("link_id"),
-         py::return_value_policy::reference_internal)
-    .def("get_mod", &MonLib::get_mod, py::arg("name"),
-         py::return_value_policy::reference_internal)
+    .def_ro("ener_lib", &MonLib::ener_lib)
+    .def_ro("monomers", &MonLib::monomers)
+    .def_ro("links", &MonLib::links)
+    .def_ro("modifications", &MonLib::modifications)
+    .def("get_link", &MonLib::get_link, nb::arg("link_id"),
+         nb::rv_policy::reference_internal)
+    .def("get_mod", &MonLib::get_mod, nb::arg("name"),
+         nb::rv_policy::reference_internal)
     .def("match_link", &MonLib::match_link,
-         py::arg("res1"), py::arg("atom1"), py::arg("alt1"),
-         py::arg("res2"), py::arg("atom2"), py::arg("alt2"),
-         py::arg("min_bond_sq")=0.,
-         py::return_value_policy::reference_internal)
+         nb::arg("res1"), nb::arg("atom1"), nb::arg("alt1"),
+         nb::arg("res2"), nb::arg("atom2"), nb::arg("alt2"),
+         nb::arg("min_bond_sq")=0.,
+         nb::rv_policy::reference_internal)
     .def("test_link", [](const MonLib& self, const ChemLink& link,
                          const std::string& res1, const std::string& atom1,
                          const std::string& res2, const std::string& atom2) {
@@ -95,8 +96,8 @@ void add_monlib(py::module& m) {
                     self.link_side_matches_residue(link.side2, res2, &aliasing2) &&
                     atom_match_with_alias(link.rt.bonds[0].id1.atom, atom1, aliasing1) &&
                     atom_match_with_alias(link.rt.bonds[0].id2.atom, atom2, aliasing2));
-      return py::make_tuple(match, aliasing1, aliasing2);
-    }, py::arg("link"), py::arg("res1"), py::arg("atom1"), py::arg("res2"), py::arg("atom2"))
+      return nb::make_tuple(match, aliasing1, aliasing2);
+    }, nb::arg("link"), nb::arg("res1"), nb::arg("atom1"), nb::arg("res2"), nb::arg("atom2"))
     .def("add_monomer_if_present", &MonLib::add_monomer_if_present)
     .def("read_monomer_doc", &MonLib::read_monomer_doc)
     .def("read_monomer_cif", [](MonLib& self, const std::string& path) {
@@ -110,7 +111,7 @@ void add_monlib(py::module& m) {
       return self.find_ideal_distance(cra1, cra2);
     })
     .def("update_old_atom_names", &MonLib::update_old_atom_names)
-    .def("path", &MonLib::path, py::arg("code")=std::string())
+    .def("path", &MonLib::path, nb::arg("code")=std::string())
     .def("__repr__", [](const MonLib& self) {
         return "<gemmi.MonLib with " +
                std::to_string(self.monomers.size()) + " monomers, " +
@@ -124,6 +125,6 @@ void add_monlib(py::module& m) {
                                const std::string& libin,
                                bool ignore_missing) {
     return read_monomer_lib(monomer_dir, resnames, gemmi::read_cif_gz, libin, ignore_missing);
-  }, py::arg("monomer_dir"), py::arg("resnames"), py::arg("libin")=std::string(),
-     py::arg("ignore_missing")=false);
+  }, nb::arg("monomer_dir"), nb::arg("resnames"), nb::arg("libin")=std::string(),
+     nb::arg("ignore_missing")=false);
 }
diff --git a/python/mtz.cpp b/python/mtz.cpp
index f4917b99c..108ffd3da 100644
--- a/python/mtz.cpp
+++ b/python/mtz.cpp
@@ -1,20 +1,22 @@
 // Copyright 2019 Global Phasing Ltd.
 
+#include "common.h"
+#include "array.h"
+#include "make_iterator.h"
+#include <nanobind/stl/bind_vector.h>
+#include <nanobind/stl/array.h>
+#include <nanobind/stl/string.h>
+#include <nanobind/stl/vector.h>
+
 #include "gemmi/mtz.hpp"
 #include "gemmi/fourier.hpp"
 #include "tostr.hpp"
 
-#include "common.h"
-#include <pybind11/stl.h>
-#include <pybind11/stl_bind.h>
-#include <pybind11/numpy.h>
-
-namespace py = pybind11;
 using namespace gemmi;
 
-PYBIND11_MAKE_OPAQUE(std::vector<Mtz::Dataset>)
-PYBIND11_MAKE_OPAQUE(std::vector<Mtz::Column>)
-PYBIND11_MAKE_OPAQUE(std::vector<Mtz::Batch>)
+NB_MAKE_OPAQUE(std::vector<Mtz::Dataset>)
+NB_MAKE_OPAQUE(std::vector<Mtz::Column>)
+NB_MAKE_OPAQUE(std::vector<Mtz::Batch>)
 
 namespace gemmi {
   // operator<< is used by stl_bind for vector's __repr__
@@ -35,111 +37,91 @@ struct VectorRef {
 // Minimal std::vector bindings, for Batch::ints and Batch::floats.
 // Don't allow the user to resize the vector, only to get and set values.
 template<typename T>
-void bind_wrapped_vector(py::handle scope, const char* name) {
+void bind_wrapped_vector(nb::handle scope, const char* name) {
   using SizeType = typename std::vector<T>::size_type;
   using DiffType = typename std::vector<T>::difference_type;
   auto wrap_idx = [&](DiffType i, SizeType length) -> SizeType {
     SizeType idx = (i >= 0 ? (SizeType)i : (SizeType)i + length);
     if (idx >= length)
-      throw py::index_error();
+      throw nb::index_error();
     return idx;
   };
   using VR = VectorRef<T>;
-  py::class_<VR>(scope, name)
+  nb::class_<VR>(scope, name)
     .def("__getitem__", [&](VR& r, DiffType i) { return r.v[wrap_idx(i, r.v.size())]; })
     .def("__setitem__", [&](VR& r, DiffType i, T x) { r.v[wrap_idx(i, r.v.size())] = x; })
     .def("__len__", [](const VR& r) { return r.v.size(); })
     ;
 }
 
-template<typename F>
-py::array_t<float> make_new_column(const Mtz& mtz, int dataset, F f) {
+template<typename Func>
+auto make_new_column(const Mtz& mtz, int dataset, Func func) {
   if (!mtz.has_data())
     throw std::runtime_error("MTZ: the data must be read first");
   const UnitCell& cell = mtz.get_cell(dataset);
   if (!cell.is_crystal())
     throw std::runtime_error("MTZ: unknown unit cell parameters");
-  py::array_t<float> arr(mtz.nreflections);
-  py::buffer_info buf = arr.request();
-  float* ptr = (float*) buf.ptr;
-  for (int i = 0; i < mtz.nreflections; ++i) {
-    int hidx = (int) mtz.columns.size() * i;
-    ptr[i] = f(cell, mtz.data[hidx], mtz.data[hidx+1], mtz.data[hidx+2]);
-  }
-  return arr;
+  size_t stride = mtz.columns.size();
+  size_t n = (size_t) mtz.nreflections;
+  auto numpy_arr = make_numpy_array<float>({n});
+  float* arr = numpy_arr.data();
+  const float* h = mtz.data.data();
+  for (size_t i = 0; i < n; ++i, h += stride)
+    arr[i] = func(cell, h[0], h[1], h[2]);
+  return numpy_arr;
 }
 
-static py::array_t<float> make_1_d2_array(const Mtz& mtz, int dataset) {
-  return make_new_column(mtz, dataset,
-                         [](const UnitCell& cell, float h, float k, float l) {
-                           return (float) cell.calculate_1_d2_double(h, k, l);
-                         });
-}
-static py::array_t<float> make_d_array(const Mtz& mtz, int dataset) {
-  return make_new_column(mtz, dataset,
-                         [](const UnitCell& cell, float h, float k, float l) {
-                           double _1_d2 = cell.calculate_1_d2_double(h, k, l);
-                           return (float) (1.0 / std::sqrt(_1_d2));
-                         });
-}
 
-void add_mtz(py::module& m) {
-  py::class_<Mtz> mtz(m, "Mtz", py::buffer_protocol());
-  py::class_<Mtz::Dataset> pyMtzDataset(mtz, "Dataset");
-  py::class_<Mtz::Column> pyMtzColumn(mtz, "Column", py::buffer_protocol());
-  py::class_<Mtz::Batch> pyMtzBatch(mtz, "Batch");
+void add_mtz(nb::module_& m) {
+  nb::class_<Mtz> mtz(m, "Mtz");
+  nb::class_<Mtz::Dataset> pyMtzDataset(mtz, "Dataset");
+  nb::class_<Mtz::Column> pyMtzColumn(mtz, "Column");
+  nb::class_<Mtz::Batch> pyMtzBatch(mtz, "Batch");
 
-  py::bind_vector<std::vector<Mtz::Dataset>>(m, "MtzDatasets");
-  py::bind_vector<std::vector<Mtz::Column>>(m, "MtzColumns");
-  py::bind_vector<std::vector<Mtz::Batch>>(m, "MtzBatches");
+  nb::bind_vector<std::vector<Mtz::Dataset>, rv_ri>(m, "MtzDatasets");
+  nb::bind_vector<std::vector<Mtz::Column>, rv_ri>(m, "MtzColumns");
+  nb::bind_vector<std::vector<Mtz::Batch>, rv_ri>(m, "MtzBatches");
   bind_wrapped_vector<int>(m, "BatchInts");
   bind_wrapped_vector<float>(m, "BatchFloats");
 
   mtz
-    .def(py::init<bool>(), py::arg("with_base")=false)
-    .def_buffer([](Mtz &self) {
-      int nrow = self.has_data() ? self.nreflections : 0;
-      int ncol = (int) self.columns.size();
-      return py::buffer_info(self.data.data(),
-                             {nrow, ncol}, // dimensions
-                             {4 * ncol, 4});  // strides
-    })
-    .def_property_readonly("array", [](const Mtz& self) {
-      int nrow = self.has_data() ? self.nreflections : 0;
-      int ncol = (int) self.columns.size();
-      return py::array_t<float>({nrow, ncol}, {4 * ncol, 4},
-                                self.data.data(), py::cast(self));
-    }, py::return_value_policy::reference_internal)
-    .def_readwrite("title", &Mtz::title)
-    .def_readwrite("nreflections", &Mtz::nreflections)
-    .def_readwrite("sort_order", &Mtz::sort_order)
-    .def_readwrite("min_1_d2", &Mtz::min_1_d2)
-    .def_readwrite("max_1_d2", &Mtz::max_1_d2)
-    .def_readwrite("valm", &Mtz::valm)
-    .def_readonly("nsymop", &Mtz::nsymop)
-    .def_readwrite("cell", &Mtz::cell)
-    .def_readwrite("spacegroup", &Mtz::spacegroup)
-    .def_readonly("spacegroup_name", &Mtz::spacegroup_name)
-    .def_readonly("spacegroup_number", &Mtz::spacegroup_number)
-    .def_readwrite("datasets", &Mtz::datasets)
-    .def_readwrite("columns", &Mtz::columns)
-    .def_readwrite("batches", &Mtz::batches)
-    .def_readwrite("history", &Mtz::history)
-    .def_readwrite("appended_text", &Mtz::appended_text)
+    .def(nb::init<bool>(), nb::arg("with_base")=false)
+    .def_prop_ro("array", [](Mtz& self) {
+      size_t nrow = self.has_data() ? (size_t) self.nreflections : 0;
+      size_t ncol = self.columns.size();
+      return nb::ndarray<nb::numpy, float, nb::ndim<2>>(
+          self.data.data(), {nrow, ncol}, nb::handle());
+    }, nb::rv_policy::reference_internal)
+    .def_rw("title", &Mtz::title)
+    .def_rw("nreflections", &Mtz::nreflections)
+    .def_rw("sort_order", &Mtz::sort_order)
+    .def_rw("min_1_d2", &Mtz::min_1_d2)
+    .def_rw("max_1_d2", &Mtz::max_1_d2)
+    .def_rw("valm", &Mtz::valm)
+    .def_ro("nsymop", &Mtz::nsymop)
+    .def_rw("cell", &Mtz::cell)
+    .def_rw("spacegroup", &Mtz::spacegroup)
+    .def_ro("spacegroup_name", &Mtz::spacegroup_name)
+    .def_ro("spacegroup_number", &Mtz::spacegroup_number)
+    .def_rw("datasets", &Mtz::datasets)
+    .def_rw("columns", &Mtz::columns)
+    .def_rw("batches", &Mtz::batches)
+    .def_rw("history", &Mtz::history)
+    .def_rw("appended_text", &Mtz::appended_text)
     .def("resolution_high", &Mtz::resolution_high)
     .def("resolution_low", &Mtz::resolution_low)
     .def("dataset", (Mtz::Dataset& (Mtz::*)(int)) &Mtz::dataset,
-         py::arg("id"))
-    .def("count", &Mtz::count, py::arg("label"))
+         nb::arg("id"))
+    .def("count", &Mtz::count, nb::arg("label"))
     .def("column_with_label",
          (Mtz::Column* (Mtz::*)(const std::string&, const Mtz::Dataset*))
                                                      &Mtz::column_with_label,
-         py::arg("label"), py::arg("dataset")=nullptr,
-         py::return_value_policy::reference_internal)
+         nb::arg("label"), nb::arg("dataset")=nb::none(),
+         nb::rv_policy::reference_internal)
     .def("rfree_column", (Mtz::Column* (Mtz::*)()) &Mtz::rfree_column,
-          py::return_value_policy::reference_internal)
+          nb::rv_policy::reference_internal)
     .def("columns_with_type", &Mtz::columns_with_type,
-         py::arg("type"), py::return_value_policy::reference_internal)
+         nb::arg("type"), nb::rv_policy::reference_internal)
     .def("column_labels", [](const Mtz& self) {
         std::vector<std::string> labels;
         labels.reserve(self.columns.size());
@@ -148,27 +130,38 @@ void add_mtz(py::module& m) {
         return labels;
     })
     .def("get_cell", (UnitCell& (Mtz::*)(int)) &Mtz::get_cell,
-         py::arg("dataset")=-1)
+         nb::arg("dataset")=-1)
     .def("set_cell_for_all", &Mtz::set_cell_for_all)
     .def("make_miller_array", [](const Mtz& self) {
-        py::array_t<int> arr({self.nreflections, 3});
-        py::buffer_info buf = arr.request();
-        int* ptr = (int*) buf.ptr;
-        for (int i = 0; i < self.nreflections; ++i)
-          for (int j = 0; j != 3; ++j)
-            ptr[3*i + j] = (int) self.data[self.columns.size() * i + j];
-        return arr;
+        size_t n = (size_t) self.nreflections;
+        auto numpy_arr = make_numpy_array<int>({n, 3});
+        int* arr = numpy_arr.data();
+        for (size_t i = 0; i < n; ++i)
+          for (size_t j = 0; j != 3; ++j)
+            *arr++ = (int) self.data[self.columns.size() * i + j];
+        return numpy_arr;
     })
-    .def("make_1_d2_array", &make_1_d2_array, py::arg("dataset")=-1)
-    .def("make_d_array", &make_d_array, py::arg("dataset")=-1)
+    .def("make_1_d2_array", [](const Mtz& mtz, int dataset) {
+        return make_new_column(mtz, dataset,
+            [](const UnitCell& cell, float h, float k, float l) noexcept {
+              return (float) cell.calculate_1_d2_double(h, k, l);
+            });
+    }, nb::arg("dataset")=-1)
+    .def("make_d_array", [](const Mtz& mtz, int dataset) {
+        return make_new_column(mtz, dataset,
+            [](const UnitCell& cell, float h, float k, float l) noexcept {
+              double _1_d2 = cell.calculate_1_d2_double(h, k, l);
+              return (float) (1.0 / std::sqrt(_1_d2));
+        });
+    }, nb::arg("dataset")=-1)
     .def("get_size_for_hkl",
          [](const Mtz& self, std::array<int,3> min_size, double sample_rate) {
           return get_size_for_hkl(MtzDataProxy{self}, min_size, sample_rate);
-    }, py::arg("min_size")=std::array<int,3>{{0,0,0}},
-       py::arg("sample_rate")=0.)
+    }, nb::arg("min_size")=std::array<int,3>{{0,0,0}},
+       nb::arg("sample_rate")=0.)
     .def("data_fits_into", [](const Mtz& self, std::array<int,3> size) {
         return data_fits_into(MtzDataProxy{self}, size);
-    }, py::arg("size"))
+    }, nb::arg("size"))
     .def("get_f_phi_on_grid", [](const Mtz& self,
                                  const std::string& f_col,
                                  const std::string& phi_col,
@@ -179,8 +172,8 @@ void add_mtz(py::module& m) {
         const Mtz::Column& phi = self.get_column_with_label(phi_col);
         FPhiProxy<MtzDataProxy> fphi(MtzDataProxy{self}, f.idx, phi.idx);
         return get_f_phi_on_grid<float>(fphi, size, half_l, order);
-    }, py::arg("f"), py::arg("phi"), py::arg("size"),
-       py::arg("half_l")=false, py::arg("order")=AxisOrder::XYZ)
+    }, nb::arg("f"), nb::arg("phi"), nb::arg("size"),
+       nb::arg("half_l")=false, nb::arg("order")=AxisOrder::XYZ)
     .def("get_value_on_grid", [](const Mtz& self,
                                  const std::string& label,
                                  std::array<int, 3> size,
@@ -189,8 +182,8 @@ void add_mtz(py::module& m) {
         const Mtz::Column& col = self.get_column_with_label(label);
         return get_value_on_grid<float>(MtzDataProxy{self}, col.idx,
                                         size, half_l, order);
-    }, py::arg("label"), py::arg("size"), py::arg("half_l")=false,
-       py::arg("order")=AxisOrder::XYZ)
+    }, nb::arg("label"), nb::arg("size"), nb::arg("half_l")=false,
+       nb::arg("order")=AxisOrder::XYZ)
     .def("transform_f_phi_to_map", [](const Mtz& self,
                                       const std::string& f_col,
                                       const std::string& phi_col,
@@ -203,46 +196,46 @@ void add_mtz(py::module& m) {
         FPhiProxy<MtzDataProxy> fphi(MtzDataProxy{self}, f.idx, phi.idx);
         return transform_f_phi_to_map2<float>(fphi, min_size, sample_rate,
                                               exact_size, order);
-    }, py::arg("f"), py::arg("phi"),
-       py::arg("min_size")=std::array<int,3>{{0,0,0}},
-       py::arg("exact_size")=std::array<int,3>{{0,0,0}},
-       py::arg("sample_rate")=0.,
-       py::arg("order")=AxisOrder::XYZ)
+    }, nb::arg("f"), nb::arg("phi"),
+       nb::arg("min_size")=std::array<int,3>{{0,0,0}},
+       nb::arg("exact_size")=std::array<int,3>{{0,0,0}},
+       nb::arg("sample_rate")=0.,
+       nb::arg("order")=AxisOrder::XYZ)
     .def("get_float", &make_asu_data<float, Mtz>,
-         py::arg("col"), py::arg("as_is")=false)
+         nb::arg("col"), nb::arg("as_is")=false)
     .def("get_int", &make_asu_data<int, Mtz>,
-         py::arg("col"), py::arg("as_is")=false)
+         nb::arg("col"), nb::arg("as_is")=false)
     .def("get_f_phi", [](const Mtz& self, const std::string& f_col,
                                           const std::string& phi_col,
                                           bool as_is) {
         return make_asu_data<std::complex<float>, 2>(self, {f_col, phi_col}, as_is);
-    }, py::arg("f"), py::arg("phi"), py::arg("as_is")=false)
+    }, nb::arg("f"), nb::arg("phi"), nb::arg("as_is")=false)
     .def("get_value_sigma", [](const Mtz& self, const std::string& f_col,
                                                 const std::string& sigma_col,
                                                 bool as_is) {
         return make_asu_data<ValueSigma<float>, 2>(self, {f_col, sigma_col}, as_is);
-    }, py::arg("f"), py::arg("sigma"), py::arg("as_is")=false)
-    .def("add_dataset", &Mtz::add_dataset, py::arg("name"),
-         py::return_value_policy::reference_internal)
-    .def("add_column", &Mtz::add_column, py::arg("label"), py::arg("type"),
-         py::arg("dataset_id")=-1, py::arg("pos")=-1, py::arg("expand_data")=true,
-         py::return_value_policy::reference_internal)
+    }, nb::arg("f"), nb::arg("sigma"), nb::arg("as_is")=false)
+    .def("add_dataset", &Mtz::add_dataset, nb::arg("name"),
+         nb::rv_policy::reference_internal)
+    .def("add_column", &Mtz::add_column, nb::arg("label"), nb::arg("type"),
+         nb::arg("dataset_id")=-1, nb::arg("pos")=-1, nb::arg("expand_data")=true,
+         nb::rv_policy::reference_internal)
     .def("replace_column", &Mtz::replace_column,
-         py::arg("dest_idx"), py::arg("src_col"),
-         py::arg("trailing_cols")=std::vector<std::string>(),
-         py::return_value_policy::reference_internal)
+         nb::arg("dest_idx"), nb::arg("src_col"),
+         nb::arg("trailing_cols")=std::vector<std::string>(),
+         nb::rv_policy::reference_internal)
     .def("copy_column", &Mtz::copy_column,
-         py::arg("dest_idx"), py::arg("src_col"),
-         py::arg("trailing_cols")=std::vector<std::string>(),
-         py::return_value_policy::reference_internal)
-    .def("remove_column", &Mtz::remove_column, py::arg("index"))
+         nb::arg("dest_idx"), nb::arg("src_col"),
+         nb::arg("trailing_cols")=std::vector<std::string>(),
+         nb::rv_policy::reference_internal)
+    .def("remove_column", &Mtz::remove_column, nb::arg("index"))
     .def("set_data", [](Mtz& self, const AsuData<std::complex<float>>& asu_data) {
          if (self.columns.size() != 5)
            fail("Mtz.set_data(): Mtz must have 5 columns to put H,K,L,F,Phi.");
          self.nreflections = (int) asu_data.v.size();
          self.data.clear();
          add_asu_f_phi_to_float_vector(self.data, asu_data);
-    }, py::arg("asu_data"))
+    }, nb::arg("asu_data"))
     .def("set_data", [](Mtz& self, const AsuData<float>& asu_data) {
          if (self.columns.size() != 4)
            fail("Mtz.set_data(): Mtz must have 4 columns.");
@@ -254,105 +247,100 @@ void add_mtz(py::module& m) {
              self.data.push_back((float) item.hkl[i]);
            self.data.push_back(item.value);
          }
-    }, py::arg("asu_data"))
-    .def("set_data", [](Mtz& self, py::array_t<float> arr) {
-         if (arr.ndim() != 2)
-           fail("Mtz.set_data(): expected 2D array.");
-         int nrow = (int) arr.shape(0);
-         int ncol = (int) arr.shape(1);
-         if (ncol != (int) self.columns.size())
+    }, nb::arg("asu_data"))
+    .def("set_data", [](Mtz& self, nb::ndarray<float, nb::ndim<2>> arr) {
+         size_t nrow = arr.shape(0);
+         size_t ncol = arr.shape(1);
+         if (ncol != self.columns.size())
            fail("Mtz.set_data(): expected " +
                 std::to_string(self.columns.size()) + " columns.");
-         self.nreflections = nrow;
+         self.nreflections = (int) nrow;
          self.data.resize(nrow * ncol);
-         auto r = arr.unchecked<2>();
-         for (py::ssize_t row = 0; row < nrow; row++)
-           for (py::ssize_t col = 0; col < ncol; col++)
+         auto r = arr.view();
+         for (size_t row = 0; row < nrow; row++)
+           for (size_t col = 0; col < ncol; col++)
              self.data[row*ncol+col] = r(row, col);
-    }, py::arg("array"))
+    }, nb::arg("array"))
     .def("update_reso", &Mtz::update_reso)
-    .def("sort", &Mtz::sort, py::arg("use_first")=3)
-    .def("ensure_asu", &Mtz::ensure_asu, py::arg("tnt_asu")=false)
+    .def("sort", &Mtz::sort, nb::arg("use_first")=3)
+    .def("ensure_asu", &Mtz::ensure_asu, nb::arg("tnt_asu")=false)
     .def("switch_to_original_hkl", &Mtz::switch_to_original_hkl)
     .def("switch_to_asu_hkl", &Mtz::switch_to_asu_hkl)
-    .def("write_to_file", &Mtz::write_to_file, py::arg("path"))
+    .def("write_to_file", &Mtz::write_to_file, nb::arg("path"))
     .def("reindex", [](Mtz& self, const Op& op) {
         std::ostringstream out;
         self.reindex(op, &out);
         return out.str();
-    }, py::arg("op"))
+    }, nb::arg("op"))
     .def("expand_to_p1", &Mtz::expand_to_p1)
     // handy for testing, but slow and can't handle duplicated column names
     .def("row_as_dict", [](const Mtz& self, const Miller& hkl) {
         size_t offset = self.find_offset_of_hkl(hkl);
-        py::dict data;
+        nb::dict data;
         if (offset != (size_t)-1)
           for (const Mtz::Column& column : self.columns)
             data[column.label.c_str()] = self.data[offset++];
         return data;
-    }, py::arg("hkl"))
+    }, nb::arg("hkl"))
     .def("__repr__", [](const Mtz& self) {
         return tostr("<gemmi.Mtz with ", self.columns.size(), " columns, ",
                      self.nreflections, " reflections>");
     });
 
   pyMtzDataset
-    .def_readwrite("id", &Mtz::Dataset::id)
-    .def_readwrite("project_name", &Mtz::Dataset::project_name)
-    .def_readwrite("crystal_name", &Mtz::Dataset::crystal_name)
-    .def_readwrite("dataset_name", &Mtz::Dataset::dataset_name)
-    .def_readwrite("cell", &Mtz::Dataset::cell)
-    .def_readwrite("wavelength", &Mtz::Dataset::wavelength)
+    .def_rw("id", &Mtz::Dataset::id)
+    .def_rw("project_name", &Mtz::Dataset::project_name)
+    .def_rw("crystal_name", &Mtz::Dataset::crystal_name)
+    .def_rw("dataset_name", &Mtz::Dataset::dataset_name)
+    .def_rw("cell", &Mtz::Dataset::cell)
+    .def_rw("wavelength", &Mtz::Dataset::wavelength)
     .def("__repr__", [](const Mtz::Dataset& self) { return tostr(self); })
     ;
   pyMtzColumn
-    .def_buffer([](Mtz::Column& self) {
-      return py::buffer_info(self.parent->data.data() + self.idx,
-                             std::vector<py::ssize_t>(1, self.size()), // dimensions
-                             {4 * self.stride()});  // strides
-    })
-    .def_property_readonly("array", [](const Mtz::Column& self) {
-      return py::array_t<float>({self.size()}, {4 * self.stride()},
-                                self.parent->data.data() + self.idx,
-                                py::cast(self));
-    }, py::return_value_policy::reference_internal)
-    .def_property_readonly("dataset",
+    .def_prop_ro("array", [](const Mtz::Column& self) {
+      return nb::ndarray<nb::numpy, float, nb::ndim<1>>(
+          self.parent->data.data() + self.idx,
+          {(size_t)self.size()},
+          nb::handle(),
+          {(int64_t) self.stride()});
+    }, nb::rv_policy::reference_internal)
+    .def_prop_ro("dataset",
             (Mtz::Dataset& (Mtz::Column::*)()) &Mtz::Column::dataset)
-    .def_readwrite("dataset_id", &Mtz::Column::dataset_id)
-    .def_readwrite("type", &Mtz::Column::type)
-    .def_readwrite("label", &Mtz::Column::label)
-    .def_readwrite("min_value", &Mtz::Column::min_value)
-    .def_readwrite("max_value", &Mtz::Column::max_value)
-    .def_readwrite("source", &Mtz::Column::source)
-    .def_readwrite("idx", &Mtz::Column::idx)
+    .def_rw("dataset_id", &Mtz::Column::dataset_id)
+    .def_rw("type", &Mtz::Column::type)
+    .def_rw("label", &Mtz::Column::label)
+    .def_rw("min_value", &Mtz::Column::min_value)
+    .def_rw("max_value", &Mtz::Column::max_value)
+    .def_rw("source", &Mtz::Column::source)
+    .def_rw("idx", &Mtz::Column::idx)
     .def("is_integer", &Mtz::Column::is_integer)
     .def("__len__", &Mtz::Column::size)
     .def("__getitem__", [](const Mtz::Column& self, int index) -> float {
         return self.at(index >= 0 ? index : index + self.size());
-    }, py::arg("index"))
+    }, nb::arg("index"))
     .def("__iter__", [](Mtz::Column& self) {
-        return py::make_iterator(self);
-    }, py::keep_alive<0, 1>())
+        return usual_iterator(self, self);
+    }, nb::keep_alive<0, 1>())
     .def("__repr__", [](const Mtz::Column& self) {
         return cat("<gemmi.Mtz.Column ", self.label, " type ", self.type, '>');
     })
     ;
   pyMtzBatch
-    .def(py::init<>())
-    .def_readwrite("number", &Mtz::Batch::number)
-    .def_readwrite("title", &Mtz::Batch::title)
-    .def_property("ints",
+    .def(nb::init<>())
+    .def_rw("number", &Mtz::Batch::number)
+    .def_rw("title", &Mtz::Batch::title)
+    .def_prop_rw("ints",
         [](Mtz::Batch& self) { return VectorRef<int>(self.ints); },
         [](Mtz::Batch& self, const VectorRef<int>& x) { self.ints = x.v; },
-        py::return_value_policy::reference_internal)
-    .def_property("floats",
+        nb::rv_policy::reference_internal)
+    .def_prop_rw("floats",
         [](Mtz::Batch& self) { return VectorRef<float>(self.floats); },
         [](Mtz::Batch& self, const VectorRef<float>& x) { self.floats = x.v; },
-        py::return_value_policy::reference_internal)
-    .def_readwrite("axes", &Mtz::Batch::axes)
-    .def_property("cell", &Mtz::Batch::get_cell, &Mtz::Batch::set_cell)
-    .def_property("dataset_id", &Mtz::Batch::dataset_id, &Mtz::Batch::set_dataset_id)
-    .def_property("wavelength", &Mtz::Batch::wavelength, &Mtz::Batch::set_wavelength)
+        nb::rv_policy::reference_internal)
+    .def_rw("axes", &Mtz::Batch::axes)
+    .def_prop_rw("cell", &Mtz::Batch::get_cell, &Mtz::Batch::set_cell)
+    .def_prop_rw("dataset_id", &Mtz::Batch::dataset_id, &Mtz::Batch::set_dataset_id)
+    .def_prop_rw("wavelength", &Mtz::Batch::wavelength, &Mtz::Batch::set_wavelength)
     .def("clone", [](const Mtz::Batch& self) { return new Mtz::Batch(self); })
     ;
 
@@ -360,5 +348,5 @@ void add_mtz(py::module& m) {
     std::unique_ptr<Mtz> mtz(new Mtz);
     mtz->read_file_gz(path, true);
     return mtz.release();
-  }, py::arg("path"));
+  }, nb::arg("path"));
 }
diff --git a/python/read.cpp b/python/read.cpp
index fc471eec5..33e4cfe8a 100644
--- a/python/read.cpp
+++ b/python/read.cpp
@@ -1,5 +1,10 @@
 // Copyright 2017 Global Phasing Ltd.
 
+#include "common.h"
+#include <nanobind/stl/bind_vector.h>
+#include <nanobind/stl/string.h>
+#include <nanobind/stl/vector.h>
+
 #include "gemmi/numb.hpp"
 #include "gemmi/cifdoc.hpp"
 #include "gemmi/cif.hpp"
@@ -13,150 +18,148 @@
 #include "gemmi/read_cif.hpp"      // for read_cif_gz, read_mmjson_gz
 #include "gemmi/mmread_gz.hpp"     // for read_structure_gz
 
-#include "common.h"
-#include <pybind11/stl.h>
-#include <pybind11/stl_bind.h>
 
-namespace py = pybind11;
 using namespace gemmi;
 
-PYBIND11_MAKE_OPAQUE(std::vector<SmallStructure::Site>)
+NB_MAKE_OPAQUE(std::vector<SmallStructure::Site>)
 
-void add_cif_read(py::module& cif) {
-  cif.def("read_file", &cif::read_file, py::arg("filename"),
+void add_cif_read(nb::module_& cif) {
+  cif.def("read_file", &cif::read_file, nb::arg("filename"),
           "Reads a CIF file copying data into Document.");
   cif.def("read", &read_cif_or_mmjson_gz,
-          py::arg("filename"), "Reads normal or gzipped CIF file.");
+          nb::arg("filename"), "Reads normal or gzipped CIF file.");
   cif.def("read_mmjson", &read_mmjson_gz,
-          py::arg("filename"), "Reads normal or gzipped mmJSON file.");
-  cif.def("read_string", &cif::read_string, py::arg("data"),
+          nb::arg("filename"), "Reads normal or gzipped mmJSON file.");
+  cif.def("read_string", &cif::read_string, nb::arg("data"),
           "Reads a string as a CIF file.");
 
   cif.def("as_string", (std::string (*)(const std::string&)) &cif::as_string,
-          py::arg("value"), "Get string content (no quotes) from raw string.");
+          nb::arg("value"), "Get string content (no quotes) from raw string.");
   cif.def("as_number", &cif::as_number,
-          py::arg("value"), py::arg("default")=NAN,
+          nb::arg("value"), nb::arg("default")=NAN,
           "Returns float number from string");
   cif.def("as_int", (int (*)(const std::string&)) &cif::as_int,
-          py::arg("value"), "Returns int number from string value.");
+          nb::arg("value"), "Returns int number from string value.");
   cif.def("as_int", (int (*)(const std::string&, int)) &cif::as_int,
-          py::arg("value"), py::arg("default"),
+          nb::arg("value"), nb::arg("default"),
           "Returns int number from string value or the second arg if null.");
-  cif.def("is_null", &cif::is_null, py::arg("value"));
+  cif.def("is_null", &cif::is_null, nb::arg("value"));
 }
 
-void add_read_structure(py::module& m) {
+void add_read_structure(nb::module_& m) {
   m.def("read_structure", [](const std::string& path, bool merge,
                              CoorFormat format, cif::Document* save_doc) {
           Structure* st = new Structure(read_structure_gz(path, format, save_doc));
           if (merge)
             st->merge_chain_parts();
           return st;
-        }, py::arg("path"), py::arg("merge_chain_parts")=true,
-           py::arg("format")=CoorFormat::Unknown,
-           py::arg("save_doc")=nullptr,
+        }, nb::arg("path"), nb::arg("merge_chain_parts")=true,
+           nb::arg("format")=CoorFormat::Unknown,
+           nb::arg("save_doc")=nb::none(),
         "Reads a coordinate file into Structure.");
   m.def("make_structure_from_block", &make_structure_from_block,
-        py::arg("block"), "Takes mmCIF block and returns Structure.");
+        nb::arg("block"), "Takes mmCIF block and returns Structure.");
   m.def("read_pdb_string", [](const std::string& s, int max_line_length,
                               bool split_chain_on_ter) {
           PdbReadOptions options;
           options.max_line_length = max_line_length;
           options.split_chain_on_ter = split_chain_on_ter;
           return new Structure(read_pdb_string(s, "string", options));
-        }, py::arg("s"), py::arg("max_line_length")=0,
-           py::arg("split_chain_on_ter")=false, "Reads a string as PDB file.");
+        }, nb::arg("s"), nb::arg("max_line_length")=0,
+           nb::arg("split_chain_on_ter")=false, "Reads a string as PDB file.");
   m.def("read_pdb", [](const std::string& path, int max_line_length,
                        bool split_chain_on_ter) {
           PdbReadOptions options;
           options.max_line_length = max_line_length;
           options.split_chain_on_ter = split_chain_on_ter;
           return new Structure(read_pdb_gz(path, options));
-        }, py::arg("filename"), py::arg("max_line_length")=0,
-           py::arg("split_chain_on_ter")=false);
+        }, nb::arg("filename"), nb::arg("max_line_length")=0,
+           nb::arg("split_chain_on_ter")=false);
 
   // from smcif.hpp
   m.def("read_small_structure", [](const std::string& path) {
           cif::Block block = cif::read_file(path).sole_block();
           return new SmallStructure(make_small_structure_from_block(block));
-        }, py::arg("path"), "Reads a small molecule CIF file.");
+        }, nb::arg("path"), "Reads a small molecule CIF file.");
   m.def("make_small_structure_from_block", &make_small_structure_from_block,
-        py::arg("block"), "Takes CIF block and returns SmallStructure.");
+        nb::arg("block"), "Takes CIF block and returns SmallStructure.");
 
   // from chemcomp_xyz.hpp
   m.def("make_structure_from_chemcomp_block",
-        &make_structure_from_chemcomp_block, py::arg("block"),
+        &make_structure_from_chemcomp_block, nb::arg("block"),
         "CIF block from CCD or monomer library -> single-residue Structure.");
 
 
   // and an unrelated function from gz.hpp
   m.def("estimate_uncompressed_size", &estimate_uncompressed_size,
-        py::arg("path"),
+        nb::arg("path"),
         "Returns uncompressed size of a .gz file (not always reliable)");
 }
 
-void add_small(py::module& m) {
+void add_small(nb::module_& m) {
   using gemmi::SmallStructure;
-  py::class_<SmallStructure> small_structure(m, "SmallStructure");
-  py::class_<SmallStructure::Site>(small_structure, "Site")
-    .def(py::init<>())
-    .def(py::init(&gemmi::atom_to_site))
-    .def_readwrite("label", &SmallStructure::Site::label)
-    .def_readwrite("type_symbol", &SmallStructure::Site::type_symbol)
-    .def_readwrite("fract", &SmallStructure::Site::fract)
-    .def_readwrite("occ", &SmallStructure::Site::occ)
-    .def_readwrite("u_iso", &SmallStructure::Site::u_iso)
-    .def_readwrite("element", &SmallStructure::Site::element)
-    .def_readwrite("charge", &SmallStructure::Site::charge)
-    .def_readwrite("disorder_group", &SmallStructure::Site::disorder_group)
-    .def_readwrite("aniso", &SmallStructure::Site::aniso)
+  nb::class_<SmallStructure> small_structure(m, "SmallStructure");
+  nb::class_<SmallStructure::Site>(small_structure, "Site")
+    .def(nb::init<>())
+    .def("__init__", [](SmallStructure::Site* site, const Atom& atom, const UnitCell& cell) {
+        new(site) SmallStructure::Site(gemmi::atom_to_site(atom, cell));
+    })
+    .def_rw("label", &SmallStructure::Site::label)
+    .def_rw("type_symbol", &SmallStructure::Site::type_symbol)
+    .def_rw("fract", &SmallStructure::Site::fract)
+    .def_rw("occ", &SmallStructure::Site::occ)
+    .def_rw("u_iso", &SmallStructure::Site::u_iso)
+    .def_rw("element", &SmallStructure::Site::element)
+    .def_rw("charge", &SmallStructure::Site::charge)
+    .def_rw("disorder_group", &SmallStructure::Site::disorder_group)
+    .def_rw("aniso", &SmallStructure::Site::aniso)
     .def("orth", &SmallStructure::Site::orth)
     .def("clone", [](const SmallStructure::Site& self) { return new SmallStructure::Site(self); })
     .def("__repr__", [](const SmallStructure::Site& self) {
         return "<gemmi.SmallStructure.Site " + self.label + ">";
     });
-  py::bind_vector<std::vector<SmallStructure::Site>>(small_structure, "SiteList");
+  nb::bind_vector<std::vector<SmallStructure::Site>, rv_ri>(small_structure, "SiteList");
 
   using AtomType = SmallStructure::AtomType;
-  py::class_<AtomType>(small_structure, "AtomType")
-    .def_readonly("symbol", &AtomType::symbol)
-    .def_readonly("element", &AtomType::element)
-    .def_readwrite("dispersion_real", &AtomType::dispersion_real)
-    .def_readwrite("dispersion_imag", &AtomType::dispersion_imag)
+  nb::class_<AtomType>(small_structure, "AtomType")
+    .def_ro("symbol", &AtomType::symbol)
+    .def_ro("element", &AtomType::element)
+    .def_rw("dispersion_real", &AtomType::dispersion_real)
+    .def_rw("dispersion_imag", &AtomType::dispersion_imag)
     .def("__repr__", [](const AtomType& self) {
         return "<gemmi.SmallStructure.AtomType " + self.symbol + ">";
     });
 
   small_structure
-    .def(py::init<>())
-    .def_readwrite("name", &SmallStructure::name)
-    .def_readwrite("cell", &SmallStructure::cell)
-    .def_readonly("spacegroup", &SmallStructure::spacegroup,
-                  py::return_value_policy::reference_internal)
-    .def_readwrite("spacegroup_hm", &SmallStructure::spacegroup_hm)
-    .def_readwrite("spacegroup_hall", &SmallStructure::spacegroup_hall)
-    .def_readwrite("spacegroup_number", &SmallStructure::spacegroup_number)
-    .def_readwrite("symops", &SmallStructure::symops)
-    .def_readwrite("sites", &SmallStructure::sites)
-    .def_readonly("atom_types", &SmallStructure::atom_types)
-    .def_readwrite("wavelength", &SmallStructure::wavelength)
+    .def(nb::init<>())
+    .def_rw("name", &SmallStructure::name)
+    .def_rw("cell", &SmallStructure::cell)
+    .def_ro("spacegroup", &SmallStructure::spacegroup,
+                  nb::rv_policy::reference_internal)
+    .def_rw("spacegroup_hm", &SmallStructure::spacegroup_hm)
+    .def_rw("spacegroup_hall", &SmallStructure::spacegroup_hall)
+    .def_rw("spacegroup_number", &SmallStructure::spacegroup_number)
+    .def_rw("symops", &SmallStructure::symops)
+    .def_rw("sites", &SmallStructure::sites)
+    .def_ro("atom_types", &SmallStructure::atom_types)
+    .def_rw("wavelength", &SmallStructure::wavelength)
     .def("add_site", [](SmallStructure& self, const SmallStructure::Site& site) {
         self.sites.push_back(site);
     })
-    .def("set_spacegroup", &SmallStructure::set_spacegroup, py::arg("order"))
+    .def("set_spacegroup", &SmallStructure::set_spacegroup, nb::arg("order"))
     .def("check_spacegroup", &SmallStructure::check_spacegroup)
     .def("get_atom_type", &SmallStructure::get_atom_type)
     .def("get_all_unit_cell_sites", &SmallStructure::get_all_unit_cell_sites)
     .def("remove_hydrogens", &SmallStructure::remove_hydrogens)
     .def("change_occupancies_to_crystallographic",
          &SmallStructure::change_occupancies_to_crystallographic,
-         py::arg("max_dist")=0.4)
+         nb::arg("max_dist")=0.4)
     .def("make_cif_block", &make_cif_block_from_small_structure)
     .def("__repr__", [](const SmallStructure& self) {
         return "<gemmi.SmallStructure: " + std::string(self.name) + ">";
     });
   m.def("mx_to_sx_structure", &gemmi::mx_to_sx_structure,
-        py::arg("st"), py::arg("n")=0);
+        nb::arg("st"), nb::arg("n")=0);
 }
 
 // used in cif.cpp
diff --git a/python/recgrid.cpp b/python/recgrid.cpp
index 95fa2b6e5..0093213d0 100644
--- a/python/recgrid.cpp
+++ b/python/recgrid.cpp
@@ -1,14 +1,16 @@
 // Copyright 2020 Global Phasing Ltd.
 
+#include "common.h"
+#include "array.h"
+#include "make_iterator.h"
+#include <nanobind/stl/array.h>
+#include <nanobind/stl/complex.h>
+#include <nanobind/stl/string.h>
+
 #include "gemmi/recgrid.hpp"
 #include "gemmi/fourier.hpp"  // for get_size_for_hkl, get_f_phi_on_grid
 #include "tostr.hpp"
 
-#include "common.h"
-#include <pybind11/numpy.h>
-#include <pybind11/stl.h>
-
-namespace py = pybind11;
 using namespace gemmi;
 
 namespace gemmi {
@@ -18,50 +20,56 @@ namespace gemmi {
   }
 }
 
-template<typename T, typename F>
-py::array_t<float> make_new_column(const AsuData<T>& asu_data, F f) {
+template<typename T, typename Func>
+auto make_new_column(const AsuData<T>& asu_data, Func f) {
   if (!asu_data.unit_cell().is_crystal())
     throw std::runtime_error("AsuData: unknown unit cell parameters");
-  py::array_t<float> arr(asu_data.size());
-  py::buffer_info buf = arr.request();
-  float* ptr = (float*) buf.ptr;
+  auto numpy_arr = make_numpy_array<float>({asu_data.size()});
+  float* arr = numpy_arr.data();
   for (size_t i = 0; i < asu_data.size(); ++i)
-    ptr[i] = static_cast<float>(f(asu_data.unit_cell(), asu_data.get_hkl(i)));
-  return arr;
+    arr[i] = static_cast<float>(f(asu_data.unit_cell(), asu_data.get_hkl(i)));
+  return numpy_arr;
 }
 
 template<typename T> void add_to_asu_data(T&) {}
-template<> void add_to_asu_data(py::class_<AsuData<std::complex<float>>>& cl) {
+template<> void add_to_asu_data(nb::class_<AsuData<std::complex<float>>>& cl) {
   using AsuData = AsuData<std::complex<float>>;
   cl.def("get_size_for_hkl", &get_size_for_hkl<AsuData>,
-         py::arg("min_size")=std::array<int,3>{{0,0,0}}, py::arg("sample_rate")=0.);
-  cl.def("data_fits_into", &data_fits_into<AsuData>, py::arg("size"));
+         nb::arg("min_size")=std::array<int,3>{{0,0,0}}, nb::arg("sample_rate")=0.);
+  cl.def("data_fits_into", &data_fits_into<AsuData>, nb::arg("size"));
   cl.def("get_f_phi_on_grid", get_f_phi_on_grid<float, AsuData>,
-         py::arg("size"), py::arg("half_l")=false, py::arg("order")=AxisOrder::XYZ);
+         nb::arg("size"), nb::arg("half_l")=false, nb::arg("order")=AxisOrder::XYZ);
   cl.def("transform_f_phi_to_map", &transform_f_phi_to_map2<float, AsuData>,
-         py::arg("min_size")=std::array<int,3>{{0,0,0}},
-         py::arg("sample_rate")=0.,
-         py::arg("exact_size")=std::array<int,3>{{0,0,0}},
-         py::arg("order")=AxisOrder::XYZ);
+         nb::arg("min_size")=std::array<int,3>{{0,0,0}},
+         nb::arg("sample_rate")=0.,
+         nb::arg("exact_size")=std::array<int,3>{{0,0,0}},
+         nb::arg("order")=AxisOrder::XYZ);
   cl.def("calculate_correlation", [](const AsuData& self, const AsuData& other) {
       return calculate_hkl_complex_correlation(self.v, other.v);
   });
 }
-template<> void add_to_asu_data(py::class_<AsuData<float>>& cl) {
+template<> void add_to_asu_data(nb::class_<AsuData<float>>& cl) {
   using AsuData = AsuData<float>;
   cl.def("calculate_correlation", [](const AsuData& self, const AsuData& other) {
       return calculate_hkl_value_correlation(self.v, other.v);
   });
 }
-template<> void add_to_asu_data(py::class_<AsuData<ValueSigma<float>>>& cl) {
+template<> void add_to_asu_data(nb::class_<AsuData<ValueSigma<float>>>& cl) {
   cl.def("discard_by_sigma_ratio", &discard_by_sigma_ratio<float>);
 }
 
+template<typename T> struct array_for {
+  using type = cpu_c_array<T>;
+};
+template<> struct array_for<ValueSigma<float>> {
+  using type = nb::ndarray<float, nb::shape<-1, 2>, nb::device::cpu, nb::c_contig>;
+};
+
 template<typename T>
-void add_asudata(py::module& m, const std::string& prefix) {
-  py::class_<HklValue<T>>(m, (prefix + "HklValue").c_str())
-    .def_readonly("hkl", &HklValue<T>::hkl)
-    .def_readwrite("value", &HklValue<T>::value)
+void add_asudata(nb::module_& m, const std::string& prefix) {
+  nb::class_<HklValue<T>>(m, (prefix + "HklValue").c_str())
+    .def_ro("hkl", &HklValue<T>::hkl)
+    .def_rw("value", &HklValue<T>::value)
     .def("__repr__", [prefix](const HklValue<T>& self) {
         return tostr("<gemmi.", prefix, "HklValue (",
                      self.hkl[0], ',', self.hkl[1], ',', self.hkl[2], ") ",
@@ -69,47 +77,55 @@ void add_asudata(py::module& m, const std::string& prefix) {
     });
 
   using AsuData = AsuData<T>;
-  py::class_<AsuData> asu_data(m, (prefix + "AsuData").c_str());
+  nb::class_<AsuData> asu_data(m, (prefix + "AsuData").c_str());
   asu_data
-    .def(py::init([](const UnitCell& unit_cell, const SpaceGroup* sg,
-                     py::array_t<int> hkl, py::array_t<T> values) {
-      auto h = hkl.unchecked<2>();
-      if (h.shape(1) != 3)
-        throw std::domain_error("error: the size of the second dimension != 3");
-      auto v = values.template unchecked<1>();
+    .def("__init__", [](AsuData* p, const UnitCell& unit_cell, const SpaceGroup* sg,
+                        cpu_miller_array hkl, typename array_for<T>::type values) {
+      new(p) AsuData;
+      auto h = hkl.view();
+      auto v = values.view();
       if (h.shape(0) != v.shape(0))
         throw std::domain_error("error: arrays have different lengths");
-      AsuData* ret = new AsuData;
-      ret->spacegroup_ = sg;
-      ret->unit_cell_ = unit_cell;
-      ret->unit_cell_.set_cell_images_from_spacegroup(ret->spacegroup_);
-      ret->v.reserve(h.shape(0));
-      for (py::ssize_t i = 0; i < h.shape(0); ++i)
-        ret->v.push_back({{{h(i, 0), h(i, 1), h(i, 2)}}, v(i)});
-      return ret;
-    }), py::arg("cell"), py::arg("sg").none(false),
-        py::arg("miller_array"), py::arg("value_array"))
-    .def("__iter__", [](AsuData& self) { return py::make_iterator(self.v); },
-         py::keep_alive<0, 1>())
+      p->spacegroup_ = sg;
+      p->unit_cell_ = unit_cell;
+      p->unit_cell_.set_cell_images_from_spacegroup(p->spacegroup_);
+      p->v.reserve(h.shape(0));
+      for (size_t i = 0; i < h.shape(0); ++i) {
+        Miller hkl {h(i, 0), h(i, 1), h(i, 2)};
+        if constexpr (std::is_same<T, ValueSigma<float>>::value)
+          p->v.push_back({hkl, T{v(i, 0), v(i, 1)}});
+        else
+          p->v.push_back({hkl, v(i)});
+      }
+    }, nb::arg("cell"), nb::arg("sg")/*.none(false)*/,
+       nb::arg("miller_array"), nb::arg("value_array"))
+    .def("__iter__", [](AsuData& self) {
+        return usual_iterator(self, self.v);
+    }, nb::keep_alive<0, 1>())
     .def("__len__", [](const AsuData& self) { return self.v.size(); })
     .def("__getitem__", [](AsuData& self, int index) -> HklValue<T>& {
         return self.v.at(normalize_index(index, self.v));
-    }, py::arg("index"), py::return_value_policy::reference_internal)
-    .def_readwrite("spacegroup", &AsuData::spacegroup_)
-    .def_readwrite("unit_cell", &AsuData::unit_cell_)
-    .def_property_readonly("miller_array", [](const AsuData& self) {
-      const HklValue<T>* data = self.v.data();
-      py::array::ShapeContainer shape({(py::ssize_t)self.v.size(), 3});
-      py::array::StridesContainer strides({(const char*)(data+1) - (const char*)data,
-                                           sizeof(int)});
-      return py::array_t<int>(shape, strides, &data->hkl[0], py::cast(self));
-    }, py::return_value_policy::reference_internal)
-    .def_property_readonly("value_array", [](const AsuData& self) {
-      const HklValue<T>* data = self.v.data();
-      py::ssize_t stride = (const char*)(data+1) - (const char*)data;
-      return py::array_t<T>({(py::ssize_t)self.v.size()}, {stride},
-                            &data->value, py::cast(self));
-    }, py::return_value_policy::reference_internal)
+    }, nb::arg("index"), nb::rv_policy::reference_internal)
+    .def_rw("spacegroup", &AsuData::spacegroup_)
+    .def_rw("unit_cell", &AsuData::unit_cell_)
+    .def_prop_ro("miller_array", [](AsuData& self) {
+      // cf. vector_member_array
+      int64_t stride = int64_t(sizeof(HklValue<T>) / sizeof(int));
+      return nb::ndarray<nb::numpy, int, nb::shape<-1,3>>(
+          &self.v[0].hkl[0], {self.v.size(), 3}, nb::handle(), {stride, 1});
+    }, nb::rv_policy::reference_internal)
+    .def_prop_ro("value_array", [](AsuData& self) {
+      if constexpr (std::is_same<T, ValueSigma<float>>::value) {
+        auto stride = sizeof(ValueSigma<HklValue<float>>) / sizeof(float);
+        return nb::ndarray<nb::numpy, float, nb::shape<-1, 2>>(
+                &(self.v.data()->value.value),
+                {self.v.size(), 2},
+                nb::handle(),
+                {(int64_t)stride, 1});
+      } else {
+        return vector_member_array(self.v, &HklValue<T>::value);
+      }
+    }, nb::rv_policy::reference_internal)
     .def("make_1_d2_array", [](const AsuData& asu_data) {
       return make_new_column(asu_data, [](const UnitCell& cell, Miller hkl) {
         return cell.calculate_1_d2(hkl);
@@ -124,7 +140,7 @@ void add_asudata(py::module& m, const std::string& prefix) {
       return count_equal_values(self.v, other.v);
     })
     .def("ensure_sorted", &AsuData::ensure_sorted)
-    .def("ensure_asu", &AsuData::ensure_asu, py::arg("tnt_asu")=false)
+    .def("ensure_asu", &AsuData::ensure_asu, nb::arg("tnt_asu")=false)
     .def("copy", [](const AsuData& self) {
       return new AsuData(self);
     })
@@ -135,87 +151,80 @@ void add_asudata(py::module& m, const std::string& prefix) {
 }
 
 template<typename TA, typename TG=TA>
-void add_asudata_and_recgrid(py::module& m,
+void add_asudata_and_recgrid(nb::module_& m,
                              const std::string& prefix_asu,
                              const std::string& rgrid_name) {
   using RecGr = ReciprocalGrid<TG>;
   // needed before add_asudata for ComplexAsuData.get_f_phi_on_grid
-  py::class_<RecGr, GridBase<TG>> recgrid(m, rgrid_name.c_str());
+  nb::class_<RecGr, GridBase<TG>> recgrid(m, rgrid_name.c_str());
 
   add_asudata<TA>(m, prefix_asu);
 
   recgrid
-    .def_readonly("half_l", &RecGr::half_l)
-    .def(py::init<>())
-    .def(py::init([](int nx, int ny, int nz) {
-      RecGr* grid = new RecGr();
+    .def_ro("half_l", &RecGr::half_l)
+    .def(nb::init<>())
+    .def("__init__", [](RecGr* grid, int nx, int ny, int nz) {
+      new(grid) RecGr();
       grid->set_size_without_checking(nx, ny, nz);
       grid->axis_order = AxisOrder::XYZ;
-      return grid;
-    }), py::arg("nx"), py::arg("ny"), py::arg("nz"))
-    .def(py::init([](py::array_t<TG> arr, const UnitCell *cell, const SpaceGroup* sg) {
-      auto r = arr.template unchecked<3>();
-      RecGr* grid = new RecGr();
+    }, nb::arg("nx"), nb::arg("ny"), nb::arg("nz"))
+    .def("__init__", [](RecGr* grid,
+                        nb::ndarray<TG, nb::ndim<3>, nb::device::cpu> arr,
+                        const UnitCell *cell, const SpaceGroup* sg) {
+      auto r = arr.view();
+      new(grid) RecGr();
       grid->set_size_without_checking((int)r.shape(0), (int)r.shape(1), (int)r.shape(2));
       grid->axis_order = AxisOrder::XYZ;
-      for (int k = 0; k < r.shape(2); ++k)
-        for (int j = 0; j < r.shape(1); ++j)
-          for (int i = 0; i < r.shape(0); ++i)
+      for (size_t k = 0; k < r.shape(2); ++k)
+        for (size_t j = 0; j < r.shape(1); ++j)
+          for (size_t i = 0; i < r.shape(0); ++i)
             grid->data[grid->index_q(i, j, k)] = r(i, j, k);
       if (cell)
         grid->unit_cell = *cell;
       if (sg)
         grid->spacegroup = sg;
-      return grid;
-    }), py::arg().noconvert(), py::arg("cell")=nullptr, py::arg("spacegroup")=nullptr)
+    }, nb::arg().noconvert(), nb::arg("cell")=nb::none(), nb::arg("spacegroup")=nb::none())
     .def("get_value", &RecGr::get_value)
     .def("get_value_or_zero", &RecGr::get_value_or_zero)
     .def("set_value", &RecGr::set_value)
     .def("to_hkl", &RecGr::to_hkl)
     .def("calculate_1_d2", &RecGr::calculate_1_d2)
     .def("calculate_d", &RecGr::calculate_d)
-    .def("get_value_by_hkl", [](RecGr &self, py::array_t<int> hkl, double unblur,
+    .def("get_value_by_hkl", [](RecGr &self, cpu_miller_array hkl, double unblur,
                                 bool mott_bethe, TA mott_bethe_000) {
-      auto h = hkl.unchecked<2>();
-      if (h.shape(1) != 3)
-        throw std::domain_error("error: the size of the second dimension != 3");
-      py::array_t<TA> vals(h.shape(0));
-      TA* ptr = (TA*) vals.request().ptr;
-      for (py::ssize_t i = 0; i < h.shape(0); ++i) {
-        Miller mi{{h(i, 0), h(i, 1), h(i, 2)}};
+      auto h = hkl.view();
+      auto vals = make_numpy_array<TA>({h.shape(0)});
+      TA* ptr = vals.data();
+      for (size_t i = 0; i < h.shape(0); ++i) {
+        Miller mi{h(i, 0), h(i, 1), h(i, 2)};
         if (mott_bethe && mi[0] == 0 && mi[1] == 0 && mi[2] == 0)
           ptr[i] = mott_bethe_000;
         else
           ptr[i] = self.get_value_by_hkl(mi, unblur, mott_bethe);
       }
       return vals;
-    }, py::arg("hkl"), py::arg("unblur")=0, py::arg("mott_bethe")=false,
-       py::arg("mott_bethe_000")=0)
+    }, nb::arg("hkl"), nb::arg("unblur")=0, nb::arg("mott_bethe")=false,
+       nb::arg("mott_bethe_000")=0)
 
     .def("prepare_asu_data", &RecGr::template prepare_asu_data<TA>,
-         py::arg("dmin")=0., py::arg("unblur")=0.,
-         py::arg("with_000")=false, py::arg("with_sys_abs")=false,
-         py::arg("mott_bethe")=false)
+         nb::arg("dmin")=0., nb::arg("unblur")=0.,
+         nb::arg("with_000")=false, nb::arg("with_sys_abs")=false,
+         nb::arg("mott_bethe")=false)
     .def("__repr__", [=](const RecGr& self) {
         return tostr("<gemmi.", rgrid_name, '(', self.nu, ", ", self.nv, ", ", self.nw, ")>");
     });
 }
 
-void add_recgrid(py::module& m) {
+void add_recgrid(nb::module_& m) {
   using VS = ValueSigma<float>;
-  try {
-    PYBIND11_NUMPY_DTYPE(VS, value, sigma);
-  } catch (py::error_already_set &) {
-    // numpy can't be imported, that's ok
-  }
-  py::class_<VS>(m, "ValueSigma")
-    .def_readwrite("value", &VS::value)
-    .def_readwrite("sigma", &VS::sigma)
+  nb::class_<VS>(m, "ValueSigma")
+    .def_rw("value", &VS::value)
+    .def_rw("sigma", &VS::sigma)
     .def("__repr__", [](const VS& self) {
         return tostr("<gemmi.ValueSigma(", self.value, ", ", self.sigma, ")>");
     });
-  py::class_<ComplexCorrelation>(m, "ComplexCorrelation")
-    .def_readonly("n", &ComplexCorrelation::n)
+  nb::class_<ComplexCorrelation>(m, "ComplexCorrelation")
+    .def_ro("n", &ComplexCorrelation::n)
     .def("coefficient", &ComplexCorrelation::coefficient)
     .def("mean_ratio", &ComplexCorrelation::mean_ratio)
     ;
diff --git a/python/scaling.cpp b/python/scaling.cpp
index 09be36fdf..7b81ec1a0 100644
--- a/python/scaling.cpp
+++ b/python/scaling.cpp
@@ -1,29 +1,28 @@
 // Copyright 2020 Global Phasing Ltd.
 
 #include "common.h"
-#include <pybind11/stl.h>
-#include <pybind11/complex.h>
-#include <pybind11/numpy.h>    // for vectorize
+#include "array.h"
+#include <nanobind/stl/array.h>
+#include <nanobind/stl/complex.h>
+#include <nanobind/stl/vector.h>  // for Scaling::get_parameters
 #include "gemmi/scaling.hpp"
 
-namespace py = pybind11;
-
-void add_scaling(py::module& m) {
+void add_scaling(nb::module_& m) {
   m.def("adp_symmetry_constraints", &gemmi::adp_symmetry_constraints);
   using Scaling = gemmi::Scaling<float>;
   using FPhiData = gemmi::AsuData<std::complex<float>>;
-  py::class_<Scaling>(m, "Scaling")
-    .def(py::init<const gemmi::UnitCell&, const gemmi::SpaceGroup*>())
-    .def_readwrite("cell", &Scaling::cell)
-    .def_readwrite("k_overall", &Scaling::k_overall)
-    .def_property("b_overall", &Scaling::get_b_overall, &Scaling::set_b_overall)
-    .def_readwrite("use_solvent", &Scaling::use_solvent)
-    .def_readwrite("k_sol", &Scaling::k_sol)
-    .def_readwrite("b_sol", &Scaling::b_sol)
-    .def_property("parameters", &Scaling::get_parameters,
+  nb::class_<Scaling>(m, "Scaling")
+    .def(nb::init<const gemmi::UnitCell&, const gemmi::SpaceGroup*>())
+    .def_rw("cell", &Scaling::cell)
+    .def_rw("k_overall", &Scaling::k_overall)
+    .def_prop_rw("b_overall", &Scaling::get_b_overall, &Scaling::set_b_overall)
+    .def_rw("use_solvent", &Scaling::use_solvent)
+    .def_rw("k_sol", &Scaling::k_sol)
+    .def_rw("b_sol", &Scaling::b_sol)
+    .def_prop_rw("parameters", &Scaling::get_parameters,
                   (void (Scaling::*)(const std::vector<double>&)) &Scaling::set_parameters)
     .def("prepare_points", &Scaling::prepare_points,
-         py::arg("calc"), py::arg("obs"), py::arg("mask")=static_cast<FPhiData*>(nullptr))
+         nb::arg("calc"), nb::arg("obs"), nb::arg("mask")=static_cast<FPhiData*>(nullptr))
     .def("fit_isotropic_b_approximately", &Scaling::fit_isotropic_b_approximately)
     .def("fit_b_star_approximately", &Scaling::fit_b_star_approximately)
     .def("fit_parameters", &Scaling::fit_parameters)
@@ -31,22 +30,14 @@ void add_scaling(py::module& m) {
     .def("fit_parameters_with_nlopt", &gemmi::fit_parameters_with_nlopt<float>)
 #endif
     .def("calculate_r_factor", &Scaling::calculate_r_factor)
-    .def("get_overall_scale_factor", &Scaling::get_overall_scale_factor, py::arg("hkl"))
-    .def("get_overall_scale_factor", [](const Scaling& self, py::array_t<int> hkl) {
-        auto h = hkl.unchecked<2>();
-        if (h.shape(1) != 3)
-          throw std::domain_error("the hkl array must have size N x 3");
-        auto len = h.shape(0);
-        py::array_t<double> arr(len);
-        double* ptr = (double*) arr.request().ptr;
-        for (int i = 0; i < len; ++i)
-          ptr[i] = self.get_overall_scale_factor({{h(i, 0), h(i, 1), h(i, 2)}});
-        return arr;
+    .def("get_overall_scale_factor", &Scaling::get_overall_scale_factor, nb::arg("hkl"))
+    .def("get_overall_scale_factor", [](const Scaling& self, cpu_miller_array hkl) {
+        return miller_function<double>(self, &Scaling::get_overall_scale_factor, hkl);
     })
-    .def("get_solvent_scale", py::vectorize(&Scaling::get_solvent_scale), py::arg("stol2"))
+    .def("get_solvent_scale", &Scaling::get_solvent_scale, nb::arg("stol2"))
     .def("scale_data", &Scaling::scale_data,
-         py::arg("asu_data"), py::arg("mask_data")=static_cast<FPhiData*>(nullptr))
+         nb::arg("asu_data"), nb::arg("mask_data")=static_cast<FPhiData*>(nullptr))
     .def("scale_value", &Scaling::scale_value,
-         py::arg("hkl"), py::arg("f_value"), py::arg("mask_value"))
+         nb::arg("hkl"), nb::arg("f_value"), nb::arg("mask_value"))
     ;
 }
diff --git a/python/search.cpp b/python/search.cpp
index 37e9eca74..14c55d5c6 100644
--- a/python/search.cpp
+++ b/python/search.cpp
@@ -4,24 +4,24 @@
 #include "gemmi/linkhunt.hpp"
 #include "gemmi/bond_idx.hpp"
 #include "common.h"
-#include <pybind11/stl.h>
-#include <pybind11/stl_bind.h>
+#include <nanobind/stl/bind_vector.h>
+#include <nanobind/stl/string.h>
+#include <nanobind/stl/vector.h>
 
-namespace py = pybind11;
 using namespace gemmi;
 
-PYBIND11_MAKE_OPAQUE(std::vector<NeighborSearch::Mark*>)
+NB_MAKE_OPAQUE(std::vector<NeighborSearch::Mark*>)
 
-void add_search(py::module& m) {
-  py::class_<NeighborSearch> neighbor_search(m, "NeighborSearch");
-  py::class_<NeighborSearch::Mark>(neighbor_search, "Mark")
-    .def_readonly("pos", &NeighborSearch::Mark::pos)
-    .def_readonly("altloc", &NeighborSearch::Mark::altloc)
-    .def_readonly("element", &NeighborSearch::Mark::element)
-    .def_readonly("image_idx", &NeighborSearch::Mark::image_idx)
-    .def_readonly("chain_idx", &NeighborSearch::Mark::chain_idx)
-    .def_readonly("residue_idx", &NeighborSearch::Mark::residue_idx)
-    .def_readonly("atom_idx", &NeighborSearch::Mark::atom_idx)
+void add_search(nb::module_& m) {
+  nb::class_<NeighborSearch> neighbor_search(m, "NeighborSearch");
+  nb::class_<NeighborSearch::Mark>(neighbor_search, "Mark")
+    .def_ro("pos", &NeighborSearch::Mark::pos)
+    .def_ro("altloc", &NeighborSearch::Mark::altloc)
+    .def_ro("element", &NeighborSearch::Mark::element)
+    .def_ro("image_idx", &NeighborSearch::Mark::image_idx)
+    .def_ro("chain_idx", &NeighborSearch::Mark::chain_idx)
+    .def_ro("residue_idx", &NeighborSearch::Mark::residue_idx)
+    .def_ro("atom_idx", &NeighborSearch::Mark::atom_idx)
     .def("to_cra", (CRA (NeighborSearch::Mark::*)(Model&) const)
                    &NeighborSearch::Mark::to_cra)
     .def("to_site", (SmallStructure::Site& (NeighborSearch::Mark::*)(SmallStructure&) const)
@@ -31,62 +31,63 @@ void add_search(py::module& m) {
                    self.chain_idx, '/', self.residue_idx, '/', self.atom_idx,
                    " element ", self.element.name(), ">");
     });
-  py::bind_vector<std::vector<NeighborSearch::Mark*>>(m, "VectorMarkPtr");
+  nb::bind_vector<std::vector<NeighborSearch::Mark*>>(m, "VectorMarkPtr");
   neighbor_search
-    .def_readonly("radius_specified", &NeighborSearch::radius_specified)
-    .def(py::init<Model&, const UnitCell&, double>(),
-         py::arg("model"), py::arg("cell"), py::arg("max_radius")/*,
-         py::keep_alive<1, 2>()*/)
-    .def(py::init([](Structure& st, double max_radius, int model_index) {
-      return new NeighborSearch(st.models.at(model_index), st.cell, max_radius);
-    }), py::arg("st"), py::arg("max_radius"), py::arg("model_index")=0,
-        py::keep_alive<1, 2>())
-    .def(py::init<SmallStructure&, double>(),
-         py::arg("small_structure"), py::arg("max_radius"),
-         py::keep_alive<1, 2>())
-    .def("populate", &NeighborSearch::populate, py::arg("include_h")=true,
+    .def_ro("radius_specified", &NeighborSearch::radius_specified)
+    .def(nb::init<Model&, const UnitCell&, double>(),
+         nb::arg("model"), nb::arg("cell"), nb::arg("max_radius")/*,
+         nb::keep_alive<1, 2>()*/)
+    .def("__init__", [](NeighborSearch* ns, Structure& st,
+                        double max_radius, int model_index) {
+      new(ns) NeighborSearch(st.models.at(model_index), st.cell, max_radius);
+    }, nb::arg("st"), nb::arg("max_radius"), nb::arg("model_index")=0,
+        nb::keep_alive<1, 2>())
+    .def(nb::init<SmallStructure&, double>(),
+         nb::arg("small_structure"), nb::arg("max_radius"),
+         nb::keep_alive<1, 2>())
+    .def("populate", &NeighborSearch::populate, nb::arg("include_h")=true,
          "Usually run after constructing NeighborSearch.")
     .def("add_chain", &NeighborSearch::add_chain,
-         py::arg("chain"), py::arg("include_h")=true)
+         nb::arg("chain"), nb::arg("include_h")=true)
     .def("add_atom", &NeighborSearch::add_atom,
-         py::arg("atom"), py::arg("n_ch"), py::arg("n_res"), py::arg("n_atom"),
+         nb::arg("atom"), nb::arg("n_ch"), nb::arg("n_res"), nb::arg("n_atom"),
          "Lower-level alternative to populate()")
     .def("add_site", &NeighborSearch::add_site,
-         py::arg("site"), py::arg("n"),
+         nb::arg("site"), nb::arg("n"),
          "Lower-level alternative to populate() for SmallStructure")
     .def("find_atoms", &NeighborSearch::find_atoms,
-         py::arg("pos"), py::arg("alt")='\0',
-         py::kw_only(), py::arg("min_dist")=0, py::arg("radius")=0,
-         py::return_value_policy::move, py::keep_alive<0, 1>())
+         nb::arg("pos"), nb::arg("alt")='\0',
+         nb::kw_only(), nb::arg("min_dist")=0, nb::arg("radius")=0,
+         nb::rv_policy::move, nb::keep_alive<0, 1>())
     .def("find_neighbors", &NeighborSearch::find_neighbors,
-         py::arg("atom"), py::arg("min_dist")=0, py::arg("max_dist")=0,
-         py::return_value_policy::move, py::keep_alive<0, 1>())
+         nb::arg("atom"), nb::arg("min_dist")=0, nb::arg("max_dist")=0,
+         nb::rv_policy::move, nb::keep_alive<0, 1>())
     .def("find_nearest_atom", &NeighborSearch::find_nearest_atom,
-         py::arg("pos"), py::arg("radius")=INFINITY,
-         py::return_value_policy::reference_internal)
+         nb::arg("pos"), nb::arg("radius")=INFINITY,
+         nb::rv_policy::reference_internal)
     .def("find_site_neighbors", &NeighborSearch::find_site_neighbors,
-         py::arg("atom"), py::arg("min_dist")=0, py::arg("max_dist")=0,
-         py::return_value_policy::move, py::keep_alive<0, 1>())
+         nb::arg("atom"), nb::arg("min_dist")=0, nb::arg("max_dist")=0,
+         nb::rv_policy::move, nb::keep_alive<0, 1>())
     .def("dist", &NeighborSearch::dist)
     .def("get_image_transformation", &NeighborSearch::get_image_transformation)
-    .def_property_readonly("grid_cell",
+    .def_prop_ro("grid_cell",
         [](const NeighborSearch& self) { return self.grid.unit_cell; })
     .def("__repr__", [](const NeighborSearch& self) {
         return cat("<gemmi.NeighborSearch with grid ",
                    self.grid.nu, ", ", self.grid.nv, ", ", self.grid.nw, '>');
     });
 
-  py::class_<ContactSearch> contactsearch(m, "ContactSearch");
-  py::enum_<ContactSearch::Ignore> csignore(contactsearch, "Ignore");
-  py::class_<ContactSearch::Result> csresult(contactsearch, "Result");
+  nb::class_<ContactSearch> contactsearch(m, "ContactSearch");
+  nb::enum_<ContactSearch::Ignore> csignore(contactsearch, "Ignore");
+  nb::class_<ContactSearch::Result> csresult(contactsearch, "Result");
 
   contactsearch
-    .def(py::init<double>())
-    .def_readwrite("search_radius", &ContactSearch::search_radius)
-    .def_readwrite("ignore", &ContactSearch::ignore)
-    .def_readwrite("twice", &ContactSearch::twice)
-    .def_readwrite("special_pos_cutoff_sq", &ContactSearch::special_pos_cutoff_sq)
-    .def_readwrite("min_occupancy", &ContactSearch::min_occupancy)
+    .def(nb::init<double>())
+    .def_rw("search_radius", &ContactSearch::search_radius)
+    .def_rw("ignore", &ContactSearch::ignore)
+    .def_rw("twice", &ContactSearch::twice)
+    .def_rw("special_pos_cutoff_sq", &ContactSearch::special_pos_cutoff_sq)
+    .def_rw("min_occupancy", &ContactSearch::min_occupancy)
     .def("setup_atomic_radii", &ContactSearch::setup_atomic_radii)
     .def("get_radius", [](const ContactSearch& self, Element el) {
         return self.get_radius(el.elem);
@@ -105,42 +106,42 @@ void add_search(py::module& m) {
     .value("SameAsu", ContactSearch::Ignore::SameAsu);
 
   csresult
-    .def_readonly("partner1", &ContactSearch::Result::partner1)
-    .def_readonly("partner2", &ContactSearch::Result::partner2)
-    .def_readonly("image_idx", &ContactSearch::Result::image_idx)
-    .def_property_readonly("dist", [](ContactSearch::Result& self) {
+    .def_ro("partner1", &ContactSearch::Result::partner1)
+    .def_ro("partner2", &ContactSearch::Result::partner2)
+    .def_ro("image_idx", &ContactSearch::Result::image_idx)
+    .def_prop_ro("dist", [](ContactSearch::Result& self) {
         return std::sqrt(self.dist_sq);
     })
     ;
 
-  py::class_<LinkHunt> linkhunt(m, "LinkHunt");
-  py::class_<LinkHunt::Match> linkhuntmatch(linkhunt, "Match");
+  nb::class_<LinkHunt> linkhunt(m, "LinkHunt");
+  nb::class_<LinkHunt::Match> linkhuntmatch(linkhunt, "Match");
   linkhunt
-    .def(py::init<>())
+    .def(nb::init<>())
     .def("index_chem_links", &LinkHunt::index_chem_links,
-         py::arg("monlib"), py::arg("use_alias")=true, py::keep_alive<1, 2>())
+         nb::arg("monlib"), nb::arg("use_alias")=true, nb::keep_alive<1, 2>())
     .def("find_possible_links", &LinkHunt::find_possible_links,
-         py::arg("st"), py::arg("bond_margin"), py::arg("radius_margin"),
-         py::arg("ignore")=ContactSearch::Ignore::SameResidue)
+         nb::arg("st"), nb::arg("bond_margin"), nb::arg("radius_margin"),
+         nb::arg("ignore")=ContactSearch::Ignore::SameResidue)
     ;
 
   linkhuntmatch
-    .def_readonly("chem_link", &LinkHunt::Match::chem_link)
-    .def_readonly("chem_link_count", &LinkHunt::Match::chem_link_count)
-    .def_readonly("cra1", &LinkHunt::Match::cra1)
-    .def_readonly("cra2", &LinkHunt::Match::cra2)
-    .def_readonly("same_image", &LinkHunt::Match::same_image)
-    .def_readonly("bond_length", &LinkHunt::Match::bond_length)
-    .def_readonly("conn", &LinkHunt::Match::conn)
+    .def_ro("chem_link", &LinkHunt::Match::chem_link)
+    .def_ro("chem_link_count", &LinkHunt::Match::chem_link_count)
+    .def_ro("cra1", &LinkHunt::Match::cra1)
+    .def_ro("cra2", &LinkHunt::Match::cra2)
+    .def_ro("same_image", &LinkHunt::Match::same_image)
+    .def_ro("bond_length", &LinkHunt::Match::bond_length)
+    .def_ro("conn", &LinkHunt::Match::conn)
     ;
 
-  py::class_<BondIndex>(m, "BondIndex")
-    .def(py::init<const Model&>(), py::keep_alive<1, 2>())
+  nb::class_<BondIndex>(m, "BondIndex")
+    .def(nb::init<const Model&>(), nb::keep_alive<1, 2>())
     .def("add_link", &BondIndex::add_link)
     .def("add_monomer_bonds", &BondIndex::add_monomer_bonds)
     .def("are_linked", &BondIndex::are_linked)
     .def("graph_distance", &BondIndex::graph_distance,
-         py::arg("a"), py::arg("b"), py::arg("same_index"),
-         py::arg("max_distance")=4)
+         nb::arg("a"), nb::arg("b"), nb::arg("same_index"),
+         nb::arg("max_distance")=4)
     ;
 }
diff --git a/python/serial.h b/python/serial.h
new file mode 100644
index 000000000..b7725f49f
--- /dev/null
+++ b/python/serial.h
@@ -0,0 +1,22 @@
+// Copyright 2024 Global Phasing Ltd.
+
+#pragma once
+#include "common.h"
+#include "gemmi/serialize.hpp"
+#include "../third_party/serializer.h"
+
+template<typename T>
+nb::bytes getstate(const T& self) {
+  std::vector<unsigned char> data;
+  zpp::serializer::memory_output_archive out(data);
+  // awkward zpp design: calling zpp::serializer::*_archive::operator()()
+  out(self);
+  return nb::bytes(data.data(), data.size());
+}
+
+template<typename T>
+void setstate(T& self, const nb::bytes& state) {
+  new(&self) T();  // probably not needed
+  const unsigned char* ptr = (unsigned char*) state.data();
+  zpp::serializer::memory_view_input_archive(ptr, state.size())(self);
+}
diff --git a/python/sf.cpp b/python/sf.cpp
index fba01fa1b..c254c99d1 100644
--- a/python/sf.cpp
+++ b/python/sf.cpp
@@ -1,8 +1,8 @@
 // Copyright 2020 Global Phasing Ltd.
 
 #include "common.h"
-#include <pybind11/stl.h>
-#include <pybind11/complex.h>
+#include <nanobind/stl/array.h>
+#include <nanobind/stl/complex.h>
 #include "gemmi/it92.hpp"
 #include "gemmi/c4322.hpp"
 #include "gemmi/neutron92.hpp"
@@ -10,37 +10,35 @@
 #include "gemmi/dencalc.hpp"  // for DensityCalculator
 #include "gemmi/fprime.hpp"   // for add_cl_fprime_for_all_elements
 
-namespace py = pybind11;
-
 template<typename Table>
-void add_sfcalc(py::module& m, const char* name, bool with_mb) {
+void add_sfcalc(nb::module_& m, const char* name, bool with_mb) {
   using SFC = gemmi::StructureFactorCalculator<Table>;
-  py::class_<SFC> sfc(m, name);
+  nb::class_<SFC> sfc(m, name);
   sfc
-    .def(py::init<const gemmi::UnitCell&>())
-    .def_readwrite("addends", &SFC::addends)
+    .def(nb::init<const gemmi::UnitCell&>())
+    .def_rw("addends", &SFC::addends)
     .def("calculate_sf_from_model", &SFC::calculate_sf_from_model)
     .def("calculate_sf_from_small_structure", &SFC::calculate_sf_from_small_structure);
   if (with_mb)
     sfc
       .def("mott_bethe_factor", &SFC::mott_bethe_factor)
       .def("calculate_mb_z", &SFC::calculate_mb_z,
-           py::arg("model"), py::arg("hkl"), py::arg("only_h")=false);
+           nb::arg("model"), nb::arg("hkl"), nb::arg("only_h")=false);
 }
 
 template<typename Table>
-void add_dencalc(py::module& m, const char* name) {
+void add_dencalc(nb::module_& m, const char* name) {
   using DenCalc = gemmi::DensityCalculator<Table, float>;
-  py::class_<DenCalc>(m, name)
-    .def(py::init<>())
-    .def_readonly("grid", &DenCalc::grid)
-    .def_readwrite("d_min", &DenCalc::d_min)
-    .def_readwrite("rate", &DenCalc::rate)
-    .def_readwrite("blur", &DenCalc::blur)
-    .def_readwrite("cutoff", &DenCalc::cutoff)
-    .def_readwrite("addends", &DenCalc::addends)
+  nb::class_<DenCalc>(m, name)
+    .def(nb::init<>())
+    .def_ro("grid", &DenCalc::grid)
+    .def_rw("d_min", &DenCalc::d_min)
+    .def_rw("rate", &DenCalc::rate)
+    .def_rw("blur", &DenCalc::blur)
+    .def_rw("cutoff", &DenCalc::cutoff)
+    .def_rw("addends", &DenCalc::addends)
     .def("set_refmac_compatible_blur", &DenCalc::set_refmac_compatible_blur,
-         py::arg("model"), py::arg("allow_negative")=false)
+         nb::arg("model"), nb::arg("allow_negative")=false)
     .def("put_model_density_on_grid", &DenCalc::put_model_density_on_grid)
     .def("initialize_grid", &DenCalc::initialize_grid)
     .def("add_model_density_to_grid", &DenCalc::add_model_density_to_grid)
@@ -64,16 +62,16 @@ void add_dencalc(py::module& m, const char* name) {
     ;
 }
 
-void add_sf(py::module& m) {
-  py::class_<gemmi::Addends>(m, "Addends")
+void add_sf(nb::module_& m) {
+  nb::class_<gemmi::Addends>(m, "Addends")
     .def("set", &gemmi::Addends::set)
     .def("get", &gemmi::Addends::get)
     .def("clear", &gemmi::Addends::clear)
     .def("add_cl_fprime", [](gemmi::Addends& self, double energy) {
         gemmi::add_cl_fprime_for_all_elements(&self.values[1], energy);
-    }, py::arg("energy"))
+    }, nb::arg("energy"))
     .def("subtract_z", &gemmi::Addends::subtract_z,
-         py::arg("except_hydrogen")=false)
+         nb::arg("except_hydrogen")=false)
     ;
 
   using IT92 = gemmi::IT92<float>;
diff --git a/python/sym.cpp b/python/sym.cpp
index 3ba12f22b..01333af64 100644
--- a/python/sym.cpp
+++ b/python/sym.cpp
@@ -2,18 +2,19 @@
 
 #include "gemmi/symmetry.hpp"
 
+#include <memory>  // for unique_ptr
 #include "common.h"
-#include <pybind11/stl.h>
-#include <pybind11/stl_bind.h>
-#include <pybind11/numpy.h>
-#include <pybind11/operators.h>
-#include "miller_a.h"
+#include "array.h"  // for miller_function
+#include <nanobind/make_iterator.h>
+#include <nanobind/operators.h>
+#include <nanobind/stl/array.h>
+#include <nanobind/stl/string.h>
+#include <nanobind/stl/vector.h>
 
-namespace py = pybind11;
 using namespace gemmi;
 
-void add_symmetry(py::module& m) {
-  py::enum_<CrystalSystem>(m, "CrystalSystem")
+void add_symmetry(nb::module_& m) {
+  nb::enum_<CrystalSystem>(m, "CrystalSystem")
     .value("Triclinic", CrystalSystem::Triclinic)
     .value("Monoclinic", CrystalSystem::Monoclinic)
     .value("Orthorhombic", CrystalSystem::Orthorhombic)
@@ -22,29 +23,33 @@ void add_symmetry(py::module& m) {
     .value("Hexagonal", CrystalSystem::Hexagonal)
     .value("Cubic", CrystalSystem::Cubic)
     ;
-  py::class_<Op>(m, "Op")
-    .def(py::init<>(&Op::identity))
-    .def(py::init(&parse_triplet))
-    .def_property_readonly_static("DEN", [](py::object) { return Op::DEN; },
+  nb::class_<Op>(m, "Op")
+    .def("__init__", [](Op* op) {
+        new(op) Op(Op::identity());
+    })
+    .def("__init__", [](Op* op, const std::string& s) {
+        new(op) Op(parse_triplet(s));
+    })
+    .def_prop_ro_static("DEN", [](nb::object) { return Op::DEN; },
                            "Denominator (integer) for the translation vector.")
-    .def_readwrite("rot", &Op::rot, "3x3 integer matrix.")
-    .def_readwrite("tran", &Op::tran,
+    .def_rw("rot", &Op::rot, "3x3 integer matrix.")
+    .def_rw("tran", &Op::tran,
        "Numerators (integers) of the translation vector. Denominator DEN=24.")
-    .def("triplet", &Op::triplet, py::arg("style")='x')
+    .def("triplet", &Op::triplet, nb::arg("style")='x')
     .def("inverse", &Op::inverse, "Returns inverted operator.")
     .def("wrap", &Op::wrap, "Wrap the translation part to [0,1)")
-    .def("translated", &Op::translated, py::arg("a"), "Adds a to tran")
+    .def("translated", &Op::translated, nb::arg("a"), "Adds a to tran")
     .def("transposed_rot", &Op::transposed_rot)
     .def("det_rot", &Op::det_rot, "Determinant of the 3x3 matrix.")
     .def("rot_type", &Op::rot_type)
-    .def("combine", &Op::combine, py::arg("b"),
+    .def("combine", &Op::combine, nb::arg("b"),
          "Combine two symmetry operations.")
     .def("seitz", [](const Op& self) {
             auto arr = self.int_seitz();
-            auto mat = py::list();
-            py::object fr = py::module::import("fractions").attr("Fraction");
+            auto mat = nb::list();
+            nb::object fr = nb::module_::import_("fractions").attr("Fraction");
             for (int i = 0; i < 4; ++i) {
-              auto row = py::list();
+              auto row = nb::list();
               for (int j = 0; j < 4; ++j) {
                 auto v = arr[i][j];
                 if (i == 3 || v == 0)
@@ -59,99 +64,105 @@ void add_symmetry(py::module& m) {
             return mat;
          }, "Returns Seitz matrix (fractions)")
     .def("float_seitz", &Op::float_seitz, "Returns Seitz matrix (floats)")
-    .def("apply_to_xyz", &Op::apply_to_xyz, py::arg("xyz"))
-    .def("apply_to_hkl", &Op::apply_to_hkl, py::arg("hkl"))
-    .def("phase_shift", &Op::phase_shift, py::arg("hkl"))
-    .def(py::self * py::self)
+    .def("apply_to_xyz", &Op::apply_to_xyz, nb::arg("xyz"))
+    .def("apply_to_hkl", &Op::apply_to_hkl, nb::arg("hkl"))
+    .def("phase_shift", &Op::phase_shift, nb::arg("hkl"))
+    .def(nb::self * nb::self)
     .def("__mul__", [](const Op &a, const std::string& b) { return a * parse_triplet(b); },
-         py::is_operator())
+         nb::is_operator())
     .def("__rmul__", [](const Op& a, const std::string& b) { return parse_triplet(b) * a; },
-         py::is_operator())
-    .def(py::self == py::self)
+         nb::is_operator())
+    .def(nb::self == nb::self)
     .def("__eq__", [](const Op& a, const std::string& b) { return a == parse_triplet(b); },
-         py::is_operator())
+         nb::is_operator())
     .def("__copy__", [](const Op& self) { return Op(self); })
-    .def("__deepcopy__", [](const Op& self, py::dict) { return Op(self); }, py::arg("memo"))
+    .def("__deepcopy__", [](const Op& self, nb::dict) { return Op(self); }, nb::arg("memo"))
     .def("__hash__", [](const Op& self) { return std::hash<Op>()(self); })
     .def("__repr__", [](const Op& self) {
         return "<gemmi.Op(\"" + self.triplet() + "\")>";
     });
 
-  m.def("parse_triplet", &parse_triplet, py::arg("triplet"),
+  m.def("parse_triplet", &parse_triplet, nb::arg("triplet"),
         "Parse coordinate triplet into gemmi.Op.");
   m.def("parse_triplet_part", [](const std::string& s) { return parse_triplet_part(s); },
         "Parse one of the three parts of a triplet.");
   m.def("make_triplet_part", &make_triplet_part,
-        py::arg("xyz"), py::arg("w"), py::arg("style")='x',
+        nb::arg("xyz"), nb::arg("w"), nb::arg("style")='x',
         "Make one of the three parts of a triplet.");
 
-  py::class_<GroupOps>(m, "GroupOps")
-    .def(py::init(&split_centering_vectors))
+  nb::class_<GroupOps>(m, "GroupOps")
+    .def("__init__", [](GroupOps* p, const std::vector<Op>& ops) {
+        new(p) GroupOps(split_centering_vectors(ops));
+    })
     .def("__iter__", [](const GroupOps& self) {
-        return py::make_iterator(self);
-    }, py::keep_alive<0, 1>())
+        return nb::make_iterator(nb::type<GroupOps>(), "iterator", self);
+    }, nb::keep_alive<0, 1>())
     .def("__eq__", [](const GroupOps &a, const GroupOps &b) { return a.is_same_as(b); },
-         py::is_operator())
+         nb::is_operator())
     .def("__len__", [](const GroupOps& g) { return g.order(); })
-    .def("__deepcopy__", [](const GroupOps& g, py::dict) { return GroupOps(g); },
-         py::arg("memo"))
-    .def_readwrite("sym_ops", &GroupOps::sym_ops,
+    .def("__deepcopy__", [](const GroupOps& g, nb::dict) { return GroupOps(g); },
+         nb::arg("memo"))
+    .def_rw("sym_ops", &GroupOps::sym_ops,
                "Symmetry operations (to be combined with centering vectors).")
-    .def_readwrite("cen_ops", &GroupOps::cen_ops, "Centering vectors.")
+    .def_rw("cen_ops", &GroupOps::cen_ops, "Centering vectors.")
     .def("add_missing_elements", &GroupOps::add_missing_elements)
     .def("find_centering", &GroupOps::find_centering)
     .def("has_same_centring", &GroupOps::has_same_centring)
     .def("has_same_rotations", &GroupOps::has_same_rotations)
     .def("is_centrosymmetric", &GroupOps::is_centrosymmetric)
     .def("is_reflection_centric", &GroupOps::is_reflection_centric)
-    .def("centric_flag_array", [](const GroupOps& g, py::array_t<int> hkl) {
+    .def("centric_flag_array", [](const GroupOps& g, cpu_miller_array hkl) {
         return miller_function<bool>(g, &GroupOps::is_reflection_centric, hkl);
     })
     .def("epsilon_factor_without_centering", &GroupOps::epsilon_factor_without_centering)
     .def("epsilon_factor", &GroupOps::epsilon_factor)
-    .def("epsilon_factor_array", [](const GroupOps& g, py::array_t<int> hkl) {
+    .def("epsilon_factor_array", [](const GroupOps& g, cpu_miller_array hkl) {
         return miller_function<int>(g, &GroupOps::epsilon_factor, hkl);
     })
-    .def("epsilon_factor_without_centering_array", [](const GroupOps& g,
-                                                      py::array_t<int> hkl) {
+    .def("epsilon_factor_without_centering_array", [](const GroupOps& g, cpu_miller_array hkl) {
         return miller_function<int>(g, &GroupOps::epsilon_factor_without_centering, hkl);
     })
     .def("is_systematically_absent", &GroupOps::is_systematically_absent)
-    .def("systematic_absences", [](const GroupOps& g, py::array_t<int> hkl) {
+    .def("systematic_absences", [](const GroupOps& g, cpu_miller_array hkl) {
         return miller_function<bool>(g, &GroupOps::is_systematically_absent, hkl);
     })
     .def("find_grid_factors", &GroupOps::find_grid_factors,
          "Minimal multiplicity for real-space grid (e.g. 1,1,6 for P61).")
-    .def("change_basis_forward", &GroupOps::change_basis_forward, py::arg("cob"),
+    .def("change_basis_forward", &GroupOps::change_basis_forward, nb::arg("cob"),
          "Applies the change-of-basis operator (in place).")
-    .def("change_basis_backward", &GroupOps::change_basis_backward, py::arg("cob"),
+    .def("change_basis_backward", &GroupOps::change_basis_backward, nb::arg("cob"),
          "Applies inverse of the change-of-basis operator (in place).")
     .def("derive_symmorphic", &GroupOps::derive_symmorphic)
     .def("add_inversion", &GroupOps::add_inversion)
     ;
 
-  py::class_<SpaceGroup, std::unique_ptr<SpaceGroup, py::nodelete>>(m, "SpaceGroup")
-    .def(py::init([](int n) {
-           return const_cast<SpaceGroup*>(&get_spacegroup_by_number(n));
-         }), py::arg("ccp4"), py::return_value_policy::reference)
-    .def(py::init([](const std::string& s) {
-           return const_cast<SpaceGroup*>(&get_spacegroup_by_name(s));
-         }), py::arg("hm"), py::return_value_policy::reference)
-    .def_readonly("number", &SpaceGroup::number, "number 1-230.")
-    .def_readonly("ccp4", &SpaceGroup::ccp4, "ccp4 number")
-    // Intel Compiler would not compile .def_readonly("hm", ...),
+  constexpr int main_table_length = int(sizeof(spacegroup_tables::main) / sizeof(SpaceGroup));
+
+  nb::class_<SpaceGroup>(m, "SpaceGroup")
+    .def(nb::new_([](int n) {
+          // a second meaning of SpaceGroup(n), for internal use in __reduce__
+          if (n < INT_MIN + main_table_length)
+            return &spacegroup_tables::main[n - INT_MIN];
+          return &get_spacegroup_by_number(n);
+    }), nb::arg("ccp4"), nb::rv_policy::reference)
+    .def(nb::new_([](const std::string& s) {
+          return &get_spacegroup_by_name(s);
+    }), nb::arg("hm"), nb::rv_policy::reference)
+    .def_ro("number", &SpaceGroup::number, "number 1-230.")
+    .def_ro("ccp4", &SpaceGroup::ccp4, "ccp4 number")
+    // Intel Compiler would not compile .def_ro("hm", ...),
     // the difference with hm, qualifier and hall is that they are char[N]
-    .def_property_readonly("hm", [](const SpaceGroup &self) -> const char* {
+    .def_prop_ro("hm", [](const SpaceGroup &self) -> const char* {
         return self.hm;
     }, "Hermann-Mauguin name")
-    .def_readonly("ext", &SpaceGroup::ext, "Extension (1, 2, H, R or none)")
-    .def_property_readonly("qualifier", [](const SpaceGroup &s) -> const char* {
+    .def_ro("ext", &SpaceGroup::ext, "Extension (1, 2, H, R or none)")
+    .def_prop_ro("qualifier", [](const SpaceGroup &s) -> const char* {
         return s.qualifier;
     }, "e.g. 'cab'")
-    .def_property_readonly("hall", [](const SpaceGroup &self) -> const char* {
+    .def_prop_ro("hall", [](const SpaceGroup &self) -> const char* {
         return self.hall;
     }, "Hall symbol")
-    .def_property_readonly("basisop", &SpaceGroup::basisop)
+    .def_prop_ro("basisop", &SpaceGroup::basisop)
     .def("xhm", &SpaceGroup::xhm, "extended Hermann-Mauguin name")
     .def("centring_type", &SpaceGroup::centring_type)
     .def("short_name", &SpaceGroup::short_name,
@@ -173,66 +184,73 @@ void add_symmetry(py::module& m) {
     .def("centred_to_primitive", &SpaceGroup::centred_to_primitive)
     .def("change_of_hand_op", &SpaceGroup::change_of_hand_op)
     .def("operations", &SpaceGroup::operations, "Group of operations")
-    .def("switch_to_asu", [](const SpaceGroup& sg, py::array_t<int> hkl) {
-        auto h = hkl.mutable_unchecked<2>();
+    .def("switch_to_asu", [](const SpaceGroup& sg,
+                             nb::ndarray<int, nb::shape<-1,-1>, nb::device::cpu> hkl) {
+        auto h = hkl.view();
         if (h.shape(1) < 3)
           throw std::domain_error("error: the size of the second dimension < 3");
         GroupOps gops = sg.operations();
         ReciprocalAsu asu(&sg);
-        for (py::ssize_t i = 0; i < h.shape(0); ++i) {
+        for (size_t i = 0; i < h.shape(0); ++i) {
           Op::Miller hkl = asu.to_asu({{h(i, 0), h(i, 1), h(i, 2)}}, gops).first;
-          for (int j = 0; j != 3; ++j)
+          for (size_t j = 0; j != 3; ++j)
             h(i, j) = hkl[j];
         }
-    }, py::arg("miller_array").noconvert())
+    }, nb::arg("miller_array").noconvert())
     // Check equality by comparing Hall symbol strings.
     // In Python, SpaceGroup always points to an entry in spacegroup_tables::main,
     // so Hall symbols are consistent. The same settings with different H-M names
     // (see space group 65 in the ITB list) are considered equal.
     .def("__eq__", [](const SpaceGroup& a, const SpaceGroup& b) {
         return strcmp(a.hall, b.hall) == 0;
-    }, py::is_operator())
+    }, nb::is_operator())
+    .def("__reduce__", [](const SpaceGroup& self) {
+        // faster than just serializing self.xhm(), but also more tricky
+        std::ptrdiff_t pos = &self - spacegroup_tables::main;
+        if (pos < 0 || pos >= main_table_length) { // multi-library problem
+          const SpaceGroup* p = &self;
+          while (p->ccp4 != 1)
+            --p;
+          pos = &self - p;
+        }
+        return nb::make_tuple(nb::type<SpaceGroup>(), nb::make_tuple(INT_MIN + (int)pos));
+    })
     .def("__repr__", [](const SpaceGroup &self) {
         return "<gemmi.SpaceGroup(\"" + self.xhm() + "\")>";
-    })
-    .def(py::pickle(
-        [](const SpaceGroup &self) {
-          return self.xhm();
-        },
-        [](const std::string &s) {
-          return const_cast<SpaceGroup*>(&get_spacegroup_by_name(s));
-        }
-    ));
+    });
 
-  py::class_<ReciprocalAsu>(m, "ReciprocalAsu")
-    .def(py::init<const SpaceGroup*, bool>(), py::arg(), py::arg("tnt")=false)
-    .def("is_in", &ReciprocalAsu::is_in, py::arg("hkl"))
+  nb::class_<ReciprocalAsu>(m, "ReciprocalAsu")
+    .def(nb::init<const SpaceGroup*, bool>(), nb::arg(), nb::arg("tnt")=false)
+    .def("is_in", &ReciprocalAsu::is_in, nb::arg("hkl"))
     .def("condition_str", &ReciprocalAsu::condition_str)
-    .def("to_asu", &ReciprocalAsu::to_asu, py::arg("hkl"), py::arg("group_ops"))
+    .def("to_asu", &ReciprocalAsu::to_asu, nb::arg("hkl"), nb::arg("group_ops"))
     ;
 
-  m.def("spacegroup_table", []() {
-            return py::make_iterator(spacegroup_tables::main);
-        }, py::return_value_policy::reference);
-  m.def("spacegroup_table_itb", []() {
-            return py::make_iterator(spacegroup_tables::main + 0,
-                                     spacegroup_tables::main + 530);
-        }, py::return_value_policy::reference);
-  m.def("generators_from_hall", &generators_from_hall, py::arg("hall"),
+  nb::handle mod = m;
+  m.def("spacegroup_table", [mod]() {
+      return nb::make_iterator<nb::rv_policy::reference>(mod, "spacegroup_iterator",
+                                                         spacegroup_tables::main);
+  });
+  m.def("spacegroup_table_itb", [mod]() {
+      return nb::make_iterator<nb::rv_policy::reference>(mod, "itb_spacegroup_iterator",
+                                                         spacegroup_tables::main + 0,
+                                                         spacegroup_tables::main + 530);
+  });
+  m.def("generators_from_hall", &generators_from_hall, nb::arg("hall"),
         "Parse Hall notation.");
-  m.def("symops_from_hall", &symops_from_hall, py::arg("hall"),
+  m.def("symops_from_hall", &symops_from_hall, nb::arg("hall"),
         "Parse Hall notation.");
   m.def("find_spacegroup_by_number", &find_spacegroup_by_number,
-        py::arg("ccp4"), py::return_value_policy::reference,
+        nb::arg("ccp4"), nb::rv_policy::reference,
         "Returns space-group of given number.");
   m.def("find_spacegroup_by_name", &find_spacegroup_by_name,
-        py::arg("hm"), py::arg("alpha")=0., py::arg("gamma")=0., py::arg("prefer")=nullptr,
-        py::return_value_policy::reference,
+        nb::arg("hm"), nb::arg("alpha")=0., nb::arg("gamma")=0., nb::arg("prefer")="",
+        nb::rv_policy::reference,
         "Returns space-group with given name.");
   m.def("get_spacegroup_reference_setting", &get_spacegroup_reference_setting,
-        py::arg("number"), py::return_value_policy::reference);
+        nb::arg("number"), nb::rv_policy::reference);
   m.def("find_spacegroup_by_ops", &find_spacegroup_by_ops,
-        py::arg("group_ops"), py::return_value_policy::reference,
+        nb::arg("group_ops"), nb::rv_policy::reference,
         "Returns space-group with identical operations.");
   m.def("seitz_to_op", &seitz_to_op);
 }
diff --git a/python/topo.cpp b/python/topo.cpp
index 31e701434..26e529978 100644
--- a/python/topo.cpp
+++ b/python/topo.cpp
@@ -5,30 +5,30 @@
 #include "gemmi/crd.hpp"       // for prepare_refmac_crd, ...
 
 #include "common.h"
-#include <pybind11/stl.h>
-#include <pybind11/stl_bind.h>
-#include <pybind11/iostream.h>  // for detail::pythonbuf
+#include <nanobind/stl/bind_vector.h>
+#include <nanobind/stl/string.h>
+#include <nanobind/stl/vector.h>  // for find_missing_atoms
+#include <nanobind/stl/unique_ptr.h>  // for prepare_topology
 
-namespace py = pybind11;
 using namespace gemmi;
 
-PYBIND11_MAKE_OPAQUE(std::vector<Topo::Bond>)
-PYBIND11_MAKE_OPAQUE(std::vector<Topo::Angle>)
-PYBIND11_MAKE_OPAQUE(std::vector<Topo::Torsion>)
-PYBIND11_MAKE_OPAQUE(std::vector<Topo::Chirality>)
-PYBIND11_MAKE_OPAQUE(std::vector<Topo::Plane>)
-PYBIND11_MAKE_OPAQUE(std::vector<Topo::Link>)
-PYBIND11_MAKE_OPAQUE(std::vector<Topo::ChainInfo>)
-PYBIND11_MAKE_OPAQUE(std::vector<Topo::ResInfo>)
-PYBIND11_MAKE_OPAQUE(std::vector<Topo::Rule>)
-PYBIND11_MAKE_OPAQUE(std::vector<Topo::Mod>)
-PYBIND11_MAKE_OPAQUE(std::vector<Topo::FinalChemComp>)
+NB_MAKE_OPAQUE(std::vector<Topo::Bond>)
+NB_MAKE_OPAQUE(std::vector<Topo::Angle>)
+NB_MAKE_OPAQUE(std::vector<Topo::Torsion>)
+NB_MAKE_OPAQUE(std::vector<Topo::Chirality>)
+NB_MAKE_OPAQUE(std::vector<Topo::Plane>)
+NB_MAKE_OPAQUE(std::vector<Topo::Link>)
+NB_MAKE_OPAQUE(std::vector<Topo::ChainInfo>)
+NB_MAKE_OPAQUE(std::vector<Topo::ResInfo>)
+NB_MAKE_OPAQUE(std::vector<Topo::Rule>)
+NB_MAKE_OPAQUE(std::vector<Topo::Mod>)
+NB_MAKE_OPAQUE(std::vector<Topo::FinalChemComp>)
 
 
-void add_topo(py::module& m) {
-  py::class_<Topo> topo(m, "Topo");
+void add_topo(nb::module_& m) {
+  nb::class_<Topo> topo(m, "Topo");
 
-  py::enum_<HydrogenChange>(m, "HydrogenChange")
+  nb::enum_<HydrogenChange>(m, "HydrogenChange")
     .value("NoChange", HydrogenChange::NoChange)
     .value("Shift", HydrogenChange::Shift)
     .value("Remove", HydrogenChange::Remove)
@@ -36,150 +36,151 @@ void add_topo(py::module& m) {
     .value("ReAddButWater", HydrogenChange::ReAddButWater)
     .value("ReAddKnown", HydrogenChange::ReAddKnown);
 
-  py::class_<Topo::Bond>(topo, "Bond")
-    .def_readonly("restr", &Topo::Bond::restr)
-    .def_readonly("atoms", &Topo::Bond::atoms)
+  nb::class_<Topo::Bond>(topo, "Bond")
+    .def_ro("restr", &Topo::Bond::restr)
+    .def_ro("atoms", &Topo::Bond::atoms)
     .def("calculate", &Topo::Bond::calculate)
     .def("calculate_z", &Topo::Bond::calculate_z)
     ;
-  py::bind_vector<std::vector<Topo::Bond>>(m, "TopoBonds");
+  nb::bind_vector<std::vector<Topo::Bond>, rv_ri>(m, "TopoBonds");
 
-  py::class_<Topo::Angle>(topo, "Angle")
-    .def_readonly("restr", &Topo::Angle::restr)
-    .def_readonly("atoms", &Topo::Angle::atoms)
+  nb::class_<Topo::Angle>(topo, "Angle")
+    .def_ro("restr", &Topo::Angle::restr)
+    .def_ro("atoms", &Topo::Angle::atoms)
     .def("calculate", &Topo::Angle::calculate)
     .def("calculate_z", &Topo::Angle::calculate_z)
     ;
-  py::bind_vector<std::vector<Topo::Angle>>(m, "TopoAngles");
+  nb::bind_vector<std::vector<Topo::Angle>, rv_ri>(m, "TopoAngles");
 
-  py::class_<Topo::Torsion>(topo, "Torsion")
-    .def_readonly("restr", &Topo::Torsion::restr)
-    .def_readonly("atoms", &Topo::Torsion::atoms)
+  nb::class_<Topo::Torsion>(topo, "Torsion")
+    .def_ro("restr", &Topo::Torsion::restr)
+    .def_ro("atoms", &Topo::Torsion::atoms)
     .def("calculate", &Topo::Torsion::calculate)
     .def("calculate_z", &Topo::Torsion::calculate_z)
     ;
-  py::bind_vector<std::vector<Topo::Torsion>>(m, "TopoTorsions");
+  nb::bind_vector<std::vector<Topo::Torsion>, rv_ri>(m, "TopoTorsions");
 
-  py::class_<Topo::Chirality>(topo, "Chirality")
-    .def_readonly("restr", &Topo::Chirality::restr)
-    .def_readonly("atoms", &Topo::Chirality::atoms)
+  nb::class_<Topo::Chirality>(topo, "Chirality")
+    .def_ro("restr", &Topo::Chirality::restr)
+    .def_ro("atoms", &Topo::Chirality::atoms)
     .def("calculate", &Topo::Chirality::calculate)
     .def("calculate_z", &Topo::Chirality::calculate_z,
-         py::arg("ideal_abs_vol"), py::arg("esd"))
+         nb::arg("ideal_abs_vol"), nb::arg("esd"))
     .def("check", &Topo::Chirality::check)
     ;
-  py::bind_vector<std::vector<Topo::Chirality>>(m, "TopoChirs");
+  nb::bind_vector<std::vector<Topo::Chirality>, rv_ri>(m, "TopoChirs");
 
-  py::class_<Topo::Plane>(topo, "Plane")
-    .def_readonly("restr", &Topo::Plane::restr)
-    .def_readonly("atoms", &Topo::Plane::atoms)
+  nb::class_<Topo::Plane>(topo, "Plane")
+    .def_ro("restr", &Topo::Plane::restr)
+    .def_ro("atoms", &Topo::Plane::atoms)
     .def("has", &Topo::Plane::has)
     ;
-  py::bind_vector<std::vector<Topo::Plane>>(m, "TopoPlanes");
+  nb::bind_vector<std::vector<Topo::Plane>, rv_ri>(m, "TopoPlanes");
 
-  py::enum_<Topo::RKind>(m, "RKind")
+  nb::enum_<Topo::RKind>(m, "RKind")
     .value("Bond", Topo::RKind::Bond)
     .value("Angle", Topo::RKind::Angle)
     .value("Torsion", Topo::RKind::Torsion)
     .value("Chirality", Topo::RKind::Chirality)
     .value("Plane", Topo::RKind::Plane)
     ;
-  py::class_<Topo::Rule>(topo, "Rule")
-    .def_readonly("rkind", &Topo::Rule::rkind)
-    .def_readonly("index", &Topo::Rule::index)
+  nb::class_<Topo::Rule>(topo, "Rule")
+    .def_ro("rkind", &Topo::Rule::rkind)
+    .def_ro("index", &Topo::Rule::index)
     ;
-  py::bind_vector<std::vector<Topo::Rule>>(m, "TopoRules");
+  nb::bind_vector<std::vector<Topo::Rule>, rv_ri>(m, "TopoRules");
 
-  py::class_<Topo::Mod>(topo, "Mod")
-    .def_readonly("id", &Topo::Mod::id)
-    .def_readonly("alias", &Topo::Mod::alias)
-    .def_readonly("altloc", &Topo::Mod::altloc)
+  nb::class_<Topo::Mod>(topo, "Mod")
+    .def_ro("id", &Topo::Mod::id)
+    .def_ro("alias", &Topo::Mod::alias)
+    .def_ro("altloc", &Topo::Mod::altloc)
     ;
-  py::bind_vector<std::vector<Topo::Mod>>(m, "TopoMods");
+  nb::bind_vector<std::vector<Topo::Mod>, rv_ri>(m, "TopoMods");
 
-  py::class_<Topo::FinalChemComp>(topo, "FinalChemComp")
-    .def_readonly("altloc", &Topo::FinalChemComp::altloc)
-    .def_readonly("cc", &Topo::FinalChemComp::cc)
+  nb::class_<Topo::FinalChemComp>(topo, "FinalChemComp")
+    .def_ro("altloc", &Topo::FinalChemComp::altloc)
+    .def_ro("cc", &Topo::FinalChemComp::cc)
     ;
-  py::bind_vector<std::vector<Topo::FinalChemComp>>(m, "TopoFinalChemComps");
-
-  py::class_<Topo::Link>(topo, "Link")
-    .def_readonly("link_id", &Topo::Link::link_id)
-    .def_readonly("res1", &Topo::Link::res1)
-    .def_readonly("res2", &Topo::Link::res2)
-    .def_readonly("alt1", &Topo::Link::alt1)
-    .def_readonly("alt2", &Topo::Link::alt2)
-    .def_readonly("link_rules", &Topo::Link::link_rules)
+  nb::bind_vector<std::vector<Topo::FinalChemComp>, rv_ri>(m, "TopoFinalChemComps");
+
+  nb::class_<Topo::Link>(topo, "Link")
+    .def_ro("link_id", &Topo::Link::link_id)
+    .def_ro("res1", &Topo::Link::res1)
+    .def_ro("res2", &Topo::Link::res2)
+    .def_ro("alt1", &Topo::Link::alt1)
+    .def_ro("alt2", &Topo::Link::alt2)
+    .def_ro("link_rules", &Topo::Link::link_rules)
     ;
-  py::bind_vector<std::vector<Topo::Link>>(m, "TopoLinks");
-
-  py::class_<Topo::ResInfo>(topo, "ResInfo")
-    .def_readonly("res", &Topo::ResInfo::res)
-    .def_readonly("prev", &Topo::ResInfo::prev)
-    .def_readonly("mods", &Topo::ResInfo::mods)
-    .def_readonly("chemcomps", &Topo::ResInfo::chemcomps)
-    .def_readonly("monomer_rules", &Topo::ResInfo::monomer_rules)
+  nb::bind_vector<std::vector<Topo::Link>, rv_ri>(m, "TopoLinks");
+
+  nb::class_<Topo::ResInfo>(topo, "ResInfo")
+    .def_ro("res", &Topo::ResInfo::res)
+    .def_ro("prev", &Topo::ResInfo::prev)
+    .def_ro("mods", &Topo::ResInfo::mods)
+    .def_ro("chemcomps", &Topo::ResInfo::chemcomps)
+    .def_ro("monomer_rules", &Topo::ResInfo::monomer_rules)
     .def("get_final_chemcomp", &Topo::ResInfo::get_final_chemcomp)
     ;
-  py::bind_vector<std::vector<Topo::ResInfo>>(m, "TopoResInfos");
-
-  py::class_<Topo::ChainInfo>(topo, "ChainInfo")
-    .def_property_readonly("chain_ref", [](const Topo::ChainInfo& self)
-        { return &self.chain_ref; }, py::return_value_policy::reference_internal)
-    .def_readonly("subchain_name", &Topo::ChainInfo::subchain_name)
-    .def_readonly("entity_id", &Topo::ChainInfo::entity_id)
-    .def_readonly("polymer", &Topo::ChainInfo::polymer)
-    .def_readonly("polymer_type", &Topo::ChainInfo::polymer_type)
-    .def_readonly("res_infos", &Topo::ChainInfo::res_infos)
+  nb::bind_vector<std::vector<Topo::ResInfo>, rv_ri>(m, "TopoResInfos");
+
+  nb::class_<Topo::ChainInfo>(topo, "ChainInfo")
+    .def_prop_ro("chain_ref", [](const Topo::ChainInfo& self)
+        { return &self.chain_ref; }, nb::rv_policy::reference_internal)
+    .def_ro("subchain_name", &Topo::ChainInfo::subchain_name)
+    .def_ro("entity_id", &Topo::ChainInfo::entity_id)
+    .def_ro("polymer", &Topo::ChainInfo::polymer)
+    .def_ro("polymer_type", &Topo::ChainInfo::polymer_type)
+    .def_ro("res_infos", &Topo::ChainInfo::res_infos)
     ;
 
-  py::class_<std::vector<Topo::ChainInfo>>(m, "TopoChainInfos")
+  nb::class_<std::vector<Topo::ChainInfo>>(m, "TopoChainInfos")
     .def("__len__", &std::vector<Topo::ChainInfo>::size)
     .def("__getitem__", [](const std::vector<Topo::ChainInfo> &self, size_t i) {return self.at(i);})
     ;
 
   topo
-    .def(py::init<>())
+    .def(nb::init<>())
     .def("adjust_hydrogen_distances", &adjust_hydrogen_distances,
-         py::arg("of"), py::arg("default_scale")=1.)
-    .def_readonly("bonds", &Topo::bonds)
-    .def_readonly("angles", &Topo::angles)
-    .def_readonly("torsions", &Topo::torsions)
-    .def_readonly("chirs", &Topo::chirs)
-    .def_readonly("planes", &Topo::planes)
-    .def_readonly("extras", &Topo::extras)
-    .def_readonly("chain_infos", &Topo::chain_infos)
+         nb::arg("of"), nb::arg("default_scale")=1.)
+    .def_ro("bonds", &Topo::bonds)
+    .def_ro("angles", &Topo::angles)
+    .def_ro("torsions", &Topo::torsions)
+    .def_ro("chirs", &Topo::chirs)
+    .def_ro("planes", &Topo::planes)
+    .def_ro("extras", &Topo::extras)
+    .def_ro("chain_infos", &Topo::chain_infos)
     .def("ideal_chiral_abs_volume", &Topo::ideal_chiral_abs_volume)
     .def("links_to_previous", [](Topo& self, Residue* res) {
         if (Topo::ResInfo* ri = self.find_resinfo(res))
           return ri->prev;
         fail("links_to_previous(): Residue not found");
-    }, py::return_value_policy::reference_internal)
+    }, nb::rv_policy::reference_internal)
     .def("first_bond_in_link", &Topo::first_bond_in_link,
-         py::return_value_policy::reference_internal)
+         nb::rv_policy::reference_internal)
     .def("set_cispeps_in_structure", &Topo::set_cispeps_in_structure)
     .def("find_missing_atoms", &find_missing_atoms,
-         py::arg("including_hydrogen")=false)
+         nb::arg("including_hydrogen")=false)
     ;
 
   m.def("prepare_topology",
     [](Structure& st, MonLib& monlib, size_t model_index,
        HydrogenChange h_change, bool reorder,
-       const py::object& pywarnings, bool ignore_unknown_links, bool use_cispeps) {
+       const nb::object& pywarnings, bool ignore_unknown_links, bool use_cispeps) {
       std::ostream* warnings = nullptr;
-      std::ostream os(nullptr);
-      std::unique_ptr<py::detail::pythonbuf> buffer;
-      if (!pywarnings.is_none()) {
-        buffer.reset(new py::detail::pythonbuf(pywarnings));
-        os.rdbuf(buffer.get());
-        warnings = &os;
-      }
+      // TODO: new way of passing warnings
+      //std::ostream os(nullptr);
+      //std::unique_ptr<nb::detail::pythonbuf> buffer;
+      //if (!pywarnings.is_none()) {
+      //  buffer.reset(new nb::detail::pythonbuf(pywarnings));
+      //  os.rdbuf(buffer.get());
+      //  warnings = &os;
+      //}
       return prepare_topology(st, monlib, model_index, h_change, reorder,
                               warnings, ignore_unknown_links, use_cispeps);
-    }, py::arg("st"), py::arg("monlib"), py::arg("model_index")=0,
-       py::arg("h_change")=HydrogenChange::NoChange, py::arg("reorder")=false,
-       py::arg("warnings")=py::none(), py::arg("ignore_unknown_links")=false,
-       py::arg("use_cispeps")=false);
+    }, nb::arg("st"), nb::arg("monlib"), nb::arg("model_index")=0,
+       nb::arg("h_change")=HydrogenChange::NoChange, nb::arg("reorder")=false,
+       nb::arg("warnings")=nb::none(), nb::arg("ignore_unknown_links")=false,
+       nb::arg("use_cispeps")=false);
 
   // crd.hpp
   m.def("setup_for_crd", &setup_for_crd);
diff --git a/python/unitcell.cpp b/python/unitcell.cpp
index 441855652..a6dafe723 100644
--- a/python/unitcell.cpp
+++ b/python/unitcell.cpp
@@ -8,13 +8,14 @@
 
 #include <array>
 #include "common.h"
-#include "arrvec.h"  // py_array_from_vector
-#include <pybind11/stl.h>
-#include <pybind11/numpy.h>
-#include <pybind11/operators.h>
-#include "miller_a.h"
+#include "array.h"  // numpy_array_from_vector, miller_function
+#include "serial.h"  // for getstate, setstate
+#include <nanobind/operators.h>
+#include <nanobind/stl/array.h>
+#include <nanobind/stl/pair.h>    // for find_lattice_2fold_ops
+#include <nanobind/stl/string.h>
+#include <nanobind/stl/vector.h>  // for UnitCell::images
 
-namespace py = pybind11;
 using namespace gemmi;
 
 static std::string triple(double x, double y, double z) {
@@ -30,27 +31,23 @@ static void mat33_from_list(Mat33& self, std::array<std::array<double,3>,3>& m)
       self.a[i][j] = m[i][j];
 }
 
-static py::tuple make_parameters_tuple(const UnitCell& u) {
-  return py::make_tuple(u.a, u.b, u.c, u.alpha, u.beta, u.gamma);
+static nb::tuple make_six_tuple(const std::array<double,6>& v) {
+  return nb::make_tuple(v[0], v[1], v[2], v[3], v[4], v[5]);
 }
 
-static py::tuple make_six_tuple(const std::array<double,6>& v) {
-  return py::make_tuple(v[0], v[1], v[2], v[3], v[4], v[5]);
-}
-
-template<typename T> void add_smat33(py::module& m, const char* name) {
+template<typename T> void add_smat33(nb::module_& m, const char* name) {
   using M = SMat33<T>;
-  py::class_<M>(m, name)
-    .def(py::init([](T u11, T u22, T u33, T u12, T u13, T u23) {
-           return M{u11, u22, u33, u12, u13, u23};
-         }), py::arg("u11"), py::arg("u22"), py::arg("u33"),
-             py::arg("u12"), py::arg("u13"), py::arg("u23"))
-    .def_readwrite("u11", &M::u11)
-    .def_readwrite("u22", &M::u22)
-    .def_readwrite("u33", &M::u33)
-    .def_readwrite("u12", &M::u12)
-    .def_readwrite("u13", &M::u13)
-    .def_readwrite("u23", &M::u23)
+  nb::class_<M>(m, name)
+    .def("__init__", [](M* p, T u11, T u22, T u33, T u12, T u13, T u23) {
+           new(p) M{u11, u22, u33, u12, u13, u23};
+         }, nb::arg("u11"), nb::arg("u22"), nb::arg("u33"),
+            nb::arg("u12"), nb::arg("u13"), nb::arg("u23"))
+    .def_rw("u11", &M::u11)
+    .def_rw("u22", &M::u22)
+    .def_rw("u33", &M::u33)
+    .def_rw("u12", &M::u12)
+    .def_rw("u13", &M::u13)
+    .def_rw("u23", &M::u23)
     .def("elements_pdb", &M::elements_pdb)
     .def("elements_voigt", &M::elements_voigt)
     .def("as_mat33", &M::as_mat33)
@@ -61,21 +58,18 @@ template<typename T> void add_smat33(py::module& m, const char* name) {
     .def("scaled", &M::template scaled<T>)
     .def("added_kI", &M::added_kI)
     .def("r_u_r", (double (M::*)(const Vec3&) const) &M::r_u_r)
-    .def("r_u_r", [](const M& self, py::array_t<int> arr) {
-        int nrow = (int) arr.shape(0);
-        int ncol = (int) arr.shape(1);
-        if (ncol != 3)
-           fail("SMat33::r_u_r(): expected 3 columns.");
+    .def("r_u_r", [](const M& self, cpu_miller_array arr) {
         std::vector<T> v;
-        v.reserve(nrow);
-        auto r = arr.unchecked<2>();
-        for (py::ssize_t row = 0; row < nrow; ++row)
-           v.push_back((T)self.r_u_r(Vec3(r(row, 0), r(row, 1), r(row, 2))));
-        return py_array_from_vector(std::move(v));
-    }, py::arg().noconvert())
+        size_t len = arr.shape(0);
+        v.reserve(len);
+        auto r = arr.view();
+        for (size_t row = 0; row < len; ++row)
+           v.push_back((T)self.r_u_r({r(row, 0), r(row, 1), r(row, 2)}));
+        return numpy_array_from_vector(std::move(v));
+    }, nb::arg().noconvert())
     .def("multiply", &M::multiply)
-    .def(py::self + py::self)
-    .def(py::self - py::self)
+    .def(nb::self + nb::self)
+    .def(nb::self - nb::self)
     .def("transformed_by", &M::template transformed_by<T>)
     .def("calculate_eigenvalues", &M::calculate_eigenvalues)
     .def("__repr__", [name](const M& m) {
@@ -84,29 +78,29 @@ template<typename T> void add_smat33(py::module& m, const char* name) {
     });
 }
 
-template<typename T> void add_box(py::module& m, const char* name) {
+template<typename T> void add_box(nb::module_& m, const char* name) {
   using M = Box<T>;
-  py::class_<M>(m, name)
-    .def(py::init<>())
-    .def_readwrite("minimum", &M::minimum)
-    .def_readwrite("maximum", &M::maximum)
+  nb::class_<M>(m, name)
+    .def(nb::init<>())
+    .def_rw("minimum", &M::minimum)
+    .def_rw("maximum", &M::maximum)
     .def("get_size", &M::get_size)
     .def("extend", &M::extend)
     .def("add_margin", &M::add_margin)
     ;
 }
 
-void add_unitcell(py::module& m) {
-  py::class_<Vec3>(m, "Vec3")
-    .def(py::init<double,double,double>())
-    .def_readwrite("x", &Vec3::x)
-    .def_readwrite("y", &Vec3::y)
-    .def_readwrite("z", &Vec3::z)
+void add_unitcell(nb::module_& m) {
+  nb::class_<Vec3>(m, "Vec3")
+    .def(nb::init<double,double,double>())
+    .def_rw("x", &Vec3::x)
+    .def_rw("y", &Vec3::y)
+    .def_rw("z", &Vec3::z)
     .def("normalized", &Vec3::normalized)
     .def("dot", &Vec3::dot)
     .def("cross", &Vec3::cross)
     .def("length", &Vec3::length)
-    .def("approx", &Vec3::approx, py::arg("other"), py::arg("epsilon"))
+    .def("approx", &Vec3::approx, nb::arg("other"), nb::arg("epsilon"))
     .def("tolist", [](const Vec3& self) {
         return std::array<double,3>{{self.x, self.y, self.z}};
     })
@@ -115,17 +109,17 @@ void add_unitcell(py::module& m) {
         self.y = v[1];
         self.z = v[2];
     })
-    .def(py::self + py::self)
-    .def(py::self - py::self)
-    .def(py::self += py::self)
-    //.def(py::self -= py::self)  // Clang warning -Wself-assign-overloaded
-    .def(operator-=(py::self, py::self))
-    .def(py::self * float())
-    .def(py::self *= float())
-    .def(float() * py::self)
-    .def(py::self / float())
-    .def(py::self /= float())
-    .def(-py::self)
+    .def(nb::self + nb::self)
+    .def(nb::self - nb::self)
+    .def(nb::self += nb::self, nb::rv_policy::none)
+    //.def(nb::self -= nb::self)  // Clang warning -Wself-assign-overloaded
+    .def(operator-=(nb::self, nb::self), nb::rv_policy::none)
+    .def(nb::self * float())
+    .def(nb::self *= float(), nb::rv_policy::none)
+    .def(float() * nb::self)
+    .def(nb::self / float())
+    .def(nb::self /= float(), nb::rv_policy::none)
+    .def(-nb::self)
     .def("__getitem__", (double (Vec3::*)(int) const) &Vec3::at)
     .def("__setitem__", [](Vec3& self, int idx, double value) {
         self.at(idx) = value;
@@ -133,37 +127,35 @@ void add_unitcell(py::module& m) {
     .def("__repr__", [](const Vec3& self) {
         return "<gemmi.Vec3(" + triple(self.x, self.y, self.z) + ")>";
     });
-  py::class_<Mat33> mat33(m, "Mat33", py::buffer_protocol());
+  nb::class_<Mat33> mat33(m, "Mat33");
   mat33
-    .def(py::init<>())
-    .def(py::init([](std::array<std::array<double,3>,3>& m) {
-       Mat33 *mat = new Mat33();
-       mat33_from_list(*mat, m);
-       return mat;
-     }))
-    .def_buffer([](Mat33 &self) {
-      return py::buffer_info(&self.a[0][0],
-                             {3, 3}, // dimensions
-                             {sizeof(double)*3, sizeof(double)});  // strides
-    })
+    .def(nb::init<>())
+    .def("__init__", [](Mat33* mat, std::array<std::array<double,3>,3>& arr) {
+       new(mat) Mat33();
+       mat33_from_list(*mat, arr);
+     })
+    .def_prop_ro("array", [](Mat33& self) {
+      return nb::ndarray<nb::numpy, double, nb::shape<3,3>, nb::c_contig>(
+          &self.a[0][0], {3, 3}, nb::handle());
+    }, nb::rv_policy::reference_internal)
     .def("row_copy", &Mat33::row_copy)
     .def("column_copy", &Mat33::column_copy)
-    .def(py::self + py::self)
-    .def(py::self - py::self)
+    .def(nb::self + nb::self)
+    .def(nb::self - nb::self)
     .def("multiply", (Mat33 (Mat33::*)(const Mat33&) const) &Mat33::multiply)
     .def("multiply", (Vec3 (Mat33::*)(const Vec3&) const) &Mat33::multiply)
     .def("left_multiply", &Mat33::left_multiply)
     .def("multiply_by_diagonal", &Mat33::multiply_by_diagonal)
     .def("transpose", &Mat33::transpose)
     .def("trace", &Mat33::trace)
-    .def("approx", &Mat33::approx, py::arg("other"), py::arg("epsilon"))
+    .def("approx", &Mat33::approx, nb::arg("other"), nb::arg("epsilon"))
     .def("determinant", &Mat33::determinant)
     .def("inverse", &Mat33::inverse)
     .def("is_identity", &Mat33::is_identity)
-    .def("tolist", [](const Mat33& m) -> std::array<std::array<double,3>,3> {
-        return {{{{m[0][0], m[0][1], m[0][2]}},
-                 {{m[1][0], m[1][1], m[1][2]}},
-                 {{m[2][0], m[2][1], m[2][2]}}}};
+    .def("tolist", [](const Mat33& mat) -> std::array<std::array<double,3>,3> {
+        return {{{{mat[0][0], mat[0][1], mat[0][2]}},
+                 {{mat[1][0], mat[1][1], mat[1][2]}},
+                 {{mat[2][0], mat[2][1], mat[2][2]}}}};
     })
     .def("fromlist", mat33_from_list)
     .def("__repr__", [](const Mat33& self) {
@@ -177,51 +169,50 @@ void add_unitcell(py::module& m) {
   add_smat33<double>(m, "SMat33d");
   add_smat33<float>(m, "SMat33f");
 
-  py::class_<Transform> transform(m, "Transform");
+  nb::class_<Transform> transform(m, "Transform");
   transform
-    .def(py::init<>())
-    .def(py::init([](const Mat33& m, const Vec3& v) {
-      Transform* tr = new Transform();
-      tr->mat = m;
-      tr->vec = v;
-      return tr;
-    }), py::arg("mat33"), py::arg("vec3"))
-    .def_readonly("mat", &Transform::mat)
-    .def_readonly("vec", &Transform::vec)
+    .def(nb::init<>())
+    .def("__init__", [](Transform* tr, const Mat33& m, const Vec3& v) {
+        new(tr) Transform();
+        tr->mat = m;
+        tr->vec = v;
+    }, nb::arg("mat33"), nb::arg("vec3"))
+    .def_ro("mat", &Transform::mat)
+    .def_ro("vec", &Transform::vec)
     .def("inverse", &Transform::inverse)
     .def("apply", &Transform::apply)
     .def("combine", &Transform::combine)
     .def("is_identity", &Transform::is_identity)
-    .def("approx", &Transform::approx, py::arg("other"), py::arg("epsilon"));
+    .def("approx", &Transform::approx, nb::arg("other"), nb::arg("epsilon"));
   transform.attr("__matmul__") = transform.attr("combine");
 
-  py::class_<Position, Vec3>(m, "Position")
-    .def(py::init<double,double,double>())
-    .def(py::init<const Vec3&>())
+  nb::class_<Position, Vec3>(m, "Position")
+    .def(nb::init<double,double,double>())
+    .def(nb::init<const Vec3&>())
     .def("dist", [](const Position& self, const Position& other) {
         return self.dist(other);
     })
-    .def(py::self + py::self)
-    .def(py::self - py::self)
-    .def(py::self += py::self)
-    .def(operator-=(py::self, py::self))
-    .def(py::self * float())
-    .def(py::self *= float())
-    .def(float() * py::self)
-    .def(py::self / float())
-    .def(py::self /= float())
-    .def(-py::self)
+    .def(nb::self + nb::self)
+    .def(nb::self - nb::self)
+    .def(nb::self += nb::self, nb::rv_policy::none)
+    .def(operator-=(nb::self, nb::self), nb::rv_policy::none)
+    .def(nb::self * float())
+    .def(nb::self *= float(), nb::rv_policy::none)
+    .def(float() * nb::self)
+    .def(nb::self / float())
+    .def(nb::self /= float(), nb::rv_policy::none)
+    .def(-nb::self)
     .def("__repr__", [](const Position& self) {
         return "<gemmi.Position(" + triple(self.x, self.y, self.z) + ")>";
     });
-  py::class_<Fractional, Vec3>(m, "Fractional")
-    .def(py::init<double,double,double>())
-    .def(py::init<const Vec3&>())
+  nb::class_<Fractional, Vec3>(m, "Fractional")
+    .def(nb::init<double,double,double>())
+    .def(nb::init<const Vec3&>())
     .def("wrap_to_unit", &Fractional::wrap_to_unit)
     .def("wrap_to_zero", &Fractional::wrap_to_zero)
     .def("__getitem__", (double (Fractional::*)(int) const) &Fractional::at)
-    .def(py::self + py::self)
-    .def(py::self - py::self)
+    .def(nb::self + nb::self)
+    .def(nb::self - nb::self)
     .def("__repr__", [](const Fractional& self) {
         return "<gemmi.Fractional(" + triple(self.x, self.y, self.z) + ")>";
     });
@@ -229,18 +220,17 @@ void add_unitcell(py::module& m) {
   add_box<Position>(m, "PositionBox");
   add_box<Fractional>(m, "FractionalBox");
 
-  py::class_<FTransform, Transform>(m, "FTransform")
-    .def(py::init<>())
+  nb::class_<FTransform, Transform>(m, "FTransform")
+    .def(nb::init<>())
     .def("apply", &FTransform::apply);
 
-
-  py::class_<NearestImage>(m, "NearestImage")
+  nb::class_<NearestImage>(m, "NearestImage")
     .def("dist", &NearestImage::dist)
     .def("same_asu", &NearestImage::same_asu)
-    .def("symmetry_code", &NearestImage::symmetry_code, py::arg("underscore")=true)
-    .def_readonly("sym_idx", &NearestImage::sym_idx)
-    .def_property_readonly("pbc_shift", [](const NearestImage& self) {
-        return py::make_tuple(self.pbc_shift[0], self.pbc_shift[1], self.pbc_shift[2]);
+    .def("symmetry_code", &NearestImage::symmetry_code, nb::arg("underscore")=true)
+    .def_ro("sym_idx", &NearestImage::sym_idx)
+    .def_prop_ro("pbc_shift", [](const NearestImage& self) {
+        return nb::make_tuple(self.pbc_shift[0], self.pbc_shift[1], self.pbc_shift[2]);
     })
     .def("__repr__", [](const NearestImage& self) {
         char buf[64];
@@ -249,44 +239,47 @@ void add_unitcell(py::module& m) {
         return std::string(buf);
     });
 
-  py::enum_<Asu>(m, "Asu")
+  nb::enum_<Asu>(m, "Asu")
     .value("Same", Asu::Same)
     .value("Different", Asu::Different)
     .value("Any", Asu::Any);
 
-  py::class_<UnitCell>(m, "UnitCell")
-    .def(py::init<>())
-    .def(py::init<double,double,double,double,double,double>(),
-         py::arg("a"), py::arg("b"), py::arg("c"),
-         py::arg("alpha"), py::arg("beta"), py::arg("gamma"))
-    .def_readonly("a", &UnitCell::a)
-    .def_readonly("b", &UnitCell::b)
-    .def_readonly("c", &UnitCell::c)
-    .def_readonly("alpha", &UnitCell::alpha)
-    .def_readonly("beta", &UnitCell::beta)
-    .def_readonly("gamma", &UnitCell::gamma)
-    .def_readonly("volume", &UnitCell::volume)
-    .def_readonly("explicit_matrices", &UnitCell::explicit_matrices)
-    .def_readonly("images", &UnitCell::images)
-    .def_property_readonly("parameters", &make_parameters_tuple)
-    .def_readonly("frac", &UnitCell::frac)
-    .def_readonly("orth", &UnitCell::orth)
+  nb::class_<UnitCell>(m, "UnitCell")
+    .def(nb::init<>())
+    .def(nb::init<double,double,double,double,double,double>(),
+         nb::arg("a"), nb::arg("b"), nb::arg("c"),
+         nb::arg("alpha"), nb::arg("beta"), nb::arg("gamma"))
+    .def_ro("a", &UnitCell::a)
+    .def_ro("b", &UnitCell::b)
+    .def_ro("c", &UnitCell::c)
+    .def_ro("alpha", &UnitCell::alpha)
+    .def_ro("beta", &UnitCell::beta)
+    .def_ro("gamma", &UnitCell::gamma)
+    .def_ro("volume", &UnitCell::volume)
+    .def_ro("explicit_matrices", &UnitCell::explicit_matrices)
+    .def_ro("images", &UnitCell::images)
+    .def_prop_ro("parameters", [](const UnitCell& u) {
+        return nb::make_tuple(u.a, u.b, u.c, u.alpha, u.beta, u.gamma);
+    })
+
+    .def_ro("frac", &UnitCell::frac)
+    .def_ro("orth", &UnitCell::orth)
     // These two functions are deprecated, use frac.mat and orth.mat.
-    .def_property_readonly("fractionalization_matrix",
+    .def_prop_ro("fractionalization_matrix",
                            [](const UnitCell& self) { return self.frac.mat; })
-    .def_property_readonly("orthogonalization_matrix",
+    .def_prop_ro("orthogonalization_matrix",
                            [](const UnitCell& self) { return self.orth.mat; })
     .def("set", &UnitCell::set)
     .def("changed_basis_forward", &UnitCell::changed_basis_forward,
-         py::arg("op"), py::arg("set_images"))
+         nb::arg("op"), nb::arg("set_images"))
     .def("changed_basis_backward", &UnitCell::changed_basis_backward,
-         py::arg("op"), py::arg("set_images"))
+         nb::arg("op"), nb::arg("set_images"))
     .def("is_compatible_with_spacegroup", &UnitCell::is_compatible_with_spacegroup,
-         py::arg("sg"), py::arg("eps")=1e-3)
+         nb::arg("sg"), nb::arg("eps")=1e-3)
     .def("is_crystal", &UnitCell::is_crystal)
-    .def("approx", &UnitCell::approx, py::arg("other"), py::arg("epsilon"))
+    .def("approx", &UnitCell::approx, nb::arg("other"), nb::arg("epsilon"))
     .def("is_similar", &UnitCell::is_similar,
-         py::arg("other"), py::arg("rel"), py::arg("deg"))
+         nb::arg("other"), nb::arg("rel"), nb::arg("deg"))
     .def("calculate_u_eq", &UnitCell::calculate_u_eq)
     .def("fractionalize", &UnitCell::fractionalize)
     .def("orthogonalize", &UnitCell::orthogonalize)
@@ -294,60 +287,55 @@ void add_unitcell(py::module& m) {
     .def("op_as_transform", &UnitCell::op_as_transform)
     .def("volume_per_image", &UnitCell::volume_per_image)
     .def("find_nearest_image", &UnitCell::find_nearest_image,
-         py::arg("ref"), py::arg("pos"), py::arg("asu")=Asu::Any)
+         nb::arg("ref"), nb::arg("pos"), nb::arg("asu")=Asu::Any)
     .def("find_nearest_pbc_image",
          (NearestImage (UnitCell::*)(const Fractional&, Fractional, int) const)
          &UnitCell::find_nearest_pbc_image,
-         py::arg("fref"), py::arg("fpos"), py::arg("image_idx")=0)
+         nb::arg("fref"), nb::arg("fpos"), nb::arg("image_idx")=0)
     .def("find_nearest_pbc_image",
          (NearestImage (UnitCell::*)(const Position&, const Position&, int) const)
          &UnitCell::find_nearest_pbc_image,
-         py::arg("ref"), py::arg("pos"), py::arg("image_idx")=0)
+         nb::arg("ref"), nb::arg("pos"), nb::arg("image_idx")=0)
     .def("find_nearest_pbc_position", &UnitCell::find_nearest_pbc_position,
-         py::arg("ref"), py::arg("pos"), py::arg("image_idx"), py::arg("inverse")=false)
+         nb::arg("ref"), nb::arg("pos"), nb::arg("image_idx"), nb::arg("inverse")=false)
     .def("is_special_position",
          (int (UnitCell::*)(const Position&, double) const)
            &UnitCell::is_special_position,
-         py::arg("pos"), py::arg("max_dist")=0.8)
+         nb::arg("pos"), nb::arg("max_dist")=0.8)
     .def("is_special_position",
          (int (UnitCell::*)(const Fractional&, double) const)
            &UnitCell::is_special_position,
-         py::arg("fpos"), py::arg("max_dist"))
-    .def("calculate_1_d2", &UnitCell::calculate_1_d2, py::arg("hkl"))
-    .def("calculate_1_d2_array", [](const UnitCell& u, py::array_t<int> hkl) {
+         nb::arg("fpos"), nb::arg("max_dist"))
+    .def("calculate_1_d2", &UnitCell::calculate_1_d2, nb::arg("hkl"))
+    .def("calculate_1_d2_array", [](const UnitCell& u, cpu_miller_array hkl) {
         return miller_function<double>(u, &UnitCell::calculate_1_d2, hkl);
     })
-    .def("calculate_d", &UnitCell::calculate_d, py::arg("hkl"))
-    .def("calculate_d_array", [](const UnitCell& u, py::array_t<int> hkl) {
+    .def("calculate_d", &UnitCell::calculate_d, nb::arg("hkl"))
+    .def("calculate_d_array", [](const UnitCell& u, cpu_miller_array hkl) {
         return miller_function<double>(u, &UnitCell::calculate_d, hkl);
     })
     .def("metric_tensor", &UnitCell::metric_tensor)
     .def("reciprocal_metric_tensor", &UnitCell::reciprocal_metric_tensor)
     .def("reciprocal", &UnitCell::reciprocal)
-    .def("get_hkl_limits", &UnitCell::get_hkl_limits, py::arg("dmin"))
-    .def("primitive_orth_matrix", &UnitCell::primitive_orth_matrix, py::arg("centring_type"))
-    .def(py::self == py::self)
+    .def("get_hkl_limits", &UnitCell::get_hkl_limits, nb::arg("dmin"))
+    .def("primitive_orth_matrix", &UnitCell::primitive_orth_matrix, nb::arg("centring_type"))
+    .def(nb::self == nb::self)
+    .def("__getstate__", &getstate<UnitCell>)
+    .def("__setstate__", &setstate<UnitCell>)
     .def("__repr__", [](const UnitCell& self) {
         return "<gemmi.UnitCell(" + triple(self.a, self.b, self.c)
              + ", " + triple(self.alpha, self.beta, self.gamma) + ")>";
-    })
-    .def(py::pickle(
-         &make_parameters_tuple,
-         [](const py::tuple p) {
-            return UnitCell (p[0].cast<double>(), p[1].cast<double>(), p[2].cast<double>(),
-                             p[3].cast<double>(), p[4].cast<double>(), p[5].cast<double>());
-         }
-    ));
+    });
 
-  py::class_<SellingVector> selling_vector(m, "SellingVector");
+  nb::class_<SellingVector> selling_vector(m, "SellingVector");
 
-  py::class_<GruberVector>(m, "GruberVector")
-    .def(py::init<const std::array<double,6>&>())
-    .def(py::init<const UnitCell&, const SpaceGroup*, bool>(),
-         py::arg("cell"), py::arg("sg"), py::arg("track_change_of_basis")=false)
-    .def(py::init<const UnitCell&, char, bool>(),
-         py::arg("cell"), py::arg("centring"), py::arg("track_change_of_basis")=false)
-    .def_property_readonly("parameters", [](const GruberVector& g) {
+  nb::class_<GruberVector>(m, "GruberVector")
+    .def(nb::init<const std::array<double,6>&>())
+    .def(nb::init<const UnitCell&, const SpaceGroup*, bool>(),
+         nb::arg("cell"), nb::arg("sg").none(), nb::arg("track_change_of_basis")=false)
+    .def(nb::init<const UnitCell&, char, bool>(),
+         nb::arg("cell"), nb::arg("centring"), nb::arg("track_change_of_basis")=false)
+    .def_prop_ro("parameters", [](const GruberVector& g) {
       return make_six_tuple(g.parameters());
     })
     .def("cell_parameters", [](const GruberVector& self) {
@@ -355,18 +343,18 @@ void add_unitcell(py::module& m) {
     })
     .def("get_cell",
          [](const GruberVector& self) { return new UnitCell(self.get_cell()); })
-    .def_property_readonly("change_of_basis", [](const GruberVector& self) {
+    .def_prop_ro("change_of_basis", [](const GruberVector& self) {
         return self.change_of_basis.get();
-    }, py::return_value_policy::reference_internal)
+    }, nb::rv_policy::reference_internal)
     .def("selling", &GruberVector::selling)
     .def("is_normalized", &GruberVector::is_normalized)
-    .def("is_buerger", &GruberVector::is_buerger, py::arg("epsilon")=1e-9)
-    .def("normalize", &GruberVector::normalize, py::arg("epsilon")=1e-9)
+    .def("is_buerger", &GruberVector::is_buerger, nb::arg("epsilon")=1e-9)
+    .def("normalize", &GruberVector::normalize, nb::arg("epsilon")=1e-9)
     .def("buerger_reduce", &GruberVector::buerger_reduce)
-    .def("niggli_step", &GruberVector::niggli_step, py::arg("epsilon"))
+    .def("niggli_step", &GruberVector::niggli_step, nb::arg("epsilon"))
     .def("niggli_reduce", &GruberVector::niggli_reduce,
-         py::arg("epsilon")=1e-9, py::arg("iteration_limit")=100)
-    .def("is_niggli", &GruberVector::is_niggli, py::arg("epsilon")=1e-9)
+         nb::arg("epsilon")=1e-9, nb::arg("iteration_limit")=100)
+    .def("is_niggli", &GruberVector::is_niggli, nb::arg("epsilon")=1e-9)
     .def("__repr__", [](const GruberVector& self) {
         char buf[256];
         snprintf_z(buf, 256, "<gemmi.GruberVector((%.2f, %.2f, %.2f, %.2f, %.2f, %.2f))>",
@@ -375,9 +363,9 @@ void add_unitcell(py::module& m) {
     });
 
   selling_vector
-    .def(py::init<const std::array<double,6>&>())
-    .def(py::init<const UnitCell&, const SpaceGroup*>())
-    .def_property_readonly("parameters", [](const SellingVector& self) {
+    .def(nb::init<const std::array<double,6>&>())
+    .def(nb::init<const UnitCell&, const SpaceGroup*>())
+    .def_prop_ro("parameters", [](const SellingVector& self) {
       return make_six_tuple(self.s);
     })
     .def("cell_parameters", [](const SellingVector& self) {
@@ -387,11 +375,11 @@ void add_unitcell(py::module& m) {
          [](const SellingVector& self) { return new UnitCell(self.get_cell()); })
     .def("sum_b_squared", &SellingVector::sum_b_squared)
     .def("gruber", &SellingVector::gruber)
-    .def("is_reduced", &SellingVector::is_reduced, py::arg("epsilon")=1e-9)
-    .def("reduce_step", &SellingVector::reduce_step, py::arg("epsilon")=1e-9)
+    .def("is_reduced", &SellingVector::is_reduced, nb::arg("epsilon")=1e-9)
+    .def("reduce_step", &SellingVector::reduce_step, nb::arg("epsilon")=1e-9)
     .def("reduce", &SellingVector::reduce,
-         py::arg("epsilon")=1e-9, py::arg("iteration_limit")=100)
-    .def("sort", &SellingVector::sort, py::arg("epsilon")=1e-9)
+         nb::arg("epsilon")=1e-9, nb::arg("iteration_limit")=100)
+    .def("sort", &SellingVector::sort, nb::arg("epsilon")=1e-9)
     .def("__repr__", [](const SellingVector& self) {
         char buf[256];
         snprintf_z(buf, 256, "<gemmi.SellingVector((%.2f, %.2f, %.2f, %.2f, %.2f, %.2f))>",
@@ -399,11 +387,12 @@ void add_unitcell(py::module& m) {
         return std::string(buf);
     });
 
+  // twin.hpp
   m.def("find_lattice_2fold_ops", &find_lattice_2fold_ops,
-        py::arg("reduced_cell"), py::arg("max_obliq"));
+        nb::arg("reduced_cell"), nb::arg("max_obliq"));
   m.def("find_lattice_symmetry_r", &find_lattice_symmetry_r);
   m.def("find_lattice_symmetry", &find_lattice_symmetry,
-        py::arg("cell"), py::arg("centring"), py::arg("max_obliq"));
+        nb::arg("cell"), nb::arg("centring"), nb::arg("max_obliq"));
   m.def("find_twin_laws", &find_twin_laws,
-        py::arg("cell"), py::arg("sg"), py::arg("max_obliq"), py::arg("all_ops"));
+        nb::arg("cell"), nb::arg("sg"), nb::arg("max_obliq"), nb::arg("all_ops"));
 }
diff --git a/python/write.cpp b/python/write.cpp
index ca60245bd..17899fdea 100644
--- a/python/write.cpp
+++ b/python/write.cpp
@@ -1,29 +1,28 @@
 // Copyright 2018 Global Phasing Ltd.
 
+#include <cassert>
 #include <sstream>  // for ostringstream
 #include "gemmi/to_mmcif.hpp"
 #include "gemmi/to_pdb.hpp"
 #include "gemmi/fstream.hpp"
 
 #include "common.h"
+#include <nanobind/stl/string.h>
 
-namespace py = pybind11;
 using namespace gemmi;
 
-void add_write(py::module& m, py::class_<Structure>& structure) {
-  py::class_<MmcifOutputGroups>(m, "MmcifOutputGroups")
-    .def(py::init([](bool all, const py::kwargs& kwargs) {
-      MmcifOutputGroups g(all);
-      if (kwargs) {
-        py::object pyg = py::cast(&g);
-        for (auto kwarg : kwargs)
-          pyg.attr(kwarg.first) = kwarg.second.cast<bool>();
-      }
-      return g;
-    }), py::arg("all"))
+void add_write(nb::module_& m, nb::class_<Structure>& structure) {
+  nb::class_<MmcifOutputGroups>(m, "MmcifOutputGroups")
+    .def(nb::init<bool>())
+    .def("__init__", [](MmcifOutputGroups* p, bool all, nb::kwargs kwargs) {
+      nb::object obj = nb::type<MmcifOutputGroups>()(all);
+      for (auto [key, value] : kwargs)
+        obj.attr(key) = nb::cast<bool>(value);
+      new(p) MmcifOutputGroups(nb::cast<const MmcifOutputGroups&>(obj));
+    }, nb::arg("all"), nb::arg("kwargs"))
 #define DEF_BIT_PROPERTY(name) \
-  .def_property(#name, [](MmcifOutputGroups g) { return g.name; }, \
-                       [](MmcifOutputGroups& g, bool v) { g.name = v; })
+  .def_prop_rw(#name, [](MmcifOutputGroups g) { return g.name; }, \
+                      [](MmcifOutputGroups& g, bool v) { g.name = v; })
     DEF_BIT_PROPERTY(atoms)
     DEF_BIT_PROPERTY(block_name)
     DEF_BIT_PROPERTY(entry)
@@ -59,22 +58,23 @@ void add_write(py::module& m, py::class_<Structure>& structure) {
     ;
 #undef DEF_BIT_PROPERTY
 
-  py::class_<PdbWriteOptions>(m, "PdbWriteOptions")
-    .def(py::init([](bool minimal, bool headers_only, const py::kwargs& kwargs) {
-      PdbWriteOptions opt;
+  nb::class_<PdbWriteOptions>(m, "PdbWriteOptions")
+    .def("__init__", [](PdbWriteOptions* opt, bool minimal, bool headers_only) {
+      new(opt) PdbWriteOptions;
       if (minimal)
-        opt = PdbWriteOptions::minimal();
+        *opt = PdbWriteOptions::minimal();
       else if (headers_only)
-        opt = PdbWriteOptions::headers_only();
-      if (kwargs) {
-        py::object py_opt = py::cast(&opt);
-        for (auto kwarg : kwargs)
-          py_opt.attr(kwarg.first) = kwarg.second.cast<bool>();
-      }
-      return opt;
-    }), py::arg("minimal")=false, py::arg("headers_only")=false)
+        *opt = PdbWriteOptions::headers_only();
+    }, nb::arg("minimal")=false, nb::arg("headers_only")=false)
+    .def("__init__", [](PdbWriteOptions* p, bool minimal, bool headers_only,
+                        nb::kwargs kwargs) {
+      nb::object obj = nb::type<PdbWriteOptions>()(minimal, headers_only);
+      for (auto [key, value] : kwargs)
+        obj.attr(key) = nb::cast<bool>(value);
+      new(p) PdbWriteOptions(nb::cast<const PdbWriteOptions&>(obj));
+    }, nb::arg("minimal")=false, nb::arg("headers_only")=false, nb::arg("kwargs"))
 #define DEF_PROPERTY(name) \
-  .def_property(#name, [](PdbWriteOptions g) { return g.name; }, \
+  .def_prop_rw(#name, [](PdbWriteOptions g) { return g.name; }, \
                        [](PdbWriteOptions& g, bool v) { g.name = v; })
     DEF_PROPERTY(minimal_file)
     DEF_PROPERTY(atom_records)
@@ -95,45 +95,36 @@ void add_write(py::module& m, py::class_<Structure>& structure) {
 
   structure
     .def("make_pdb_string", &make_pdb_string,
-         py::arg_v("options", PdbWriteOptions(), "PdbWriteOptions()"))
-    .def("write_pdb", [](const Structure& st, const std::string& path,
-                         PdbWriteOptions options) {
+         nb::arg("options").sig("PdbWriteOptions()")=PdbWriteOptions())
+    .def("write_pdb", [](const Structure& st, const std::string& path, PdbWriteOptions options) {
         Ofstream f(path);
         write_pdb(st, f.ref(), options);
     })
-
     // deprecated - kept for compatibility
-    .def("write_pdb", [](const Structure& st, const std::string& path,
-                         const py::kwargs& kwargs) {
-        PdbWriteOptions opt;
-        if (kwargs) {
-          py::object py_opt = py::cast(&opt);
-          for (auto kwarg : kwargs)
-            py_opt.attr(kwarg.first) = kwarg.second.cast<bool>();
-        }
+    .def("write_pdb", [](const Structure& st, const std::string& path, nb::kwargs kwargs) {
         Ofstream f(path);
-        write_pdb(st, f.ref(), opt);
-    }, py::arg("path"))
+        nb::object options = nb::type<PdbWriteOptions>()(**kwargs);
+        write_pdb(st, f.ref(), nb::cast<const PdbWriteOptions&>(options));
+    }, nb::arg("path"), nb::arg("kwargs"))
     // deprecated
     .def("make_pdb_headers", &make_pdb_headers)
     // deprecated
     .def("write_minimal_pdb", [](const Structure& st, const std::string& path) {
        Ofstream f(path);
        write_minimal_pdb(st, f.ref());
-    }, py::arg("path"))
+    }, nb::arg("path"))
     // deprecated
     .def("make_minimal_pdb", [](const Structure& st) {
        std::ostringstream os;
        write_minimal_pdb(st, os);
        return os.str();
     })
-
     .def("make_mmcif_document", &make_mmcif_document,
-         py::arg_v("groups", MmcifOutputGroups(true), "MmcifOutputGroups(True)"))
+         nb::arg("groups").sig("MmcifOutputGroups(True)")=MmcifOutputGroups(true))
     .def("make_mmcif_block", &make_mmcif_block,
-         py::arg_v("groups", MmcifOutputGroups(true), "MmcifOutputGroups(True)"))
-    .def("update_mmcif_block", &update_mmcif_block, py::arg("block"),
-         py::arg_v("groups", MmcifOutputGroups(true), "MmcifOutputGroups(True)"))
+         nb::arg("groups").sig("MmcifOutputGroups(True)")=MmcifOutputGroups(true))
+    .def("update_mmcif_block", &update_mmcif_block, nb::arg("block"),
+         nb::arg("groups").sig("MmcifOutputGroups(True)")=MmcifOutputGroups(true))
     .def("make_mmcif_headers", &make_mmcif_headers)
     ;
 }
diff --git a/run-tests.sh b/run-tests.sh
index 3614151b4..b11ffb609 100755
--- a/run-tests.sh
+++ b/run-tests.sh
@@ -70,11 +70,6 @@ if [ $1 = x -o $1 = a ]; then
     echo 'Run codespell'
     codespell include src prog python fortran tests examples docs wasm tools ||:
 
-    echo 'Run pybind11-stubgen'
-    pybind11-stubgen --dry-run --exit-code gemmi \
-        --enum-class-locations='Ignore:gemmi.ContactSearch' \
-        --enum-class-locations='.+:gemmi'
-
     echo 'Checking serialize.hpp...'
     $PYTHON tools/check_serialize.py
 fi
diff --git a/tests/test_examples.py b/tests/test_examples.py
index ad68be693..d6ab10e12 100644
--- a/tests/test_examples.py
+++ b/tests/test_examples.py
@@ -54,10 +54,9 @@ def test_from_json(self):
     def test_map2mtz(self):
         sys.argv = ['map2mtz.py', MAP_FILE, os.devnull]
         import map2mtz  # noqa: F401
-    @unittest.skipIf(sys.version_info[0] == 2, 'this example is Py3 only')
     def test_multiproc(self):
         sys.stdout = open(os.devnull, 'w')
-        import multiproc  # noqa: F401
+        import multiproc
         multiproc.main(PDB_FILE)
 
     # In this example we use file produced with two commands:
@@ -68,8 +67,7 @@ def test_multiproc(self):
     # AXIS X Z Y
     # MODE mapin
     # eof
-    @unittest.skipIf(numpy is None or sys.version_info[0] == 2,
-                     'this example is Py3 only, requires NumPy')
+    @unittest.skipIf(numpy is None, 'requires NumPy')
     def test_maskcheck(self):
         import maskcheck
         with io.StringIO() as buf, contextlib.redirect_stdout(buf):
diff --git a/tests/test_hkl.py b/tests/test_hkl.py
index c957f6a32..8e75b770e 100755
--- a/tests/test_hkl.py
+++ b/tests/test_hkl.py
@@ -199,7 +199,7 @@ def test_scaling(self):
         rblock = gemmi.as_refln_blocks(doc)[0]
         fobs_data = rblock.get_value_sigma('F_meas_au', 'F_meas_sigma_au')
         if numpy:
-            self.assertEqual(fobs_data.value_array.shape, (367,))
+            self.assertEqual(fobs_data.value_array.shape, (367, 2))
 
         # without mask
         fc_data = rblock.get_f_phi('F_calc_au', 'phase_calc')
@@ -240,8 +240,11 @@ def check_limits_17(limits):
         check_limits_17(binner.limits)
         hkls = [[0,0,1], [3,3,3], [10,10,10]]
         bins = [0,9,16]
-        self.assertEqual(list(binner.get_bins(hkls)), bins)
-        inv_d2 = [mtz.cell.calculate_1_d2(h) for h in hkls]
+        # TODO: remove explicit call to numpy.array after this is implemented:
+        # https://github.com/wjakob/nanobind/discussions/327
+        self.assertEqual(list(binner.get_bins(numpy.array(hkls))), bins)
+        # TODO: remove explicit call to numpy.array, as above
+        inv_d2 = numpy.array([mtz.cell.calculate_1_d2(h) for h in hkls])
         self.assertEqual(list(binner.get_bins_from_1_d2(inv_d2)), bins)
 
 class TestConversion(unittest.TestCase):
diff --git a/tests/test_mol.py b/tests/test_mol.py
index bd0d39564..6efe8275f 100644
--- a/tests/test_mol.py
+++ b/tests/test_mol.py
@@ -3,8 +3,9 @@
 import gzip
 from io import StringIO
 import os
-import sys
+import pickle
 import unittest
+
 import gemmi
 from common import full_path, get_path_for_tempfile
 try:
@@ -478,8 +479,7 @@ def test_read_write_1orc_via_cif(self):
 
     def test_read_write_1lzh(self, via_cif=False):
         path = full_path('1lzh.pdb.gz')
-        mode = 'rt' if sys.version_info >= (3,) else 'r'
-        with gzip.open(path, mode=mode) as f:
+        with gzip.open(path, mode='rt') as f:
             expected = [line for line in f if is_written_to_pdb(line, via_cif)]
         out_lines = self.write_and_read(gemmi.read_structure(path), via_cif)
         self.assertEqual(expected[0], out_lines[0])
@@ -870,5 +870,23 @@ def write_and_read(**kwargs):
         self.assertEqual(write_and_read(preserve_serial=True),
                          [('B OXT', 1), ('B CU', 3), ('A CU', 4)])
 
+    def test_serialization(self):
+        st = gemmi.read_structure(full_path('5e5z.pdb'))
+        unpickled = pickle.loads(pickle.dumps(st))
+        self.assertEqual(st.make_pdb_string(), unpickled.make_pdb_string())
+        unpickled[0] = pickle.loads(pickle.dumps(st[0]))
+        self.assertEqual(st.make_pdb_string(), unpickled.make_pdb_string())
+        chain = st[0][0]
+        unpickled_chain = pickle.loads(pickle.dumps(chain))
+        self.assertEqual(chain.name, unpickled_chain.name)
+        self.assertEqual(len(chain), len(unpickled_chain))
+        res = chain[0]
+        unpickled_res = pickle.loads(pickle.dumps(res))
+        self.assertEqual(res.name, unpickled_res.name)
+        self.assertEqual(len(res), len(unpickled_res))
+        atom = res[1]
+        unpickled_atom = pickle.loads(pickle.dumps(atom))
+        self.assertEqual(atom.name, unpickled_atom.name)
+
 if __name__ == '__main__':
     unittest.main()
diff --git a/tests/test_symmetry.py b/tests/test_symmetry.py
index 799d143d3..28511b65e 100644
--- a/tests/test_symmetry.py
+++ b/tests/test_symmetry.py
@@ -235,7 +235,7 @@ def test_with_sgtbx(self):
         if sgtbx is None:
             return
         for s in gemmi.spacegroup_table():
-            self.compare_hall_symops_with_sgtbx(s.hall.encode())
+            self.compare_hall_symops_with_sgtbx(s.hall)
         self.compare_hall_symops_with_sgtbx('C -4 -2b', existing_group=False)
 
     def test_table(self):
diff --git a/tests/test_unitcell.py b/tests/test_unitcell.py
index bacbc547f..fa0a25ebf 100644
--- a/tests/test_unitcell.py
+++ b/tests/test_unitcell.py
@@ -4,7 +4,6 @@
 from math import pi  # , isnan
 import pickle
 from random import random
-import sys
 import gemmi
 
 def assert_almost_equal_seq(self, a, b, delta=None):
@@ -77,9 +76,8 @@ def test_triclinic_cell(self):
         tr_o_f = cell.orth @ cell.frac
         self.assertTrue(tr_o_f.approx(gemmi.Transform(), 1e-15))
         self.assertTrue(tr_o_f.approx(tr_o_f.inverse(), 1e-15))
-        if sys.version_info >= (3, 5):
-            mat = eval('cell.orth.mat @ cell.frac.mat')  # avoid SyntaxError
-            self.assertTrue(mat.approx(gemmi.Mat33(), 1e-15))
+        mat = cell.orth.mat @ cell.frac.mat
+        self.assertTrue(mat.approx(gemmi.Mat33(), 1e-15))
         pos = gemmi.Position(-15, -17, 190)
         frac = cell.fractionalize(pos)
         pos2 = cell.orthogonalize(frac)
diff --git a/third_party/serializer.h b/third_party/serializer.h
new file mode 100644
index 000000000..8c7adb86a
--- /dev/null
+++ b/third_party/serializer.h
@@ -0,0 +1,3282 @@
+#ifndef ZPP_SERIALIZER_H
+#define ZPP_SERIALIZER_H
+
+#include <algorithm>
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <initializer_list>
+#include <memory>
+#include <new>
+#include <stdexcept>
+#include <string>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+#include <vector>
+#if __cplusplus >= 201703L
+#include <optional>
+#include <variant>
+#endif
+#ifdef ZPP_SERIALIZER_FREESTANDING
+#include <string_view>
+#else
+#include <mutex>
+#include <shared_mutex>
+#include <unordered_map>
+#endif
+
+namespace zpp
+{
+/**
+ * Supports serialization of objects and polymorphic objects.
+ * Example of non polymorphic serialization:
+ * ~~~
+ * class point
+ * {
+ * public:
+ *     point() = default;
+ *     point(int x, int y) noexcept :
+ *           m_x(x),
+ *           m_y(y)
+ *       {
+ *       }
+ *
+ *     friend zpp::serializer::access;
+ *     template <typename Archive, typename Self>
+ *     static void serialize(Archive & archive, Self & self)
+ *     {
+ *         archive(self.m_x, self.m_y);
+ *     }
+ *
+ *     int get_x() const noexcept
+ *     {
+ *           return m_x;
+ *       }
+ *
+ *       int get_y() const noexcept
+ *       {
+ *           return m_y;
+ *       }
+ *
+ * private:
+ *     int m_x = 0;
+ *     int m_y = 0;
+ * };
+ *
+ * static void foo()
+ * {
+ *     std::vector<unsigned char> data;
+ *     zpp::serializer::memory_input_archive in(data);
+ *     zpp::serializer::memory_output_archive out(data);
+ *
+ *     out(point(1337, 1338));
+ *
+ *     point my_point;
+ *     in(my_point);
+ *
+ *     std::cout << my_point.get_x() << ' ' << my_point.get_y() << '\n';
+ * }
+ * ~~~
+ *
+ * Example of polymorphic serialization:
+ * ~~~
+ * class person : public zpp::serializer::polymorphic
+ * {
+ * public:
+ *     person() = default;
+ *     explicit person(std::string name) noexcept :
+ *           m_name(std::move(name))
+ *       {
+ *       }
+ *
+ *     friend zpp::serializer::access;
+ *     template <typename Archive, typename Self>
+ *     static void serialize(Archive & archive, Self & self)
+ *     {
+ *           archive(self.m_name);
+ *       }
+ *
+ *       const std::string & get_name() const noexcept
+ *       {
+ *           return m_name;
+ *       }
+ *
+ *     virtual void print() const
+ *     {
+ *         std::cout << "person: " << m_name;
+ *     }
+ *
+ * private:
+ *     std::string m_name;
+ * };
+ *
+ * class student : public person
+ * {
+ * public:
+ *     student() = default;
+ *     student(std::string name, std::string university) noexcept :
+ *         person(std::move(name)),
+ *         m_university(std::move(university))
+ *     {
+ *     }
+ *
+ *     friend zpp::serializer::access;
+ *     template <typename Archive, typename Self>
+ *     static void serialize(Archive & archive, Self & self)
+ *     {
+ *         person::serialize(archive, self);
+ *           archive(self.m_university);
+ *       }
+ *
+ *     virtual void print() const
+ *     {
+ *         std::cout << "student: " << person::get_name() << ' ' <<
+ * m_university << '\n';
+ *     }
+ *
+ * private:
+ *     std::string m_university;
+ * };
+ *
+ * namespace
+ * {
+ * zpp::serializer::register_types<
+ *    zpp::serializer::make_type<person,
+ * zpp::serializer::make_id("v1::person")>,
+ *    zpp::serializer::make_type<student,
+ * zpp::serializer::make_id("v1::student")> > _; } // <anynymous namespace>
+ *
+ * static void foo()
+ * {
+ *     std::vector<unsigned char> data;
+ *     zpp::serializer::memory_input_archive in(data);
+ *     zpp::serializer::memory_output_archive out(data);
+ *
+ *     std::unique_ptr<person> my_person =
+ * std::make_unique<student>("1337", "1337University"); out(my_person);
+ *
+ *     my_person = nullptr;
+ *     in(my_person);
+ *
+ *     my_person->print();
+ * }
+ *
+ * static void bar()
+ * {
+ *     std::vector<unsigned char> data;
+ *     zpp::serializer::memory_input_archive in(data);
+ *     zpp::serializer::memory_output_archive out(data);
+ *
+ *     out(zpp::serializer::as_polymorphic(student("1337",
+ * "1337University")));
+ *
+ *     std::unique_ptr<person> my_person;
+ *     in(my_person);
+ *
+ *     my_person->print();
+ * }
+ * ~~~
+ */
+namespace serializer
+{
+#ifdef ZPP_SERIALIZER_FREESTANDING
+namespace freestanding
+{
+/**
+ * Returns the error category for a given error code enumeration type,
+ * using an argument dependent lookup of a user implemented category
+ * function.
+ */
+template <typename ErrorCode>
+decltype(auto) category()
+{
+    return category(ErrorCode{});
+}
+
+/**
+ * The error category which responsible for translating error codes to
+ * error messages.
+ */
+class error_category
+{
+public:
+    /**
+     * Returns the error category name.
+     */
+    virtual std::string_view name() const noexcept = 0;
+
+    /**
+     * Return the error message for a given error code.
+     * For success codes, it is unspecified what value is returned.
+     * For convienience, you may return zpp::error::no_error for success.
+     * All other codes must return non empty string views.
+     */
+    virtual std::string_view message(int code) const noexcept = 0;
+
+    /**
+     * Returns true if success code, else false.
+     */
+    bool success(int code) const
+    {
+        return code == m_success_code;
+    }
+
+protected:
+    /**
+     * Creates an error category whose success code is 'success_code'.
+     */
+    constexpr error_category(int success_code) :
+        m_success_code(success_code)
+    {
+    }
+
+    /**
+     * Destroys the error category.
+     */
+    ~error_category() = default;
+
+private:
+    /**
+     * The success code.
+     */
+    int m_success_code{};
+};
+
+/**
+ * Creates an error category, whose name and success
+ * code are specified, as well as a message translation
+ * logic that returns the error message for every error code.
+ * Note: message translation must not throw.
+ */
+template <typename ErrorCode, typename Messages>
+constexpr auto make_error_category(std::string_view name,
+                                   ErrorCode success_code,
+                                   Messages && messages)
+{
+    // Create a category with the name and messages.
+    class category final : public error_category,
+                           private std::remove_reference_t<Messages>
+    {
+    public:
+        constexpr category(std::string_view name,
+                           ErrorCode success_code,
+                           Messages && messages) :
+            error_category(
+                std::underlying_type_t<ErrorCode>(success_code)),
+            std::remove_reference_t<Messages>(
+                std::forward<Messages>(messages)),
+            m_name(name)
+        {
+        }
+
+        std::string_view name() const noexcept override
+        {
+            return m_name;
+        }
+
+        std::string_view message(int code) const noexcept override
+        {
+            return this->operator()(ErrorCode{code});
+        }
+
+    private:
+        std::string_view m_name;
+    } category(name, success_code, std::forward<Messages>(messages));
+
+    // Return the category.
+    return category;
+}
+
+/**
+ * Represents an error to be initialized from an error code
+ * enumeration.
+ * The error code enumeration must have 'int' as underlying type.
+ * Defining an error code enum and a category for it goes as follows.
+ * Example:
+ * ~~~
+ * namespace my_namespace
+ * {
+ * enum class my_error : int
+ * {
+ *     success = 0,
+ *     something_bad = 1,
+ *     something_really_bad = 2,
+ * };
+ *
+ * inline const zpp::error_category & category(my_error)
+ * {
+ *     constexpr static auto error_category =
+ *         zpp::make_error_category("my_category", my_error::success,
+ *             [](auto code) -> std::string_view {
+ *                 switch (code) {
+ *                     case my_error::success:
+ *                         return zpp::error::no_error;
+ *                     case my_code:something_bad:
+ *                         return "Something bad happened.";
+ *                     case my_error::something_really_bad:
+ *                         return "Something really bad happened.";
+ *                     default:
+ *                         return "Unknown error occurred.";
+ *                 }
+ *             }
+ *         );
+ *     return error_category;
+ * }
+ * } // my_namespace
+ * ~~~
+ */
+class error
+{
+public:
+    /**
+     * Disables default construction.
+     */
+    error() = delete;
+
+    /**
+     * Constructs an error from an error code enumeration, the
+     * category is looked by using argument dependent lookup on a
+     * function named 'category' that receives the error code
+     * enumeration value.
+     */
+    template <typename ErrorCode>
+    error(ErrorCode error_code) :
+        m_category(std::addressof(
+            zpp::serializer::freestanding::category<ErrorCode>())),
+        m_code(std::underlying_type_t<ErrorCode>(error_code))
+    {
+    }
+
+    /**
+     * Constructs an error from an error code enumeration, the
+     * category is given explicitly in this overload.
+     */
+    template <typename ErrorCode>
+    error(ErrorCode error_code, const error_category & category) :
+        m_category(std::addressof(category)),
+        m_code(std::underlying_type_t<ErrorCode>(error_code))
+    {
+    }
+
+    /**
+     * Returns the error category.
+     */
+    const error_category & category() const
+    {
+        return *m_category;
+    }
+
+    /**
+     * Returns the error code.
+     */
+    int code() const
+    {
+        return m_code;
+    }
+
+    /**
+     * Returns the error message. Calling this on
+     * a success error is implementation defined according
+     * to the error category.
+     */
+    std::string_view message() const
+    {
+        return m_category->message(m_code);
+    }
+
+    /**
+     * Returns true if the error indicates success, else false.
+     */
+    explicit operator bool() const
+    {
+        return m_category->success(m_code);
+    }
+
+    /**
+     * No error message value.
+     */
+    static constexpr std::string_view no_error{};
+
+private:
+    /**
+     * The error category.
+     */
+    const error_category * m_category{};
+
+    /**
+     * The error code.
+     */
+    int m_code{};
+};
+} // namespace freestanding
+
+enum class error : int
+{
+    success = 0,
+    out_of_range = 1,
+    variant_is_valueless = 2,
+    null_pointer_serialization = 3,
+};
+
+inline const freestanding::error_category & category(error)
+{
+    constexpr static auto error_category =
+        freestanding::make_error_category(
+            "zpp::serializer",
+            error::success,
+            [](auto code) -> std::string_view {
+                switch (code) {
+                case error::success:
+                    return freestanding::error::no_error;
+                case error::out_of_range:
+                    return "[zpp::serializer] Out of range error";
+                case error::variant_is_valueless:
+                    return "[zpp::serializer] Cannot serialize a "
+                           "valueless variant.";
+                case error::null_pointer_serialization:
+                    return "[zpp::serializer] Cannot serialize a null "
+                           "pointer.";
+                default:
+                    return "[zpp::serializer] Unknown error occurred.";
+                }
+            });
+    return error_category;
+}
+#endif // ZPP_SERIALIZER_FREESTANDING
+
+namespace detail
+{
+/**
+ * Map any sequence of types to void.
+ */
+template <typename...>
+using void_t = void;
+
+/**
+ * Tests if all conditions are true, empty means true.
+ * Example:
+ * ~~~
+ * all_of<true, false, true>::value == false
+ * all_of<true, true>::value == true
+ * all_of<false, false>::value == false
+ * all_of<>::value == true
+ * ~~~
+ */
+template <bool... bConditions>
+struct all_of : std::true_type
+{
+};
+
+template <bool... bConditions>
+struct all_of<false, bConditions...> : std::false_type
+{
+};
+
+template <bool... bConditions>
+struct all_of<true, bConditions...> : all_of<bConditions...>
+{
+};
+
+template <>
+struct all_of<true> : std::true_type
+{
+};
+
+/**
+ * Remove const of container value_type
+ */
+template <typename Container, typename = void>
+struct container_nonconst_value_type
+{
+    using type = std::remove_const_t<typename Container::value_type>;
+};
+
+/**
+ * Same as above, except in case of std::map and std::unordered_map, and
+ * similar, we also need to remove the const of the key type.
+ */
+template <template <typename...> class Container,
+          typename KeyType,
+          typename MappedType,
+          typename... ExtraTypes>
+struct container_nonconst_value_type<
+    Container<KeyType, MappedType, ExtraTypes...>,
+    void_t<
+        // Require existence of key_type.
+        typename Container<KeyType, MappedType, ExtraTypes...>::key_type,
+
+        // Require existence of mapped_type.
+        typename Container<KeyType, MappedType, ExtraTypes...>::
+            mapped_type,
+
+        // Require that the value type is a pair of const KeyType and
+        // MappedType.
+        std::enable_if_t<std::is_same<
+            std::pair<const KeyType, MappedType>,
+            typename Container<KeyType, MappedType, ExtraTypes...>::
+                value_type>::value>>>
+{
+    using type = std::pair<KeyType, MappedType>;
+};
+
+/**
+ * Alias to the above.
+ */
+template <typename Container>
+using container_nonconst_value_type_t =
+    typename container_nonconst_value_type<Container>::type;
+
+/**
+ * The serializer exception template.
+ */
+template <typename Base, std::size_t Id>
+class exception : public Base
+{
+public:
+    /**
+     * Use the constructors from the base class.
+     */
+    using Base::Base;
+};
+
+/**
+ * A no operation, single byte has same representation in little/big
+ * endian.
+ */
+inline constexpr std::uint8_t swap_byte_order(std::uint8_t value) noexcept
+{
+    return value;
+}
+
+/**
+ * Swaps the byte order of a given integer.
+ */
+inline constexpr std::uint16_t
+swap_byte_order(std::uint16_t value) noexcept
+{
+    return (std::uint16_t(swap_byte_order(std::uint8_t(value))) << 8) |
+           (swap_byte_order(std::uint8_t(value >> 8)));
+}
+
+/**
+ * Swaps the byte order of a given integer.
+ */
+inline constexpr std::uint32_t
+swap_byte_order(std::uint32_t value) noexcept
+{
+    return (std::uint32_t(swap_byte_order(std::uint16_t(value))) << 16) |
+           (swap_byte_order(std::uint16_t(value >> 16)));
+}
+
+/**
+ * Swaps the byte order of a given integer.
+ */
+inline constexpr std::uint64_t
+swap_byte_order(std::uint64_t value) noexcept
+{
+    return (std::uint64_t(swap_byte_order(std::uint32_t(value))) << 32) |
+           (swap_byte_order(std::uint32_t(value >> 32)));
+}
+
+/**
+ * Rotates the given number left by count bits.
+ */
+template <typename Integer>
+constexpr auto rotate_left(Integer number, std::size_t count)
+{
+    return (number << count) | (number >> ((sizeof(number) * 8) - count));
+}
+
+/**
+ * Checks if has 'data()' member function.
+ */
+template <typename Type, typename = void>
+struct has_data_member_function : std::false_type
+{
+};
+
+/**
+ * Checks if has 'data()' member function.
+ */
+template <typename Type>
+struct has_data_member_function<
+    Type,
+    void_t<decltype(std::declval<Type &>().data())>> : std::true_type
+{
+};
+
+} // namespace detail
+
+/**
+ * @name Exceptions
+ * @{
+ */
+using out_of_range = detail::exception<std::out_of_range, 0>;
+using undeclared_polymorphic_type_error =
+    detail::exception<std::runtime_error, 1>;
+using attempt_to_serialize_null_pointer_error =
+    detail::exception<std::logic_error, 2>;
+using polymorphic_type_mismatch_error =
+    detail::exception<std::runtime_error, 3>;
+using attempt_to_serialize_valueless_variant =
+    detail::exception<std::runtime_error, 4>;
+using variant_index_out_of_range = detail::exception<std::out_of_range, 5>;
+/**
+ * @}
+ */
+
+/**
+ * If C++17 or greater, use shared mutex, else, use shared timed mutex.
+ */
+#ifndef ZPP_SERIALIZER_FREESTANDING
+#if __cplusplus >= 201703L
+/**
+ * The shared mutex type, defined to shared mutex when available.
+ */
+using shared_mutex = std::shared_mutex;
+#else
+/**
+ * The shared mutex type, defined to shared timed mutex when shared mutex
+ * is not available.
+ */
+using shared_mutex = std::shared_timed_mutex;
+#endif
+#endif
+
+/**
+ * The base class for polymorphic serialization.
+ */
+class polymorphic
+{
+public:
+    /**
+     * Pure virtual destructor, in order to become abstract
+     * and make derived classes polymorphic.
+     */
+    virtual ~polymorphic() = 0;
+};
+
+/**
+ * Default implementation for the destructor.
+ */
+inline polymorphic::~polymorphic() = default;
+
+/**
+ * Allow serialization with saving (output) archives, of objects held by
+ * reference, that will be serialized as polymorphic, meaning, with leading
+ * polymorphic serialization id.
+ */
+template <typename Type>
+class polymorphic_wrapper
+{
+public:
+    /**
+     * Constructs from the given object to be serialized as polymorphic.
+     */
+    explicit polymorphic_wrapper(const Type & object) noexcept :
+        m_object(object)
+    {
+        static_assert(std::is_base_of<polymorphic, Type>::value,
+                      "The given type is not derived from polymorphic");
+    }
+
+    /**
+     * Returns the object to be serialized as polymorphic.
+     */
+    const Type & operator*() const noexcept
+    {
+        return m_object;
+    }
+
+private:
+    /**
+     * The object to be serialized as polymorphic.
+     */
+    const Type & m_object;
+}; // polymorphic_wrapper
+
+/**
+ * A facility to save object with leading polymorphic serialization id.
+ */
+template <typename Type>
+auto as_polymorphic(const Type & object) noexcept
+{
+    return polymorphic_wrapper<Type>(object);
+}
+
+/**
+ * The size type of the serializer.
+ * It is used to indicate the size for containers.
+ */
+using size_type = std::uint32_t;
+
+/**
+ * The serialization id type,
+ */
+using id_type = std::uint64_t;
+
+/**
+ * This class grants the serializer access to the serialized types.
+ */
+class access
+{
+public:
+    /**
+     * Allows placement construction of types.
+     */
+    template <typename Item, typename... Arguments>
+    static auto
+    placement_new(void * pAddress, Arguments &&... arguments) noexcept(
+        noexcept(Item(std::forward<Arguments>(arguments)...)))
+    {
+        return ::new (pAddress)
+            Item(std::forward<Arguments>(arguments)...);
+    }
+
+    /**
+     * Allows dynamic construction of types.
+     * This overload is for non polymorphic serialization.
+     */
+    template <typename Item,
+              typename... Arguments,
+              typename = std::enable_if_t<
+                  !std::is_base_of<polymorphic, Item>::value>>
+    static auto make_unique(Arguments &&... arguments)
+    {
+        // Construct the requested type, using new since constructor might
+        // be private.
+        return std::unique_ptr<Item>(
+            new Item(std::forward<Arguments>(arguments)...));
+    }
+
+    /**
+     * Allows dynamic construction of types.
+     * This overload is for polymorphic serialization.
+     */
+    template <typename Item,
+              typename... Arguments,
+              typename = std::enable_if_t<
+                  std::is_base_of<polymorphic, Item>::value>,
+              typename = void>
+    static auto make_unique(Arguments &&... arguments)
+    {
+        // We create a deleter that will delete using the base class
+        // polymorphic which, as we declared, has a public virtual
+        // destructor.
+        struct deleter
+        {
+            void operator()(Item * item) noexcept
+            {
+                delete static_cast<polymorphic *>(item);
+            }
+        };
+
+        // Construct the requested type, using new since constructor might
+        // be private.
+        return std::unique_ptr<Item, deleter>(
+            new Item(std::forward<Arguments>(arguments)...));
+    }
+
+    /**
+     * Allows destruction of types.
+     */
+    template <typename Item>
+    static void destruct(Item & item) noexcept
+    {
+        item.~Item();
+    }
+}; // access
+
+/**
+ * Enables serialization of arbitrary byte data.
+ * Use only with care.
+ */
+template <typename Item>
+class bytes
+{
+public:
+    /**
+     * Constructs the bytes wrapper from pointer and count of items.
+     */
+    bytes(Item * items, std::size_t count) : m_items(items), m_count(count)
+    {
+    }
+
+    /**
+     * Returns a pointer to the first item.
+     */
+    Item * data() const noexcept
+    {
+        return m_items;
+    }
+
+    /**
+     * Returns the size in bytes of the bytes data.
+     */
+    std::size_t size_in_bytes() const noexcept
+    {
+        return m_count * sizeof(Item);
+    }
+
+    /**
+     * Returns the count of items in the bytes wrapper.
+     */
+    std::size_t count() const noexcept
+    {
+        return m_count;
+    }
+
+private:
+    /**
+     * Pointer to the items.
+     */
+    Item * m_items = nullptr;
+
+    /**
+     * The number of items.
+     */
+    std::size_t m_count{};
+};
+
+/**
+ * Allows serialization as bytes data.
+ * Use only with care.
+ */
+template <typename Item>
+bytes<Item> as_bytes(Item * item, std::size_t count)
+{
+    static_assert(std::is_trivially_copyable<Item>::value,
+                  "Must be trivially copyable");
+
+    return {item, count};
+}
+
+/**
+ * Allows serialization as bytes data.
+ * Use only with care.
+ */
+inline bytes<unsigned char> as_bytes(void * data, std::size_t size)
+{
+    return {static_cast<unsigned char *>(data), size};
+}
+
+/**
+ * Allows serialization as bytes data.
+ */
+inline bytes<const unsigned char> as_bytes(const void * data,
+                                           std::size_t size)
+{
+    return {static_cast<const unsigned char *>(data), size};
+}
+
+/**
+ * The serialization method type.
+ */
+template <typename Archive, typename = void>
+struct serialization_method;
+
+/**
+ * The serialization method type exporter, for loading (input) archives.
+ */
+template <typename Archive>
+struct serialization_method<Archive, typename Archive::loading>
+{
+    /**
+     * Disabled default constructor.
+     */
+    serialization_method() = delete;
+
+    /**
+     * The exported type.
+     */
+    using type = void (*)(Archive &, std::unique_ptr<polymorphic> &);
+}; // serialization_method
+
+/**
+ * The serialization method type exporter, for saving (output) archives.
+ */
+template <typename Archive>
+struct serialization_method<Archive, typename Archive::saving>
+{
+    /**
+     * Disabled default constructor.
+     */
+    serialization_method() = delete;
+
+    /**
+     * The exported type.
+     */
+    using type = void (*)(Archive &, const polymorphic &);
+}; // serialization_method
+
+/**
+ * The serialization method type.
+ */
+template <typename Archive>
+using serialization_method_t =
+    typename serialization_method<Archive>::type;
+
+/**
+ * Make a serialization method from type and a loading (input) archive.
+ */
+template <typename Archive,
+          typename Type,
+          typename...,
+          typename = typename Archive::loading>
+serialization_method_t<Archive> make_serialization_method() noexcept
+{
+    return [](Archive & archive, std::unique_ptr<polymorphic> & object) {
+        auto concrete_type = access::make_unique<Type>();
+        archive(*concrete_type);
+        object.reset(concrete_type.release());
+    };
+}
+
+/**
+ * Make a serialization method from type and a saving (output) archive.
+ */
+template <typename Archive,
+          typename Type,
+          typename...,
+          typename = typename Archive::saving,
+          typename = void>
+serialization_method_t<Archive> make_serialization_method() noexcept
+{
+    return [](Archive & archive, const polymorphic & object) {
+        archive(dynamic_cast<const Type &>(object));
+    };
+}
+
+/**
+ * This is the base archive of the serializer.
+ * It enables saving and loading items into/from the archive, via
+ * operator().
+ */
+template <typename ArchiveType>
+class archive
+{
+public:
+    /**
+     * The derived archive type.
+     */
+    using archive_type = ArchiveType;
+
+    /**
+     * Save/Load the given items into/from the archive.
+     */
+    template <typename... Items>
+    auto operator()(Items &&... items)
+    {
+        // Disallow serialization of pointer types.
+        static_assert(
+            detail::all_of<!std::is_pointer<
+                std::remove_reference_t<Items>>::value...>::value,
+            "Serialization of pointer types is not allowed");
+
+        // Serialize the items.
+        return serialize_items(std::forward<Items>(items)...);
+    }
+
+protected:
+    /**
+     * Constructs the archive.
+     */
+    archive() = default;
+
+    /**
+     * Protected destructor to allow safe public inheritance.
+     */
+    ~archive() = default;
+
+private:
+    /**
+     * Serialize the given items, one by one.
+     */
+    template <typename Item, typename... Items>
+    auto serialize_items(Item && first, Items &&... items)
+    {
+#ifndef ZPP_SERIALIZER_FREESTANDING
+        // Invoke serialize_item the first item.
+        serialize_item(std::forward<Item>(first));
+#else
+        // Invoke serialize_item the first item.
+        if (auto result = serialize_item(std::forward<Item>(first));
+            !result) {
+            return result;
+        }
+#endif
+        // Serialize the rest of the items.
+        return serialize_items(std::forward<Items>(items)...);
+    }
+
+    /**
+     * Serializes zero items.
+     */
+    auto serialize_items()
+    {
+#ifdef ZPP_SERIALIZER_FREESTANDING
+        return freestanding::error{error::success};
+#endif
+    }
+
+    /**
+     * Serialize a single item.
+     * This overload is for class type items with serialize method.
+     */
+    template <typename Item,
+              typename...,
+              typename = decltype(std::remove_reference_t<Item>::serialize(
+                  std::declval<archive_type &>(), std::declval<Item &>()))>
+    auto serialize_item(Item && item)
+    {
+        // Forward as lvalue.
+        return std::remove_reference_t<Item>::serialize(concrete_archive(),
+                                                        item);
+    }
+
+    /**
+     * Serialize a single item.
+     * This overload is for types with outer serialize method.
+     */
+    template <typename Item,
+              typename...,
+              typename = decltype(serialize(std::declval<archive_type &>(),
+                                            std::declval<Item &>())),
+              typename = void>
+    auto serialize_item(Item && item)
+    {
+        // Forward as lvalue.
+        return serialize(concrete_archive(), item);
+    }
+
+    /**
+     * Serialize a single item.
+     * This overload is for fundamental types.
+     */
+    template <typename Item,
+              typename...,
+              typename = std::enable_if_t<std::is_fundamental<
+                  std::remove_reference_t<Item>>::value>,
+              typename = void,
+              typename = void>
+    auto serialize_item(Item && item)
+    {
+        // Forward as lvalue.
+        return concrete_archive().serialize(item);
+    }
+
+    /**
+     * Serialize a single item.
+     * This overload is for enum classes.
+     */
+    template <typename Item,
+              typename...,
+              typename = std::enable_if_t<
+                  std::is_enum<std::remove_reference_t<Item>>::value>,
+              typename = void,
+              typename = void,
+              typename = void>
+    auto serialize_item(Item && item)
+    {
+        // If the enum is const, we want the type to be a const type, else
+        // non-const.
+        using integral_type = std::conditional_t<
+            std::is_const<std::remove_reference_t<Item>>::value,
+            const std::underlying_type_t<std::remove_reference_t<Item>>,
+            std::underlying_type_t<std::remove_reference_t<Item>>>;
+
+        // Cast the enum to the underlying type, and forward as lvalue.
+        return concrete_archive().serialize(
+            reinterpret_cast<std::add_lvalue_reference_t<integral_type>>(
+                item));
+    }
+
+    /**
+     * Serialize bytes data.
+     */
+    template <typename T>
+    auto serialize_item(bytes<T> && item)
+    {
+        return concrete_archive().serialize(item.data(),
+                                            item.size_in_bytes());
+    }
+
+    /**
+     * Returns the concrete archive.
+     */
+    archive_type & concrete_archive()
+    {
+        return static_cast<archive_type &>(*this);
+    }
+}; // archive
+
+/**
+ * This archive serves as an output archive, which saves data into memory.
+ * Every save operation appends data into the vector or view type.
+ * This archive serves as an optimization and type erasure for the view
+ * type for polymorphic serialization.
+ */
+class basic_memory_output_archive
+    : public archive<basic_memory_output_archive>
+{
+public:
+    /**
+     * The base archive.
+     */
+    using base = archive<basic_memory_output_archive>;
+
+    /**
+     * Declare base as friend.
+     */
+    friend base;
+
+    /**
+     * saving archive.
+     */
+    using saving = void;
+
+protected:
+    /**
+     * Constructs a memory output archive, that outputs to the given
+     * vector.
+     */
+    explicit basic_memory_output_archive(
+        std::vector<unsigned char> & output) noexcept :
+        m_output_vector(std::addressof(output))
+    {
+    }
+
+    /**
+     * Constructs a memory output archive, that outputs to the given
+     * view.
+     */
+    basic_memory_output_archive(unsigned char * data,
+                                std::size_t size) noexcept :
+        m_data(data),
+        m_capacity(size)
+    {
+    }
+
+    /**
+     * Serialize a single item - save its data.
+     */
+    template <typename Item>
+    auto serialize(Item && item)
+    {
+        // Check if we are about to go beyond the capacity.
+        if (m_offset + sizeof(item) > m_capacity) {
+            if (!m_output_vector) {
+#ifndef ZPP_SERIALIZER_FREESTANDING
+                throw out_of_range(
+                    "Serialization to view type archive is out of range.");
+#else
+                return freestanding::error{error::out_of_range};
+#endif
+            }
+            m_capacity = (m_capacity + sizeof(item)) * 3 / 2;
+            m_output_vector->resize(m_capacity);
+            m_data = m_output_vector->data();
+        }
+
+        // Copy the data to the end of the view.
+        std::copy_n(
+            reinterpret_cast<const unsigned char *>(std::addressof(item)),
+            sizeof(item),
+            m_data + m_offset);
+
+        // Increase the offset.
+        m_offset += sizeof(item);
+
+#ifdef ZPP_SERIALIZER_FREESTANDING
+        return freestanding::error{error::success};
+#endif
+    }
+
+    /**
+     * Serialize bytes data - save its data.
+     */
+    auto serialize(const void * data, std::size_t size)
+    {
+        // Check if we are about to go beyond the capacity.
+        if (m_offset + size > m_capacity) {
+            if (!m_output_vector) {
+#ifndef ZPP_SERIALIZER_FREESTANDING
+                throw out_of_range(
+                    "Serialization to view type archive is out of range.");
+#else
+                return freestanding::error{error::out_of_range};
+#endif
+            }
+            m_capacity = (m_capacity + size) * 3 / 2;
+            m_output_vector->resize(m_capacity);
+            m_data = m_output_vector->data();
+        }
+
+        // Copy the data to the end of the output.
+        std::copy_n(static_cast<const unsigned char *>(data),
+                    size,
+                    m_data + m_offset);
+
+        // Increase the offset.
+        m_offset += size;
+
+#ifdef ZPP_SERIALIZER_FREESTANDING
+        return freestanding::error{error::success};
+#endif
+    }
+
+    /**
+     * Resizes the vector to the desired size.
+     */
+    void fit_vector()
+    {
+        m_output_vector->resize(m_offset);
+    }
+
+    /**
+     * Refresh the vector.
+     */
+    void refresh_vector() noexcept
+    {
+        m_data = m_output_vector->data();
+        m_capacity = m_output_vector->size();
+        m_offset = m_capacity;
+    }
+
+    /**
+     * Returns the data pointer.
+     */
+    unsigned char * data() const noexcept
+    {
+        return m_data;
+    }
+
+    /**
+     * Returns the current offset.
+     */
+    std::size_t offset() const noexcept
+    {
+        return m_offset;
+    }
+
+    /**
+     * Returns the current offset.
+     */
+    void reset(std::size_t offset = {}) noexcept
+    {
+        m_offset = offset;
+    }
+
+private:
+    /**
+     * The output vector, may be null in which case working with
+     * view type represented by data and size below.
+     */
+    std::vector<unsigned char> * m_output_vector{};
+
+    /**
+     * Points to the data.
+     */
+    unsigned char * m_data{};
+
+    /**
+     * The current capacity size of the data.
+     */
+    std::size_t m_capacity{};
+
+    /**
+     * The offset of the output data.
+     */
+    std::size_t m_offset{};
+}; // basic_memory_output_archive
+
+/**
+ * This archive serves as an output archive, which saves data into memory.
+ * Every save operation appends data into a user provided view type.
+ */
+class memory_view_output_archive : private basic_memory_output_archive
+{
+public:
+    /**
+     * The base archive.
+     */
+    using base = basic_memory_output_archive;
+
+    /**
+     * Constructing the view from pointer and size.
+     */
+    memory_view_output_archive(unsigned char * data,
+                               std::size_t size) noexcept :
+        basic_memory_output_archive(data, size)
+    {
+    }
+
+    /**
+     * Constructs a memory output archive, that outputs to the given
+     * view type.
+     */
+    template <typename View,
+              typename...,
+              typename ViewType = std::remove_reference_t<View>,
+              typename = decltype(std::declval<View &>().size()),
+              typename = decltype(std::declval<View &>().begin()),
+              typename = decltype(std::declval<View &>().end()),
+              typename = decltype(std::declval<View &>().data()),
+              typename = std::enable_if_t<
+                  std::is_trivially_destructible<ViewType>::value>,
+              typename = std::enable_if_t<
+                  std::is_same<typename ViewType::value_type,
+                               unsigned char>::value &&
+                  std::is_base_of<std::random_access_iterator_tag,
+                                  typename std::iterator_traits<
+                                      typename ViewType::iterator>::
+                                      iterator_category>::value>>
+    explicit memory_view_output_archive(View && view) noexcept :
+        memory_view_output_archive(view.data(), view.size())
+    {
+    }
+
+    /**
+     * Saves items into the archive.
+     */
+    template <typename... Items>
+    auto operator()(Items &&... items)
+    {
+        // Save previous offset.
+        auto offset = this->offset();
+
+#ifndef ZPP_SERIALIZER_FREESTANDING
+        try {
+            // Serialize the items.
+            base::operator()(std::forward<Items>(items)...);
+        } catch (...) {
+            this->reset(offset);
+            throw;
+        }
+#else
+        // Serialize the items.
+        auto result = base::operator()(std::forward<Items>(items)...);
+        if (!result) {
+            this->reset(offset);
+        }
+        return result;
+#endif
+    }
+
+    /**
+     * Returns the data pointer.
+     */
+    using base::data;
+
+    /**
+     * Returns the current offset in the data.
+     */
+    using base::offset;
+
+    /**
+     * Allow to reset offset for advanced use.
+     */
+    using base::reset;
+};
+
+/**
+ * This archive serves as an output archive, which saves data into memory.
+ * Every save operation appends data into the vector.
+ */
+class memory_output_archive : private basic_memory_output_archive
+{
+public:
+    /**
+     * The base archive.
+     */
+    using base = basic_memory_output_archive;
+
+    /**
+     * Constructs a memory output archive, that outputs to the given
+     * vector.
+     */
+    explicit memory_output_archive(
+        std::vector<unsigned char> & output) noexcept :
+        basic_memory_output_archive(output)
+    {
+    }
+
+    /**
+     * Saves items into the archive.
+     */
+    template <typename... Items>
+    auto operator()(Items &&... items)
+    {
+        refresh_vector();
+
+        // The original offset.
+        auto offset = this->offset();
+
+#ifndef ZPP_SERIALIZER_FREESTANDING
+        // Serialize the items.
+        try {
+            base::operator()(std::forward<Items>(items)...);
+            fit_vector();
+        } catch (...) {
+            this->reset(offset);
+            throw;
+        }
+#else
+        // Serialize the items.
+        auto result = base::operator()(std::forward<Items>(items)...);
+        if (!result) {
+            this->reset(offset);
+            return result;
+        }
+
+        fit_vector();
+        return result;
+#endif
+    }
+
+    /**
+     * Returns the data pointer.
+     */
+    using base::data;
+
+    /**
+     * Returns the current offset in the data.
+     */
+    using base::offset;
+
+    /**
+     * Allow to reset offset for advanced use.
+     */
+    using base::reset;
+};
+
+/**
+ * This archive serves as the memory view input archive, which loads data
+ * from non owning memory. Every load operation advances an offset to that
+ * the next data may be loaded on the next iteration.
+ */
+class memory_view_input_archive : public archive<memory_view_input_archive>
+{
+public:
+    /**
+     * The base archive.
+     */
+    using base = archive<memory_view_input_archive>;
+
+    /**
+     * Declare base as friend.
+     */
+    friend base;
+
+    /**
+     * Loading archive.
+     */
+    using loading = void;
+
+    /**
+     * Construct a memory view input archive, that loads data from an array
+     * of given pointer and size.
+     */
+    memory_view_input_archive(const unsigned char * input,
+                              std::size_t size) noexcept :
+        m_input(input),
+        m_size(size)
+    {
+    }
+
+    /**
+     * Constructs a memory view input  archive, that loads data from
+     * the given view type.
+     */
+    template <typename View,
+              typename...,
+              typename ViewType = std::remove_reference_t<View>,
+              typename = decltype(std::declval<View &>().size()),
+              typename = decltype(std::declval<View &>().begin()),
+              typename = decltype(std::declval<View &>().end()),
+              typename = decltype(std::declval<View &>().data()),
+              typename = std::enable_if_t<
+                  std::is_trivially_destructible<ViewType>::value>,
+              typename = std::enable_if_t<
+                  std::is_same<
+                      std::remove_const_t<typename ViewType::value_type>,
+                      unsigned char>::value &&
+                  std::is_base_of<std::random_access_iterator_tag,
+                                  typename std::iterator_traits<
+                                      typename ViewType::iterator>::
+                                      iterator_category>::value>>
+    explicit memory_view_input_archive(View && view) noexcept :
+        memory_view_input_archive(view.data(), view.size())
+    {
+    }
+
+    /**
+     * Returns the current offset in the input data.
+     */
+    const unsigned char * data() const noexcept
+    {
+        return m_input;
+    }
+
+    /**
+     * Returns the current offset in the input data.
+     */
+    std::size_t offset() const noexcept
+    {
+        return m_offset;
+    }
+
+    /**
+     * Resets the serialization to offset, to allow advanced use.
+     */
+    void reset(std::size_t offset = {}) noexcept
+    {
+        m_offset = offset;
+    }
+
+protected:
+    /**
+     * Serialize a single item - load it from the vector.
+     */
+    template <typename Item>
+    auto serialize(Item && item)
+    {
+        // Verify that the vector is large enough to contain the item.
+        if (m_size < (sizeof(item) + m_offset)) {
+#ifndef ZPP_SERIALIZER_FREESTANDING
+            throw out_of_range("Input vector was not large enough to "
+                               "contain the requested item");
+#else
+            return freestanding::error{error::out_of_range};
+#endif
+        }
+
+        // Fetch the item from the vector.
+        std::copy_n(
+            m_input + m_offset,
+            sizeof(item),
+            reinterpret_cast<unsigned char *>(std::addressof(item)));
+
+        // Increase the offset according to item size.
+        m_offset += sizeof(item);
+
+#ifdef ZPP_SERIALIZER_FREESTANDING
+        return freestanding::error{error::success};
+#endif
+    }
+
+    /**
+     * Serializes bytes data.
+     */
+    auto serialize(void * data, std::size_t size)
+    {
+        // Verify that the vector is large enough to contain the data.
+        if (m_size < (size + m_offset)) {
+#ifndef ZPP_SERIALIZER_FREESTANDING
+            throw out_of_range("Input vector was not large enough to "
+                               "contain the requested item");
+#else
+            return freestanding::error{error::out_of_range};
+#endif
+        }
+
+        // Fetch the bytes data from the vector.
+        std::copy_n(
+            m_input + m_offset, size, static_cast<unsigned char *>(data));
+
+        // Increase the offset according to data size.
+        m_offset += size;
+
+#ifdef ZPP_SERIALIZER_FREESTANDING
+        return freestanding::error{error::success};
+#endif
+    }
+
+private:
+    /**
+     * The input data.
+     */
+    const unsigned char * m_input{};
+
+    /**
+     * The input size.
+     */
+    std::size_t m_size{};
+
+    /**
+     * The next input.
+     */
+    std::size_t m_offset{};
+}; // memory_view_input_archive
+
+/**
+ * This archive serves as the memory input archive, which loads data from
+ * owning memory. Every load operation erases data from the beginning of
+ * the vector.
+ */
+class memory_input_archive : private memory_view_input_archive
+{
+public:
+    /**
+     * The base archive.
+     */
+    using base = memory_view_input_archive;
+
+    /**
+     * Construct a memory input archive from a vector.
+     */
+    memory_input_archive(std::vector<unsigned char> & input) :
+        memory_view_input_archive(input.data(), input.size()),
+        m_input(std::addressof(input))
+    {
+    }
+
+    /**
+     * Load items from the archive.
+     */
+    template <typename... Items>
+    auto operator()(Items &&... items)
+    {
+        // Update the input archive.
+        static_cast<memory_view_input_archive &>(*this) = {
+            m_input->data(), m_input->size()};
+
+        // Save the original offset.
+        auto offset = this->offset();
+
+#ifndef ZPP_SERIALIZER_FREESTANDING
+        try {
+            // Load the items.
+            memory_view_input_archive::operator()(
+                std::forward<Items>(items)...);
+        } catch (...) {
+            // Reset the offset back.
+            reset(offset);
+            throw;
+        }
+#else // ZPP_SERIALIZER_FREESTANDING
+
+        // Load the items.
+        if (auto result = memory_view_input_archive::operator()(
+                std::forward<Items>(items)...);
+            !result) {
+            // Reset the offset back.
+            reset(offset);
+            return result;
+        }
+#endif
+
+        // Erase the loaded elements.
+        m_input->erase(m_input->begin(),
+                       m_input->begin() + this->offset());
+
+        // Reset to offset zero.
+        reset();
+
+#ifdef ZPP_SERIALIZER_FREESTANDING
+        return freestanding::error{error::success};
+#endif
+    }
+
+    /**
+     * Returns the data pointer;
+     */
+    using base::data;
+
+    /**
+     * Returns the current offset in the data.
+     */
+    using base::offset;
+
+    /**
+     * Allow to reset offset for advanced use.
+     */
+    using base::reset;
+
+private:
+    /**
+     * The input data.
+     */
+    std::vector<unsigned char> * m_input{};
+};
+
+#ifndef ZPP_SERIALIZER_FREESTANDING
+/**
+ * This class manages polymorphic type registration for serialization
+ * process.
+ */
+template <typename Archive>
+class registry
+{
+public:
+    static_assert(!std::is_reference<Archive>::value,
+                  "Disallows reference type for archive in registry");
+
+    /**
+     * Returns the global instance of the registry.
+     */
+    static registry & get_instance() noexcept
+    {
+        static registry registry;
+        return registry;
+    }
+
+    /**
+     * Add a serialization method for a given polymorphic type and id.
+     */
+    template <typename Type, id_type id>
+    void add()
+    {
+        add<Type>(id);
+    }
+
+    /**
+     * Adds a serialization method for a given polymorphic type and id.
+     */
+    template <typename Type>
+    void add(id_type id)
+    {
+        add(id,
+            typeid(Type).name(),
+            make_serialization_method<Archive, Type>());
+    }
+
+    /**
+     * Add a serialization method for a given polymorphic type information
+     * string and id. The behavior is undefined if the type isn't derived
+     * from polymorphic.
+     */
+    void add(id_type id,
+             std::string type_information_string,
+             serialization_method_t<Archive> serialization_method)
+    {
+        // Lock the serialization method maps for write access.
+        std::lock_guard<shared_mutex> lock(m_shared_mutex);
+
+        // Add the serialization id to serialization method mapping.
+        m_serialization_id_to_method.emplace(
+            id, std::move(serialization_method));
+
+        // Add the type information to to serialization id mapping.
+        m_type_information_to_serialization_id.emplace(
+            std::move(type_information_string), id);
+    }
+
+    /**
+     * Serialize a polymorphic type, in case of a loading (input) archive.
+     */
+    template <typename...,
+              typename ArchiveType = Archive,
+              typename = typename ArchiveType::loading>
+    void serialize(Archive & archive,
+                   std::unique_ptr<polymorphic> & object)
+    {
+        id_type id{};
+
+        // Load the serialization id.
+        archive(id);
+
+        // Lock the serialization method maps for read access.
+        std::shared_lock<shared_mutex> lock(m_shared_mutex);
+
+        // Find the serialization method.
+        auto serialization_id_to_method_pair =
+            m_serialization_id_to_method.find(id);
+        if (m_serialization_id_to_method.end() ==
+            serialization_id_to_method_pair) {
+            throw undeclared_polymorphic_type_error(
+                "Undeclared polymorphic serialization type error.");
+        }
+
+        // Fetch the serialization method.
+        auto serialization_method =
+            serialization_id_to_method_pair->second;
+
+        // Unlock the serialization method maps.
+        lock.unlock();
+
+        // Serialize (load) the given object.
+        serialization_method(archive, object);
+    }
+
+    /**
+     * Serialize a polymorphic type, in case of a saving (output) archive.
+     */
+    template <typename...,
+              typename ArchiveType = Archive,
+              typename = typename ArchiveType::saving>
+    void serialize(Archive & archive, const polymorphic & object)
+    {
+        // Lock the serialization method maps for read access.
+        std::shared_lock<shared_mutex> lock(m_shared_mutex);
+
+        // Find the serialization id.
+        auto type_information_to_serialization_id_pair =
+            m_type_information_to_serialization_id.find(
+                typeid(object).name());
+        if (m_type_information_to_serialization_id.end() ==
+            type_information_to_serialization_id_pair) {
+            throw undeclared_polymorphic_type_error(
+                "Undeclared polymorphic serialization type error.");
+        }
+
+        // Fetch the serialization id.
+        auto id = type_information_to_serialization_id_pair->second;
+
+        // Find the serialization method.
+        auto serialization_id_to_method_pair =
+            m_serialization_id_to_method.find(id);
+        if (m_serialization_id_to_method.end() ==
+            serialization_id_to_method_pair) {
+            throw undeclared_polymorphic_type_error(
+                "Undeclared polymorphic serialization type error.");
+        }
+
+        // Fetch the serialization method.
+        auto serialization_method =
+            serialization_id_to_method_pair->second;
+
+        // Unlock the serialization method maps.
+        lock.unlock();
+
+        // Serialize (save) the serialization id.
+        archive(id);
+
+        // Serialize (save) the given object.
+        serialization_method(archive, object);
+    }
+
+private:
+    /**
+     * Default constructor, defaulted.
+     */
+    registry() = default;
+
+private:
+    /**
+     * The shared mutex that protects the maps below.
+     */
+    shared_mutex m_shared_mutex;
+
+    /**
+     * A map between serialization id to method.
+     */
+    std::unordered_map<id_type, serialization_method_t<Archive>>
+        m_serialization_id_to_method;
+
+    /**
+     * A map between type information string to serialization id.
+     */
+    std::unordered_map<std::string, id_type>
+        m_type_information_to_serialization_id;
+};     // registry
+#endif // ZPP_SERIALIZER_FREESTANDING
+
+/**
+ * Serialize resizable containers, operates on loading (input) archives.
+ */
+template <
+    typename Archive,
+    typename Container,
+    typename SizeType = size_type,
+    typename...,
+    typename = decltype(std::declval<Container &>().size()),
+    typename = decltype(std::declval<Container &>().begin()),
+    typename = decltype(std::declval<Container &>().end()),
+    typename = decltype(std::declval<Container &>().resize(std::size_t())),
+    typename = std::enable_if_t<
+        std::is_class<typename Container::value_type>::value ||
+        !std::is_base_of<
+            std::random_access_iterator_tag,
+            typename std::iterator_traits<
+                typename Container::iterator>::iterator_category>::value>,
+    typename = typename Archive::loading,
+    typename = void,
+    typename = void,
+    typename = void,
+    typename = void>
+auto serialize(Archive & archive, Container & container)
+{
+    SizeType size{};
+
+    // Fetch the number of items to load.
+#ifndef ZPP_SERIALIZER_FREESTANDING
+    archive(size);
+#else
+    if (auto result = archive(size); !result) {
+        return result;
+    }
+#endif
+
+    // Resize the container to match the size.
+    container.resize(size);
+
+    // Serialize all the items.
+    for (auto & item : container) {
+#ifndef ZPP_SERIALIZER_FREESTANDING
+        archive(item);
+#else
+        if (auto result = archive(item); !result) {
+            return result;
+        }
+#endif
+    }
+
+#ifdef ZPP_SERIALIZER_FREESTANDING
+    return freestanding::error{error::success};
+#endif
+}
+
+/**
+ * Serialize containers, operates on saving (output) archives.
+ */
+template <
+    typename Archive,
+    typename Container,
+    typename SizeType = size_type,
+    typename...,
+    typename = decltype(std::declval<Container &>().size()),
+    typename = decltype(std::declval<Container &>().begin()),
+    typename = decltype(std::declval<Container &>().end()),
+    typename = std::enable_if_t<
+        std::is_class<typename Container::value_type>::value ||
+        !std::is_base_of<
+            std::random_access_iterator_tag,
+            typename std::iterator_traits<
+                typename Container::iterator>::iterator_category>::value ||
+        !detail::has_data_member_function<Container>::value>,
+    typename = typename Archive::saving,
+    typename = void,
+    typename = void,
+    typename = void,
+    typename = void,
+    typename = void>
+auto serialize(Archive & archive, const Container & container)
+{
+#ifndef ZPP_SERIALIZER_FREESTANDING
+    // Save the container size.
+    archive(static_cast<SizeType>(container.size()));
+#else
+    if (auto result = archive(static_cast<SizeType>(container.size()));
+        !result) {
+        return result;
+    }
+#endif
+
+    // Serialize all the items.
+    for (auto & item : container) {
+#ifndef ZPP_SERIALIZER_FREESTANDING
+        archive(item);
+#else
+        if (auto result = archive(item); !result) {
+            return result;
+        }
+#endif
+    }
+
+#ifdef ZPP_SERIALIZER_FREESTANDING
+    return freestanding::error{error::success};
+#endif
+}
+
+/**
+ * Serialize view containers, operates on loading (input) archives.
+ */
+template <
+    typename Archive,
+    typename Container,
+    typename SizeType = size_type,
+    typename...,
+    typename = decltype(std::declval<Container &>().size()),
+    typename = decltype(std::declval<Container &>().begin()),
+    typename = decltype(std::declval<Container &>().end()),
+    typename =
+        std::enable_if_t<std::is_trivially_destructible<Container>::value>,
+    typename = std::enable_if_t<
+        std::is_class<typename Container::value_type>::value ||
+        !std::is_base_of<
+            std::random_access_iterator_tag,
+            typename std::iterator_traits<
+                typename Container::iterator>::iterator_category>::value>,
+    typename = typename Archive::loading,
+    typename = void,
+    typename = void,
+    typename = void,
+    typename = void,
+    typename = void>
+auto serialize(Archive & archive, Container & container)
+{
+    SizeType size{};
+
+    // Fetch the number of items to load.
+#ifndef ZPP_SERIALIZER_FREESTANDING
+    archive(size);
+#else
+    if (auto result = archive(size); !result) {
+        return result;
+    }
+#endif
+
+    // Check size.
+    if (size > container.size()) {
+#ifndef ZPP_SERIALIZER_FREESTANDING
+        throw out_of_range("View type container out of range.");
+#else
+        return freestanding::error{error::out_of_range};
+#endif
+    }
+
+    // Resize the view container to match the size.
+    container = {container.data(), size};
+
+    // Serialize all the items.
+    for (auto & item : container) {
+#ifndef ZPP_SERIALIZER_FREESTANDING
+        archive(item);
+#else
+        if (auto result = archive(item); !result) {
+            return result;
+        }
+#endif
+
+#ifdef ZPP_SERIALIZER_FREESTANDING
+        return freestanding::error{error::success};
+#endif
+    }
+}
+
+/**
+ * Serialize resizable, continuous containers, of fundamental or
+ * enumeration types. Operates on loading (input) archives.
+ */
+template <
+    typename Archive,
+    typename Container,
+    typename SizeType = size_type,
+    typename...,
+    typename = decltype(std::declval<Container &>().size()),
+    typename = decltype(std::declval<Container &>().begin()),
+    typename = decltype(std::declval<Container &>().end()),
+    typename = decltype(std::declval<Container &>().resize(std::size_t())),
+    typename = decltype(std::declval<Container &>().data()),
+    typename = std::enable_if_t<
+        std::is_fundamental<typename Container::value_type>::value ||
+        std::is_enum<typename Container::value_type>::value>,
+    typename = std::enable_if_t<std::is_base_of<
+        std::random_access_iterator_tag,
+        typename std::iterator_traits<
+            typename Container::iterator>::iterator_category>::value>,
+    typename = typename Archive::loading,
+    typename = void,
+    typename = void,
+    typename = void,
+    typename = void>
+auto serialize(Archive & archive, Container & container)
+{
+    SizeType size{};
+
+    // Fetch the number of items to load.
+#ifndef ZPP_SERIALIZER_FREESTANDING
+    archive(size);
+#else
+    if (auto result = archive(size); !result) {
+        return result;
+    }
+#endif
+
+    // Resize the container to match the size.
+    container.resize(size);
+
+    // If the size is zero, return.
+    if (!size) {
+#ifndef ZPP_SERIALIZER_FREESTANDING
+        return;
+#else
+        return freestanding::error{error::success};
+#endif
+    }
+
+    // Serialize the bytes data.
+    return archive(as_bytes(std::addressof(container[0]),
+                            static_cast<SizeType>(container.size())));
+}
+
+/**
+ * Serialize continuous containers, of fundamental or
+ * enumeration types. Operates on saving (output) archives.
+ */
+template <typename Archive,
+          typename Container,
+          typename SizeType = size_type,
+          typename...,
+          typename = decltype(std::declval<Container &>().size()),
+          typename = decltype(std::declval<Container &>().begin()),
+          typename = decltype(std::declval<Container &>().end()),
+          typename = decltype(std::declval<Container &>().data()),
+          typename = std::enable_if_t<
+              std::is_fundamental<typename Container::value_type>::value ||
+              std::is_enum<typename Container::value_type>::value>,
+          typename = std::enable_if_t<std::is_base_of<
+              std::random_access_iterator_tag,
+              typename std::iterator_traits<typename Container::iterator>::
+                  iterator_category>::value>,
+          typename = typename Archive::saving,
+          typename = void,
+          typename = void,
+          typename = void,
+          typename = void,
+          typename = void>
+auto serialize(Archive & archive, const Container & container)
+{
+    // The container size.
+    auto size = static_cast<SizeType>(container.size());
+
+    // Save the container size.
+#ifndef ZPP_SERIALIZER_FREESTANDING
+    archive(size);
+#else
+    if (auto result = archive(size); !result) {
+        return result;
+    }
+#endif
+
+    // If the size is zero, return.
+    if (!size) {
+#ifndef ZPP_SERIALIZER_FREESTANDING
+        return;
+#else
+        return freestanding::error{error::success};
+#endif
+    }
+
+    // Serialize the bytes data.
+    return archive(as_bytes(std::addressof(container[0]),
+                            static_cast<SizeType>(container.size())));
+}
+
+/**
+ * Serialize continuous view containers, of fundamental or
+ * enumeration types. Operates on loading (input) archives.
+ */
+template <typename Archive,
+          typename Container,
+          typename SizeType = size_type,
+          typename...,
+          typename = decltype(std::declval<Container &>().size()),
+          typename = decltype(std::declval<Container &>().begin()),
+          typename = decltype(std::declval<Container &>().end()),
+          typename = decltype(std::declval<Container &>().data()),
+          typename = std::enable_if_t<
+              std::is_trivially_destructible<Container>::value>,
+          typename = std::enable_if_t<
+              std::is_fundamental<typename Container::value_type>::value ||
+              std::is_enum<typename Container::value_type>::value>,
+          typename = std::enable_if_t<std::is_base_of<
+              std::random_access_iterator_tag,
+              typename std::iterator_traits<typename Container::iterator>::
+                  iterator_category>::value>,
+          typename = typename Archive::loading,
+          typename = void,
+          typename = void,
+          typename = void,
+          typename = void,
+          typename = void>
+auto serialize(Archive & archive, Container & container)
+{
+    SizeType size{};
+
+    // Fetch the number of items to load.
+#ifndef ZPP_SERIALIZER_FREESTANDING
+    archive(size);
+#else
+    if (auto result = archive(size); !result) {
+        return result;
+    }
+#endif
+
+    // Check the size.
+    if (size > container.size()) {
+#ifndef ZPP_SERIALIZER_FREESTANDING
+        throw out_of_range("View type container out of range.");
+#else
+        return freestanding::error{error::out_of_range};
+#endif
+    }
+
+    // Resize the view container to match the size.
+    container = {container.data(), size};
+
+    // If the size is zero, return.
+    if (!size) {
+#ifndef ZPP_SERIALIZER_FREESTANDING
+        return;
+#else
+        return freestanding::error{error::success};
+#endif
+    }
+
+    // Serialize the bytes data.
+    return archive(as_bytes(std::addressof(container[0]),
+                            static_cast<SizeType>(container.size())));
+}
+
+/**
+ * Serialize Associative and UnorderedAssociative containers, operates on
+ * loading (input) archives.
+ */
+template <typename Archive,
+          typename Container,
+          typename SizeType = size_type,
+          typename...,
+          typename = decltype(std::declval<Container &>().size()),
+          typename = decltype(std::declval<Container &>().begin()),
+          typename = decltype(std::declval<Container &>().end()),
+          typename = typename Container::value_type,
+          typename = typename Container::key_type,
+          typename = typename Archive::loading>
+auto serialize(Archive & archive, Container & container)
+{
+    SizeType size{};
+
+    // Fetch the number of items to load.
+#ifndef ZPP_SERIALIZER_FREESTANDING
+    archive(size);
+#else
+    if (auto result = archive(size); !result) {
+        return result;
+    }
+#endif
+
+    // Serialize all the items.
+    for (SizeType i{}; i < size; ++i) {
+        // Deduce the container item type.
+        using item_type =
+            detail::container_nonconst_value_type_t<Container>;
+
+        // Create just enough storage properly aligned for one item.
+        std::aligned_storage_t<sizeof(item_type), alignof(item_type)>
+            storage;
+
+        // Create the object at the storage.
+        std::unique_ptr<item_type, void (*)(item_type *)> object(
+            access::placement_new<item_type>(std::addressof(storage)),
+            [](auto pointer) { access::destruct(*pointer); });
+
+        // Serialize the object.
+#ifndef ZPP_SERIALIZER_FREESTANDING
+        archive(*object);
+#else
+        if (auto result = archive(*object); !result) {
+            return result;
+        }
+#endif
+
+        // Insert the item to the container.
+        container.insert(std::move(*object));
+    }
+
+#ifdef ZPP_SERIALIZER_FREESTANDING
+    return freestanding::error{error::success};
+#endif
+}
+
+/**
+ * Serialize arrays, operates on loading (input) archives.
+ * This overload is for non fundamental non enumeration types.
+ */
+template <typename Archive,
+          typename Item,
+          std::size_t size,
+          typename...,
+          typename = std::enable_if_t<!std::is_fundamental<Item>::value &&
+                                      !std::is_enum<Item>::value>,
+          typename = typename Archive::loading>
+auto serialize(Archive & archive, Item (&array)[size])
+{
+    // Serialize every item.
+    for (auto & item : array) {
+#ifndef ZPP_SERIALIZER_FREESTANDING
+        archive(item);
+#else
+        if (auto result = archive(item); !result) {
+            return result;
+        }
+#endif
+    }
+
+#ifdef ZPP_SERIALIZER_FREESTANDING
+    return freestanding::error{error::success};
+#endif
+}
+
+/**
+ * Serialize arrays, operates on loading (input) archives.
+ * This overload is for fundamental or enumeration types.
+ */
+template <typename Archive,
+          typename Item,
+          std::size_t size,
+          typename...,
+          typename = std::enable_if_t<std::is_fundamental<Item>::value ||
+                                      std::is_enum<Item>::value>,
+          typename = typename Archive::loading,
+          typename = void>
+auto serialize(Archive & archive, Item (&array)[size])
+{
+    return archive(as_bytes(array, size));
+}
+
+/**
+ * Serialize arrays, operates on saving (output) archives.
+ * This overload is for non fundamental non enumeration types.
+ */
+template <typename Archive,
+          typename Item,
+          std::size_t size,
+          typename...,
+          typename = std::enable_if_t<!std::is_fundamental<Item>::value &&
+                                      !std::is_enum<Item>::value>,
+          typename = typename Archive::saving>
+auto serialize(Archive & archive, const Item (&array)[size])
+{
+    // Serialize every item.
+    for (auto & item : array) {
+#ifndef ZPP_SERIALIZER_FREESTANDING
+        archive(item);
+#else
+        if (auto result = archive(item); !result) {
+            return result;
+        }
+#endif
+    }
+
+#ifdef ZPP_SERIALIZER_FREESTANDING
+    return freestanding::error{error::success};
+#endif
+}
+
+/**
+ * Serialize arrays, operates on saving (output) archives.
+ * This overload is for fundamental or enumeration types.
+ */
+template <typename Archive,
+          typename Item,
+          std::size_t size,
+          typename...,
+          typename = std::enable_if_t<std::is_fundamental<Item>::value ||
+                                      std::is_enum<Item>::value>,
+          typename = typename Archive::saving,
+    typename = void>
+auto serialize(Archive & archive, const Item (&array)[size])
+{
+    return archive(as_bytes(array, size));
+}
+
+/**
+ * Serialize std::array, operates on loading (input) archives.
+ * This overload is for non fundamental non enumeration types.
+ */
+template <typename Archive,
+          typename Item,
+          std::size_t size,
+          typename...,
+          typename = std::enable_if_t<!std::is_fundamental<Item>::value &&
+                                      !std::is_enum<Item>::value>,
+          typename = typename Archive::loading>
+auto serialize(Archive & archive, std::array<Item, size> & array)
+{
+    // Serialize every item.
+    for (auto & item : array) {
+#ifndef ZPP_SERIALIZER_FREESTANDING
+        archive(item);
+#else
+        if (auto result = archive(item); !result) {
+            return result;
+        }
+#endif
+    }
+
+#ifdef ZPP_SERIALIZER_FREESTANDING
+    return freestanding::error{error::success};
+#endif
+}
+
+/**
+ * Serialize std::array, operates on loading (input) archives.
+ * This overload is for fundamental or enumeration types.
+ */
+template <typename Archive,
+          typename Item,
+          std::size_t size,
+          typename...,
+          typename = std::enable_if_t<std::is_fundamental<Item>::value ||
+                                      std::is_enum<Item>::value>,
+          typename = typename Archive::loading,
+          typename = void>
+auto serialize(Archive & archive, std::array<Item, size> & array)
+{
+    return archive(as_bytes(std::addressof(array[0]), size));
+}
+
+/**
+ * Serialize std::array, operates on saving (output) archives.
+ * This overload is for non fundamental non enumeration types.
+ */
+template <typename Archive,
+          typename Item,
+          std::size_t size,
+          typename...,
+          typename = std::enable_if_t<!std::is_fundamental<Item>::value &&
+                                      !std::is_enum<Item>::value>,
+          typename = typename Archive::saving>
+auto serialize(Archive & archive, const std::array<Item, size> & array)
+{
+    // Serialize every item.
+    for (auto & item : array) {
+#ifndef ZPP_SERIALIZER_FREESTANDING
+        archive(item);
+#else
+        if (auto result = archive(item); !result) {
+            return result;
+        }
+#endif
+    }
+
+#ifdef ZPP_SERIALIZER_FREESTANDING
+    return freestanding::error{error::success};
+#endif
+}
+
+/**
+ * Serialize std::array, operates on saving (output) archives.
+ * This overload is for fundamental or enumeration types.
+ */
+template <typename Archive,
+          typename Item,
+          std::size_t size,
+          typename...,
+          typename = std::enable_if_t<std::is_fundamental<Item>::value ||
+                                      std::is_enum<Item>::value>,
+          typename = typename Archive::saving,
+          typename = void>
+auto serialize(Archive & archive, const std::array<Item, size> & array)
+{
+    return archive(as_bytes(std::addressof(array[0]), size));
+}
+
+/**
+ * Serialize std::pair, operates on loading (input) archives.
+ */
+template <typename Archive,
+          typename First,
+          typename Second,
+          typename...,
+          typename = typename Archive::loading>
+auto serialize(Archive & archive, std::pair<First, Second> & pair)
+{
+    // Serialize first, then second.
+    return archive(pair.first, pair.second);
+}
+
+/**
+ * Serialize std::pair, operates on saving (output) archives.
+ */
+template <typename Archive,
+          typename First,
+          typename Second,
+          typename...,
+          typename = typename Archive::saving>
+auto serialize(Archive & archive, const std::pair<First, Second> & pair)
+{
+    // Serialize first, then second.
+    return archive(pair.first, pair.second);
+}
+
+/**
+ * Serialize std::tuple, operates on loading (input) archives.
+ */
+template <typename Archive,
+          typename... TupleItems,
+          typename = typename Archive::loading>
+auto serialize(Archive & archive, std::tuple<TupleItems...> & tuple)
+{
+    // Delegate to a helper function with an index sequence.
+    return serialize(
+        archive, tuple, std::make_index_sequence<sizeof...(TupleItems)>());
+}
+
+/**
+ * Serialize std::tuple, operates on saving (output) archives.
+ */
+template <typename Archive,
+          typename... TupleItems,
+          typename = typename Archive::saving>
+auto serialize(Archive & archive, const std::tuple<TupleItems...> & tuple)
+{
+    // Delegate to a helper function with an index sequence.
+    return serialize(
+        archive, tuple, std::make_index_sequence<sizeof...(TupleItems)>());
+}
+
+/**
+ * Serialize std::tuple, operates on loading (input) archives.
+ * This overload serves as a helper function that accepts an index
+ * sequence.
+ */
+template <typename Archive,
+          typename... TupleItems,
+          std::size_t... Indices,
+          typename = typename Archive::loading>
+auto serialize(Archive & archive,
+               std::tuple<TupleItems...> & tuple,
+               std::index_sequence<Indices...>)
+{
+    return archive(std::get<Indices>(tuple)...);
+}
+
+/**
+ * Serialize std::tuple, operates on saving (output) archives.
+ * This overload serves as a helper function that accepts an index
+ * sequence.
+ */
+template <typename Archive,
+          typename... TupleItems,
+          std::size_t... Indices,
+          typename = typename Archive::saving>
+auto serialize(Archive & archive,
+               const std::tuple<TupleItems...> & tuple,
+               std::index_sequence<Indices...>)
+{
+    return archive(std::get<Indices>(tuple)...);
+}
+
+#if __cplusplus >= 201703L
+/**
+ * Serialize std::optional, operates on loading (input) archives.
+ */
+template <typename Archive,
+          typename Type,
+          typename...,
+          typename = typename Archive::loading>
+auto serialize(Archive & archive, std::optional<Type> & optional)
+{
+    // Load whether has value.
+    bool has_value{};
+#ifndef ZPP_SERIALIZER_FREESTANDING
+    archive(has_value);
+#else
+    if (auto result = archive(has_value); !result) {
+        return result;
+    }
+#endif
+
+    // If does not have a value.
+    if (!has_value) {
+        optional = std::nullopt;
+#ifndef ZPP_SERIALIZER_FREESTANDING
+        return;
+#else
+        return freestanding::error{error::success};
+#endif
+    }
+
+    // If the type is default constructible.
+    if constexpr (std::is_default_constructible_v<Type>) {
+        // Create the value if does not exist.
+        if (!optional) {
+            optional = Type{};
+        }
+
+        // Load the value.
+#ifndef ZPP_SERIALIZER_FREESTANDING
+        archive(*optional);
+#else
+        if (auto result = archive(*optional); !result) {
+            return result;
+        }
+#endif
+    } else {
+        // The object storage.
+        std::aligned_storage_t<sizeof(Type), alignof(Type)> storage;
+
+        // Create the object at the storage.
+        std::unique_ptr<Type, void (*)(Type *)> object(
+            access::placement_new<Type>(std::addressof(storage)),
+            [](auto pointer) { access::destruct(*pointer); });
+
+        // Load the object.
+#ifndef ZPP_SERIALIZER_FREESTANDING
+        archive(*object);
+#else
+        if (auto result = archive(*optional); !result) {
+            return result;
+        }
+#endif
+
+        // Assign the loaded object.
+        optional = std::move(*object);
+    }
+
+#ifdef ZPP_SERIALIZER_FREESTANDING
+    return freestanding::error{error::success};
+#endif
+}
+
+/**
+ * Serialize std::optional, operates on saving (output) archives.
+ */
+template <typename Archive,
+          typename Type,
+          typename...,
+          typename = typename Archive::saving>
+auto serialize(Archive & archive, const std::optional<Type> & optional)
+{
+    // Save has value.
+    bool has_value = optional.has_value();
+
+    // If has value, save it.
+    if (has_value) {
+        return archive(has_value, *optional);
+    } else {
+        return archive(has_value);
+    }
+}
+
+/**
+ * Serialize std::variant, operates on loading (input) archives.
+ */
+template <typename Archive,
+          typename... Types,
+          typename = typename Archive::loading>
+auto serialize(Archive & archive, std::variant<Types...> & variant)
+{
+    // Test for maximum number of types.
+    static_assert(sizeof...(Types) < 0xff, "Max variant types reached.");
+
+    // The variant index.
+    unsigned char index{};
+
+    // Load the index.
+#ifndef ZPP_SERIALIZER_FREESTANDING
+    archive(index);
+#else
+    if (auto result = archive(index); !result) {
+        return result;
+    }
+#endif
+
+    // Check that loaded index is inside bounds.
+    if (index >= sizeof...(Types)) {
+#ifndef ZPP_SERIALIZER_FREESTANDING
+        throw variant_index_out_of_range("Variant index out of range");
+#else
+        return freestanding::error{error::out_of_range};
+#endif
+    }
+
+    // The variant type.
+    using variant_type = std::variant<Types...>;
+
+    // Loader type.
+    using loader_type =
+        void (*)(Archive & archive, variant_type & variant);
+
+    // Loaders per variant index.
+    static constexpr loader_type loaders[] = {[](auto & archive,
+                                                 auto & variant) {
+        // If the type is default constructible.
+        if constexpr (std::is_default_constructible_v<Types>) {
+            // If does not have the needed type, assign it.
+            if (!std::get_if<Types>(&variant)) {
+                variant = Types{};
+            }
+
+            // Load the value.
+            return archive(*std::get_if<Types>(&variant));
+        } else {
+            // The object storage.
+            std::aligned_storage_t<sizeof(Types), alignof(Types)> storage;
+
+            // Create the object at the storage.
+            std::unique_ptr<Types, void (*)(Types *)> object(
+                access::placement_new<Types>(std::addressof(storage)),
+                [](auto pointer) { access::destruct(*pointer); });
+
+            // Load the object.
+#ifndef ZPP_SERIALIZER_FREESTANDING
+            archive(*object);
+#else
+            if (auto result = archive(*object); !result) {
+                return result;
+            }
+#endif
+
+            // Assign the loaded object.
+            variant = std::move(*object);
+        }
+    }...};
+
+    // Execute the appropriate loader.
+    return loaders[index](archive, variant);
+}
+
+/**
+ * Serialize std::variant, operates on saving (output) archives.
+ */
+template <typename Archive,
+          typename... Types,
+          typename = typename Archive::saving>
+auto serialize(Archive & archive, const std::variant<Types...> & variant)
+{
+    // Test for maximum number of types.
+    static_assert(sizeof...(Types) < 0xff, "Max variant types reached.");
+
+    // The variant index.
+    auto variant_index = variant.index();
+
+    // Disallow serializations of valueless variant.
+    if (std::variant_npos == variant_index) {
+#ifndef ZPP_SERIALIZER_FREESTANDING
+        throw attempt_to_serialize_valueless_variant(
+            "Cannot serialize a valueless variant.");
+#else
+        return freestanding::error{error::variant_is_valueless};
+#endif
+    }
+
+    // The index to save.
+    auto index = static_cast<unsigned char>(variant_index & 0xff);
+
+    // Save the variant object.
+    return std::visit(
+        [index, &archive](auto & object) {
+            return archive(index, object);
+        },
+        variant);
+}
+#endif
+
+/**
+ * Serialize std::unique_ptr of non polymorphic, in case of a loading
+ * (input) archive.
+ */
+template <typename Archive,
+          typename Type,
+          typename...,
+          typename =
+              std::enable_if_t<!std::is_base_of<polymorphic, Type>::value>,
+          typename = typename Archive::loading>
+auto serialize(Archive & archive, std::unique_ptr<Type> & object)
+{
+    // Construct a new object.
+    auto loaded_object = access::make_unique<Type>();
+
+    // Serialize the object.
+#ifndef ZPP_SERIALIZER_FREESTANDING
+    archive(*loaded_object);
+#else
+    if (auto result = archive(*loaded_object); !result) {
+        return result;
+    }
+#endif
+
+    // Transfer the object.
+    object.reset(loaded_object.release());
+
+#ifdef ZPP_SERIALIZER_FREESTANDING
+    return freestanding::error{error::success};
+#endif
+}
+
+/**
+ * Serialize std::unique_ptr of non polymorphic, in case of a saving
+ * (output) archive.
+ */
+template <typename Archive,
+          typename Type,
+          typename...,
+          typename =
+              std::enable_if_t<!std::is_base_of<polymorphic, Type>::value>,
+          typename = typename Archive::saving>
+auto serialize(Archive & archive, const std::unique_ptr<Type> & object)
+{
+    // Prevent serialization of null pointers.
+    if (nullptr == object) {
+#ifndef ZPP_SERIALIZER_FREESTANDING
+        throw attempt_to_serialize_null_pointer_error(
+            "Attempt to serialize null pointer.");
+#else
+        return freestanding::error{error::null_pointer_serialization};
+#endif
+    }
+
+    // Serialize the object.
+    return archive(*object);
+}
+
+#ifndef ZPP_SERIALIZER_FREESTANDING
+/**
+ * Serialize std::unique_ptr of polymorphic, in case of a loading (input)
+ * archive.
+ */
+template <
+    typename Archive,
+    typename Type,
+    typename...,
+    typename = std::enable_if_t<std::is_base_of<polymorphic, Type>::value>,
+    typename = typename Archive::loading,
+    typename = void>
+void serialize(Archive & archive, std::unique_ptr<Type> & object)
+{
+    std::unique_ptr<polymorphic> loaded_type;
+
+    // Get the instance of the polymorphic registry.
+    auto & registry_instance = registry<Archive>::get_instance();
+
+    // Serialize the object using the registry.
+    registry_instance.serialize(archive, loaded_type);
+
+    try {
+        // Check if the loaded type is convertible to Type.
+        object.reset(&dynamic_cast<Type &>(*loaded_type));
+
+        // Release the object.
+        loaded_type.release();
+    } catch (const std::bad_cast &) {
+        // The loaded type was not convertible to Type.
+        throw polymorphic_type_mismatch_error(
+            "Polymorphic serialization type mismatch.");
+    }
+}
+
+/**
+ * Serialize std::unique_ptr of polymorphic, in case of a saving (output)
+ * archive.
+ */
+template <
+    typename Archive,
+    typename Type,
+    typename...,
+    typename = std::enable_if_t<std::is_base_of<polymorphic, Type>::value>,
+    typename = typename Archive::saving,
+    typename = void>
+void serialize(Archive & archive, const std::unique_ptr<Type> & object)
+{
+    // Prevent serialization of null pointers.
+    if (nullptr == object) {
+        throw attempt_to_serialize_null_pointer_error(
+            "Attempt to serialize null pointer.");
+    }
+
+    // Get the instance of the polymorphic registry.
+    auto & registry_instance = registry<Archive>::get_instance();
+
+    // Serialize the object using the registry.
+    registry_instance.serialize(archive, *object);
+}
+#endif // ZPP_SERIALIZER_FREESTANDING
+
+/**
+ * Serialize std::shared_ptr of non polymorphic, in case of a loading
+ * (input) archive.
+ */
+template <typename Archive,
+          typename Type,
+          typename...,
+          typename =
+              std::enable_if_t<!std::is_base_of<polymorphic, Type>::value>,
+          typename = typename Archive::loading>
+auto serialize(Archive & archive, std::shared_ptr<Type> & object)
+{
+    // Construct a new object.
+    auto loaded_object = access::make_unique<Type>();
+
+    // Serialize the object.
+#ifndef ZPP_SERIALIZER_FREESTANDING
+    archive(*loaded_object);
+#else
+    if (auto result = archive(*loaded_object); !result) {
+        return result;
+    }
+#endif
+
+    // Transfer the object.
+    object.reset(loaded_object.release());
+
+#ifdef ZPP_SERIALIZER_FREESTANDING
+    return freestanding::error{error::success};
+#endif
+}
+
+/**
+ * Serialize std::shared_ptr of non polymorphic, in case of a saving
+ * (output) archive.
+ */
+template <typename Archive,
+          typename Type,
+          typename...,
+          typename =
+              std::enable_if_t<!std::is_base_of<polymorphic, Type>::value>,
+          typename = typename Archive::saving>
+auto serialize(Archive & archive, const std::shared_ptr<Type> & object)
+{
+    // Prevent serialization of null pointers.
+    if (nullptr == object) {
+#ifndef ZPP_SERIALIZER_FREESTANDING
+        throw attempt_to_serialize_null_pointer_error(
+            "Attempt to serialize null pointer.");
+#else
+        return freestanding::error{error::null_pointer_serialization};
+#endif
+    }
+
+    // Serialize the object.
+    return archive(*object);
+}
+
+/**
+ * Represents a container object with specific
+ * size type requirements.
+ */
+template <typename SizeType, typename Container>
+class sized_container
+{
+public:
+    /**
+     * Must be class type.
+     */
+    static_assert(std::is_class<Container>::value,
+                  "Container must be a class type.");
+
+    /**
+     * Must be unsigned integral type.
+     */
+    static_assert(std::is_unsigned<SizeType>::value,
+                  "Size must be an unsigned integral type.");
+
+    /*
+     * Construct the sized container.
+     */
+    explicit sized_container(Container & container) : container(container)
+    {
+    }
+
+    /**
+     * Call serialize directly with the size type parameter.
+     */
+    template <typename Archive, typename Self>
+    static auto serialize(Archive & archive, Self & self)
+    {
+        using zpp::serializer::serialize;
+        return serialize<Archive, Container, SizeType>(archive,
+                                                       self.container);
+    }
+
+    /**
+     * The wrapped container type.
+     */
+    Container & container;
+};
+
+/**
+ * Creates a wrapper object of sized_container to
+ * allow serialization with specific size type requirements.
+ */
+template <typename SizeType, typename Container>
+auto size_is(Container && container)
+{
+    return sized_container<SizeType, std::remove_reference_t<Container>>(
+        container);
+}
+
+#ifndef ZPP_SERIALIZER_FREESTANDING
+/**
+ * Serialize std::shared_ptr of polymorphic, in case of a loading (input)
+ * archive.
+ */
+template <
+    typename Archive,
+    typename Type,
+    typename...,
+    typename = std::enable_if_t<std::is_base_of<polymorphic, Type>::value>,
+    typename = typename Archive::loading,
+    typename = void>
+void serialize(Archive & archive, std::shared_ptr<Type> & object)
+{
+    std::unique_ptr<polymorphic> loaded_type;
+
+    // Get the instance of the polymorphic registry.
+    auto & registry_instance = registry<Archive>::get_instance();
+
+    // Serialize the object using the registry.
+    registry_instance.serialize(archive, loaded_type);
+
+    try {
+        // Check if the loaded type is convertible to Type.
+        object.reset(&dynamic_cast<Type &>(*loaded_type));
+
+        // Release the object.
+        loaded_type.release();
+    } catch (const std::bad_cast &) {
+        // The loaded type was not convertible to Type.
+        throw polymorphic_type_mismatch_error(
+            "Polymorphic serialization type mismatch.");
+    }
+}
+
+/**
+ * Serialize std::shared_ptr of polymorphic, in case of a saving (output)
+ * archive.
+ */
+template <
+    typename Archive,
+    typename Type,
+    typename...,
+    typename = std::enable_if_t<std::is_base_of<polymorphic, Type>::value>,
+    typename = typename Archive::saving,
+    typename = void>
+void serialize(Archive & archive, const std::shared_ptr<Type> & object)
+{
+    // Prevent serialization of null pointers.
+    if (nullptr == object) {
+        throw attempt_to_serialize_null_pointer_error(
+            "Attempt to serialize null pointer.");
+    }
+
+    // Get the instance of the polymorphic registry.
+    auto & registry_instance = registry<Archive>::get_instance();
+
+    // Serialize the object using the registry.
+    registry_instance.serialize(archive, *object);
+}
+
+/**
+ * Serialize types wrapped with polymorphic_wrapper,
+ * which is supported only for saving (output) archives.
+ * Usually used with the as_polymorphic facility.
+ */
+template <typename Archive,
+          typename Type,
+          typename...,
+          typename = typename Archive::saving>
+void serialize(Archive & archive, const polymorphic_wrapper<Type> & object)
+{
+    // Get the instance of the polymorphic registry.
+    auto & registry_instance = registry<Archive>::get_instance();
+
+    // Serialize using the registry.
+    registry_instance.serialize(archive, *object);
+}
+
+/**
+ * A meta container that holds a sequence of archives.
+ */
+template <typename... Archives>
+struct archive_sequence
+{
+};
+
+/**
+ * The built in archives.
+ */
+using builtin_archives = archive_sequence<memory_view_input_archive,
+                                          basic_memory_output_archive>;
+
+/**
+ * Makes a meta pair of type and id.
+ */
+template <typename Type, id_type id>
+struct make_type;
+
+/**
+ * Registers user defined polymorphic types to serialization registry.
+ */
+template <typename... ExtraTypes>
+class register_types;
+
+/**
+ * A no operation class, registers an empty list of types.
+ */
+template <>
+class register_types<>
+{
+};
+
+/**
+ * Registers user defined polymorphic types to serialization registry.
+ */
+template <typename Type, id_type id, typename... ExtraTypes>
+class register_types<make_type<Type, id>, ExtraTypes...>
+    : private register_types<ExtraTypes...>
+{
+public:
+    /**
+     * Registers the type to the built in archives of the serializer.
+     */
+    register_types() noexcept : register_types(builtin_archives())
+    {
+    }
+
+    /**
+     * Registers the type to every archive in the given archive sequence.
+     */
+    template <typename... Archives>
+    register_types(archive_sequence<Archives...> archives) noexcept
+    {
+        register_type_to_archives(archives);
+    }
+
+private:
+    /**
+     * Registers the type to every archive in the given archive sequence.
+     */
+    template <typename Archive, typename... Archives>
+    void register_type_to_archives(
+        archive_sequence<Archive, Archives...>) noexcept
+    {
+        // Register the type to the first archive.
+        register_type_to_archive<Archive>();
+
+        // Register the type to the other archives.
+        register_type_to_archives(archive_sequence<Archives...>());
+    }
+
+    /**
+     * Registers the type to an empty archive sequence - does nothing.
+     */
+    void register_type_to_archives(archive_sequence<>) noexcept
+    {
+    }
+
+    /**
+     * Registers the type to the given archive.
+     * Must throw no exceptions since this will most likely execute
+     * during static construction.
+     * The effect of failure is that the type will not be registered,
+     * it will be detected during runtime.
+     */
+    template <typename Archive>
+    void register_type_to_archive() noexcept
+    {
+        try {
+            registry<Archive>::get_instance().template add<Type, id>();
+        } catch (...) {
+        }
+    }
+}; // register_types
+
+/**
+ * Accepts a name and returns its serialization id.
+ * We return the first 8 bytes of the sha1 on the given name.
+ */
+template <std::size_t size>
+constexpr id_type make_id(const char (&name)[size])
+{
+    // Initialize constants.
+    std::uint32_t h0 = 0x67452301u;
+    std::uint32_t h1 = 0xEFCDAB89u;
+    std::uint32_t h2 = 0x98BADCFEu;
+    std::uint32_t h3 = 0x10325476u;
+    std::uint32_t h4 = 0xC3D2E1F0u;
+
+    // Initialize the message size in bits.
+    std::uint64_t message_size = (size - 1) * 8;
+
+    // Calculate the size aligned to 64 bytes (512 bits).
+    constexpr std::size_t aligned_message_size =
+        (((size + sizeof(std::uint64_t)) + 63) / 64) * 64;
+
+    // Construct the pre-processed message.
+    std::uint32_t preprocessed_message[aligned_message_size /
+                                       sizeof(std::uint32_t)] = {};
+    for (std::size_t i{}; i < size - 1; ++i) {
+        preprocessed_message[i / 4] |= detail::swap_byte_order(
+            std::uint32_t(name[i])
+            << ((sizeof(std::uint32_t) - 1 - (i % 4)) * 8));
+    }
+
+    // Append the byte 0x80.
+    preprocessed_message[(size - 1) / 4] |= detail::swap_byte_order(
+        std::uint32_t(0x80)
+        << ((sizeof(std::uint32_t) - 1 - ((size - 1) % 4)) * 8));
+
+    // Append the length in bits, in 64 bit, big endian.
+    preprocessed_message[(aligned_message_size / sizeof(std::uint32_t)) -
+                         2] =
+        detail::swap_byte_order(std::uint32_t(message_size >> 32));
+    preprocessed_message[(aligned_message_size / sizeof(std::uint32_t)) -
+                         1] =
+        detail::swap_byte_order(std::uint32_t(message_size));
+
+    // Process the message in successive 512-bit chunks.
+    for (std::size_t i{};
+         i < (aligned_message_size / sizeof(std::uint32_t));
+         i += 16) {
+        std::uint32_t w[80] = {};
+
+        // Set the value of w.
+        for (std::size_t j{}; j < 16; ++j) {
+            w[j] = preprocessed_message[i + j];
+        }
+
+        // Extend the sixteen 32-bit words into eighty 32-bit words.
+        for (std::size_t j = 16; j < 80; ++j) {
+            w[j] = detail::swap_byte_order(detail::rotate_left(
+                detail::swap_byte_order(w[j - 3] ^ w[j - 8] ^ w[j - 14] ^
+                                        w[j - 16]),
+                1));
+        }
+
+        // Initialize hash values for this chunk.
+        auto a = h0;
+        auto b = h1;
+        auto c = h2;
+        auto d = h3;
+        auto e = h4;
+
+        // Main loop.
+        for (std::size_t j{}; j < 80; ++j) {
+            std::uint32_t f{};
+            std::uint32_t k{};
+            if (j <= 19) {
+                f = (b & c) | ((~b) & d);
+                k = 0x5A827999u;
+            } else if (j <= 39) {
+                f = b ^ c ^ d;
+                k = 0x6ED9EBA1u;
+            } else if (j <= 59) {
+                f = (b & c) | (b & d) | (c & d);
+                k = 0x8F1BBCDCu;
+            } else {
+                f = b ^ c ^ d;
+                k = 0xCA62C1D6u;
+            }
+
+            auto temp = detail::rotate_left(a, 5) + f + e + k +
+                        detail::swap_byte_order(w[j]);
+            e = d;
+            d = c;
+            c = detail::rotate_left(b, 30);
+            b = a;
+            a = temp;
+        }
+
+        // Add this chunk's hash to result so far.
+        h0 += a;
+        h1 += b;
+        h2 += c;
+        h3 += d;
+        h4 += e;
+    }
+
+    // Produce the first 8 bytes of the hash in little endian.
+    return detail::swap_byte_order((std::uint64_t(h0) << 32) | h1);
+} // make_id
+#endif // ZPP_SERIALIZER_FREESTANDING
+
+} // namespace serializer
+} // namespace zpp
+
+#endif // ZPP_SERIALIZER_H
diff --git a/tools/linux-wheels.sh b/tools/linux-wheels.sh
index ec9663200..cc136f39e 100755
--- a/tools/linux-wheels.sh
+++ b/tools/linux-wheels.sh
@@ -1,4 +1,7 @@
 #!/bin/bash
+#
+# NOTE: this script is not used anymore. We use cibuildwheel now.
+#
 # based on
 # https://github.com/pypa/python-manylinux-demo/blob/master/travis/build-wheels.sh
 set -e -u -x
@@ -18,7 +21,6 @@ function repair_wheel {
 # Compile wheels
 #for PYBIN in /opt/python/cp38*/bin; do
 for PYBIN in /opt/python/*/bin; do
-    "${PYBIN}/pip" install pybind11
     "${PYBIN}/pip" wheel -v /io/ --no-deps -w wheelhouse/
 done
 
diff --git a/tools/upstream-check.py b/tools/upstream-check.py
index 017c70f09..11e1d2c12 100755
--- a/tools/upstream-check.py
+++ b/tools/upstream-check.py
@@ -8,8 +8,8 @@
 from urllib.request import urlopen
 
 TAGGED_REPOS = {
-    'pybind/pybind11': 'v2.6.1',
-    'scikit-build/scikit-build-core': 'v0.9.4',
+    'wjakob/nanobind': 'v2.1.0',
+    'scikit-build/scikit-build-core': 'v0.10.5',
     'taocpp/PEGTL': '2.8.3',
     'cxong/tinydir': '1.2.6',
     'fastfloat/fast_float': 'v6.1.5',
@@ -29,11 +29,11 @@ def load_json(url):
 
 def check_tags():
     for repo, version in TAGGED_REPOS.items():
-        url = 'https://api.github.com/repos/%s/releases/latest' % repo
-        data = load_json(url)
-        if 'tag_name' in data:
+        try:
+            url = 'https://api.github.com/repos/%s/releases/latest' % repo
+            data = load_json(url)
             latest_tag = data['tag_name']
-        else:
+        except IOError:
             data = load_json('https://api.github.com/repos/%s/tags' % repo)
             latest_tag = data[0]['name']
         mark = ('   !!!' if version != latest_tag else '')