diff --git a/.github/ISSUE_TEMPLATE/config.yml b/.github/ISSUE_TEMPLATE/config.yml
index 4d31afe411d..7919c91f0c6 100644
--- a/.github/ISSUE_TEMPLATE/config.yml
+++ b/.github/ISSUE_TEMPLATE/config.yml
@@ -5,7 +5,7 @@ contact_links:
     about: Ask and answer questions about PyO3 on Discussions
   - name: 🔧 Troubleshooting
     url: https://github.com/PyO3/pyo3/discussions
-    about: For troubleshooting help, see the Discussions 
+    about: For troubleshooting help, see the Discussions
   - name: 👋 Chat
-    url: https://gitter.im/PyO3/Lobby
-    about: Engage with PyO3's users and developers on Gitter
\ No newline at end of file
+    url: https://discord.gg/33kcChzH7f
+    about: Engage with PyO3's users and developers on Discord
diff --git a/.github/actions/fetch-merge-base/action.yml b/.github/actions/fetch-merge-base/action.yml
new file mode 100644
index 00000000000..7ddbce5b65e
--- /dev/null
+++ b/.github/actions/fetch-merge-base/action.yml
@@ -0,0 +1,31 @@
+name: 'Fetch Merge Base'
+description: 'Fetches the merge base between two branches, deepening the git checkout until complete'
+inputs:
+  base_ref:
+    description: 'The base branch reference'
+    required: true
+  head_ref:
+    description: 'The head branch reference'
+    required: true
+outputs:
+  merge_base:
+    description: 'The merge base commit SHA'
+    value: ${{ steps.fetch_merge_base.outputs.merge_base }}
+runs:
+  using: "composite"
+  steps:
+  - name: Fetch Merge Base
+    id: fetch_merge_base
+    shell: bash
+    run: |
+      # fetch the merge commit between the PR base and head
+      git fetch -u --progress --depth=1 origin "+$BASE_REF:$BASE_REF" "+$HEAD_REF:$HEAD_REF"
+      while [ -z "$(git merge-base "$BASE_REF" "$HEAD_REF")" ]; do
+        git fetch -u -q --deepen="10" origin "$BASE_REF" "$HEAD_REF";
+      done
+
+      MERGE_BASE=$(git merge-base "$BASE_REF" "$HEAD_REF")
+      echo "merge_base=$MERGE_BASE" >> $GITHUB_OUTPUT
+    env:
+      BASE_REF: "${{ inputs.base_ref }}"
+      HEAD_REF: "${{ inputs.head_ref }}"
diff --git a/.github/dependabot.yml b/.github/dependabot.yml
index 33f29d79418..f8a257e28f3 100644
--- a/.github/dependabot.yml
+++ b/.github/dependabot.yml
@@ -5,8 +5,18 @@
 
 version: 2
 updates:
-  - package-ecosystem: "cargo" # See documentation for possible values
-    directory: "/" # Location of package manifests
+  - package-ecosystem: "cargo"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+
+  - package-ecosystem: "cargo"
+    directory: "/pyo3-benches/"
+    schedule:
+      interval: "weekly"
+
+  - package-ecosystem: "cargo"
+    directory: "/pyo3-ffi-check/"
     schedule:
       interval: "weekly"
 
diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md
index b344525cabe..2156c1d7322 100644
--- a/.github/pull_request_template.md
+++ b/.github/pull_request_template.md
@@ -5,9 +5,8 @@ By submitting these contributions you agree for them to be dual-licensed under P
 Please consider adding the following to your pull request:
  - an entry for this PR in newsfragments - see [https://pyo3.rs/main/contributing.html#documenting-changes]
    - or start the PR title with `docs:` if this is a docs-only change to skip the check
+   - or start the PR title with `ci:` if this is a ci-only change to skip the check
  - docs to all new functions and / or detail in the guide
  - tests for all new or changed functions
 
-PyO3's CI pipeline will check your pull request. To run its tests
-locally, you can run ```nox```. See ```nox --list-sessions```
-for a list of supported actions.
+PyO3's CI pipeline will check your pull request, thus make sure you have checked the `Contributing.md` guidelines. To run most of its tests locally, you can run `nox`. See `nox --list-sessions` for a list of supported actions.
diff --git a/.github/workflows/benches.yml b/.github/workflows/benches.yml
index 01ab5f802dd..19dd9d145c4 100644
--- a/.github/workflows/benches.yml
+++ b/.github/workflows/benches.yml
@@ -9,34 +9,41 @@ on:
   # performance analysis in order to generate initial data.
   workflow_dispatch:
 
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref_name }}-${{ github.event.pull_request.number || github.sha }}-benches
+  cancel-in-progress: true
+
 jobs:
   benchmarks:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-24.04
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
+      - uses: actions/checkout@v5
+      - uses: actions/setup-python@v6
+        with:
+          python-version: "3.13"
       - uses: dtolnay/rust-toolchain@stable
         with:
           components: rust-src
 
-      - uses: actions/cache@v4
+      - uses: Swatinem/rust-cache@v2
         with:
-          path: |
-            ~/.cargo/registry
-            ~/.cargo/git
-            pyo3-benches/target
-            target
-          key: cargo-${{ runner.os }}-bench-${{ hashFiles('**/Cargo.toml') }}
-        continue-on-error: true
+          workspaces: |
+            .
+            pyo3-benches
+          save-if: ${{ github.ref == 'refs/heads/main' || contains(github.event.pull_request.labels.*.name, 'CI-save-pr-cache') }}
+          cache-all-crates: "true"
+          cache-workspace-crates: "true"
 
-      - name: Install cargo-codspeed
-        run: cargo install cargo-codspeed
+      - uses: taiki-e/install-action@v2
+        with:
+          tool: cargo-codspeed
 
       - name: Install nox
-        run: pip install nox
+        run: pip install nox[uv]
 
       - name: Run the benchmarks
-        uses: CodSpeedHQ/action@v2
+        uses: CodSpeedHQ/action@v4
         with:
           run: nox -s codspeed
           token: ${{ secrets.CODSPEED_TOKEN }}
+          mode: instrumentation
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index af05eb20376..f8e6229cc00 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -16,116 +16,104 @@ on:
       rust-target:
         required: true
         type: string
-      extra-features:
+      MSRV:
         required: true
         type: string
+      verbose:
+        type: boolean
+        default: false
+
+env:
+  NOX_DEFAULT_VENV_BACKEND: uv
 
 jobs:
   build:
-    continue-on-error: ${{ endsWith(inputs.python-version, '-dev') || contains(fromJSON('["3.7", "pypy3.7"]'), inputs.python-version) || inputs.rust == 'beta' || inputs.rust == 'nightly' }}
+    continue-on-error: ${{ endsWith(inputs.python-version, '-dev') || contains(fromJSON('["3.7", "3.8"]'), inputs.python-version) || contains(fromJSON('["beta", "nightly"]'), inputs.rust) }}
     runs-on: ${{ inputs.os }}
+    if: ${{ !(startsWith(inputs.python-version, 'graalpy') && startsWith(inputs.os, 'windows')) }}
     steps:
-      - uses: actions/checkout@v4
-
-      - name: Set up Python ${{ inputs.python-version }}
-        uses: actions/setup-python@v5
+      - uses: actions/checkout@v5
+        with:
+          # For PRs, we need to run on the real PR head, not the resultant merge of the PR into the target branch.
+          #
+          # This is necessary for coverage reporting to make sense; we then get exactly the coverage change
+          # between the base branch and the real PR head.
+          #
+          # If it were run on the merge commit the problem is that the coverage potentially does not align
+          # with the commit diff, because the merge may affect line numbers.
+          ref: ${{ github.event_name == 'pull_request' && github.event.pull_request.head.sha || github.sha }}
+
+      # installs using setup-python do not work for arm macOS 3.9 and below
+      - if: ${{ !(inputs.os == 'macos-latest' && contains(fromJSON('["3.7", "3.8", "3.9"]'), inputs.python-version) && inputs.python-architecture == 'x64') }}
+        name: Set up Python ${{ inputs.python-version }}
+        uses: actions/setup-python@v6
         with:
           python-version: ${{ inputs.python-version }}
           architecture: ${{ inputs.python-architecture }}
-          check-latest: ${{ startsWith(inputs.python-version, 'pypy') }}  # PyPy can have FFI changes within Python versions, which creates pain in CI
+          # PyPy can have FFI changes within Python versions, which creates pain in CI
+          check-latest: ${{ startsWith(inputs.python-version, 'pypy') }}
+
+      # workaround for the above, only available for 3.9
+      - if: ${{ inputs.os == 'macos-latest' && contains(fromJSON('["3.9"]'), inputs.python-version) && inputs.python-architecture == 'x64' }}
+        name: Set up Python ${{ inputs.python-version }}
+        uses: astral-sh/setup-uv@v7
+        with:
+          python-version: cpython-${{ inputs.python-version }}-macos-x86-64
 
       - name: Install nox
-        run: python -m pip install --upgrade pip && pip install nox
+        run: python -m pip install --upgrade pip && pip install nox[uv]
 
       - name: Install Rust toolchain
         uses: dtolnay/rust-toolchain@master
         with:
           toolchain: ${{ inputs.rust }}
           targets: ${{ inputs.rust-target }}
-          # needed to correctly format errors, see #1865
-          components: rust-src
+          # rust-src needed to correctly format errors, see #1865
+          components: rust-src,llvm-tools-preview
+
+      # On windows 32 bit, we are running on an x64 host, so we need to specifically set the target
+      # NB we don't do this for *all* jobs because it breaks coverage of proc macros to have an
+      # explicit target set.
+      - name: Set Rust target for Windows 32-bit
+        if: inputs.os == 'windows-latest' && inputs.python-architecture == 'x86'
+        shell: bash
+        run: |
+          echo "CARGO_BUILD_TARGET=i686-pc-windows-msvc" >> $GITHUB_ENV
+
+      # windows on arm image contains x86-64 libclang
+      - name: Install LLVM and Clang
+        if: inputs.os == 'windows-11-arm'
+        uses: KyleMayes/install-llvm-action@v2
+        with:
+          # to match windows-2022 images
+          version: "18"
+
+      - name: Install zoneinfo backport for Python 3.7 / 3.8
+        if: contains(fromJSON('["3.7", "3.8"]'), inputs.python-version)
+        run: python -m pip install backports.zoneinfo
 
       - uses: Swatinem/rust-cache@v2
         with:
-          key: cargo-${{ inputs.python-architecture }}
-        continue-on-error: true
+          save-if: ${{ github.ref == 'refs/heads/main' || contains(github.event.pull_request.labels.*.name, 'CI-save-pr-cache') }}
 
       - if: inputs.os == 'ubuntu-latest'
         name: Prepare LD_LIBRARY_PATH (Ubuntu only)
         run: echo LD_LIBRARY_PATH=${pythonLocation}/lib >> $GITHUB_ENV
 
-      - if: inputs.rust == '1.56.0'
-        name: Prepare minimal package versions (MSRV only)
-        run: nox -s set-minimal-package-versions
+      - if: inputs.rust == inputs.MSRV
+        name: Prepare MSRV package versions
+        run: nox -s set-msrv-package-versions
 
       - if: inputs.rust != 'stable'
         name: Ignore changed error messages when using trybuild
         run: echo "TRYBUILD=overwrite" >> "$GITHUB_ENV"
 
-      - name: Build docs
-        run: nox -s docs
-
-      - name: Build (no features)
-        run: cargo build --lib --tests --no-default-features
-
-      # --no-default-features when used with `cargo build/test -p` doesn't seem to work!
-      - name: Build pyo3-build-config (no features)
-        run: |
-          cd pyo3-build-config
-          cargo build --no-default-features
-
-      # Run tests (except on PyPy, because no embedding API).
-      - if: ${{ !startsWith(inputs.python-version, 'pypy') }}
-        name: Test (no features)
-        run: cargo test --no-default-features --lib --tests
-
-      # --no-default-features when used with `cargo build/test -p` doesn't seem to work!
-      - name: Test pyo3-build-config (no features)
-        run: |
-          cd pyo3-build-config
-          cargo test --no-default-features
-
-      - name: Build (all additive features)
-        run: cargo build --lib --tests --no-default-features --features "full ${{ inputs.extra-features }}"
-
-      - if: ${{ startsWith(inputs.python-version, 'pypy') }}
-        name: Build PyPy (abi3-py37)
-        run: cargo build --lib --tests --no-default-features --features "abi3-py37 full ${{ inputs.extra-features }}"
-
-      # Run tests (except on PyPy, because no embedding API).
-      - if: ${{ !startsWith(inputs.python-version, 'pypy') }}
-        name: Test
-        run: cargo test --no-default-features --features "full ${{ inputs.extra-features }}"
-
-      # Run tests again, but in abi3 mode
-      - if: ${{ !startsWith(inputs.python-version, 'pypy') }}
-        name: Test (abi3)
-        run: cargo test --no-default-features --features "abi3 full ${{ inputs.extra-features }}"
-
-      # Run tests again, for abi3-py37 (the minimal Python version)
-      - if: ${{ (!startsWith(inputs.python-version, 'pypy')) && (inputs.python-version != '3.7') }}
-        name: Test (abi3-py37)
-        run: cargo test --no-default-features --features "abi3-py37 full ${{ inputs.extra-features }}"
-
-      - name: Test proc-macro code
-        run: cargo test --manifest-path=pyo3-macros-backend/Cargo.toml
-
-      - name: Test build config
-        run: cargo test --manifest-path=pyo3-build-config/Cargo.toml
-
-      - name: Test python examples and tests
-        shell: bash
-        run: nox -s test-py
-        env:
-          CARGO_TARGET_DIR: ${{ github.workspace }}/target
-
       - uses: dorny/paths-filter@v3
-        # pypy 3.7 and 3.8 are not PEP 3123 compliant so fail checks here
-        if: ${{ inputs.rust == 'stable' && inputs.python-version != 'pypy3.7' && inputs.python-version != 'pypy3.8' }}
+        if: ${{ inputs.rust == 'stable' && !startsWith(inputs.python-version, 'graalpy') }}
         id: ffi-changes
         with:
-          base: ${{ github.event.pull_request.base.ref || github.event.merge_group.base_ref }}
-          ref: ${{ github.event.pull_request.head.ref || github.event.merge_group.head_ref }}
+          base: ${{ github.event.merge_group.base_ref }}
+          ref: ${{ github.event.merge_group.head_ref }}
           filters: |
             changed:
               - 'pyo3-ffi/**'
@@ -134,68 +122,52 @@ jobs:
               - '.github/workflows/build.yml'
 
       - name: Run pyo3-ffi-check
-        # pypy 3.7 and 3.8 are not PEP 3123 compliant so fail checks here, nor
-        # is pypy 3.9 on windows
-        if: ${{ endsWith(inputs.python-version, '-dev') || (steps.ffi-changes.outputs.changed == 'true' && inputs.rust == 'stable' && inputs.python-version != 'pypy3.7' && inputs.python-version != 'pypy3.8' && !(inputs.python-version == 'pypy3.9' && contains(inputs.os, 'windows'))) }}
+        # TODO: investigate graalpy failures
+        if: ${{ endsWith(inputs.python-version, '-dev') || (steps.ffi-changes.outputs.changed == 'true' && inputs.rust == 'stable' && !startsWith(inputs.python-version, 'graalpy')) }}
         run: nox -s ffi-check
 
+      - name: Install cargo-llvm-cov
+        uses: taiki-e/install-action@cargo-llvm-cov
 
-      - name: Test cross compilation
-        if: ${{ inputs.os == 'ubuntu-latest' && inputs.python-version == '3.9' }}
-        uses: PyO3/maturin-action@v1
-        env:
-          PYO3_CROSS_LIB_DIR: /opt/python/cp39-cp39/lib
-        with:
-          target: aarch64-unknown-linux-gnu
-          manylinux: auto
-          args: --release -i python3.9 -m examples/maturin-starter/Cargo.toml
-
-      - run: sudo rm -rf examples/maturin-starter/target
-        if: ${{ inputs.os == 'ubuntu-latest' && inputs.python-version == '3.9' }}
-      - name: Test cross compile to same architecture
-        if: ${{ inputs.os == 'ubuntu-latest' && inputs.python-version == '3.9' }}
-        uses: PyO3/maturin-action@v1
-        env:
-          PYO3_CROSS_LIB_DIR: /opt/python/cp39-cp39/lib
-        with:
-          target: x86_64-unknown-linux-gnu
-          manylinux: auto
-          args: --release -i python3.9 -m examples/maturin-starter/Cargo.toml
+      - name: Prepare coverage environment
+        run: |
+          cargo llvm-cov clean --workspace --profraw-only
+          nox -s set-coverage-env
 
-      - name: Test cross compilation
-        if: ${{ inputs.os == 'macos-latest' && inputs.python-version == '3.9' }}
-        uses: PyO3/maturin-action@v1
-        with:
-          target: aarch64-apple-darwin
-          args: --release -i python3.9 -m examples/maturin-starter/Cargo.toml
+      - name: Build docs
+        run: nox -s docs
+
+      - name: Run Rust tests
+        run: nox -s test-rust
 
-      - name: Test cross compile to Windows
-        if: ${{ inputs.os == 'ubuntu-latest' && inputs.python-version == '3.8' }}
+      - name: Test python examples and tests
+        shell: bash
+        run: nox -s test-py
         env:
-          XWIN_ARCH: x86_64
-        run: |
-          set -ex
-          sudo apt-get install -y mingw-w64 llvm
-          rustup target add x86_64-pc-windows-gnu x86_64-pc-windows-msvc
-          pip install cargo-xwin
-          # abi3
-          cargo build --manifest-path examples/maturin-starter/Cargo.toml --features abi3 --target x86_64-pc-windows-gnu
-          cargo xwin build --manifest-path examples/maturin-starter/Cargo.toml --features abi3 --target x86_64-pc-windows-msvc
-          # non-abi3
-          export PYO3_CROSS_PYTHON_VERSION=3.9
-          cargo build --manifest-path examples/maturin-starter/Cargo.toml --features generate-import-lib --target x86_64-pc-windows-gnu
-          cargo xwin build --manifest-path examples/maturin-starter/Cargo.toml --features generate-import-lib --target x86_64-pc-windows-msvc
-
-      - name: Test cross compile to Windows with maturin
-        if: ${{ inputs.os == 'ubuntu-latest' && inputs.python-version == '3.8' }}
-        uses: PyO3/maturin-action@v1
+          CARGO_TARGET_DIR: ${{ github.workspace }}/target
+
+      - name: Generate coverage report
+        # needs investigation why llvm-cov fails on windows-11-arm
+        continue-on-error: ${{ inputs.os == 'windows-11-arm' }}
+        run: cargo llvm-cov
+          --package=pyo3
+          --package=pyo3-build-config
+          --package=pyo3-macros-backend
+          --package=pyo3-macros
+          --package=pyo3-ffi
+          report --codecov --output-path coverage.json
+
+      - name: Upload coverage report
+        uses: codecov/codecov-action@v5
+        # needs investigation why llvm-cov fails on windows-11-arm
+        continue-on-error: ${{ inputs.os == 'windows-11-arm' }}
         with:
-          target: x86_64-pc-windows-gnu
-          args: -i python3.8 -m examples/maturin-starter/Cargo.toml --features abi3
+          files: coverage.json
+          name: ${{ inputs.os }}/${{ inputs.python-version }}/${{ inputs.rust }}
+          token: ${{ secrets.CODECOV_TOKEN }}
 
     env:
-      CARGO_TERM_VERBOSE: true
-      CARGO_BUILD_TARGET: ${{ inputs.rust-target }}
+      CARGO_TERM_VERBOSE: ${{ inputs.verbose }}
       RUST_BACKTRACE: 1
       RUSTFLAGS: "-D warnings"
       RUSTDOCFLAGS: "-D warnings"
diff --git a/.github/workflows/cache-cleanup.yml b/.github/workflows/cache-cleanup.yml
new file mode 100644
index 00000000000..02e8a6ab3cb
--- /dev/null
+++ b/.github/workflows/cache-cleanup.yml
@@ -0,0 +1,31 @@
+name: CI Cache Cleanup
+on:
+  pull_request_target:
+    types:
+      - closed
+
+jobs:
+  cleanup:
+    runs-on: ubuntu-latest
+    permissions:
+      actions: write
+    steps:
+      - name: Cleanup
+        run: |
+          gh extension install actions/gh-actions-cache
+
+          echo "Fetching list of cache key"
+          cacheKeysForPR=$(gh actions-cache list -R $REPO -B $BRANCH -L 100 | cut -f 1 )
+
+          ## Setting this to not fail the workflow while deleting cache keys.
+          set +e
+          echo "Deleting caches..."
+          for cacheKey in $cacheKeysForPR
+          do
+              gh actions-cache delete -R $REPO -B $BRANCH --confirm -- $cacheKey
+          done
+          echo "Done"
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          REPO: ${{ github.repository }}
+          BRANCH: refs/pull/${{ github.event.pull_request.number }}/merge
diff --git a/.github/workflows/changelog.yml b/.github/workflows/changelog.yml
index 0a782b4010f..760918ce40a 100644
--- a/.github/workflows/changelog.yml
+++ b/.github/workflows/changelog.yml
@@ -9,7 +9,9 @@ jobs:
     name: Check changelog entry
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
-      - run: python -m pip install --upgrade pip && pip install nox
+      - uses: actions/checkout@v5
+      - uses: actions/setup-python@v6
+        with:
+          python-version: '3.13'
+      - run: python -m pip install --upgrade pip && pip install nox[uv]
       - run: nox -s check-changelog
diff --git a/.github/workflows/ci-cache-warmup.yml b/.github/workflows/ci-cache-warmup.yml
new file mode 100644
index 00000000000..2b05a1e98c0
--- /dev/null
+++ b/.github/workflows/ci-cache-warmup.yml
@@ -0,0 +1,34 @@
+name: CI Cache Warmup
+
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  cross-compilation-windows:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+      - uses: actions/setup-python@v6
+        with:
+          python-version: "3.13"
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          targets: x86_64-pc-windows-gnu,x86_64-pc-windows-msvc
+          components: rust-src
+      - uses: actions/cache/restore@v4
+        with:
+          # https://github.com/PyO3/maturin/discussions/1953
+          path: ~/.cache/cargo-xwin
+          key: cargo-xwin-cache
+      - name: Test cross compile to Windows
+        run: |
+          set -ex
+          sudo apt-get install -y mingw-w64 llvm
+          pip install nox
+          nox -s test-cross-compilation-windows
+      - uses: actions/cache/save@v4
+        with:
+          path: ~/.cache/cargo-xwin
+          key: cargo-xwin-cache
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 22281185caa..2270eb1432f 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -1,9 +1,6 @@
 name: CI
 
 on:
-  push:
-    branches:
-      - main
   pull_request:
   merge_group:
     types: [checks_requested]
@@ -18,12 +15,13 @@ env:
 
 jobs:
   fmt:
-    if: github.ref != 'refs/heads/main'
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
-      - run: python -m pip install --upgrade pip && pip install nox
+      - uses: actions/checkout@v5
+      - uses: actions/setup-python@v6
+        with:
+          python-version: "3.13"
+      - run: python -m pip install --upgrade pip && pip install nox[uv]
       - uses: dtolnay/rust-toolchain@stable
         with:
           components: rustfmt
@@ -31,122 +29,109 @@ jobs:
         run: nox -s ruff
       - name: Check rust formatting (rustfmt)
         run: nox -s rustfmt
+      - name: Check markdown formatting (rumdl)
+        run: nox -s rumdl
+
+  resolve:
+    runs-on: ubuntu-latest
+    outputs:
+      MSRV: ${{ steps.resolve-msrv.outputs.MSRV }}
+      verbose: ${{ runner.debug == '1' }}
+    steps:
+      - uses: actions/checkout@v5
+      - uses: actions/setup-python@v6
+        with:
+          python-version: "3.13"
+      - name: resolve MSRV
+        id: resolve-msrv
+        run: echo MSRV=`python -c 'import tomllib; print(tomllib.load(open("Cargo.toml", "rb"))["workspace"]["package"]["rust-version"])'` >> $GITHUB_OUTPUT
 
   semver-checks:
-    if: github.ref != 'refs/heads/main'
+    if: github.event_name == 'pull_request'
     needs: [fmt]
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
+      - uses: actions/checkout@v5
+      - uses: actions/setup-python@v6
+        with:
+          python-version: "3.13"
+      - name: Fetch merge base
+        id: fetch_merge_base
+        uses: ./.github/actions/fetch-merge-base
+        with:
+          base_ref: "refs/heads/${{ github.event.pull_request.base.ref }}"
+          head_ref: "refs/pull/${{ github.event.pull_request.number }}/merge"
       - uses: obi1kenobi/cargo-semver-checks-action@v2
+        with:
+          baseline-rev: ${{ steps.fetch_merge_base.outputs.merge_base }}
 
   check-msrv:
-    needs: [fmt]
+    needs: [fmt, resolve]
     runs-on: ubuntu-latest
-    if: github.ref != 'refs/heads/main'
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
       - uses: dtolnay/rust-toolchain@master
         with:
-          toolchain: 1.56.0
-          targets: x86_64-unknown-linux-gnu
+          toolchain: ${{ needs.resolve.outputs.MSRV }}
           components: rust-src
-      - uses: actions/setup-python@v5
+      - uses: actions/setup-python@v6
         with:
-          architecture: "x64"
+          python-version: "3.13"
       - uses: Swatinem/rust-cache@v2
         with:
-          key: check-msrv-1.56.0
-        continue-on-error: true
-      - run: python -m pip install --upgrade pip && pip install nox
-      - name: Prepare minimal package versions
-        run: nox -s set-minimal-package-versions
-      - run: nox -s check-all
+          save-if: ${{ github.ref == 'refs/heads/main' || contains(github.event.pull_request.labels.*.name, 'CI-save-pr-cache') }}
+      - run: python -m pip install --upgrade pip && pip install nox[uv]
+      # This is a smoke test to confirm that CI will run on MSRV (including dev dependencies)
+      - name: Check with MSRV package versions
+        run: |
+          nox -s set-msrv-package-versions
+          nox -s check-all
 
     env:
       CARGO_BUILD_TARGET: x86_64-unknown-linux-gnu
 
   clippy:
     needs: [fmt]
-    runs-on: ${{ matrix.platform.os }}
-    if: github.ref != 'refs/heads/main'
+    runs-on: ubuntu-24.04-arm
     strategy:
       # If one platform fails, allow the rest to keep testing if `CI-no-fail-fast` label is present
       fail-fast: ${{ !contains(github.event.pull_request.labels.*.name, 'CI-no-fail-fast') }}
       matrix:
         rust: [stable]
-        platform: [
-          {
-            os: "macos-latest",
-            python-architecture: "x64",
-            rust-target: "x86_64-apple-darwin",
-          },
-          {
-            os: "ubuntu-latest",
-            python-architecture: "x64",
-            rust-target: "x86_64-unknown-linux-gnu",
-          },
-          {
-            os: "ubuntu-latest",
-            python-architecture: "x64",
-            rust-target: "powerpc64le-unknown-linux-gnu",
-          },
-          {
-            os: "ubuntu-latest",
-            python-architecture: "x64",
-            rust-target: "s390x-unknown-linux-gnu",
-          },
-          {
-            os: "ubuntu-latest",
-            python-architecture: "x64",
-            rust-target: "wasm32-wasi",
-          },
-          {
-            os: "windows-latest",
-            python-architecture: "x64",
-            rust-target: "x86_64-pc-windows-msvc",
-          },
-          {
-            os: "windows-latest",
-            python-architecture: "x86",
-            rust-target: "i686-pc-windows-msvc",
-          },
-        ]
+        target:
+          [
+            "aarch64-apple-darwin",
+            "x86_64-unknown-linux-gnu",
+            "aarch64-unknown-linux-gnu",
+            "powerpc64le-unknown-linux-gnu",
+            "s390x-unknown-linux-gnu",
+            "wasm32-wasip1",
+            "x86_64-pc-windows-msvc",
+            "i686-pc-windows-msvc",
+            "aarch64-pc-windows-msvc",
+          ]
         include:
           # Run beta clippy as a way to detect any incoming lints which may affect downstream users
           - rust: beta
-            platform:
-              {
-                os: "ubuntu-latest",
-                python-architecture: "x64",
-                rust-target: "x86_64-unknown-linux-gnu",
-              }
-    name: clippy/${{ matrix.platform.rust-target }}/${{ matrix.rust }}
-    continue-on-error: ${{ matrix.platform.rust != 'stable' }}
+            target: "x86_64-unknown-linux-gnu"
+    name: clippy/${{ matrix.target }}/${{ matrix.rust }}
+    continue-on-error: ${{ matrix.rust != 'stable' }}
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
       - uses: dtolnay/rust-toolchain@master
         with:
           toolchain: ${{ matrix.rust }}
-          targets: ${{ matrix.platform.rust-target }}
+          targets: ${{ matrix.target }}
           components: clippy,rust-src
-      - uses: actions/setup-python@v5
-        with:
-          architecture: ${{ matrix.platform.python-architecture }}
-      - uses: Swatinem/rust-cache@v2
-        with:
-          key: clippy-${{ matrix.platform.rust-target }}-${{ matrix.platform.os }}-${{ matrix.rust }}
-        continue-on-error: true
-      - run: python -m pip install --upgrade pip && pip install nox
-      - run: nox -s clippy-all
+      - uses: astral-sh/setup-uv@v7
+      - run: uvx nox -s clippy-all
     env:
-      CARGO_BUILD_TARGET: ${{ matrix.platform.rust-target }}
+      CARGO_BUILD_TARGET: ${{ matrix.target }}
 
   build-pr:
     if: ${{ !contains(github.event.pull_request.labels.*.name, 'CI-build-full') && github.event_name == 'pull_request' }}
     name: python${{ matrix.python-version }}-${{ matrix.platform.python-architecture }} ${{ matrix.platform.os }} rust-${{ matrix.rust }}
-    needs: [fmt]
+    needs: [fmt, resolve]
     uses: ./.github/workflows/build.yml
     with:
       os: ${{ matrix.platform.os }}
@@ -154,27 +139,32 @@ jobs:
       python-architecture: ${{ matrix.platform.python-architecture }}
       rust: ${{ matrix.rust }}
       rust-target: ${{ matrix.platform.rust-target }}
-      extra-features: ${{ matrix.platform.extra-features }}
+      MSRV: ${{ needs.resolve.outputs.MSRV }}
+      verbose: ${{ needs.resolve.outputs.verbose == 'true' }}
     secrets: inherit
     strategy:
       # If one platform fails, allow the rest to keep testing if `CI-no-fail-fast` label is present
       fail-fast: ${{ !contains(github.event.pull_request.labels.*.name, 'CI-no-fail-fast') }}
       matrix:
-        extra-features: ["multiple-pymethods"]
         rust: [stable]
-        python-version: ["3.12"]
+        python-version: ["3.14"]
         platform:
           [
             {
               os: "macos-latest",
-              python-architecture: "x64",
-              rust-target: "x86_64-apple-darwin",
+              python-architecture: "arm64",
+              rust-target: "aarch64-apple-darwin",
             },
             {
               os: "ubuntu-latest",
               python-architecture: "x64",
               rust-target: "x86_64-unknown-linux-gnu",
             },
+            {
+              os: "ubuntu-24.04-arm",
+              python-architecture: "arm64",
+              rust-target: "aarch64-unknown-linux-gnu",
+            },
             {
               os: "windows-latest",
               python-architecture: "x64",
@@ -185,23 +175,38 @@ jobs:
               python-architecture: "x86",
               rust-target: "i686-pc-windows-msvc",
             },
+            {
+              os: "windows-11-arm",
+              python-architecture: "arm64",
+              rust-target: "aarch64-pc-windows-msvc",
+            },
           ]
         include:
           # Test nightly Rust on PRs so that PR authors have a chance to fix nightly
           # failures, as nightly does not block merge.
           - rust: nightly
-            python-version: "3.12"
+            python-version: "3.14"
             platform:
               {
                 os: "ubuntu-latest",
                 python-architecture: "x64",
                 rust-target: "x86_64-unknown-linux-gnu",
               }
-            extra-features: "nightly multiple-pymethods"
+          # Also test free-threaded Python just for latest Python version, on ubuntu
+          # (run for all OSes on build-full)
+          - rust: stable
+            python-version: "3.14t"
+            platform:
+              {
+                os: "ubuntu-latest",
+                python-architecture: "x64",
+                rust-target: "x86_64-unknown-linux-gnu",
+              }
+
   build-full:
-    if: ${{ contains(github.event.pull_request.labels.*.name, 'CI-build-full') || (github.event_name != 'pull_request' && github.ref != 'refs/heads/main') }}
+    if: ${{ contains(github.event.pull_request.labels.*.name, 'CI-build-full') || github.event_name != 'pull_request' }}
     name: python${{ matrix.python-version }}-${{ matrix.platform.python-architecture }} ${{ matrix.platform.os }} rust-${{ matrix.rust }}
-    needs: [fmt]
+    needs: [fmt, resolve]
     uses: ./.github/workflows/build.yml
     with:
       os: ${{ matrix.platform.os }}
@@ -209,32 +214,35 @@ jobs:
       python-architecture: ${{ matrix.platform.python-architecture }}
       rust: ${{ matrix.rust }}
       rust-target: ${{ matrix.platform.rust-target }}
-      extra-features: ${{ matrix.platform.extra-features }}
+      MSRV: ${{ needs.resolve.outputs.MSRV }}
+      verbose: ${{ needs.resolve.outputs.verbose == 'true' }}
     secrets: inherit
     strategy:
       # If one platform fails, allow the rest to keep testing if `CI-no-fail-fast` label is present
       fail-fast: ${{ !contains(github.event.pull_request.labels.*.name, 'CI-no-fail-fast') }}
       matrix:
-        extra-features: ["multiple-pymethods"]  # Because MSRV doesn't support this
         rust: [stable]
-        python-version: [
-          "3.7",
-          "3.8",
-          "3.9",
-          "3.10",
-          "3.11",
-          "3.12",
-          "pypy3.7",
-          "pypy3.8",
-          "pypy3.9",
-          "pypy3.10",
-        ]
+        python-version:
+          [
+            "3.7",
+            "3.8",
+            "3.9",
+            "3.10",
+            "3.11",
+            "3.12",
+            "3.13",
+            "3.13t",
+            "3.14",
+            "3.14t",
+            "pypy3.11",
+            "graalpy25.0",
+          ]
         platform:
           [
             {
               os: "macos-latest",
-              python-architecture: "x64",
-              rust-target: "x86_64-apple-darwin",
+              python-architecture: "arm64",
+              rust-target: "aarch64-apple-darwin",
             },
             {
               os: "ubuntu-latest",
@@ -249,63 +257,149 @@ jobs:
           ]
         include:
           # Test minimal supported Rust version
-          - rust: 1.56.0
-            python-version: "3.12"
+          - rust: ${{ needs.resolve.outputs.MSRV }}
+            python-version: "3.14"
             platform:
               {
                 os: "ubuntu-latest",
                 python-architecture: "x64",
                 rust-target: "x86_64-unknown-linux-gnu",
               }
-            extra-features: ""
 
           # Test the `nightly` feature
           - rust: nightly
-            python-version: "3.12"
+            python-version: "3.14"
             platform:
               {
                 os: "ubuntu-latest",
                 python-architecture: "x64",
                 rust-target: "x86_64-unknown-linux-gnu",
               }
-            extra-features: "nightly multiple-pymethods"
 
           # Run rust beta to help catch toolchain regressions
           - rust: beta
-            python-version: "3.12"
+            python-version: "3.14"
             platform:
               {
                 os: "ubuntu-latest",
                 python-architecture: "x64",
                 rust-target: "x86_64-unknown-linux-gnu",
               }
-            extra-features: "multiple-pymethods"
 
-          # Test 32-bit Windows only with the latest Python version
+          # Test 32-bit Windows and x64 macOS only with the latest Python version
           - rust: stable
-            python-version: "3.12"
+            python-version: "3.14"
             platform:
               {
                 os: "windows-latest",
                 python-architecture: "x86",
                 rust-target: "i686-pc-windows-msvc",
               }
-            extra-features: "multiple-pymethods"
+          - rust: stable
+            python-version: "3.14"
+            platform:
+              {
+                os: "macos-latest",
+                python-architecture: "x64",
+                rust-target: "x86_64-apple-darwin",
+              }
+          # ubuntu-latest (24.04) no longer supports 3.7, so run on 22.04
+          - rust: stable
+            python-version: "3.7"
+            platform:
+              {
+                os: "ubuntu-22.04",
+                python-architecture: "x64",
+                rust-target: "x86_64-unknown-linux-gnu",
+              }
+
+          # arm64 macOS Python not available on GitHub Actions until 3.10, test older versions on x64
+          - rust: stable
+            python-version: "3.7"
+            platform:
+              {
+                os: "macos-15-intel",
+                python-architecture: "x64",
+                rust-target: "x86_64-apple-darwin",
+              }
+          - rust: stable
+            python-version: "3.8"
+            platform:
+              {
+                os: "macos-15-intel",
+                python-architecture: "x64",
+                rust-target: "x86_64-apple-darwin",
+              }
+          - rust: stable
+            python-version: "3.9"
+            platform:
+              {
+                os: "macos-15-intel",
+                python-architecture: "x64",
+                rust-target: "x86_64-apple-darwin",
+              }
+          # test latest Python on arm64 linux & windows runners
+          - rust: stable
+            python-version: "3.14"
+            platform:
+              {
+                os: "ubuntu-24.04-arm",
+                python-architecture: "arm64",
+                rust-target: "aarch64-unknown-linux-gnu",
+              }
+          - rust: stable
+            python-version: "3.14"
+            platform:
+              {
+                os: "windows-11-arm",
+                python-architecture: "arm64",
+                rust-target: "aarch64-pc-windows-msvc",
+              }
+        exclude:
+          # ubuntu-latest (24.04) no longer supports 3.7
+          - python-version: "3.7"
+            platform: { os: "ubuntu-latest" }
+          # arm64 macOS Python not available on GitHub Actions until 3.10
+          - rust: stable
+            python-version: "3.7"
+            platform:
+              {
+                os: "macos-latest",
+                python-architecture: "arm64",
+                rust-target: "aarch64-apple-darwin",
+              }
+          - rust: stable
+            python-version: "3.8"
+            platform:
+              {
+                os: "macos-latest",
+                python-architecture: "arm64",
+                rust-target: "aarch64-apple-darwin",
+              }
+          - rust: stable
+            python-version: "3.9"
+            platform:
+              {
+                os: "macos-latest",
+                python-architecture: "arm64",
+                rust-target: "aarch64-apple-darwin",
+              }
 
   valgrind:
-    if: ${{ contains(github.event.pull_request.labels.*.name, 'CI-build-full') || (github.event_name != 'pull_request' && github.ref != 'refs/heads/main') }}
+    if: ${{ contains(github.event.pull_request.labels.*.name, 'CI-build-full') || github.event_name != 'pull_request' }}
     needs: [fmt]
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
+      - uses: actions/checkout@v5
+      - uses: actions/setup-python@v6
+        with:
+          python-version: "3.13"
       - uses: Swatinem/rust-cache@v2
         with:
-          key: cargo-valgrind
-        continue-on-error: true
+          save-if: ${{ github.ref == 'refs/heads/main' || contains(github.event.pull_request.labels.*.name, 'CI-save-pr-cache') }}
       - uses: dtolnay/rust-toolchain@stable
       - uses: taiki-e/install-action@valgrind
-      - run: python -m pip install --upgrade pip && pip install nox
+      - run: python -m pip install --upgrade pip && pip install nox[uv]
       - run: nox -s test-rust -- release skip-full
     env:
       CARGO_TARGET_X86_64_UNKNOWN_LINUX_GNU_RUNNER: valgrind --leak-check=no --error-exitcode=1
@@ -313,90 +407,54 @@ jobs:
       TRYBUILD: overwrite
 
   careful:
-    if: ${{ contains(github.event.pull_request.labels.*.name, 'CI-build-full') || (github.event_name != 'pull_request' && github.ref != 'refs/heads/main') }}
+    if: ${{ contains(github.event.pull_request.labels.*.name, 'CI-build-full') || github.event_name != 'pull_request' }}
     needs: [fmt]
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
+      - uses: actions/checkout@v5
+      - uses: actions/setup-python@v6
+        with:
+          python-version: "3.13"
       - uses: Swatinem/rust-cache@v2
         with:
-          key: cargo-careful
-        continue-on-error: true
+          save-if: ${{ github.ref == 'refs/heads/main' || contains(github.event.pull_request.labels.*.name, 'CI-save-pr-cache') }}
       - uses: dtolnay/rust-toolchain@nightly
         with:
           components: rust-src
       - uses: taiki-e/install-action@cargo-careful
-      - run: python -m pip install --upgrade pip && pip install nox
+      - run: python -m pip install --upgrade pip && pip install nox[uv]
       - run: nox -s test-rust -- careful skip-full
     env:
       RUST_BACKTRACE: 1
       TRYBUILD: overwrite
 
   docsrs:
-    if: ${{ contains(github.event.pull_request.labels.*.name, 'CI-build-full') || (github.event_name != 'pull_request' && github.ref != 'refs/heads/main') }}
+    if: ${{ contains(github.event.pull_request.labels.*.name, 'CI-build-full') || github.event_name != 'pull_request' }}
     needs: [fmt]
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
+      - uses: actions/checkout@v5
+      - uses: actions/setup-python@v6
+        with:
+          python-version: "3.13"
       - uses: Swatinem/rust-cache@v2
         with:
-          key: cargo-careful
-        continue-on-error: true
+          save-if: ${{ github.ref == 'refs/heads/main' || contains(github.event.pull_request.labels.*.name, 'CI-save-pr-cache') }}
       - uses: dtolnay/rust-toolchain@nightly
         with:
           components: rust-src
-      - run: cargo rustdoc --lib --no-default-features --features full -Zunstable-options --config "build.rustdocflags=[\"--cfg\", \"docsrs\"]"
-
-  coverage:
-    needs: [fmt]
-    name: coverage-${{ matrix.os }}
-    strategy:
-      matrix:
-        os: ["windows", "macos", "ubuntu"]
-    runs-on: ${{ matrix.os }}-latest
-    steps:
-      - if: ${{ github.event_name == 'pull_request' && matrix.os != 'ubuntu' }}
-        id: should-skip
-        shell: bash
-        run: echo 'skip=true' >> $GITHUB_OUTPUT
-      - uses: actions/checkout@v4
-        if: steps.should-skip.outputs.skip != 'true'
-      - uses: actions/setup-python@v5
-        if: steps.should-skip.outputs.skip != 'true'
-      - uses: Swatinem/rust-cache@v2
-        if: steps.should-skip.outputs.skip != 'true'
-        with:
-          key: coverage-cargo-${{ matrix.os }}
-        continue-on-error: true
-      - uses: dtolnay/rust-toolchain@stable
-        if: steps.should-skip.outputs.skip != 'true'
-        with:
-          components: llvm-tools-preview,rust-src
-      - name: Install cargo-llvm-cov
-        if: steps.should-skip.outputs.skip != 'true'
-        uses: taiki-e/install-action@cargo-llvm-cov
-      - run: python -m pip install --upgrade pip && pip install nox
-        if: steps.should-skip.outputs.skip != 'true'
-      - run: nox -s coverage
-        if: steps.should-skip.outputs.skip != 'true'
-      - uses: codecov/codecov-action@v4
-        if: steps.should-skip.outputs.skip != 'true'
-        with:
-          file: coverage.json
-          name: ${{ matrix.os }}
-          token: ${{ secrets.CODECOV_TOKEN }}
+      - run: cargo rustdoc --lib --no-default-features --features full,jiff-02 -Zunstable-options --config "build.rustdocflags=[\"--cfg\", \"docsrs\"]"
 
   emscripten:
     name: emscripten
-    if: ${{ contains(github.event.pull_request.labels.*.name, 'CI-build-full') || (github.event_name != 'pull_request' && github.ref != 'refs/heads/main') }}
+    if: ${{ contains(github.event.pull_request.labels.*.name, 'CI-build-full') || github.event_name != 'pull_request' }}
+    needs: [fmt]
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
+      - uses: actions/checkout@v5
+      - uses: actions/setup-python@v6
         with:
-          # TODO bump emscripten builds to test on 3.12
+          # TODO bump emscripten builds to test on 3.13
           python-version: 3.11
         id: setup-python
       - name: Install Rust toolchain
@@ -404,42 +462,47 @@ jobs:
         with:
           targets: wasm32-unknown-emscripten
           components: rust-src
-      - uses: actions/setup-node@v4
+      - uses: actions/setup-node@v6
         with:
-          node-version: 14
-      - run: python -m pip install --upgrade pip && pip install nox
-      - uses: actions/cache@v4
+          node-version: 18
+      - run: python -m pip install --upgrade pip && pip install nox[uv]
+      - uses: actions/cache/restore@v4
         id: cache
         with:
           path: |
             .nox/emscripten
-          key: ${{ hashFiles('emscripten/*') }} - ${{ hashFiles('noxfile.py') }} - ${{ steps.setup-python.outputs.python-path }}
+          key: emscripten-${{ hashFiles('emscripten/*') }}-${{ hashFiles('noxfile.py') }}-${{ steps.setup-python.outputs.python-path }}
       - uses: Swatinem/rust-cache@v2
         with:
-          key: cargo-emscripten-wasm32
+          save-if: ${{ github.ref == 'refs/heads/main' || contains(github.event.pull_request.labels.*.name, 'CI-save-pr-cache') }}
       - name: Build
         if: steps.cache.outputs.cache-hit != 'true'
         run: nox -s build-emscripten
       - name: Test
         run: nox -s test-emscripten
+      - uses: actions/cache/save@v4
+        if: ${{ github.ref == 'refs/heads/main' || contains(github.event.pull_request.labels.*.name, 'CI-save-pr-cache') }}
+        with:
+          path: |
+            .nox/emscripten
+          key: emscripten-${{ hashFiles('emscripten/*') }}-${{ hashFiles('noxfile.py') }}-${{ steps.setup-python.outputs.python-path }}
 
   test-debug:
+    if: ${{ contains(github.event.pull_request.labels.*.name, 'CI-build-full') || github.event_name != 'pull_request' }}
     needs: [fmt]
-    if: github.ref != 'refs/heads/main'
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
       - uses: Swatinem/rust-cache@v2
         with:
-          key: cargo-test-debug
-        continue-on-error: true
+          save-if: ${{ github.ref == 'refs/heads/main' || contains(github.event.pull_request.labels.*.name, 'CI-save-pr-cache') }}
       - uses: dtolnay/rust-toolchain@stable
         with:
           components: rust-src
       - name: Install python3 standalone debug build with nox
         run: |
-          PBS_RELEASE="20231002"
-          PBS_PYTHON_VERSION="3.12.0"
+          PBS_RELEASE="20241219"
+          PBS_PYTHON_VERSION="3.13.1"
           PBS_ARCHIVE="cpython-${PBS_PYTHON_VERSION}+${PBS_RELEASE}-x86_64-unknown-linux-gnu-debug-full.tar.zst"
           wget "https://github.com/indygreg/python-build-standalone/releases/download/$%7BPBS_RELEASE%7D/$%7BPBS_ARCHIVE%7D"
           tar -I zstd -xf "${PBS_ARCHIVE}"
@@ -450,15 +513,15 @@ jobs:
           echo PYTHONHOME=$(pwd)/python/install >> $GITHUB_ENV
           echo PYO3_PYTHON=$(pwd)/python/install/bin/python3 >> $GITHUB_ENV
       - run: python3 -m sysconfig
-      - run: python3 -m pip install --upgrade pip && pip install nox
+      - run: python3 -m pip install --upgrade pip && pip install nox[uv]
       - run: |
           PYO3_CONFIG_FILE=$(mktemp)
           cat > $PYO3_CONFIG_FILE << EOF
           implementation=CPython
-          version=3.12
+          version=3.13
           shared=true
           abi3=false
-          lib_name=python3.12d
+          lib_name=python3.13d
           lib_dir=${{ github.workspace }}/python/install/lib
           executable=${{ github.workspace }}/python/install/bin/python3
           pointer_width=64
@@ -470,16 +533,190 @@ jobs:
 
   test-version-limits:
     needs: [fmt]
-    if: ${{ contains(github.event.pull_request.labels.*.name, 'CI-build-full') || (github.event_name != 'pull_request' && github.ref != 'refs/heads/main') }}
+    if: ${{ contains(github.event.pull_request.labels.*.name, 'CI-build-full') || github.event_name != 'pull_request' }}
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
+      - uses: actions/setup-python@v6
+        with:
+          python-version: "3.13"
       - uses: Swatinem/rust-cache@v2
-        continue-on-error: true
+        with:
+          save-if: ${{ github.ref == 'refs/heads/main' || contains(github.event.pull_request.labels.*.name, 'CI-save-pr-cache') }}
       - uses: dtolnay/rust-toolchain@stable
-      - run: python3 -m pip install --upgrade pip && pip install nox
+      - run: python3 -m pip install --upgrade pip && pip install nox[uv]
       - run: python3 -m nox -s test-version-limits
 
+  check-feature-powerset:
+    needs: [fmt, resolve]
+    if: ${{ contains(github.event.pull_request.labels.*.name, 'CI-build-full') || github.event_name != 'pull_request' }}
+    runs-on: ubuntu-latest
+    name: check-feature-powerset ${{ matrix.rust }}
+    strategy:
+      # run on stable and MSRV to check that all combinations of features are expected to build fine on our supported
+      # range of compilers
+      matrix:
+        rust: ["stable"]
+        include:
+          - rust: ${{ needs.resolve.outputs.MSRV }}
+    steps:
+      - uses: actions/checkout@v5
+      - uses: actions/setup-python@v6
+        with:
+          python-version: "3.13"
+      - uses: Swatinem/rust-cache@v2
+        with:
+          save-if: ${{ github.ref == 'refs/heads/main' || contains(github.event.pull_request.labels.*.name, 'CI-save-pr-cache') }}
+      - uses: dtolnay/rust-toolchain@master
+        with:
+          toolchain: stable
+      - uses: taiki-e/install-action@v2
+        with:
+          tool: cargo-hack,cargo-minimal-versions
+      - run: python3 -m pip install --upgrade pip && pip install nox[uv]
+      - run: python3 -m nox -s check-feature-powerset -- ${{ matrix.rust != 'stable' && 'minimal-versions' || '' }}
+
+  test-cross-compilation:
+    needs: [fmt]
+    if: ${{ contains(github.event.pull_request.labels.*.name, 'CI-build-full') || github.event_name != 'pull_request' }}
+    runs-on: ${{ matrix.os }}
+    name: test-cross-compilation ${{ matrix.os }} -> ${{ matrix.target }}
+    strategy:
+      # If one platform fails, allow the rest to keep testing if `CI-no-fail-fast` label is present
+      fail-fast: ${{ !contains(github.event.pull_request.labels.*.name, 'CI-no-fail-fast') }}
+      matrix:
+        include:
+          # ubuntu "cross compile" to itself
+          - os: "ubuntu-latest"
+            target: "x86_64-unknown-linux-gnu"
+            flags: "-i python3.13"
+            manylinux: auto
+          # ubuntu x86_64 -> aarch64
+          - os: "ubuntu-latest"
+            target: "aarch64-unknown-linux-gnu"
+            flags: "-i python3.13"
+            manylinux: auto
+          # ubuntu x86_64 -> windows x86_64
+          - os: "ubuntu-latest"
+            target: "x86_64-pc-windows-gnu"
+            flags: "-i python3.13 --features generate-import-lib"
+          # windows x86_64 -> aarch64
+          - os: "windows-latest"
+            target: "aarch64-pc-windows-msvc"
+            flags: "-i python3.13 --features generate-import-lib"
+    steps:
+      - uses: actions/checkout@v5
+      - uses: actions/setup-python@v6
+        with:
+          python-version: "3.13"
+      - uses: Swatinem/rust-cache@v2
+        with:
+          workspaces: examples/maturin-starter
+          save-if: ${{ github.ref == 'refs/heads/main' || contains(github.event.pull_request.labels.*.name, 'CI-save-pr-cache') }}
+          key: ${{ matrix.target }}
+      - name: Setup cross-compiler
+        if: ${{ matrix.target == 'x86_64-pc-windows-gnu' }}
+        run: sudo apt-get install -y mingw-w64 llvm
+      - name: Compile version-specific library
+        uses: PyO3/maturin-action@v1
+        with:
+          target: ${{ matrix.target }}
+          manylinux: ${{ matrix.manylinux }}
+          args: --release -m examples/maturin-starter/Cargo.toml ${{ matrix.flags }}
+      - name: Compile abi3 library
+        uses: PyO3/maturin-action@v1
+        with:
+          target: ${{ matrix.target }}
+          manylinux: ${{ matrix.manylinux }}
+          args: --release -m examples/maturin-starter/Cargo.toml --features abi3 ${{ matrix.flags }}
+
+  test-cross-compilation-windows:
+    needs: [fmt]
+    if: ${{ contains(github.event.pull_request.labels.*.name, 'CI-build-full') || github.event_name != 'pull_request' }}
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+      - uses: actions/setup-python@v6
+        with:
+          python-version: "3.13"
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          targets: x86_64-pc-windows-gnu,x86_64-pc-windows-msvc
+          components: rust-src
+      # load cache (prepared in ci-cache-warmup.yml)
+      - uses: actions/cache/restore@v4
+        with:
+          path: ~/.cache/cargo-xwin
+          key: cargo-xwin-cache
+      - name: Test cross compile to Windows
+        run: |
+          set -ex
+          sudo apt-get install -y mingw-w64 llvm
+          pip install nox
+          nox -s test-cross-compilation-windows
+
+  test-introspection:
+    needs: [fmt]
+    if: ${{ contains(github.event.pull_request.labels.*.name, 'CI-test-introspection') || contains(github.event.pull_request.labels.*.name, 'CI-build-full') || github.event_name != 'pull_request' }}
+    strategy:
+      matrix:
+        platform:
+          [
+            {
+              os: "macos-latest",
+              python-architecture: "arm64",
+              rust-target: "aarch64-apple-darwin",
+            },
+            {
+              os: "ubuntu-latest",
+              python-architecture: "x64",
+              rust-target: "x86_64-unknown-linux-gnu",
+            },
+            {
+              os: "windows-latest",
+              python-architecture: "x64",
+              rust-target: "x86_64-pc-windows-msvc",
+            },
+            {
+              os: "windows-latest",
+              python-architecture: "x86",
+              rust-target: "i686-pc-windows-msvc",
+            },
+          ]
+    runs-on: ${{ matrix.platform.os }}
+    steps:
+      - uses: actions/checkout@v5
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          targets: ${{ matrix.platform.rust-target }}
+          components: rust-src
+      - uses: actions/setup-python@v6
+        with:
+          python-version: "3.13"
+          architecture: ${{ matrix.platform.python-architecture }}
+      - uses: Swatinem/rust-cache@v2
+        with:
+          save-if: ${{ github.ref == 'refs/heads/main' || contains(github.event.pull_request.labels.*.name, 'CI-save-pr-cache') }}
+      - run: python -m pip install --upgrade pip && pip install nox[uv]
+      - run: nox -s test-introspection
+    env:
+      CARGO_BUILD_TARGET: ${{ matrix.platform.rust-target }}
+
+  test-introspection-pr:
+    needs: [fmt]
+    if: ${{ !contains(github.event.pull_request.labels.*.name, 'CI-build-full') && github.event_name == 'pull_request' }}
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          components: rust-src
+      - uses: actions/setup-python@v6
+        with:
+          python-version: "3.13"
+      - run: python -m pip install --upgrade pip && pip install nox[uv]
+      - run: nox -s test-introspection
+
   conclusion:
     needs:
       - fmt
@@ -490,10 +727,13 @@ jobs:
       - valgrind
       - careful
       - docsrs
-      - coverage
       - emscripten
       - test-debug
       - test-version-limits
+      - check-feature-powerset
+      - test-cross-compilation
+      - test-cross-compilation-windows
+      - test-introspection
     if: always()
     runs-on: ubuntu-latest
     steps:
diff --git a/.github/workflows/coverage-pr-base.yml b/.github/workflows/coverage-pr-base.yml
new file mode 100644
index 00000000000..7b21b399266
--- /dev/null
+++ b/.github/workflows/coverage-pr-base.yml
@@ -0,0 +1,33 @@
+# This runs as a separate job because it needs to run on the `pull_request_target` event
+# in order to access the CODECOV_TOKEN secret.
+#
+# This is safe because this doesn't run arbitrary code from PRs.
+
+name: Set Codecov PR base
+on:
+  # See safety note / doc at the top of this file.
+  pull_request_target:
+
+jobs:
+  coverage-pr-base:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+      - uses: actions/setup-python@v6
+        with:
+          python-version: '3.13'
+      - name: Fetch merge base
+        id: fetch_merge_base
+        uses: ./.github/actions/fetch-merge-base
+        with:
+          base_ref: "refs/heads/${{ github.event.pull_request.base.ref }}"
+          head_ref: "refs/pull/${{ github.event.pull_request.number }}/head"
+      - name: Set PR base on codecov
+        run: |
+          pip install codecov-cli
+          codecovcli pr-base-picking \
+            --base-sha ${{ steps.fetch_merge_base.outputs.merge_base }} \
+            --pr ${{ github.event.number }} \
+            --slug PyO3/pyo3 \
+            --token ${{ secrets.CODECOV_TOKEN }} \
+            --service github
diff --git a/.github/workflows/gh-pages.yml b/.github/workflows/gh-pages.yml
deleted file mode 100644
index ec8874d5841..00000000000
--- a/.github/workflows/gh-pages.yml
+++ /dev/null
@@ -1,139 +0,0 @@
-name: gh-pages
-
-on:
-  push:
-    branches:
-      - main
-  pull_request:
-  release:
-    types: [published]
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.sha }}
-  cancel-in-progress: true
-
-env:
-  CARGO_TERM_COLOR: always
-
-jobs:
-  guide-build:
-    runs-on: ubuntu-latest
-    outputs:
-      tag_name: ${{ steps.prepare_tag.outputs.tag_name }}
-    steps:
-      - uses: actions/checkout@v4
-
-      - uses: dtolnay/rust-toolchain@nightly
-
-      - name: Setup mdBook
-        uses: peaceiris/actions-mdbook@v1
-        with:
-          mdbook-version: "0.4.19"
-
-      - name: Prepare tag
-        id: prepare_tag
-        run: |
-          TAG_NAME="${GITHUB_REF##*/}"
-          echo "::set-output name=tag_name::${TAG_NAME}"
-
-      # This builds the book in target/guide.
-      - name: Build the guide
-        run: |
-          python -m pip install --upgrade pip && pip install nox
-          nox -s build-guide
-        env:
-          PYO3_VERSION_TAG: ${{ steps.prepare_tag.outputs.tag_name }}
-
-      - name: Deploy docs and the guide
-        if: ${{ github.event_name == 'release' }}
-        uses: peaceiris/actions-gh-pages@v3
-        with:
-          github_token: ${{ secrets.GITHUB_TOKEN }}
-          publish_dir: ./target/guide/
-          destination_dir: ${{ steps.prepare_tag.outputs.tag_name }}
-          full_commit_message: "Upload documentation for ${{ steps.prepare_tag.outputs.tag_name }}"
-
-  cargo-benchmark:
-    if: ${{ github.ref_name == 'main' }}
-    name: Cargo benchmark
-    needs: guide-build
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
-      - uses: dtolnay/rust-toolchain@stable
-
-      - uses: actions/cache@v4
-        with:
-          path: |
-            ~/.cargo/registry
-            ~/.cargo/git
-            target
-          key: cargo-${{ runner.os }}-bench-${{ hashFiles('**/Cargo.toml') }}
-        continue-on-error: true
-
-      - name: Run benchmarks
-        run: |
-          python -m pip install --upgrade pip && pip install nox
-          for bench in pyo3-benches/benches/*.rs; do
-            bench_name=$(basename "$bench" .rs)
-            nox -s bench -- --bench "$bench_name" -- --output-format bencher | tee -a output.txt
-          done
-
-      # Download previous benchmark result from cache (if exists)
-      - name: Download previous benchmark data
-        uses: actions/cache@v4
-        with:
-          path: ./cache
-          key: ${{ runner.os }}-benchmark
-
-      # Run `github-action-benchmark` action
-      - name: Store benchmark result
-        uses: benchmark-action/github-action-benchmark@v1
-        with:
-          name: pyo3-bench
-          # What benchmark tool the output.txt came from
-          tool: "cargo"
-          # Where the output from the benchmark tool is stored
-          output-file-path: output.txt
-          # GitHub API token to make a commit comment
-          github-token: ${{ secrets.GITHUB_TOKEN }}
-          auto-push: ${{ github.event_name != 'pull_request' }}
-
-  pytest-benchmark:
-    if: ${{ github.ref_name == 'main' }}
-    name: Pytest benchmark
-    needs: cargo-benchmark
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
-      - uses: dtolnay/rust-toolchain@stable
-
-      - uses: actions/cache@v4
-        with:
-          path: |
-            ~/.cargo/registry
-            ~/.cargo/git
-            target
-          key: cargo-${{ runner.os }}-pytest-bench-${{ hashFiles('**/Cargo.toml') }}
-        continue-on-error: true
-
-      - name: Download previous benchmark data
-        uses: actions/cache@v4
-        with:
-          path: ./cache
-          key: ${{ runner.os }}-pytest-benchmark
-
-      - name: Run benchmarks
-        run: |
-          python -m pip install --upgrade pip && pip install nox
-          nox -f pytests/noxfile.py -s bench -- --benchmark-json $(pwd)/output.json
-      - name: Store benchmark result
-        uses: benchmark-action/github-action-benchmark@v1
-        with:
-          name: pytest-bench
-          tool: "pytest"
-          output-file-path: output.json
-          github-token: ${{ secrets.GITHUB_TOKEN }}
-          auto-push: ${{ github.event_name != 'pull_request' }}
diff --git a/.github/workflows/netlify-build.yml b/.github/workflows/netlify-build.yml
new file mode 100644
index 00000000000..6150af3db24
--- /dev/null
+++ b/.github/workflows/netlify-build.yml
@@ -0,0 +1,78 @@
+name: netlify-build
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+  release:
+    types: [published]
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.sha }}
+  cancel-in-progress: true
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  guide-build:
+    runs-on: ubuntu-latest
+    outputs:
+      tag_name: ${{ steps.prepare_tag.outputs.tag_name }}
+    steps:
+      - uses: actions/checkout@v5
+      - uses: actions/setup-python@v6
+        with:
+          python-version: "3.13"
+
+      - uses: dtolnay/rust-toolchain@nightly
+
+      - name: Setup mdBook
+        uses: taiki-e/install-action@v2
+        with:
+          tool: mdbook, mdbook-linkcheck, lychee
+
+      - name: Prepare tag
+        id: prepare_tag
+        run: |
+          TAG_NAME="${GITHUB_REF##*/}"
+          echo "tag_name=${TAG_NAME}" >> $GITHUB_OUTPUT
+
+      # This builds the book in target/guide/.
+      - name: Build the guide
+        run: |
+          python -m pip install --upgrade pip && pip install nox[uv]
+          nox -s ${{ github.event_name == 'release' && 'build-guide' || 'check-guide' }}
+        env:
+          PYO3_VERSION_TAG: ${{ steps.prepare_tag.outputs.tag_name }}
+          # allows lychee to get better rate limits from github
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      # We store the versioned guides on GitHub's gh-pages branch for convenience
+      # (the full gh-pages branch is pulled in the build-netlify-site step)
+      - name: Deploy the guide
+        if: ${{ github.event_name == 'release' }}
+        uses: peaceiris/actions-gh-pages@v4
+        with:
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          publish_dir: ./target/guide/
+          destination_dir: ${{ steps.prepare_tag.outputs.tag_name }}
+          full_commit_message: "Upload documentation for ${{ steps.prepare_tag.outputs.tag_name }}"
+
+      - name: Get current PyO3 version
+        run: |
+          PYO3_VERSION=$(cargo search pyo3 --limit 1 | head -1 | tr -s ' ' | cut -d ' ' -f 3 | tr -d '"')
+          echo "PYO3_VERSION=${PYO3_VERSION}" >> $GITHUB_ENV
+
+      - name: Build the site
+        run: |
+          python -m pip install --upgrade pip && pip install nox[uv] towncrier requests
+          nox -s build-netlify-site -- ${{ (github.ref != 'refs/heads/main' && '--preview') || '' }}
+
+      # Upload the built site as an artifact for deploy workflow to consume
+      - name: Upload Build Artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: site
+          path: ./netlify_build
diff --git a/.github/workflows/netlify-deploy.yml b/.github/workflows/netlify-deploy.yml
new file mode 100644
index 00000000000..0985e3a6584
--- /dev/null
+++ b/.github/workflows/netlify-deploy.yml
@@ -0,0 +1,69 @@
+# This runs as a separate job because it needs to run on the `workflow_run` event
+# in order to access the netlify secrets.
+#
+# This is safe because this doesn't run arbitrary code from PRs.
+
+name: netlify-deploy
+
+on:
+  workflow_run:
+    workflows: ["netlify-build"]
+    types:
+      - completed
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    if: github.event.workflow_run.conclusion == 'success'
+    environment: netlify
+
+    steps:
+      - name: Download Build Artifact
+        uses: actions/download-artifact@v5
+        with:
+          name: site
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          run-id: ${{ github.event.workflow_run.id }}
+
+      - name: Install netlify-cli
+        run: |
+          npm install -g netlify-cli
+
+      - name: Deploy to Netlify
+        run: |
+          ls -la
+          DEBUG=* netlify deploy \
+              --site ${{ secrets.NETLIFY_SITE_ID }} \
+              --auth ${{ secrets.NETLIFY_TOKEN }} \
+              ${{ ((github.event.workflow_run.head_repository.full_name == 'PyO3/pyo3') && (github.event.workflow_run.head_branch == 'main') && '--prod') || '' }} \
+              --json | tee deploy_output.json
+
+      # credit: https://www.raulmelo.me/en/blog/deploying-netlify-github-actions-guide
+      - name: Generate URL Preview
+        id: url_preview
+        if: ${{ github.event.workflow_run.event == 'pull_request' }}
+        run: |
+          NETLIFY_PREVIEW_URL=$(jq -r '.deploy_url' deploy_output.json)
+          echo "NETLIFY_PREVIEW_URL=$NETLIFY_PREVIEW_URL" >> "$GITHUB_OUTPUT"
+
+      - name: Post Netlify Preview Status to PR
+        if: ${{ github.event.workflow_run.event == 'pull_request' }}
+        uses: actions/github-script@v8
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          script: |
+            const previewUrl = '${{ steps.url_preview.outputs.NETLIFY_PREVIEW_URL }}';
+            const commitSha = '${{ github.event.workflow_run.head_sha }}';
+
+            await github.rest.repos.createCommitStatus({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              sha: commitSha,
+              state: 'success',
+              target_url: previewUrl,
+              description: 'click to view Netlify preview deploy',
+              context: 'netlify-deploy / preview'
+            });
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
new file mode 100644
index 00000000000..d7642ab10b5
--- /dev/null
+++ b/.github/workflows/release.yml
@@ -0,0 +1,34 @@
+name: Release Rust Crate
+
+on:
+  push:
+    tags:
+      - "v*"
+  workflow_dispatch:
+    inputs:
+      version:
+        description: The version to build
+
+jobs:
+  release:
+    permissions:
+      id-token: write
+
+    runs-on: ubuntu-latest
+    environment: release
+    steps:
+      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        with:
+          # The tag to build or the tag received by the tag event
+          ref: ${{ github.event.inputs.version || github.ref }}
+          persist-credentials: false
+
+      - uses: astral-sh/setup-uv@v7
+
+      - uses: rust-lang/crates-io-auth-action@v1
+        id: auth
+
+      - name: Publish to crates.io
+        run: uvx nox -s publish
+        env:
+          CARGO_REGISTRY_TOKEN: ${{ steps.auth.outputs.token }}
diff --git a/.gitignore b/.gitignore
index 4240d326f71..da64603db5f 100644
--- a/.gitignore
+++ b/.gitignore
@@ -14,6 +14,8 @@ dist/
 .eggs/
 venv*
 guide/book/
+guide/src/LICENSE-APACHE
+guide/src/LICENSE-MIT
 *.so
 *.out
 *.egg-info
@@ -22,5 +24,7 @@ pip-wheel-metadata
 valgrind-python.supp
 *.pyd
 lcov.info
+coverage.json
 netlify_build/
 .nox/
+.vscode/
diff --git a/.netlify/build.sh b/.netlify/build.sh
index 10ec241c1d7..dedacb28fb3 100755
--- a/.netlify/build.sh
+++ b/.netlify/build.sh
@@ -2,6 +2,7 @@
 
 set -uex
 
+rustup update nightly
 rustup default nightly
 
 PYO3_VERSION=$(cargo search pyo3 --limit 1 | head -1 | tr -s ' ' | cut -d ' ' -f 3 | tr -d '"')
@@ -48,6 +49,15 @@ done
 # Add latest redirect
 echo "/latest/* /v${PYO3_VERSION}/:splat 302" >> netlify_build/_redirects
 
+# some backwards compatbiility redirects
+echo "/latest/building_and_distribution/* /latest/building-and-distribution/:splat 302" >> netlify_build/_redirects
+echo "/latest/building-and-distribution/multiple_python_versions/* /latest/building-and-distribution/multiple-python-versions:splat 302" >> netlify_build/_redirects
+echo "/latest/function/error_handling/* /latest/function/error-handling/:splat 302" >> netlify_build/_redirects
+echo "/latest/getting_started/* /latest/getting-started/:splat 302" >> netlify_build/_redirects
+echo "/latest/python_from_rust/* /latest/python-from-rust/:splat 302" >> netlify_build/_redirects
+echo "/latest/python_typing_hints/* /latest/python-typing-hints/:splat 302" >> netlify_build/_redirects
+echo "/latest/trait_bounds/* /latest/trait-bounds/:splat 302" >> netlify_build/_redirects
+
 ## Add landing page redirect
 if [ "${CONTEXT}" == "deploy-preview" ]; then
     echo "/ /main/" >> netlify_build/_redirects
@@ -71,9 +81,25 @@ if [ "${INSTALLED_MDBOOK_VERSION}" != "mdbook v${MDBOOK_VERSION}" ]; then
     cargo install mdbook@${MDBOOK_VERSION} --force
 fi
 
-pip install nox
+# Install latest mdbook-linkcheck. Netlify will cache the cargo bin dir, so this will
+# only build mdbook-linkcheck if needed.
+MDBOOK_LINKCHECK_VERSION=$(cargo search mdbook-linkcheck --limit 1 | head -1 | tr -s ' ' | cut -d ' ' -f 3 | tr -d '"')
+INSTALLED_MDBOOK_LINKCHECK_VERSION=$(mdbook-linkcheck --version || echo "none")
+if [ "${INSTALLED_MDBOOK_LINKCHECK_VERSION}" != "mdbook v${MDBOOK_LINKCHECK_VERSION}" ]; then
+    cargo install mdbook-linkcheck@${MDBOOK_LINKCHECK_VERSION} --force
+fi
+
+# Install latest mdbook-tabs. Netlify will cache the cargo bin dir, so this will
+# only build mdbook-tabs if needed.
+MDBOOK_TABS_VERSION=$(cargo search mdbook-tabs --limit 1 | head -1 | tr -s ' ' | cut -d ' ' -f 3 | tr -d '"')
+INSTALLED_MDBOOK_TABS_VERSION=$(mdbook-tabs --version || echo "none")
+if [ "${INSTALLED_MDBOOK_TABS_VERSION}" != "mdbook-tabs v${MDBOOK_TABS_VERSION}" ]; then
+    cargo install mdbook-tabs@${MDBOOK_TABS_VERSION} --force
+fi
+
+pip install nox[uv]
 nox -s build-guide
-mv target/guide netlify_build/main/
+mv target/guide/ netlify_build/main/
 
 ## Build public docs
 
diff --git a/.netlify/redirect.sh b/.netlify/redirect.sh
new file mode 100644
index 00000000000..46d2dbeedef
--- /dev/null
+++ b/.netlify/redirect.sh
@@ -0,0 +1,49 @@
+# Add redirect for each documented version
+set +x  # these loops get very spammy and fill the deploy log
+
+for d in netlify_build/v*; do
+    version="${d/netlify_build\/v/}"
+    echo "/v$version/doc/* https://docs.rs/pyo3/$version/:splat" >> netlify_build/_redirects
+    if [ $version != $PYO3_VERSION ]; then
+        # for old versions, mark the files in the latest version as the canonical URL
+        for file in $(find $d -type f); do
+            file_path="${file/$d\//}"
+            # remove index.html and/or .html suffix to match the page URL on the
+            # final netlfiy site
+            url_path="$file_path"
+            if [[ $file_path == index.html ]]; then
+                url_path=""
+            elif [[ $file_path == *.html ]]; then
+                url_path="${file_path%.html}"
+            fi
+            echo "/v$version/$url_path" >> netlify_build/_headers
+            if test -f "netlify_build/v$PYO3_VERSION/$file_path"; then
+                echo "  Link: <https://pyo3.rs/v$PYO3_VERSION/$url_path>; rel=\"canonical\"" >> netlify_build/_headers
+            else
+                # this file doesn't exist in the latest guide, don't index it
+                echo "  X-Robots-Tag: noindex" >> netlify_build/_headers
+            fi
+        done
+    fi
+done
+
+# Add latest redirect
+echo "/latest/* /v${PYO3_VERSION}/:splat 302" >> netlify_build/_redirects
+
+# some backwards compatbiility redirects
+echo "/latest/building_and_distribution/* /latest/building-and-distribution/:splat 302" >> netlify_build/_redirects
+echo "/latest/building-and-distribution/multiple_python_versions/* /latest/building-and-distribution/multiple-python-versions:splat 302" >> netlify_build/_redirects
+echo "/latest/function/error_handling/* /latest/function/error-handling/:splat 302" >> netlify_build/_redirects
+echo "/latest/getting_started/* /latest/getting-started/:splat 302" >> netlify_build/_redirects
+echo "/latest/python_from_rust/* /latest/python-from-rust/:splat 302" >> netlify_build/_redirects
+echo "/latest/python_typing_hints/* /latest/python-typing-hints/:splat 302" >> netlify_build/_redirects
+echo "/latest/trait_bounds/* /latest/trait-bounds/:splat 302" >> netlify_build/_redirects
+
+## Add landing page redirect
+if [ "${CONTEXT}" == "deploy-preview" ]; then
+    echo "/ /main/" >> netlify_build/_redirects
+else
+    echo "/ /v${PYO3_VERSION}/ 302" >> netlify_build/_redirects
+fi
+
+set -x
\ No newline at end of file
diff --git a/.python-version b/.python-version
deleted file mode 100644
index e4fba218358..00000000000
--- a/.python-version
+++ /dev/null
@@ -1 +0,0 @@
-3.12
diff --git a/Architecture.md b/Architecture.md
index 9ec20931c10..2b081a487e4 100644
--- a/Architecture.md
+++ b/Architecture.md
@@ -37,18 +37,15 @@ automated tooling because:
   - it gives us best control about how to adapt C conventions to Rust, and
   - there are many Python interpreter versions we support in a single set of files.
 
-We aim to provide straight-forward Rust wrappers resembling the file structure of
-[`cpython/Include`](https://github.com/python/cpython/tree/v3.9.2/Include).
+We aim to provide straight-forward Rust wrappers resembling the file structure of [`cpython/Include`](https://github.com/python/cpython/tree/main/Include).
 
-However, we still lack some APIs and are continuously updating the module to match
-the file contents upstream in CPython.
-The tracking issue is [#1289](https://github.com/PyO3/pyo3/issues/1289), and contribution is welcome.
+We are continuously updating the module to match the latest CPython version which PyO3 supports (i.e. as of time of writing Python 3.13). The tracking issue is [#1289](https://github.com/PyO3/pyo3/issues/1289), and contribution is welcome.
 
 In the [`pyo3-ffi`] crate, there is lots of conditional compilation such as `#[cfg(Py_LIMITED_API)]`,
 `#[cfg(Py_3_7)]`, and `#[cfg(PyPy)]`.
 `Py_LIMITED_API` corresponds to `#define Py_LIMITED_API` macro in Python/C API.
 With `Py_LIMITED_API`, we can build a Python-version-agnostic binary called an
-[abi3 wheel](https://pyo3.rs/latest/building_and_distribution.html#py_limited_apiabi3).
+[abi3 wheel](https://pyo3.rs/latest/building-and-distribution.html#py_limited_apiabi3).
 `Py_3_7` means that the API is available from Python >= 3.7.
 There are also `Py_3_8`, `Py_3_9`, and so on.
 `PyPy` means that the API definition is for PyPy.
@@ -59,6 +56,7 @@ Those flags are set in [`build.rs`](#6-buildrs-and-pyo3-build-config).
 [`src/types`] contains bindings to [built-in types](https://docs.python.org/3/library/stdtypes.html)
 of Python, such as `dict` and `list`.
 For historical reasons, Python's `object` is called `PyAny` in PyO3 and located in [`src/types/any.rs`].
+
 Currently, `PyAny` is a straightforward wrapper of `ffi::PyObject`, defined as:
 
 ```rust
@@ -66,38 +64,16 @@ Currently, `PyAny` is a straightforward wrapper of `ffi::PyObject`, defined as:
 pub struct PyAny(UnsafeCell<ffi::PyObject>);
 ```
 
-All built-in types are defined as a C struct.
-For example, `dict` is defined as:
-
-```c
-typedef struct {
-    /* Base object */
-    PyObject ob_base;
-    /* Number of items in the dictionary */
-    Py_ssize_t ma_used;
-    /* Dictionary version */
-    uint64_t ma_version_tag;
-    PyDictKeysObject *ma_keys;
-    PyObject **ma_values;
-} PyDictObject;
-```
-
-However, we cannot access such a specific data structure with `#[cfg(Py_LIMITED_API)]` set.
-Thus, all builtin objects are implemented as opaque types by wrapping `PyAny`, e.g.,:
+Concrete Python objects are implemented by wrapping `PyAny`, e.g.,:
 
 ```rust
 #[repr(transparent)]
 pub struct PyDict(PyAny);
 ```
 
-Note that `PyAny` is not a pointer, and it is usually used as a pointer to the object in the
-Python heap, as `&PyAny`.
-This design choice can be changed
-(see the discussion in [#1056](https://github.com/PyO3/pyo3/issues/1056)).
+These types are not intended to be accessed directly, and instead are used through the `Py<T>` and `Bound<T>` smart pointers.
 
-Since we need lots of boilerplate for implementing common traits for these types
-(e.g., `AsPyPointer`, `AsRef<PyAny>`, and `Debug`), we have some macros in
-[`src/types/mod.rs`].
+We have some macros in [`src/types/mod.rs`] which make it easier to implement APIs for concrete Python types.
 
 ## 3. `PyClass` and related functionalities
 
@@ -109,23 +85,23 @@ To realize object-oriented programming in C, all Python objects have `ob_base: P
 first field in their structure definition. Thanks to this guarantee, casting `*mut A` to `*mut PyObject`
 is valid if `A` is a Python object.
 
-To ensure this guarantee, we have a wrapper struct `PyCell<T>` in [`src/pycell.rs`] which is roughly:
+To ensure this guarantee, we have a wrapper struct `PyClassObject<T>` in [`src/pycell/impl_.rs`] which is roughly:
 
 ```rust
 #[repr(C)]
-pub struct PyCell<T: PyClass> {
+pub struct PyClassObject<T> {
     ob_base: crate::ffi::PyObject,
     inner: T,
 }
 ```
 
-Thus, when copying a Rust struct to a Python object, we first allocate `PyCell` on the Python heap and then
+Thus, when copying a Rust struct to a Python object, we first allocate `PyClassObject` on the Python heap and then
 move `T` into it.
-Also, `PyCell` provides [RefCell](https://doc.rust-lang.org/std/cell/struct.RefCell.html)-like methods
-to ensure Rust's borrow rules.
-See [the documentation](https://docs.rs/pyo3/latest/pyo3/pycell/struct.PyCell.html) for more.
 
-`PyCell<T>` requires that `T` implements `PyClass`.
+The primary way to interact with Python objects implemented in Rust is through the `Bound<'py, T>` smart pointer.
+By having the `'py` lifetime of the `Python<'py>` token, this ties the lifetime of the `Bound<'py, T>` smart pointer to the lifetime for which the thread is attached to the Python interpreter and allows PyO3 to call Python APIs at maximum efficiency.
+
+`Bound<'py, T>` requires that `T` implements `PyClass`.
 This trait is somewhat complex and derives many traits, but the most important one is `PyTypeInfo`
 in [`src/type_object.rs`].
 `PyTypeInfo` is also implemented for built-in types.
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 9104db2921f..2872fac91a0 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -10,6 +10,747 @@ To see unreleased changes, please see the [CHANGELOG on the main branch guide](h
 
 <!-- towncrier release notes start -->
 
+## [0.27.0] - 2025-10-19
+
+### Packaging
+
+- Extend range of supported versions of `hashbrown` optional dependency to include version 0.16. [#5428](https://github.com/PyO3/pyo3/pull/5428)
+- Bump optional `num-bigint` dependency minimum version to 0.4.4. [#5471](https://github.com/PyO3/pyo3/pull/5471)
+- Test against Python 3.14 final release. [#5499](https://github.com/PyO3/pyo3/pull/5499)
+- Drop support for PyPy 3.9 and 3.10. [#5516](https://github.com/PyO3/pyo3/pull/5516)
+- Provide a better error message when building an outdated PyO3 for a too-new Python version. [#5519](https://github.com/PyO3/pyo3/pull/5519)
+
+### Added
+
+- Add `FromPyObjectOwned` as convenient trait bound for `FromPyObject` when the data is not borrowed from Python. [#4390](https://github.com/PyO3/pyo3/pull/4390)
+- Add `Borrowed::extract`, same as `PyAnyMethods::extract`, but does not restrict the lifetime by deref. [#4390](https://github.com/PyO3/pyo3/pull/4390)
+- `experimental-inspect`: basic support for `#[derive(IntoPyObject)]` (no struct fields support yet). [#5365](https://github.com/PyO3/pyo3/pull/5365)
+- `experimental-inspect`: support `#[pyo3(get, set)]` and `#[pyclass(get_all, set_all)]`. [#5370](https://github.com/PyO3/pyo3/pull/5370)
+- Add `PyTypeCheck::classinfo_object` that returns an object that can be used as parameter in `isinstance` or `issubclass`. [#5387](https://github.com/PyO3/pyo3/pull/5387)
+- Implement `PyTypeInfo` on `datetime.*` types even when the limited API is enabled. [#5388](https://github.com/PyO3/pyo3/pull/5388)
+- Implement `PyTypeInfo` on `PyIterator`, `PyMapping` and `PySequence`. [#5402](https://github.com/PyO3/pyo3/pull/5402)
+- Implement `PyTypeInfo` on `PyCode` when using the stable ABI. [#5403](https://github.com/PyO3/pyo3/pull/5403)
+- Implement `PyTypeInfo` on `PyWeakrefReference` when using the stable ABI. [#5404](https://github.com/PyO3/pyo3/pull/5404)
+- Add `pyo3::sync::RwLockExt` trait, analogous to `pyo3::sync::MutexExt` for readwrite locks. [#5435](https://github.com/PyO3/pyo3/pull/5435)
+- Add `PyString::from_bytes`. [#5437](https://github.com/PyO3/pyo3/pull/5437)
+- Implement `AsRef<[u8]>` for `PyBytes`. [#5445](https://github.com/PyO3/pyo3/pull/5445)
+- Add `CastError` and `CastIntoError`. [#5468](https://github.com/PyO3/pyo3/pull/5468)
+- Add `PyCapsuleMethods::pointer_checked` and `PyCapsuleMethods::is_valid_checked`. [#5474](https://github.com/PyO3/pyo3/pull/5474)
+- Add `Borrowed::cast`, `Borrowed::cast_exact` and `Borrowed::cast_unchecked`. [#5475](https://github.com/PyO3/pyo3/pull/5475)
+- Add conversions for `jiff::civil::ISOWeekDate`. [#5478](https://github.com/PyO3/pyo3/pull/5478)
+- Add conversions for `&Cstr`, `Cstring` and `Cow<Cstr>`. [#5482](https://github.com/PyO3/pyo3/pull/5482)
+- add `#[pyclass(skip_from_py_object)]` option, to opt-out of the `FromPyObject: PyClass + Clone` blanket impl. [#5488](https://github.com/PyO3/pyo3/pull/5488)
+- Add `PyErr::add_note`. [#5489](https://github.com/PyO3/pyo3/pull/5489)
+- Add `FromPyObject` impl for `Cow<Path>` & `Cow<OsStr>`. [#5497](https://github.com/PyO3/pyo3/pull/5497)
+- Add `#[pyclass(from_py_object)]` pyclass option, to opt-in to the extraction of pyclasses by value (requires `Clone`). [#5506](https://github.com/PyO3/pyo3/pull/5506)
+
+### Changed
+
+- Rework `FromPyObject` trait for flexibility and performance: [#4390](https://github.com/PyO3/pyo3/pull/4390)
+  - Add a second lifetime to `FromPyObject`, to allow borrowing data from Python objects (e.g. `&str` from Python `str`).
+  - Replace `extract_bound` with `extract`, which takes `Borrowed<'a, 'py, PyAny>`.
+- Optimize `FromPyObject` implementations for `Vec<u8>` and `[u8; N]` from `bytes` and `bytearray`. [#5244](https://github.com/PyO3/pyo3/pull/5244)
+- Deprecate `#[pyfn]` attribute. [#5384](https://github.com/PyO3/pyo3/pull/5384)
+- Fetch type name dynamically on cast errors instead of using `PyTypeCheck::NAME`. [#5387](https://github.com/PyO3/pyo3/pull/5387)
+- Deprecate `PyTypeCheck::NAME` in favour of `PyTypeCheck::classinfo_object` which provides the type information at runtime. [#5387](https://github.com/PyO3/pyo3/pull/5387)
+- `PyClassGuard(Mut)` and `PyRef(Mut)` extraction now returns an opaque Rust error [#5413](https://github.com/PyO3/pyo3/pull/5413)
+- Fetch type name dynamically when exporting types implementing `PyTypeInfo` with `#[pymodule_use]`. [#5414](https://github.com/PyO3/pyo3/pull/5414)
+- Improve `Debug` representation of `PyBuffer<T>`. [#5442](https://github.com/PyO3/pyo3/pull/5442)
+- `experimental-inspect`: change the way introspection data is emitted in the binaries to avoid a pointer indirection and simplify parsing. [#5450](https://github.com/PyO3/pyo3/pull/5450)
+- Optimize `Py<T>::drop` for the case when attached to the Python interpreter. [#5454](https://github.com/PyO3/pyo3/pull/5454)
+- Replace `DowncastError` and `DowncastIntoError` with `CastError` and `CastIntoError`. [#5468](https://github.com/PyO3/pyo3/pull/5468)
+- Enable fast-path for 128-bit integer conversions on `GraalPy`. [#5471](https://github.com/PyO3/pyo3/pull/5471)
+- Deprecate `PyAnyMethods::downcast` functions in favour of `Bound::cast` functions. [#5472](https://github.com/PyO3/pyo3/pull/5472)
+- Make `PyTypeCheck` an `unsafe trait`. [#5473](https://github.com/PyO3/pyo3/pull/5473)
+- Deprecate unchecked `PyCapsuleMethods`: `pointer()`, `reference()`, and `is_valid()`. [#5474](https://github.com/PyO3/pyo3/pull/5474)
+- Reduce lifetime of return value in `PyCapsuleMethods::reference`. [#5474](https://github.com/PyO3/pyo3/pull/5474)
+- `PyCapsuleMethods::name` now returns `CapsuleName` wrapper instead of `&CStr`. [#5474](https://github.com/PyO3/pyo3/pull/5474)
+- Deprecate `import_exception_bound` in favour of `import_exception`. [#5480](https://github.com/PyO3/pyo3/pull/5480)
+- `PyList::get_item_unchecked`, `PyTuple::get_item_unchecked`, and `PyTuple::get_borrowed_item_unchecked` no longer check for null values at the provided index. [#5494](https://github.com/PyO3/pyo3/pull/5494)
+- Allow converting naive datetime into chrono `DateTime<Local>`. [#5507](https://github.com/PyO3/pyo3/pull/5507)
+
+### Removed
+
+- Removed `FromPyObjectBound` trait. [#4390](https://github.com/PyO3/pyo3/pull/4390)
+
+### Fixed
+
+- Fix compilation failure on `wasm32-wasip2`. [#5368](https://github.com/PyO3/pyo3/pull/5368)
+- Fix `OsStr` conversion for non-utf8 strings on Windows. [#5444](https://github.com/PyO3/pyo3/pull/5444)
+- Fix issue with `cargo vendor` caused by gitignored build artifact `emscripten/pybuilddir.txt`. [#5456](https://github.com/PyO3/pyo3/pull/5456)
+- Stop leaking `PyMethodDef` instances inside `#[pyfunction]` macro generated code. [#5459](https://github.com/PyO3/pyo3/pull/5459)
+- Don't export definition of FFI struct `PyObjectObFlagsAndRefcnt` on 32-bit Python 3.14 (doesn't exist). [#5499](https://github.com/PyO3/pyo3/pull/5499)
+- Fix failure to build for `abi3` interpreters on Windows using maturin's built-in sysconfig in combination with the `generate-import-lib` feature. [#5503](https://github.com/PyO3/pyo3/pull/5503)
+- Fix FFI definitions `PyModule_ExecDef` and `PyModule_FromDefAndSpec2` on PyPy. [#5529](https://github.com/PyO3/pyo3/pull/5529)
+
+## [0.26.0] - 2025-08-29
+
+### Packaging
+
+- Bump hashbrown dependency to 0.15. [#5152](https://github.com/PyO3/pyo3/pull/5152)
+- Update MSRV to 1.74. [#5171](https://github.com/PyO3/pyo3/pull/5171)
+- Set the same maximum supported version for alternative interpreters as for CPython. [#5192](https://github.com/PyO3/pyo3/pull/5192)
+- Add optional `bytes` dependency to add conversions for `bytes::Bytes`. [#5252](https://github.com/PyO3/pyo3/pull/5252)
+- Publish new crate `pyo3-introspection` to pair with the `experimental-inspect` feature. [#5300](https://github.com/PyO3/pyo3/pull/5300)
+- The `PYO3_BUILD_EXTENSION_MODULE` now causes the same effect as the `extension-module` feature. Eventually we expect maturin and setuptools-rust to set this environment variable automatically. Users with their own build systems will need to do the same. [#5343](https://github.com/PyO3/pyo3/pull/5343)
+
+### Added
+
+- Add `#[pyo3(warn(message = "...", category = ...))]` attribute for automatic warnings generation for `#[pyfunction]` and `#[pymethods]`. [#4364](https://github.com/PyO3/pyo3/pull/4364)
+- Add `PyMutex`, available on Python 3.13 and newer. [#4523](https://github.com/PyO3/pyo3/pull/4523)
+- Add FFI definition `PyMutex_IsLocked`, available on Python 3.14 and newer. [#4523](https://github.com/PyO3/pyo3/pull/4523)
+- Add `PyString::from_encoded_object`. [#5017](https://github.com/PyO3/pyo3/pull/5017)
+- `experimental-inspect`: add basic input type annotations. [#5089](https://github.com/PyO3/pyo3/pull/5089)
+- Add FFI function definitions for `PyFrameObject` from CPython 3.13. [#5154](https://github.com/PyO3/pyo3/pull/5154)
+- `experimental-inspect`: tag modules created using `#[pymodule]` or `#[pymodule_init]` functions as incomplete. [#5207](https://github.com/PyO3/pyo3/pull/5207)
+- `experimental-inspect`: add basic return type support. [#5208](https://github.com/PyO3/pyo3/pull/5208)
+- Add `PyCode::compile` and `PyCodeMethods::run` to create and execute code objects. [#5217](https://github.com/PyO3/pyo3/pull/5217)
+- Add `PyOnceLock` type for thread-safe single-initialization. [#5223](https://github.com/PyO3/pyo3/pull/5223)
+- Add `PyClassGuard(Mut)` pyclass holders. In the future they will replace `PyRef(Mut)`. [#5233](https://github.com/PyO3/pyo3/pull/5233)
+- `experimental-inspect`: allow annotations in `#[pyo3(signature)]` signature attribute. [#5241](https://github.com/PyO3/pyo3/pull/5241)
+- Implement `MutexExt` for parking_lot's/lock_api `ReentrantMutex`. [#5258](https://github.com/PyO3/pyo3/pull/5258)
+- `experimental-inspect`: support class associated constants. [#5272](https://github.com/PyO3/pyo3/pull/5272)
+- Add `Bound::cast` family of functions superseding the `PyAnyMethods::downcast` family. [#5289](https://github.com/PyO3/pyo3/pull/5289)
+- Add FFI definitions `Py_Version` and `Py_IsFinalizing`. [#5317](https://github.com/PyO3/pyo3/pull/5317)
+- `experimental-inspect`: add output type annotation for `#[pyclass]`. [#5320](https://github.com/PyO3/pyo3/pull/5320)
+- `experimental-inspect`: support `#[pyclass(eq, eq_int, ord, hash, str)]`. [#5338](https://github.com/PyO3/pyo3/pull/5338)
+- `experimental-inspect`: add basic support for `#[derive(FromPyObject)]` (no struct fields support yet). [#5339](https://github.com/PyO3/pyo3/pull/5339)
+- Add `Python::try_attach`. [#5342](https://github.com/PyO3/pyo3/pull/5342)
+
+### Changed
+
+- Use `Py_TPFLAGS_DISALLOW_INSTANTIATION` instead of a `__new__` which always fails for a `#[pyclass]` without a `#[new]` on Python 3.10 and up. [#4568](https://github.com/PyO3/pyo3/pull/4568)
+- `PyModule::from_code` now defaults `file_name` to `<string>` if empty. [#4777](https://github.com/PyO3/pyo3/pull/4777)
+- Deprecate `PyString::from_object` in favour of `PyString::from_encoded_object`. [#5017](https://github.com/PyO3/pyo3/pull/5017)
+- When building with `abi3` for a Python version newer than pyo3 supports, automatically fall back to an abi3 build for the latest supported version. [#5144](https://github.com/PyO3/pyo3/pull/5144)
+- Change `is_instance_of` trait bound from `PyTypeInfo` to `PyTypeCheck`. [#5146](https://github.com/PyO3/pyo3/pull/5146)
+- Many PyO3 proc macros now report multiple errors instead of only the first one. [#5159](https://github.com/PyO3/pyo3/pull/5159)
+- Change `MutexExt` return type to be an associated type. [#5201](https://github.com/PyO3/pyo3/pull/5201)
+- Use `PyCallArgs` for `Py::call` and friends so they're equivalent to their `Bound` counterpart. [#5206](https://github.com/PyO3/pyo3/pull/5206)
+- Rename `Python::with_gil` to `Python::attach`. [#5209](https://github.com/PyO3/pyo3/pull/5209)
+- Rename `Python::allow_threads` to `Python::detach` [#5221](https://github.com/PyO3/pyo3/pull/5221)
+- Deprecate `GILOnceCell` type in favour of `PyOnceLock`. [#5223](https://github.com/PyO3/pyo3/pull/5223)
+- Rename `pyo3::prepare_freethreaded_python` to `Python::initialize`. [#5247](https://github.com/PyO3/pyo3/pull/5247)
+- Convert `PyMemoryError` into/from `io::ErrorKind::OutOfMemory`. [#5256](https://github.com/PyO3/pyo3/pull/5256)
+- Deprecate `GILProtected`. [#5285](https://github.com/PyO3/pyo3/pull/5285)
+- Move `#[pyclass]` docstring formatting from import time to compile time. [#5286](https://github.com/PyO3/pyo3/pull/5286)
+- `Python::attach` will now panic if the Python interpreter is in the process of shutting down. [#5317](https://github.com/PyO3/pyo3/pull/5317)
+- Add fast-path to `PyTypeInfo::type_object` for `#[pyclass]` types. [#5324](https://github.com/PyO3/pyo3/pull/5324)
+- Deprecate `PyObject` type alias for `Py<PyAny>`. [#5325](https://github.com/PyO3/pyo3/pull/5325)
+- Rename `Python::with_gil_unchecked` to `Python::attach_unchecked`. [#5340](https://github.com/PyO3/pyo3/pull/5340)
+- Rename `Python::assume_gil_acquired` to `Python::assume_attached`. [#5354](https://github.com/PyO3/pyo3/pull/5354)
+
+### Removed
+
+- Remove FFI definition of internals of `PyFrameObject`. [#5154](https://github.com/PyO3/pyo3/pull/5154)
+- Remove `Eq` and `PartialEq` implementations on `PyGetSetDef` FFI definition. [#5196](https://github.com/PyO3/pyo3/pull/5196)
+- Remove private FFI definitions `_Py_IsCoreInitialized` and `_Py_InitializeMain`. [#5317](https://github.com/PyO3/pyo3/pull/5317)
+
+### Fixed
+
+- Use critical section in `PyByteArray::to_vec` on freethreaded build to replicate GIL-enabled "soundness". [#4742](https://github.com/PyO3/pyo3/pull/4742)
+- Fix precision loss when converting `bigdecimal` into Python. [#5198](https://github.com/PyO3/pyo3/pull/5198)
+- Don't treat win7 target as a cross-compilation. [#5210](https://github.com/PyO3/pyo3/pull/5210)
+- WASM targets no longer require exception handling support for Python < 3.14. [#5239](https://github.com/PyO3/pyo3/pull/5239)
+- Fix segfault when dropping `PyBuffer<T>` after the Python interpreter has been finalized. [#5242](https://github.com/PyO3/pyo3/pull/5242)
+- `experimental-inspect`: better automated imports generation. [#5251](https://github.com/PyO3/pyo3/pull/5251)
+- `experimental-inspect`: fix introspection of `__richcmp__`, `__concat__`, `__repeat__`, `__inplace_concat__` and `__inplace_repeat__`. [#5273](https://github.com/PyO3/pyo3/pull/5273)
+- fixed a leaked borrow, when converting a mutable sub class into a frozen base class using `PyRef::into_super` [#5281](https://github.com/PyO3/pyo3/pull/5281)
+- Fix FFI definition `Py_Exit` (never returns, was `()` return value, now `!`). [#5317](https://github.com/PyO3/pyo3/pull/5317)
+- `experimental-inspect`: fix handling of module members gated behind `#[cfg(...)]` attributes. [#5318](https://github.com/PyO3/pyo3/pull/5318)
+
+## [0.25.1] - 2025-06-12
+### Packaging
+
+- Add support for Windows on ARM64. [#5145](https://github.com/PyO3/pyo3/pull/5145)
+- Add `chrono-local` feature for optional conversions for chrono's `Local` timezone & `DateTime<Local>` instances. [#5174](https://github.com/PyO3/pyo3/pull/5174)
+
+### Added
+
+- Add FFI definition `PyBytes_AS_STRING`. [#5121](https://github.com/PyO3/pyo3/pull/5121)
+- Add support for module associated consts introspection. [#5150](https://github.com/PyO3/pyo3/pull/5150)
+
+### Changed
+
+- Enable "vectorcall" FFI definitions on GraalPy. [#5121](https://github.com/PyO3/pyo3/pull/5121)
+- Use `Py_Is` function on GraalPy [#5121](https://github.com/PyO3/pyo3/pull/5121)
+
+### Fixed
+
+- Report a better compile error for `async` declarations when not using `experimental-async` feature. [#5156](https://github.com/PyO3/pyo3/pull/5156)
+- Fix implementation of `FromPyObject` for `uuid::Uuid` on big-endian architectures. [#5161](https://github.com/PyO3/pyo3/pull/5161)
+- Fix segmentation faults on 32-bit x86 with Python 3.14. [#5180](https://github.com/PyO3/pyo3/pull/5180)
+
+## [0.25.0] - 2025-05-14
+
+### Packaging
+
+- Support Python 3.14.0b1. [#4811](https://github.com/PyO3/pyo3/pull/4811)
+- Bump supported GraalPy version to 24.2. [#5116](https://github.com/PyO3/pyo3/pull/5116)
+- Add optional `bigdecimal` dependency to add conversions for `bigdecimal::BigDecimal`. [#5011](https://github.com/PyO3/pyo3/pull/5011)
+- Add optional `time` dependency to add conversions for `time` types. [#5057](https://github.com/PyO3/pyo3/pull/5057)
+- Remove `cfg-if` dependency. [#5110](https://github.com/PyO3/pyo3/pull/5110)
+- Add optional `ordered_float` dependency to add conversions for `ordered_float::NotNan` and `ordered_float::OrderedFloat`. [#5114](https://github.com/PyO3/pyo3/pull/5114)
+
+### Added
+
+- Add initial type stub generation to the `experimental-inspect` feature. [#3977](https://github.com/PyO3/pyo3/pull/3977)
+- Add `#[pyclass(generic)]` option to support runtime generic typing. [#4926](https://github.com/PyO3/pyo3/pull/4926)
+- Implement `OnceExt` & `MutexExt` for `parking_lot` & `lock_api`. Use the new extension traits by enabling the `arc_lock`, `lock_api`, or `parking_lot` cargo features. [#5044](https://github.com/PyO3/pyo3/pull/5044)
+- Implement `From`/`Into` for `Borrowed<T>` -> `Py<T>`. [#5054](https://github.com/PyO3/pyo3/pull/5054)
+- Add `PyTzInfo` constructors. [#5055](https://github.com/PyO3/pyo3/pull/5055)
+- Add FFI definition `PY_INVALID_STACK_EFFECT`. [#5064](https://github.com/PyO3/pyo3/pull/5064)
+- Implement `AsRef<Py<PyAny>>` for `Py<T>`, `Bound<T>` and `Borrowed<T>`. [#5071](https://github.com/PyO3/pyo3/pull/5071)
+- Add FFI definition `PyModule_Add` and `compat::PyModule_Add`. [#5085](https://github.com/PyO3/pyo3/pull/5085)
+- Add FFI definitions `Py_HashBuffer`, `Py_HashPointer`, and `PyObject_GenericHash`. [#5086](https://github.com/PyO3/pyo3/pull/5086)
+- Support `#[pymodule_export]` on `const` items in declarative modules. [#5096](https://github.com/PyO3/pyo3/pull/5096)
+- Add `#[pyclass(immutable_type)]` option (on Python 3.14+ with `abi3`, or 3.10+ otherwise) for immutable type objects. [#5101](https://github.com/PyO3/pyo3/pull/5101)
+- Support `#[pyo3(rename_all)]` support on `#[derive(IntoPyObject)]`. [#5112](https://github.com/PyO3/pyo3/pull/5112)
+- Add `PyRange` wrapper. [#5117](https://github.com/PyO3/pyo3/pull/5117)
+
+### Changed
+
+- Enable use of `datetime` types with `abi3` feature enabled. [#4970](https://github.com/PyO3/pyo3/pull/4970)
+- Deprecate `timezone_utc` in favor of `PyTzInfo::utc`. [#5055](https://github.com/PyO3/pyo3/pull/5055)
+- Reduce visibility of some CPython implementation details: [#5064](https://github.com/PyO3/pyo3/pull/5064)
+  - The FFI definition `PyCodeObject` is now an opaque struct on all Python versions.
+  - The FFI definition `PyFutureFeatures` is now only defined up until Python 3.10 (it was present in CPython headers but unused in 3.11 and 3.12).
+- Change `PyAnyMethods::is` to take `other: &Bound<T>`. [#5071](https://github.com/PyO3/pyo3/pull/5071)
+- Change `Py::is` to take `other: &Py<T>`. [#5071](https://github.com/PyO3/pyo3/pull/5071)
+- Change `PyVisit::call` to take `T: Into<Option<&Py<T>>>`. [#5071](https://github.com/PyO3/pyo3/pull/5071)
+- Expose `PyDateTime_DATE_GET_TZINFO` and `PyDateTime_TIME_GET_TZINFO` on PyPy 3.10 and later. [#5079](https://github.com/PyO3/pyo3/pull/5079)
+- Add `#[track_caller]` to `with_gil` and `with_gil_unchecked`. [#5109](https://github.com/PyO3/pyo3/pull/5109)
+- Use `std::thread::park()` instead of `libc::pause()` or `sleep(9999999)`. [#5115](https://github.com/PyO3/pyo3/pull/5115)
+
+### Removed
+
+- Remove all functionality deprecated in PyO3 0.23. [#4982](https://github.com/PyO3/pyo3/pull/4982)
+- Remove deprecated `IntoPy` and `ToPyObject` traits. [#5010](https://github.com/PyO3/pyo3/pull/5010)
+- Remove private types from `pyo3-ffi` (i.e. starting with `_Py`) which are not referenced by public APIs: `_PyLocalMonitors`, `_Py_GlobalMonitors`, `_PyCoCached`, `_PyCoLineInstrumentationData`, `_PyCoMonitoringData`, `_PyCompilerSrcLocation`, `_PyErr_StackItem`. [#5064](https://github.com/PyO3/pyo3/pull/5064)
+- Remove FFI definition `PyCode_GetNumFree` (PyO3 cannot support it due to knowledge of the code object). [#5064](https://github.com/PyO3/pyo3/pull/5064)
+- Remove `AsPyPointer` trait. [#5071](https://github.com/PyO3/pyo3/pull/5071)
+- Remove support for the deprecated string form of `from_py_with`. [#5097](https://github.com/PyO3/pyo3/pull/5097)
+- Remove FFI definitions of private static variables: `_PyMethodWrapper_Type`, `_PyCoroWrapper_Type`, `_PyImport_FrozenBootstrap`, `_PyImport_FrozenStdlib`, `_PyImport_FrozenTest`, `_PyManagedBuffer_Type`, `_PySet_Dummy`, `_PyWeakref_ProxyType`, and `_PyWeakref_CallableProxyType`. [#5105](https://github.com/PyO3/pyo3/pull/5105)
+- Remove FFI definitions `PyASCIIObjectState`, `PyUnicode_IS_ASCII`, `PyUnicode_IS_COMPACT`, and `PyUnicode_IS_COMPACT_ASCII` on Python 3.14 and newer. [#5133](https://github.com/PyO3/pyo3/pull/5133)
+
+### Fixed
+
+- Correctly pick up the shared state for conda-based Python installation when reading information from sysconfigdata. [#5037](https://github.com/PyO3/pyo3/pull/5037)
+- Fix compile failure with `#[derive(IntoPyObject, FromPyObject)]` when using `#[pyo3()]` options recognised by only one of the two derives. [#5070](https://github.com/PyO3/pyo3/pull/5070)
+- Fix various compile errors from missing FFI definitions using certain feature combinations on PyPy and GraalPy. [#5091](https://github.com/PyO3/pyo3/pull/5091)
+- Fallback on `backports.zoneinfo` for python <3.9 when converting timezones into python. [#5120](https://github.com/PyO3/pyo3/pull/5120)
+
+## [0.24.2] - 2025-04-21
+
+### Fixed
+
+- Fix `unused_imports` lint of `#[pyfunction]` and `#[pymethods]` expanded in `macro_rules` context. [#5030](https://github.com/PyO3/pyo3/pull/5030)
+- Fix size of `PyCodeObject::_co_instrumentation_version` ffi struct member on Python 3.13 for systems where `uintptr_t` is not 64 bits. [#5048](https://github.com/PyO3/pyo3/pull/5048)
+- Fix struct-type complex enum variant fields incorrectly exposing raw identifiers as `r#ident` in Python bindings. [#5050](https://github.com/PyO3/pyo3/pull/5050)
+
+## [0.24.1] - 2025-03-31
+
+### Added
+
+- Add `abi3-py313` feature. [#4969](https://github.com/PyO3/pyo3/pull/4969)
+- Add `PyAnyMethods::getattr_opt`. [#4978](https://github.com/PyO3/pyo3/pull/4978)
+- Add `PyInt::new` constructor for all supported number types (i32, u32, i64, u64, isize, usize). [#4984](https://github.com/PyO3/pyo3/pull/4984)
+- Add `pyo3::sync::with_critical_section2`. [#4992](https://github.com/PyO3/pyo3/pull/4992)
+- Implement `PyCallArgs` for `Borrowed<'_, 'py, PyTuple>`, `&Bound<'py, PyTuple>`, and `&Py<PyTuple>`. [#5013](https://github.com/PyO3/pyo3/pull/5013)
+
+### Fixed
+
+- Fix `is_type_of` for native types not using same specialized check as `is_type_of_bound`. [#4981](https://github.com/PyO3/pyo3/pull/4981)
+- Fix `Probe` class naming issue with `#[pymethods]`. [#4988](https://github.com/PyO3/pyo3/pull/4988)
+- Fix compile failure with required `#[pyfunction]` arguments taking `Option<&str>` and `Option<&T>` (for `#[pyclass]` types). [#5002](https://github.com/PyO3/pyo3/pull/5002)
+- Fix `PyString::from_object` causing of bounds reads with `encoding` and `errors` parameters which are not nul-terminated. [#5008](https://github.com/PyO3/pyo3/pull/5008)
+- Fix compile error when additional options follow after `crate` for `#[pyfunction]`. [#5015](https://github.com/PyO3/pyo3/pull/5015)
+
+## [0.24.0] - 2025-03-09
+
+### Packaging
+
+- Add supported CPython/PyPy versions to cargo package metadata. [#4756](https://github.com/PyO3/pyo3/pull/4756)
+- Bump `target-lexicon` dependency to 0.13. [#4822](https://github.com/PyO3/pyo3/pull/4822)
+- Add optional `jiff` dependency to add conversions for `jiff` datetime types. [#4823](https://github.com/PyO3/pyo3/pull/4823)
+- Add optional `uuid` dependency to add conversions for `uuid::Uuid`. [#4864](https://github.com/PyO3/pyo3/pull/4864)
+- Bump minimum supported `inventory` version to 0.3.5. [#4954](https://github.com/PyO3/pyo3/pull/4954)
+
+### Added
+
+- Add `PyIterator::send` method to allow sending values into a python generator. [#4746](https://github.com/PyO3/pyo3/pull/4746)
+- Add `PyCallArgs` trait for passing arguments into the Python calling protocol. This enabled using a faster calling convention for certain types, improving performance. [#4768](https://github.com/PyO3/pyo3/pull/4768)
+- Add `#[pyo3(default = ...']` option for `#[derive(FromPyObject)]` to set a default value for extracted fields of named structs. [#4829](https://github.com/PyO3/pyo3/pull/4829)
+- Add `#[pyo3(into_py_with = ...)]` option for `#[derive(IntoPyObject, IntoPyObjectRef)]`. [#4850](https://github.com/PyO3/pyo3/pull/4850)
+- Add FFI definitions `PyThreadState_GetFrame` and `PyFrame_GetBack`. [#4866](https://github.com/PyO3/pyo3/pull/4866)
+- Optimize `last` for `BoundListIterator`, `BoundTupleIterator` and `BorrowedTupleIterator`. [#4878](https://github.com/PyO3/pyo3/pull/4878)
+- Optimize `Iterator::count()` for `PyDict`, `PyList`, `PyTuple` & `PySet`. [#4878](https://github.com/PyO3/pyo3/pull/4878)
+- Optimize `nth`, `nth_back`, `advance_by` and `advance_back_by` for `BoundTupleIterator` [#4897](https://github.com/PyO3/pyo3/pull/4897)
+- Add support for `types.GenericAlias` as `pyo3::types::PyGenericAlias`. [#4917](https://github.com/PyO3/pyo3/pull/4917)
+- Add `MutextExt` trait to help avoid deadlocks with the GIL while locking a `std::sync::Mutex`. [#4934](https://github.com/PyO3/pyo3/pull/4934)
+- Add `#[pyo3(rename_all = "...")]` option for `#[derive(FromPyObject)]`. [#4941](https://github.com/PyO3/pyo3/pull/4941)
+
+### Changed
+
+- Optimize `nth`, `nth_back`, `advance_by` and `advance_back_by` for `BoundListIterator`. [#4810](https://github.com/PyO3/pyo3/pull/4810)
+- Use `DerefToPyAny` in blanket implementations of `From<Py<T>>` and `From<Bound<'py, T>>` for `PyObject`. [#4593](https://github.com/PyO3/pyo3/pull/4593)
+- Map `io::ErrorKind::IsADirectory`/`NotADirectory` to the corresponding Python exception on Rust 1.83+. [#4747](https://github.com/PyO3/pyo3/pull/4747)
+- `PyAnyMethods::call` and friends now require `PyCallArgs` for their positional arguments. [#4768](https://github.com/PyO3/pyo3/pull/4768)
+- Expose FFI definitions for `PyObject_Vectorcall(Method)` on the stable abi on 3.12+. [#4853](https://github.com/PyO3/pyo3/pull/4853)
+- `#[pyo3(from_py_with = ...)]` now take a path rather than a string literal [#4860](https://github.com/PyO3/pyo3/pull/4860)
+- Format Python traceback in impl Debug for PyErr. [#4900](https://github.com/PyO3/pyo3/pull/4900)
+- Convert `PathBuf` & `Path` into Python `pathlib.Path` instead of `PyString`. [#4925](https://github.com/PyO3/pyo3/pull/4925)
+- Relax parsing of exotic Python versions. [#4949](https://github.com/PyO3/pyo3/pull/4949)
+- PyO3 threads now hang instead of `pthread_exit` trying to acquire the GIL when the interpreter is shutting down. This mimics the [Python 3.14](https://github.com/python/cpython/issues/87135) behavior and avoids undefined behavior and crashes. [#4874](https://github.com/PyO3/pyo3/pull/4874)
+
+### Removed
+
+- Remove implementations of `Deref` for `PyAny` and other "native" types. [#4593](https://github.com/PyO3/pyo3/pull/4593)
+- Remove implicit default of trailing optional arguments (see #2935) [#4729](https://github.com/PyO3/pyo3/pull/4729)
+- Remove the deprecated implicit eq fallback for simple enums. [#4730](https://github.com/PyO3/pyo3/pull/4730)
+
+### Fixed
+
+- Correct FFI definition of `PyIter_Send` to return a `PySendResult`. [#4746](https://github.com/PyO3/pyo3/pull/4746)
+- Fix a thread safety issue in the runtime borrow checker used by mutable pyclass instances on the free-threaded build. [#4948](https://github.com/PyO3/pyo3/pull/4948)
+
+
+## [0.23.5] - 2025-02-22
+
+### Packaging
+
+- Add support for PyPy3.11 [#4760](https://github.com/PyO3/pyo3/pull/4760)
+
+### Fixed
+
+- Fix thread-unsafe implementation of freelist pyclasses on the free-threaded build. [#4902](https://github.com/PyO3/pyo3/pull/4902)
+- Re-enable a workaround for situations where CPython incorrectly does not add `__builtins__` to `__globals__` in code executed by `Python::py_run` (was removed in PyO3 0.23.0). [#4921](https://github.com/PyO3/pyo3/pull/4921)
+
+## [0.23.4] - 2025-01-10
+
+### Added
+
+- Add `PyList::locked_for_each`, which uses a critical section to lock the list on the free-threaded build. [#4789](https://github.com/PyO3/pyo3/pull/4789)
+- Add `pyo3_build_config::add_python_framework_link_args` build script API to set rpath when using macOS system Python. [#4833](https://github.com/PyO3/pyo3/pull/4833)
+
+### Changed
+
+- Use `datetime.fold` to distinguish ambiguous datetimes when converting to and from `chrono::DateTime<Tz>` (rather than erroring). [#4791](https://github.com/PyO3/pyo3/pull/4791)
+- Optimize PyList iteration on the free-threaded build. [#4789](https://github.com/PyO3/pyo3/pull/4789)
+
+### Fixed
+
+- Fix unnecessary internal `py.allow_threads` GIL-switch when attempting to access contents of a `PyErr` which originated from Python (could lead to unintended deadlocks). [#4766](https://github.com/PyO3/pyo3/pull/4766)
+- Fix thread-unsafe access of dict internals in `BoundDictIterator` on the free-threaded build. [#4788](https://github.com/PyO3/pyo3/pull/4788)
+* Fix unnecessary critical sections in `BoundDictIterator` on the free-threaded build. [#4788](https://github.com/PyO3/pyo3/pull/4788)
+- Fix time-of-check to time-of-use issues with list iteration on the free-threaded build. [#4789](https://github.com/PyO3/pyo3/pull/4789)
+- Fix `chrono::DateTime<Tz>` to-Python conversion when `Tz` is `chrono_tz::Tz`. [#4790](https://github.com/PyO3/pyo3/pull/4790)
+- Fix `#[pyclass]` not being able to be named `Probe`. [#4794](https://github.com/PyO3/pyo3/pull/4794)
+- Fix not treating cross-compilation from x64 to aarch64 on Windows as a cross-compile. [#4800](https://github.com/PyO3/pyo3/pull/4800)
+- Fix missing struct fields on GraalPy when subclassing builtin classes. [#4802](https://github.com/PyO3/pyo3/pull/4802)
+- Fix generating import lib for PyPy when `abi3` feature is enabled. [#4806](https://github.com/PyO3/pyo3/pull/4806)
+- Fix generating import lib for python3.13t when `abi3` feature is enabled. [#4808](https://github.com/PyO3/pyo3/pull/4808)
+- Fix compile failure for raw identifiers like `r#box` in `derive(FromPyObject)`. [#4814](https://github.com/PyO3/pyo3/pull/4814)
+- Fix compile failure for `#[pyclass]` enum variants with more than 12 fields. [#4832](https://github.com/PyO3/pyo3/pull/4832)
+
+
+## [0.23.3] - 2024-12-03
+
+### Packaging
+
+- Bump optional `python3-dll-a` dependency to 0.2.11. [#4749](https://github.com/PyO3/pyo3/pull/4749)
+
+### Fixed
+
+- Fix unresolved symbol link failures on Windows when compiling for Python 3.13t with `abi3` features enabled. [#4733](https://github.com/PyO3/pyo3/pull/4733)
+- Fix unresolved symbol link failures on Windows when compiling for Python 3.13t using the `generate-import-lib` feature. [#4749](https://github.com/PyO3/pyo3/pull/4749)
+- Fix compile-time regression in PyO3 0.23.0 where changing `PYO3_CONFIG_FILE` would not reconfigure PyO3 for the new interpreter. [#4758](https://github.com/PyO3/pyo3/pull/4758)
+
+## [0.23.2] - 2024-11-25
+
+### Added
+
+- Add `IntoPyObjectExt` trait. [#4708](https://github.com/PyO3/pyo3/pull/4708)
+
+### Fixed
+
+- Fix compile failures when building for free-threaded Python when the `abi3` or `abi3-pyxx` features are enabled. [#4719](https://github.com/PyO3/pyo3/pull/4719)
+- Fix `ambiguous_associated_items` lint error in `#[pyclass]` and `#[derive(IntoPyObject)]` macros. [#4725](https://github.com/PyO3/pyo3/pull/4725)
+
+
+## [0.23.1] - 2024-11-16
+
+Re-release of 0.23.0 with fixes to docs.rs build.
+
+## [0.23.0] - 2024-11-15
+
+### Packaging
+
+- Drop support for PyPy 3.7 and 3.8. [#4582](https://github.com/PyO3/pyo3/pull/4582)
+- Extend range of supported versions of `hashbrown` optional dependency to include version 0.15. [#4604](https://github.com/PyO3/pyo3/pull/4604)
+- Bump minimum version of `eyre` optional dependency to 0.6.8. [#4617](https://github.com/PyO3/pyo3/pull/4617)
+- Bump minimum version of `hashbrown` optional dependency to 0.14.5. [#4617](https://github.com/PyO3/pyo3/pull/4617)
+- Bump minimum version of `indexmap` optional dependency to 2.5.0. [#4617](https://github.com/PyO3/pyo3/pull/4617)
+- Bump minimum version of `num-complex` optional dependency to 0.4.6. [#4617](https://github.com/PyO3/pyo3/pull/4617)
+- Bump minimum version of `chrono-tz` optional dependency to 0.10. [#4617](https://github.com/PyO3/pyo3/pull/4617)
+- Support free-threaded Python 3.13t. [#4588](https://github.com/PyO3/pyo3/pull/4588)
+
+### Added
+
+- Add `IntoPyObject` (fallible) conversion trait to convert from Rust to Python values. [#4060](https://github.com/PyO3/pyo3/pull/4060)
+- Add `#[pyclass(str="<format string>")]` option to generate `__str__` based on a `Display` implementation or format string. [#4233](https://github.com/PyO3/pyo3/pull/4233)
+- Implement `PartialEq` for `Bound<'py, PyInt>` with `u8`, `u16`, `u32`, `u64`, `u128`, `usize`, `i8`, `i16`, `i32`, `i64`, `i128` and `isize`. [#4317](https://github.com/PyO3/pyo3/pull/4317)
+- Implement `PartialEq<f64>` and `PartialEq<f32>` for `Bound<'py, PyFloat>`. [#4348](https://github.com/PyO3/pyo3/pull/4348)
+- Add `as_super` and `into_super` methods for `Bound<T: PyClass>`. [#4351](https://github.com/PyO3/pyo3/pull/4351)
+- Add FFI definitions `PyCFunctionFast` and `PyCFunctionFastWithKeywords` [#4415](https://github.com/PyO3/pyo3/pull/4415)
+- Add FFI definitions for `PyMutex` on Python 3.13 and newer. [#4421](https://github.com/PyO3/pyo3/pull/4421)
+- Add `PyDict::locked_for_each` to iterate efficiently on freethreaded Python. [#4439](https://github.com/PyO3/pyo3/pull/4439)
+- Add FFI definitions `PyObject_GetOptionalAttr`, `PyObject_GetOptionalAttrString`, `PyObject_HasAttrWithError`, `PyObject_HasAttrStringWithError`, `Py_CONSTANT_*` constants, `Py_GetConstant`, `Py_GetConstantBorrowed`, and `PyType_GetModuleByDef` on Python 3.13 and newer. [#4447](https://github.com/PyO3/pyo3/pull/4447)
+- Add FFI definitions for the Python critical section API available on Python 3.13 and newer. [#4477](https://github.com/PyO3/pyo3/pull/4477)
+- Add derive macro for `IntoPyObject`. [#4495](https://github.com/PyO3/pyo3/pull/4495)
+- Add `Borrowed::as_ptr`. [#4520](https://github.com/PyO3/pyo3/pull/4520)
+- Add FFI definition for `PyImport_AddModuleRef`. [#4529](https://github.com/PyO3/pyo3/pull/4529)
+- Add `PyAnyMethods::try_iter`. [#4553](https://github.com/PyO3/pyo3/pull/4553)
+- Add `pyo3::sync::with_critical_section`, a wrapper around the Python Critical Section API added in Python 3.13. [#4587](https://github.com/PyO3/pyo3/pull/4587)
+- Add `#[pymodule(gil_used = false)]` option to declare that a module supports the free-threaded build. [#4588](https://github.com/PyO3/pyo3/pull/4588)
+- Add `PyModule::gil_used` method to declare that a module supports the free-threaded build. [#4588](https://github.com/PyO3/pyo3/pull/4588)
+- Add FFI definition `PyDateTime_CAPSULE_NAME`. [#4634](https://github.com/PyO3/pyo3/pull/4634)
+- Add `PyMappingProxy` type to represent the `mappingproxy` Python class. [#4644](https://github.com/PyO3/pyo3/pull/4644)
+- Add FFI definitions `PyList_Extend` and `PyList_Clear`. [#4667](https://github.com/PyO3/pyo3/pull/4667)
+- Add derive macro for `IntoPyObjectRef`. [#4674](https://github.com/PyO3/pyo3/pull/4674)
+- Add `pyo3::sync::OnceExt` and `pyo3::sync::OnceLockExt` traits. [#4676](https://github.com/PyO3/pyo3/pull/4676)
+
+### Changed
+
+- Prefer `IntoPyObject` over `IntoPy<Py<PyAny>>>` for `#[pyfunction]` and `#[pymethods]` return types. [#4060](https://github.com/PyO3/pyo3/pull/4060)
+- Report multiple errors from `#[pyclass]` and `#[pyo3(..)]` attributes. [#4243](https://github.com/PyO3/pyo3/pull/4243)
+- Nested declarative `#[pymodule]` are automatically treated as submodules (no `PyInit_` entrypoint is created). [#4308](https://github.com/PyO3/pyo3/pull/4308)
+- Deprecate `PyAnyMethods::is_ellipsis` (`Py::is_ellipsis` was deprecated in PyO3 0.20). [#4322](https://github.com/PyO3/pyo3/pull/4322)
+- Deprecate `PyLong` in favor of `PyInt`. [#4347](https://github.com/PyO3/pyo3/pull/4347)
+- Rename `IntoPyDict::into_py_dict_bound` to `IntoPyDict::into_py_dict`. [#4388](https://github.com/PyO3/pyo3/pull/4388)
+- `PyModule::from_code` now expects `&CStr` as arguments instead of `&str`. [#4404](https://github.com/PyO3/pyo3/pull/4404)
+- Use "fastcall" Python calling convention for `#[pyfunction]`s when compiling on abi3 for Python 3.10 and up. [#4415](https://github.com/PyO3/pyo3/pull/4415)
+- Remove `Copy` and `Clone` from `PyObject` struct FFI definition. [#4434](https://github.com/PyO3/pyo3/pull/4434)
+- `Python::eval` and `Python::run` now take a `&CStr` instead of `&str`. [#4435](https://github.com/PyO3/pyo3/pull/4435)
+- Deprecate `IPowModulo`, `PyClassAttributeDef`, `PyGetterDef`, `PyMethodDef`, `PyMethodDefType`, and `PySetterDef` from PyO3's public API. [#4441](https://github.com/PyO3/pyo3/pull/4441)
+- `IntoPyObject` impls for `Vec<u8>`, `&[u8]`, `[u8; N]`, `Cow<[u8]>` and `SmallVec<[u8; N]>` now convert into Python `bytes` rather than a `list` of integers. [#4442](https://github.com/PyO3/pyo3/pull/4442)
+- Emit a compile-time error when attempting to subclass a class that doesn't allow subclassing. [#4453](https://github.com/PyO3/pyo3/pull/4453)
+- `IntoPyDict::into_py_dict` is now fallible due to `IntoPyObject` migration. [#4493](https://github.com/PyO3/pyo3/pull/4493)
+- The `abi3` feature will now override config files provided via `PYO3_BUILD_CONFIG`. [#4497](https://github.com/PyO3/pyo3/pull/4497)
+- Disable the `GILProtected` struct on free-threaded Python. [#4504](https://github.com/PyO3/pyo3/pull/4504)
+- Updated FFI definitions for functions and struct fields that have been deprecated or removed from CPython. [#4534](https://github.com/PyO3/pyo3/pull/4534)
+- Disable `PyListMethods::get_item_unchecked` on free-threaded Python. [#4539](https://github.com/PyO3/pyo3/pull/4539)
+- Add `GILOnceCell::import`. [#4542](https://github.com/PyO3/pyo3/pull/4542)
+- Deprecate `PyAnyMethods::iter` in favour of `PyAnyMethods::try_iter`. [#4553](https://github.com/PyO3/pyo3/pull/4553)
+- The `#[pyclass]` macro now requires a types to be `Sync`. (Except for `#[pyclass(unsendable)]` types). [#4566](https://github.com/PyO3/pyo3/pull/4566)
+- `PyList::new` and `PyTuple::new` are now fallible due to `IntoPyObject` migration. [#4580](https://github.com/PyO3/pyo3/pull/4580)
+- `PyErr::matches` is now fallible due to `IntoPyObject` migration. [#4595](https://github.com/PyO3/pyo3/pull/4595)
+- Deprecate `ToPyObject` in favour of `IntoPyObject` [#4595](https://github.com/PyO3/pyo3/pull/4595)
+- Deprecate `PyWeakrefMethods::get_option`. [#4597](https://github.com/PyO3/pyo3/pull/4597)
+- Seal `PyWeakrefMethods` trait. [#4598](https://github.com/PyO3/pyo3/pull/4598)
+- Remove `PyNativeTypeInitializer` and `PyObjectInit` from the PyO3 public API. [#4611](https://github.com/PyO3/pyo3/pull/4611)
+- Deprecate `IntoPy` in favor of `IntoPyObject` [#4618](https://github.com/PyO3/pyo3/pull/4618)
+- Eagerly normalize exceptions in `PyErr::take()` and `PyErr::fetch()` on Python 3.11 and older. [#4655](https://github.com/PyO3/pyo3/pull/4655)
+- Move `IntoPy::type_output` to `IntoPyObject::type_output`. [#4657](https://github.com/PyO3/pyo3/pull/4657)
+- Change return type of `PyMapping::keys`, `PyMapping::values` and `PyMapping::items` to `Bound<'py, PyList>` instead of `Bound<'py, PySequence>`. [#4661](https://github.com/PyO3/pyo3/pull/4661)
+- Complex enums now allow field types that either implement `IntoPyObject` by reference or by value together with `Clone`. This makes `Py<T>` available as field type. [#4694](https://github.com/PyO3/pyo3/pull/4694)
+
+
+### Removed
+
+- Remove all functionality deprecated in PyO3 0.20. [#4322](https://github.com/PyO3/pyo3/pull/4322)
+- Remove all functionality deprecated in PyO3 0.21. [#4323](https://github.com/PyO3/pyo3/pull/4323)
+- Deprecate `PyUnicode` in favour of `PyString`. [#4370](https://github.com/PyO3/pyo3/pull/4370)
+- Remove deprecated `gil-refs` feature. [#4378](https://github.com/PyO3/pyo3/pull/4378)
+- Remove private FFI definitions `_Py_IMMORTAL_REFCNT`, `_Py_IsImmortal`, `_Py_TPFLAGS_STATIC_BUILTIN`, `_Py_Dealloc`, `_Py_IncRef`, `_Py_DecRef`. [#4447](https://github.com/PyO3/pyo3/pull/4447)
+- Remove private FFI definitions `_Py_c_sum`, `_Py_c_diff`, `_Py_c_neg`, `_Py_c_prod`, `_Py_c_quot`, `_Py_c_pow`, `_Py_c_abs`. [#4521](https://github.com/PyO3/pyo3/pull/4521)
+- Remove `_borrowed` methods of `PyWeakRef` and `PyWeakRefProxy`. [#4528](https://github.com/PyO3/pyo3/pull/4528)
+- Removed private FFI definition `_PyErr_ChainExceptions`. [#4534](https://github.com/PyO3/pyo3/pull/4534)
+
+### Fixed
+
+- Fix invalid library search path `lib_dir` when cross-compiling. [#4389](https://github.com/PyO3/pyo3/pull/4389)
+- Fix FFI definition `Py_Is` for PyPy on 3.10 to call the function defined by PyPy. [#4447](https://github.com/PyO3/pyo3/pull/4447)
+- Fix compile failure when using `#[cfg]` attributes for simple enum variants. [#4509](https://github.com/PyO3/pyo3/pull/4509)
+- Fix compiler warning for `non_snake_case` method names inside `#[pymethods]` generated code. [#4567](https://github.com/PyO3/pyo3/pull/4567)
+- Fix compile error with `#[derive(FromPyObject)]` generic struct with trait bounds. [#4645](https://github.com/PyO3/pyo3/pull/4645)
+- Fix compile error for `#[classmethod]` and `#[staticmethod]` on magic methods. [#4654](https://github.com/PyO3/pyo3/pull/4654)
+- Fix compile warning for `unsafe_op_in_unsafe_fn` in generated macro code. [#4674](https://github.com/PyO3/pyo3/pull/4674)
+- Fix incorrect deprecation warning for `#[pyclass] enum`s with custom `__eq__` implementation. [#4692](https://github.com/PyO3/pyo3/pull/4692)
+- Fix `non_upper_case_globals` lint firing for generated `__match_args__` on complex enums. [#4705](https://github.com/PyO3/pyo3/pull/4705)
+
+## [0.22.5] - 2024-10-15
+
+### Fixed
+
+- Fix regression in 0.22.4 of naming collision in `__clear__` slot and `clear` method generated code. [#4619](https://github.com/PyO3/pyo3/pull/4619)
+
+
+## [0.22.4] - 2024-10-12
+
+### Added
+
+- Add FFI definition `PyWeakref_GetRef` and `compat::PyWeakref_GetRef`. [#4528](https://github.com/PyO3/pyo3/pull/4528)
+
+### Changed
+
+- Deprecate `_borrowed` methods on `PyWeakRef` and `PyWeakrefProxy` (just use the owning forms). [#4590](https://github.com/PyO3/pyo3/pull/4590)
+
+### Fixed
+
+- Revert removal of private FFI function `_PyLong_NumBits` on Python 3.13 and later. [#4450](https://github.com/PyO3/pyo3/pull/4450)
+- Fix `__traverse__` functions for base classes not being called by subclasses created with `#[pyclass(extends = ...)]`. [#4563](https://github.com/PyO3/pyo3/pull/4563)
+- Fix regression in 0.22.3 failing compiles under `#![forbid(unsafe_code)]`. [#4574](https://github.com/PyO3/pyo3/pull/4574)
+- Fix `create_exception` macro triggering lint and compile errors due to interaction with `gil-refs` feature. [#4589](https://github.com/PyO3/pyo3/pull/4589)
+- Workaround possible use-after-free in `_borrowed` methods on `PyWeakRef` and `PyWeakrefProxy` by leaking their contents. [#4590](https://github.com/PyO3/pyo3/pull/4590)
+- Fix crash calling `PyType_GetSlot` on static types before Python 3.10. [#4599](https://github.com/PyO3/pyo3/pull/4599)
+
+
+## [0.22.3] - 2024-09-15
+
+### Added
+
+- Add `pyo3::ffi::compat` namespace with compatibility shims for C API functions added in recent versions of Python.
+- Add FFI definition `PyDict_GetItemRef` on Python 3.13 and newer, and `compat::PyDict_GetItemRef` for all versions. [#4355](https://github.com/PyO3/pyo3/pull/4355)
+- Add FFI definition `PyList_GetItemRef` on Python 3.13 and newer, and `pyo3_ffi::compat::PyList_GetItemRef` for all versions. [#4410](https://github.com/PyO3/pyo3/pull/4410)
+- Add FFI definitions `compat::Py_NewRef` and `compat::Py_XNewRef`. [#4445](https://github.com/PyO3/pyo3/pull/4445)
+- Add FFI definitions `compat::PyObject_CallNoArgs` and `compat::PyObject_CallMethodNoArgs`. [#4461](https://github.com/PyO3/pyo3/pull/4461)
+- Add `GilOnceCell<Py<T>>::clone_ref`. [#4511](https://github.com/PyO3/pyo3/pull/4511)
+
+### Changed
+
+- Improve error messages for `#[pyfunction]` defined inside `#[pymethods]`. [#4349](https://github.com/PyO3/pyo3/pull/4349)
+- Improve performance of calls to Python by using the vectorcall calling convention where possible. [#4456](https://github.com/PyO3/pyo3/pull/4456)
+- Mention the type name in the exception message when trying to instantiate a class with no constructor defined. [#4481](https://github.com/PyO3/pyo3/pull/4481)
+
+### Removed
+
+- Remove private FFI definition `_Py_PackageContext`. [#4420](https://github.com/PyO3/pyo3/pull/4420)
+
+### Fixed
+
+- Fix compile failure in declarative `#[pymodule]` under presence of `#![no_implicit_prelude]`. [#4328](https://github.com/PyO3/pyo3/pull/4328)
+- Fix use of borrowed reference in `PyDict::get_item` (unsafe in free-threaded Python). [#4355](https://github.com/PyO3/pyo3/pull/4355)
+- Fix `#[pyclass(eq)]` macro hygiene issues for structs and enums. [#4359](https://github.com/PyO3/pyo3/pull/4359)
+- Fix hygiene/span issues of `#[pyfunction]` and `#[pymethods]` generated code which affected expansion in `macro_rules` context. [#4382](https://github.com/PyO3/pyo3/pull/4382)
+- Fix `unsafe_code` lint error in `#[pyclass]` generated code. [#4396](https://github.com/PyO3/pyo3/pull/4396)
+- Fix async functions returning a tuple only returning the first element to Python. [#4407](https://github.com/PyO3/pyo3/pull/4407)
+- Fix use of borrowed reference in `PyList::get_item` (unsafe in free-threaded Python). [#4410](https://github.com/PyO3/pyo3/pull/4410)
+- Correct FFI definition `PyArg_ParseTupleAndKeywords` to take `*const *const c_char` instead of `*mut *mut c_char` on Python 3.13 and up. [#4420](https://github.com/PyO3/pyo3/pull/4420)
+- Fix a soundness bug with `PyClassInitializer`: panic if adding subclass to existing instance via `PyClassInitializer::from(Py<BaseClass>).add_subclass(SubClass)`. [#4454](https://github.com/PyO3/pyo3/pull/4454)
+- Fix illegal reference counting op inside implementation of `__traverse__` handlers. [#4479](https://github.com/PyO3/pyo3/pull/4479)
+
+## [0.22.2] - 2024-07-17
+
+### Packaging
+
+- Require opt-in to freethreaded Python using the `UNSAFE_PYO3_BUILD_FREE_THREADED=1` environment variable (it is not yet supported by PyO3). [#4327](https://github.com/PyO3/pyo3/pull/4327)
+
+### Changed
+
+- Use FFI function calls for reference counting on all abi3 versions. [#4324](https://github.com/PyO3/pyo3/pull/4324)
+- `#[pymodule(...)]` now directly accepts all relevant `#[pyo3(...)]` options. [#4330](https://github.com/PyO3/pyo3/pull/4330)
+
+### Fixed
+
+- Fix compile failure in declarative `#[pymodule]` under presence of `#![no_implicit_prelude]`. [#4328](https://github.com/PyO3/pyo3/pull/4328)
+- Fix compile failure due to c-string literals on Rust < 1.79. [#4353](https://github.com/PyO3/pyo3/pull/4353)
+
+## [0.22.1] - 2024-07-06
+
+### Added
+
+- Add `#[pyo3(submodule)]` option for declarative `#[pymodule]`s. [#4301](https://github.com/PyO3/pyo3/pull/4301)
+- Implement `PartialEq<bool>` for `Bound<'py, PyBool>`. [#4305](https://github.com/PyO3/pyo3/pull/4305)
+
+### Fixed
+
+- Return `NotImplemented` instead of raising `TypeError` from generated equality method when comparing different types. [#4287](https://github.com/PyO3/pyo3/pull/4287)
+- Handle full-path `#[pyo3::prelude::pymodule]` and similar for `#[pyclass]` and `#[pyfunction]` in declarative modules. [#4288](https://github.com/PyO3/pyo3/pull/4288)
+- Fix 128-bit int regression on big-endian platforms with Python <3.13. [#4291](https://github.com/PyO3/pyo3/pull/4291)
+- Stop generating code that will never be covered with declarative modules. [#4297](https://github.com/PyO3/pyo3/pull/4297)
+- Fix invalid deprecation warning for trailing optional on `#[setter]` function. [#4304](https://github.com/PyO3/pyo3/pull/4304)
+
+## [0.22.0] - 2024-06-24
+
+### Packaging
+
+- Update `heck` dependency to 0.5. [#3966](https://github.com/PyO3/pyo3/pull/3966)
+- Extend range of supported versions of `chrono-tz` optional dependency to include version 0.10. [#4061](https://github.com/PyO3/pyo3/pull/4061)
+- Update MSRV to 1.63. [#4129](https://github.com/PyO3/pyo3/pull/4129)
+- Add optional `num-rational` feature to add conversions with Python's `fractions.Fraction`. [#4148](https://github.com/PyO3/pyo3/pull/4148)
+- Support Python 3.13. [#4184](https://github.com/PyO3/pyo3/pull/4184)
+
+### Added
+
+- Add `PyWeakref`, `PyWeakrefReference` and `PyWeakrefProxy`. [#3835](https://github.com/PyO3/pyo3/pull/3835)
+- Support `#[pyclass]` on enums that have tuple variants. [#4072](https://github.com/PyO3/pyo3/pull/4072)
+- Add support for scientific notation in `Decimal` conversion. [#4079](https://github.com/PyO3/pyo3/pull/4079)
+- Add `pyo3_disable_reference_pool` conditional compilation flag to avoid the overhead of the global reference pool at the cost of known limitations as explained in the performance section of the guide. [#4095](https://github.com/PyO3/pyo3/pull/4095)
+- Add `#[pyo3(constructor = (...))]` to customize the generated constructors for complex enum variants. [#4158](https://github.com/PyO3/pyo3/pull/4158)
+- Add `PyType::module`, which always matches Python `__module__`. [#4196](https://github.com/PyO3/pyo3/pull/4196)
+- Add `PyType::fully_qualified_name` which matches the "fully qualified name" defined in [PEP 737](https://peps.python.org/pep-0737). [#4196](https://github.com/PyO3/pyo3/pull/4196)
+- Add `PyTypeMethods::mro` and `PyTypeMethods::bases`. [#4197](https://github.com/PyO3/pyo3/pull/4197)
+- Add `#[pyclass(ord)]` to implement ordering based on `PartialOrd`. [#4202](https://github.com/PyO3/pyo3/pull/4202)
+- Implement `ToPyObject` and `IntoPy<PyObject>` for `PyBackedStr` and `PyBackedBytes`. [#4205](https://github.com/PyO3/pyo3/pull/4205)
+- Add `#[pyclass(hash)]` option to implement `__hash__` in terms of the `Hash` implementation [#4206](https://github.com/PyO3/pyo3/pull/4206)
+- Add `#[pyclass(eq)]` option to generate `__eq__` based on `PartialEq`, and `#[pyclass(eq_int)]` for simple enums to implement equality based on their discriminants. [#4210](https://github.com/PyO3/pyo3/pull/4210)
+- Implement `From<Bound<'py, T>>` for `PyClassInitializer<T>`. [#4214](https://github.com/PyO3/pyo3/pull/4214)
+- Add `as_super` methods to `PyRef` and `PyRefMut` for accessing the base class by reference. [#4219](https://github.com/PyO3/pyo3/pull/4219)
+- Implement `PartialEq<str>` for `Bound<'py, PyString>`. [#4245](https://github.com/PyO3/pyo3/pull/4245)
+- Implement `PyModuleMethods::filename` on PyPy. [#4249](https://github.com/PyO3/pyo3/pull/4249)
+- Implement `PartialEq<[u8]>` for `Bound<'py, PyBytes>`. [#4250](https://github.com/PyO3/pyo3/pull/4250)
+- Add `pyo3_ffi::c_str` macro to create `&'static CStr` on Rust versions which don't have 1.77's `c""` literals. [#4255](https://github.com/PyO3/pyo3/pull/4255)
+- Support `bool` conversion with `numpy` 2.0's `numpy.bool` type [#4258](https://github.com/PyO3/pyo3/pull/4258)
+- Add `PyAnyMethods::{bitnot, matmul, floor_div, rem, divmod}`. [#4264](https://github.com/PyO3/pyo3/pull/4264)
+
+### Changed
+
+- Change the type of `PySliceIndices::slicelength` and the `length` parameter of `PySlice::indices()`. [#3761](https://github.com/PyO3/pyo3/pull/3761)
+- Deprecate implicit default for trailing optional arguments [#4078](https://github.com/PyO3/pyo3/pull/4078)
+- `Clone`ing pointers into the Python heap has been moved behind the `py-clone` feature, as it must panic without the GIL being held as a soundness fix. [#4095](https://github.com/PyO3/pyo3/pull/4095)
+- Add `#[track_caller]` to all `Py<T>`, `Bound<'py, T>` and `Borrowed<'a, 'py, T>` methods which can panic. [#4098](https://github.com/PyO3/pyo3/pull/4098)
+- Change `PyAnyMethods::dir` to be fallible and return `PyResult<Bound<'py, PyList>>` (and similar for `PyAny::dir`). [#4100](https://github.com/PyO3/pyo3/pull/4100)
+- The global reference pool (to track pending reference count decrements) is now initialized lazily to avoid the overhead of taking a mutex upon function entry when the functionality is not actually used. [#4178](https://github.com/PyO3/pyo3/pull/4178)
+- Emit error messages when using `weakref` or `dict` when compiling for `abi3` for Python older than 3.9. [#4194](https://github.com/PyO3/pyo3/pull/4194)
+- Change `PyType::name` to always match Python `__name__`. [#4196](https://github.com/PyO3/pyo3/pull/4196)
+- Remove CPython internal ffi call for complex number including: add, sub, mul, div, neg, abs, pow. Added PyAnyMethods::{abs, pos, neg} [#4201](https://github.com/PyO3/pyo3/pull/4201)
+- Deprecate implicit integer comparison for simple enums in favor of `#[pyclass(eq_int)]`. [#4210](https://github.com/PyO3/pyo3/pull/4210)
+- Set the `module=` attribute of declarative modules' child `#[pymodule]`s and `#[pyclass]`es. [#4213](https://github.com/PyO3/pyo3/pull/4213)
+- Set the `module` option for complex enum variants from the value set on the complex enum `module`. [#4228](https://github.com/PyO3/pyo3/pull/4228)
+- Respect the Python "limited API" when building for the `abi3` feature on PyPy or GraalPy. [#4237](https://github.com/PyO3/pyo3/pull/4237)
+- Optimize code generated by `#[pyo3(get)]` on `#[pyclass]` fields. [#4254](https://github.com/PyO3/pyo3/pull/4254)
+- `PyCFunction::new`, `PyCFunction::new_with_keywords` and `PyCFunction::new_closure` now take `&'static CStr` name and doc arguments (previously was `&'static str`). [#4255](https://github.com/PyO3/pyo3/pull/4255)
+- The `experimental-declarative-modules` feature is now stabilized and available by default. [#4257](https://github.com/PyO3/pyo3/pull/4257)
+
+### Fixed
+
+- Fix panic when `PYO3_CROSS_LIB_DIR` is set to a missing path. [#4043](https://github.com/PyO3/pyo3/pull/4043)
+- Fix a compile error when exporting an exception created with `create_exception!` living in a different Rust module using the `declarative-module` feature. [#4086](https://github.com/PyO3/pyo3/pull/4086)
+- Fix FFI definitions of `PY_VECTORCALL_ARGUMENTS_OFFSET` and `PyVectorcall_NARGS` to fix a false-positive assertion. [#4104](https://github.com/PyO3/pyo3/pull/4104)
+- Disable `PyUnicode_DATA` on PyPy: not exposed by PyPy. [#4116](https://github.com/PyO3/pyo3/pull/4116)
+- Correctly handle `#[pyo3(from_py_with = ...)]` attribute on dunder (`__magic__`) method arguments instead of silently ignoring it. [#4117](https://github.com/PyO3/pyo3/pull/4117)
+- Fix a compile error when declaring a standalone function or class method with a Python name that is a Rust keyword. [#4226](https://github.com/PyO3/pyo3/pull/4226)
+- Fix declarative modules discarding doc comments on the `mod` node. [#4236](https://github.com/PyO3/pyo3/pull/4236)
+- Fix `__dict__` attribute missing for `#[pyclass(dict)]` instances when building for `abi3` on Python 3.9. [#4251](https://github.com/PyO3/pyo3/pull/4251)
+
+## [0.21.2] - 2024-04-16
+
+### Changed
+
+- Deprecate the `PySet::empty()` gil-ref constructor. [#4082](https://github.com/PyO3/pyo3/pull/4082)
+
+### Fixed
+
+- Fix compile error for `async fn` in `#[pymethods]` with a `&self` receiver and more than one additional argument. [#4035](https://github.com/PyO3/pyo3/pull/4035)
+- Improve error message for wrong receiver type in `__traverse__`. [#4045](https://github.com/PyO3/pyo3/pull/4045)
+- Fix compile error when exporting a `#[pyclass]` living in a different Rust module using the `experimental-declarative-modules` feature. [#4054](https://github.com/PyO3/pyo3/pull/4054)
+- Fix `missing_docs` lint triggering on documented `#[pymodule]` functions. [#4067](https://github.com/PyO3/pyo3/pull/4067)
+- Fix undefined symbol errors for extension modules on AIX (by linking `libpython`). [#4073](https://github.com/PyO3/pyo3/pull/4073)
+
+## [0.21.1] - 2024-04-01
+
+### Added
+
+- Implement `Send` and `Sync` for `PyBackedStr` and `PyBackedBytes`. [#4007](https://github.com/PyO3/pyo3/pull/4007)
+- Implement `Clone`, `Debug`, `PartialEq`, `Eq`, `PartialOrd`, `Ord` and `Hash` implementation for `PyBackedBytes` and `PyBackedStr`, and `Display` for `PyBackedStr`. [#4020](https://github.com/PyO3/pyo3/pull/4020)
+- Add `import_exception_bound!` macro to import exception types without generating GIL Ref functionality for them. [#4027](https://github.com/PyO3/pyo3/pull/4027)
+
+### Changed
+
+- Emit deprecation warning for uses of GIL Refs as `#[setter]` function arguments. [#3998](https://github.com/PyO3/pyo3/pull/3998)
+- Add `#[inline]` hints on many `Bound` and `Borrowed` methods. [#4024](https://github.com/PyO3/pyo3/pull/4024)
+
+### Fixed
+
+- Handle `#[pyo3(from_py_with = "")]` in `#[setter]` methods [#3995](https://github.com/PyO3/pyo3/pull/3995)
+- Allow extraction of `&Bound` in `#[setter]` methods. [#3998](https://github.com/PyO3/pyo3/pull/3998)
+- Fix some uncovered code blocks emitted by `#[pymodule]`, `#[pyfunction]` and `#[pyclass]` macros. [#4009](https://github.com/PyO3/pyo3/pull/4009)
+- Fix typo in the panic message when a class referenced in `pyo3::import_exception!` does not exist. [#4012](https://github.com/PyO3/pyo3/pull/4012)
+- Fix compile error when using an async `#[pymethod]` with a receiver and additional arguments. [#4015](https://github.com/PyO3/pyo3/pull/4015)
+
+
+## [0.21.0] - 2024-03-25
+
+### Added
+
+- Add support for GraalPy (24.0 and up). [#3247](https://github.com/PyO3/pyo3/pull/3247)
+- Add `PyMemoryView` type. [#3514](https://github.com/PyO3/pyo3/pull/3514)
+- Allow `async fn` in for `#[pyfunction]` and `#[pymethods]`, with the `experimental-async` feature. [#3540](https://github.com/PyO3/pyo3/pull/3540) [#3588](https://github.com/PyO3/pyo3/pull/3588) [#3599](https://github.com/PyO3/pyo3/pull/3599) [#3931](https://github.com/PyO3/pyo3/pull/3931)
+- Implement `PyTypeInfo` for `PyEllipsis`, `PyNone` and `PyNotImplemented`. [#3577](https://github.com/PyO3/pyo3/pull/3577)
+- Support `#[pyclass]` on enums that have non-unit variants. [#3582](https://github.com/PyO3/pyo3/pull/3582)
+- Support `chrono` feature with `abi3` feature. [#3664](https://github.com/PyO3/pyo3/pull/3664)
+- `FromPyObject`, `IntoPy<PyObject>` and `ToPyObject` are implemented on `std::duration::Duration` [#3670](https://github.com/PyO3/pyo3/pull/3670)
+- Add `PyString::to_cow`. Add `Py<PyString>::to_str`, `Py<PyString>::to_cow`, and `Py<PyString>::to_string_lossy`, as ways to access Python string data safely beyond the GIL lifetime. [#3677](https://github.com/PyO3/pyo3/pull/3677)
+- Add `Bound<T>` and `Borrowed<T>` smart pointers as a new API for accessing Python objects. [#3686](https://github.com/PyO3/pyo3/pull/3686)
+- Add `PyNativeType::as_borrowed` to convert "GIL refs" to the new `Bound` smart pointer. [#3692](https://github.com/PyO3/pyo3/pull/3692)
+- Add `FromPyObject::extract_bound` method, to migrate `FromPyObject` implementations to the Bound API. [#3706](https://github.com/PyO3/pyo3/pull/3706)
+- Add `gil-refs` feature to allow continued use of the deprecated GIL Refs APIs. [#3707](https://github.com/PyO3/pyo3/pull/3707)
+- Add methods to `PyAnyMethods` for binary operators (`add`, `sub`, etc.) [#3712](https://github.com/PyO3/pyo3/pull/3712)
+- Add `chrono-tz` feature allowing conversion between `chrono_tz::Tz` and `zoneinfo.ZoneInfo` [#3730](https://github.com/PyO3/pyo3/pull/3730)
+- Add FFI definition `PyType_GetModuleByDef`. [#3734](https://github.com/PyO3/pyo3/pull/3734)
+- Conversion between `std::time::SystemTime` and `datetime.datetime` [#3736](https://github.com/PyO3/pyo3/pull/3736)
+- Add `Py::as_any` and `Py::into_any`. [#3785](https://github.com/PyO3/pyo3/pull/3785)
+- Add `PyStringMethods::encode_utf8`. [#3801](https://github.com/PyO3/pyo3/pull/3801)
+- Add `PyBackedStr` and `PyBackedBytes`, as alternatives to `&str` and `&bytes` where a Python object owns the data. [#3802](https://github.com/PyO3/pyo3/pull/3802) [#3991](https://github.com/PyO3/pyo3/pull/3991)
+- Allow `#[pymodule]` macro on Rust `mod` blocks, with the `experimental-declarative-modules` feature. [#3815](https://github.com/PyO3/pyo3/pull/3815)
+- Implement `ExactSizeIterator` for `set` and `frozenset` iterators on `abi3` feature. [#3849](https://github.com/PyO3/pyo3/pull/3849)
+- Add `Py::drop_ref` to explicitly drop a `Py`` and immediately decrease the Python reference count if the GIL is already held. [#3871](https://github.com/PyO3/pyo3/pull/3871)
+- Allow `#[pymodule]` macro on single argument functions that take `&Bound<'_, PyModule>`. [#3905](https://github.com/PyO3/pyo3/pull/3905)
+- Implement `FromPyObject` for `Cow<str>`. [#3928](https://github.com/PyO3/pyo3/pull/3928)
+- Implement `Default` for `GILOnceCell`. [#3971](https://github.com/PyO3/pyo3/pull/3971)
+- Add `PyDictMethods::into_mapping`, `PyListMethods::into_sequence` and `PyTupleMethods::into_sequence`. [#3982](https://github.com/PyO3/pyo3/pull/3982)
+
+### Changed
+
+- `PyDict::from_sequence` now takes a single argument of type `&PyAny` (previously took two arguments `Python` and `PyObject`). [#3532](https://github.com/PyO3/pyo3/pull/3532)
+- Deprecate `Py::is_ellipsis` and `PyAny::is_ellipsis` in favour of `any.is(py.Ellipsis())`. [#3577](https://github.com/PyO3/pyo3/pull/3577)
+- Split some `PyTypeInfo` functionality into new traits `HasPyGilRef` and `PyTypeCheck`. [#3600](https://github.com/PyO3/pyo3/pull/3600)
+- Deprecate `PyTryFrom` and `PyTryInto` traits in favor of `any.downcast()` via the `PyTypeCheck` and `PyTypeInfo` traits. [#3601](https://github.com/PyO3/pyo3/pull/3601)
+- Allow async methods to accept `&self`/`&mut self` [#3609](https://github.com/PyO3/pyo3/pull/3609)
+- `FromPyObject` for set types now also accept `frozenset` objects as input. [#3632](https://github.com/PyO3/pyo3/pull/3632)
+- `FromPyObject` for `bool` now also accepts NumPy's `bool_` as input. [#3638](https://github.com/PyO3/pyo3/pull/3638)
+- Add `AsRefSource` associated type to `PyNativeType`. [#3653](https://github.com/PyO3/pyo3/pull/3653)
+- Rename `.is_true` to `.is_truthy` on `PyAny` and `Py<PyAny>` to clarify that the test is not based on identity with or equality to the True singleton. [#3657](https://github.com/PyO3/pyo3/pull/3657)
+- `PyType::name` is now `PyType::qualname` whereas `PyType::name` efficiently accesses the full name which includes the module name. [#3660](https://github.com/PyO3/pyo3/pull/3660)
+- The `Iter(A)NextOutput` types are now deprecated and `__(a)next__` can directly return anything which can be converted into Python objects, i.e. awaitables do not need to be wrapped into `IterANextOutput` or `Option` any more. `Option` can still be used as well and returning `None` will trigger the fast path for `__next__`, stopping iteration without having to raise a `StopIteration` exception. [#3661](https://github.com/PyO3/pyo3/pull/3661)
+- Implement `FromPyObject` on `chrono::DateTime<Tz>` for all `Tz`, not just `FixedOffset` and `Utc`. [#3663](https://github.com/PyO3/pyo3/pull/3663)
+- Add lifetime parameter to `PyTzInfoAccess` trait. For the deprecated gil-ref API, the trait is now implemented for `&'py PyTime` and `&'py PyDateTime` instead of `PyTime` and `PyDate`. [#3679](https://github.com/PyO3/pyo3/pull/3679)
+- Calls to `__traverse__` become no-ops for unsendable pyclasses if on the wrong thread, thereby avoiding hard aborts at the cost of potential leakage. [#3689](https://github.com/PyO3/pyo3/pull/3689)
+- Include `PyNativeType` in `pyo3::prelude`. [#3692](https://github.com/PyO3/pyo3/pull/3692)
+- Improve performance of `extract::<i64>` (and other integer types) by avoiding call to `__index__()` converting the value to an integer for 3.10+. Gives performance improvement of around 30% for successful extraction. [#3742](https://github.com/PyO3/pyo3/pull/3742)
+- Relax bound of `FromPyObject` for `Py<T>` to just `T: PyTypeCheck`. [#3776](https://github.com/PyO3/pyo3/pull/3776)
+- `PySet` and `PyFrozenSet` iterators now always iterate the equivalent of `iter(set)`. (A "fast path" with no noticeable performance benefit was removed.) [#3849](https://github.com/PyO3/pyo3/pull/3849)
+- Move implementations of `FromPyObject` for `&str`, `Cow<str>`, `&[u8]` and `Cow<[u8]>` onto a temporary trait `FromPyObjectBound` when `gil-refs` feature is deactivated. [#3928](https://github.com/PyO3/pyo3/pull/3928)
+- Deprecate `GILPool`, `Python::with_pool`, and `Python::new_pool`. [#3947](https://github.com/PyO3/pyo3/pull/3947)
+
+### Removed
+
+- Remove all functionality deprecated in PyO3 0.19. [#3603](https://github.com/PyO3/pyo3/pull/3603)
+
+### Fixed
+
+- Match PyPy 7.3.14 in removing PyPy-only symbol `Py_MAX_NDIMS` in favour of `PyBUF_MAX_NDIM`. [#3757](https://github.com/PyO3/pyo3/pull/3757)
+- Fix segmentation fault using `datetime` types when an invalid `datetime` module is on sys.path. [#3818](https://github.com/PyO3/pyo3/pull/3818)
+- Fix `non_local_definitions` lint warning triggered by many PyO3 macros. [#3901](https://github.com/PyO3/pyo3/pull/3901)
+- Disable `PyCode` and `PyCode_Type` on PyPy: `PyCode_Type` is not exposed by PyPy. [#3934](https://github.com/PyO3/pyo3/pull/3934)
+
+## [0.21.0-beta.0] - 2024-03-10
+
+Prerelease of PyO3 0.21. See [the GitHub diff](https://github.com/pyo3/pyo3/compare/v0.21.0-beta.0...v0.21.0) for what changed between 0.21.0-beta.0 and the final release.
+
+## [0.20.3] - 2024-02-23
+
+### Packaging
+
+- Add `portable-atomic` dependency. [#3619](https://github.com/PyO3/pyo3/pull/3619)
+- Check maximum version of Python at build time and for versions not yet supported require opt-in to the `abi3` stable ABI by the environment variable `PYO3_USE_ABI3_FORWARD_COMPATIBILITY=1`. [#3821](https://github.com/PyO3/pyo3/pull/3821)
+
+### Fixed
+
+- Use `portable-atomic` to support platforms without 64-bit atomics. [#3619](https://github.com/PyO3/pyo3/pull/3619)
+- Fix compilation failure with `either` feature enabled without `experimental-inspect` enabled. [#3834](https://github.com/PyO3/pyo3/pull/3834)
+
 ## [0.20.2] - 2024-01-04
 
 ### Packaging
@@ -66,7 +807,7 @@ To see unreleased changes, please see the [CHANGELOG on the main branch guide](h
 ### Changed
 
 - Change `PySet::discard` to return `PyResult<bool>` (previously returned nothing). [#3281](https://github.com/PyO3/pyo3/pull/3281)
-- Optimize implmentation of `IntoPy` for Rust tuples to Python tuples. [#3321](https://github.com/PyO3/pyo3/pull/3321)
+- Optimize implementation of `IntoPy` for Rust tuples to Python tuples. [#3321](https://github.com/PyO3/pyo3/pull/3321)
 - Change `PyDict::get_item` to no longer suppress arbitrary exceptions (the return type is now `PyResult<Option<&PyAny>>` instead of `Option<&PyAny>`), and deprecate `PyDict::get_item_with_error`. [#3330](https://github.com/PyO3/pyo3/pull/3330)
 - Deprecate FFI definitions which are deprecated in Python 3.12. [#3336](https://github.com/PyO3/pyo3/pull/3336)
 - `AsPyPointer` is now an `unsafe trait`. [#3358](https://github.com/PyO3/pyo3/pull/3358)
@@ -173,7 +914,7 @@ To see unreleased changes, please see the [CHANGELOG on the main branch guide](h
 - Add `#[pyo3(from_item_all)]` when deriving `FromPyObject` to specify `get_item` as getter for all fields. [#3120](https://github.com/PyO3/pyo3/pull/3120)
 - Add `pyo3::exceptions::PyBaseExceptionGroup` for Python 3.11, and corresponding FFI definition `PyExc_BaseExceptionGroup`. [#3141](https://github.com/PyO3/pyo3/pull/3141)
 - Accept `#[new]` with `#[classmethod]` to create a constructor which receives a (subtype's) class/`PyType` as its first argument. [#3157](https://github.com/PyO3/pyo3/pull/3157)
-- Add `PyClass::get` and `Py::get` for GIL-indepedent access to classes with `#[pyclass(frozen)]`. [#3158](https://github.com/PyO3/pyo3/pull/3158)
+- Add `PyClass::get` and `Py::get` for GIL-independent access to classes with `#[pyclass(frozen)]`. [#3158](https://github.com/PyO3/pyo3/pull/3158)
 - Add `PyAny::is_exact_instance` and `PyAny::is_exact_instance_of`. [#3161](https://github.com/PyO3/pyo3/pull/3161)
 
 ### Changed
@@ -600,7 +1341,7 @@ To see unreleased changes, please see the [CHANGELOG on the main branch guide](h
 - Respect Rust privacy rules for items wrapped with `wrap_pyfunction` and `wrap_pymodule`. [#2081](https://github.com/PyO3/pyo3/pull/2081)
 - Add modulo argument to `__ipow__` magic method. [#2083](https://github.com/PyO3/pyo3/pull/2083)
 - Fix FFI definition for `_PyCFunctionFast`. [#2126](https://github.com/PyO3/pyo3/pull/2126)
-- `PyDateTimeAPI` and `PyDateTime_TimeZone_UTC` are are now unsafe functions instead of statics. [#2126](https://github.com/PyO3/pyo3/pull/2126)
+- `PyDateTimeAPI` and `PyDateTime_TimeZone_UTC` are now unsafe functions instead of statics. [#2126](https://github.com/PyO3/pyo3/pull/2126)
 - `PyDateTimeAPI` does not implicitly call `PyDateTime_IMPORT` anymore to reflect the original Python API more closely. Before the first call to `PyDateTime_IMPORT` a null pointer is returned. Therefore before calling any of the following FFI functions `PyDateTime_IMPORT` must be called to avoid undefined behavior: [#2126](https://github.com/PyO3/pyo3/pull/2126)
   - `PyDateTime_TimeZone_UTC`
   - `PyDate_Check`
@@ -1131,8 +1872,8 @@ To see unreleased changes, please see the [CHANGELOG on the main branch guide](h
 - Change return type of `PyTuple::slice` and `PyTuple::split_from` from `Py<PyTuple>` to `&PyTuple`. [#970](https://github.com/PyO3/pyo3/pull/970)
 - Change return type of `PyTuple::as_slice` to `&[&PyAny]`. [#971](https://github.com/PyO3/pyo3/pull/971)
 - Rename `PyTypeInfo::type_object` to `type_object_raw`, and add `Python` argument. [#975](https://github.com/PyO3/pyo3/pull/975)
-- Update `num-complex` optional dependendency from `0.2` to `0.3`. [#977](https://github.com/PyO3/pyo3/pull/977)
-- Update `num-bigint` optional dependendency from `0.2` to `0.3`. [#978](https://github.com/PyO3/pyo3/pull/978)
+- Update `num-complex` optional dependency from `0.2` to `0.3`. [#977](https://github.com/PyO3/pyo3/pull/977)
+- Update `num-bigint` optional dependency from `0.2` to `0.3`. [#978](https://github.com/PyO3/pyo3/pull/978)
 - `#[pyproto]` is re-implemented without specialization. [#961](https://github.com/PyO3/pyo3/pull/961)
 - `PyClassAlloc::alloc` is renamed to `PyClassAlloc::new`. [#990](https://github.com/PyO3/pyo3/pull/990)
 - `#[pyproto]` methods can now have return value `T` or `PyResult<T>` (previously only `PyResult<T>` was supported). [#996](https://github.com/PyO3/pyo3/pull/996)
@@ -1465,7 +2206,7 @@ Yanked
 - `IntoPyDictPointer` was replace by `IntoPyDict` which doesn't convert `PyDict` itself anymore and returns a `PyDict` instead of `*mut PyObject`.
 - `PyTuple::new` now takes an `IntoIterator` instead of a slice
 - Updated to syn 0.15
-- Splitted `PyTypeObject` into `PyTypeObject` without the create method and `PyTypeCreate` with requires `PyObjectAlloc<Self> + PyTypeInfo + Sized`.
+- Split `PyTypeObject` into `PyTypeObject` without the create method and `PyTypeCreate` with requires `PyObjectAlloc<Self> + PyTypeInfo + Sized`.
 - Ran `cargo edition --fix` which prefixed path with `crate::` for rust 2018
 - Renamed `async` to `pyasync` as async will be a keyword in the 2018 edition.
 - Starting to use `NonNull<*mut PyObject>` for Py and PyObject by ijl [#260](https://github.com/PyO3/pyo3/pull/260)
@@ -1538,7 +2279,7 @@ Yanked
 - `proc_macro` has been stabilized on nightly ([rust-lang/rust#52081](https://github.com/rust-lang/rust/pull/52081)). This means that we can remove the `proc_macro` feature, but now we need the `use_extern_macros` from the 2018 edition instead.
 - All proc macro are now prefixed with `py` and live in the prelude. This means you can use `#[pyclass]`, `#[pymethods]`, `#[pyproto]`, `#[pyfunction]` and `#[pymodinit]` directly, at least after a `use pyo3::prelude::*`. They were also moved into a module called `proc_macro`. You shouldn't use `#[pyo3::proc_macro::pyclass]` or other longer paths in attributes because `proc_macro_path_invoc` isn't going to be stabilized soon.
 - Renamed the `base` option in the `pyclass` macro to `extends`.
-- `#[pymodinit]` uses the function name as module name, unless the name is overrriden with `#[pymodinit(name)]`
+- `#[pymodinit]` uses the function name as module name, unless the name is overridden with `#[pymodinit(name)]`
 - The guide is now properly versioned.
 
 ## [0.2.7] - 2018-05-18
@@ -1612,7 +2353,7 @@ Yanked
 - Added inheritance support #15
 - Added weakref support #56
 - Added subclass support #64
-- Added `self.__dict__` supoort #68
+- Added `self.__dict__` support #68
 - Added `pyo3::prelude` module #70
 - Better `Iterator` support for PyTuple, PyList, PyDict #75
 - Introduce IntoPyDictPointer similar to IntoPyTuple #69
@@ -1628,7 +2369,31 @@ Yanked
 
 - Initial release
 
-[Unreleased]: https://github.com/pyo3/pyo3/compare/v0.20.2...HEAD
+[Unreleased]: https://github.com/pyo3/pyo3/compare/v0.27.0...HEAD
+[0.27.0]: https://github.com/pyo3/pyo3/compare/v0.26.0...v0.27.0
+[0.26.0]: https://github.com/pyo3/pyo3/compare/v0.25.1...v0.26.0
+[0.25.1]: https://github.com/pyo3/pyo3/compare/v0.25.0...v0.25.1
+[0.25.0]: https://github.com/pyo3/pyo3/compare/v0.24.2...v0.25.0
+[0.24.2]: https://github.com/pyo3/pyo3/compare/v0.24.1...v0.24.2
+[0.24.1]: https://github.com/pyo3/pyo3/compare/v0.24.0...v0.24.1
+[0.24.0]: https://github.com/pyo3/pyo3/compare/v0.23.5...v0.24.0
+[0.23.5]: https://github.com/pyo3/pyo3/compare/v0.23.4...v0.23.5
+[0.23.4]: https://github.com/pyo3/pyo3/compare/v0.23.3...v0.23.4
+[0.23.3]: https://github.com/pyo3/pyo3/compare/v0.23.2...v0.23.3
+[0.23.2]: https://github.com/pyo3/pyo3/compare/v0.23.1...v0.23.2
+[0.23.1]: https://github.com/pyo3/pyo3/compare/v0.23.0...v0.23.1
+[0.23.0]: https://github.com/pyo3/pyo3/compare/v0.22.5...v0.23.0
+[0.22.5]: https://github.com/pyo3/pyo3/compare/v0.22.4...v0.22.5
+[0.22.4]: https://github.com/pyo3/pyo3/compare/v0.22.3...v0.22.4
+[0.22.3]: https://github.com/pyo3/pyo3/compare/v0.22.2...v0.22.3
+[0.22.2]: https://github.com/pyo3/pyo3/compare/v0.22.1...v0.22.2
+[0.22.1]: https://github.com/pyo3/pyo3/compare/v0.22.0...v0.22.1
+[0.22.0]: https://github.com/pyo3/pyo3/compare/v0.21.2...v0.22.0
+[0.21.2]: https://github.com/pyo3/pyo3/compare/v0.21.1...v0.21.2
+[0.21.1]: https://github.com/pyo3/pyo3/compare/v0.21.0...v0.21.1
+[0.21.0]: https://github.com/pyo3/pyo3/compare/v0.20.3...v0.21.0
+[0.21.0-beta.0]: https://github.com/pyo3/pyo3/compare/v0.20.3...v0.21.0-beta.0
+[0.20.3]: https://github.com/pyo3/pyo3/compare/v0.20.2...v0.20.3
 [0.20.2]: https://github.com/pyo3/pyo3/compare/v0.20.1...v0.20.2
 [0.20.1]: https://github.com/pyo3/pyo3/compare/v0.20.0...v0.20.1
 [0.20.0]: https://github.com/pyo3/pyo3/compare/v0.19.2...v0.20.0
@@ -1674,7 +2439,7 @@ Yanked
 [0.9.2]: https://github.com/pyo3/pyo3/compare/v0.9.1...v0.9.2
 [0.9.1]: https://github.com/pyo3/pyo3/compare/v0.9.0...v0.9.1
 [0.9.0]: https://github.com/pyo3/pyo3/compare/v0.8.5...v0.9.0
-[0.8.4]: https://github.com/pyo3/pyo3/compare/v0.8.4...v0.8.5
+[0.8.5]: https://github.com/pyo3/pyo3/compare/v0.8.4...v0.8.5
 [0.8.4]: https://github.com/pyo3/pyo3/compare/v0.8.3...v0.8.4
 [0.8.3]: https://github.com/pyo3/pyo3/compare/v0.8.2...v0.8.3
 [0.8.2]: https://github.com/pyo3/pyo3/compare/v0.8.1...v0.8.2
@@ -1683,7 +2448,8 @@ Yanked
 [0.7.0]: https://github.com/pyo3/pyo3/compare/v0.6.0...v0.7.0
 [0.6.0]: https://github.com/pyo3/pyo3/compare/v0.5.3...v0.6.0
 [0.5.3]: https://github.com/pyo3/pyo3/compare/v0.5.2...v0.5.3
-[0.5.2]: https://github.com/pyo3/pyo3/compare/v0.5.0...v0.5.2
+[0.5.2]: https://github.com/pyo3/pyo3/compare/v0.5.1...v0.5.2
+[0.5.1]: https://github.com/pyo3/pyo3/compare/v0.5.0...v0.5.1
 [0.5.0]: https://github.com/pyo3/pyo3/compare/v0.4.1...v0.5.0
 [0.4.1]: https://github.com/pyo3/pyo3/compare/v0.4.0...v0.4.1
 [0.4.0]: https://github.com/pyo3/pyo3/compare/v0.3.2...v0.4.0
diff --git a/Cargo.toml b/Cargo.toml
index 5386b76f573..3c2e5372fbb 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "pyo3"
-version = "0.21.0-dev"
+version = "0.27.0"
 description = "Bindings to Python interpreter"
 authors = ["PyO3 Project and Contributors <https://github.com/PyO3>"]
 readme = "README.md"
@@ -10,46 +10,67 @@ repository = "https://github.com/pyo3/pyo3"
 documentation = "https://docs.rs/crate/pyo3/"
 categories = ["api-bindings", "development-tools::ffi"]
 license = "MIT OR Apache-2.0"
-exclude = ["/.gitignore", ".cargo/config", "/codecov.yml", "/Makefile", "/pyproject.toml", "/noxfile.py", "/.github", "/tests/test_compile_error.rs", "/tests/ui"]
+exclude = [
+    "/.gitignore",
+    ".cargo/config",
+    "/codecov.yml",
+    "/Makefile",
+    "/pyproject.toml",
+    "/noxfile.py",
+    "/.github",
+    "/tests/test_compile_error.rs",
+    "/tests/ui",
+]
 edition = "2021"
-rust-version = "1.56"
+rust-version.workspace = true
 
 [dependencies]
-cfg-if = "1.0"
 libc = "0.2.62"
-parking_lot = ">= 0.11, < 0.13"
-memoffset = "0.9"
-portable-atomic = "1.0"
+once_cell = "1.21"
 
 # ffi bindings to the python interpreter, split into a separate crate so they can be used independently
-pyo3-ffi = { path = "pyo3-ffi", version = "=0.21.0-dev" }
+pyo3-ffi = { path = "pyo3-ffi", version = "=0.27.0" }
 
 # support crates for macros feature
-pyo3-macros = { path = "pyo3-macros", version = "=0.21.0-dev", optional = true }
+pyo3-macros = { path = "pyo3-macros", version = "=0.27.0", optional = true }
 indoc = { version = "2.0.1", optional = true }
 unindent = { version = "0.2.1", optional = true }
 
 # support crate for multiple-pymethods feature
-inventory = { version = "0.3.0", optional = true }
+inventory = { version = "0.3.5", optional = true }
 
 # crate integrations that can be added using the eponymous features
-anyhow = { version = "1.0", optional = true }
+anyhow = { version = "1.0.1", optional = true }
+bigdecimal = { version = "0.4.7", optional = true }
+bytes = { version = "1.10", optional = true }
 chrono = { version = "0.4.25", default-features = false, optional = true }
-chrono-tz = { version = ">= 0.6, < 0.9", default-features = false, optional = true }
+chrono-tz = { version = ">= 0.10, < 0.11", default-features = false, optional = true }
 either = { version = "1.9", optional = true }
-eyre = { version = ">= 0.4, < 0.7", optional = true }
-hashbrown = { version = ">= 0.9, < 0.15", optional = true }
-indexmap = { version = ">= 1.6, < 3", optional = true }
-num-bigint = { version = "0.4", optional = true }
-num-complex = { version = ">= 0.2, < 0.5", optional = true }
-rust_decimal = { version = "1.0.0", default-features = false, optional = true }
+eyre = { version = ">= 0.6.8, < 0.7", optional = true }
+hashbrown = { version = ">= 0.15.0, < 0.17", optional = true, default-features = false }
+indexmap = { version = ">= 2.5.0, < 3", optional = true }
+jiff-02 = { package = "jiff", version = "0.2", optional = true }
+num-bigint = { version = "0.4.4", optional = true }
+num-complex = { version = ">= 0.4.6, < 0.5", optional = true }
+num-rational = { version = "0.4.1", optional = true }
+num-traits = { version = "0.2.16", optional = true }
+ordered-float = { version = "5.0.0", default-features = false, optional = true }
+rust_decimal = { version = "1.15", default-features = false, optional = true }
+time = { version = "0.3.38", default-features = false, optional = true }
 serde = { version = "1.0", optional = true }
 smallvec = { version = "1.0", optional = true }
+uuid = { version = "1.11.0", optional = true }
+lock_api = { version = "0.4", optional = true }
+parking_lot = { version = "0.12", optional = true }
+iana-time-zone = { version = "0.1", optional = true, features = ["fallback"]}
+
+[target.'cfg(not(target_has_atomic = "64"))'.dependencies]
+portable-atomic = "1.0"
 
 [dev-dependencies]
 assert_approx_eq = "1.1.0"
 chrono = "0.4.25"
-chrono-tz = ">= 0.6, < 0.9"
+chrono-tz = ">= 0.10, < 0.11"
 # Required for "and $N others" normalization
 trybuild = ">=1.0.70"
 proptest = { version = "1.0", default-features = false, features = ["std"] }
@@ -58,16 +79,23 @@ serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0.61"
 rayon = "1.6.1"
 futures = "0.3.28"
+tempfile = "3.12.0"
+static_assertions = "1.1.0"
+uuid = { version = "1.10.0", features = ["v4"] }
+parking_lot = { version = "0.12.3", features = ["arc_lock"] }
 
 [build-dependencies]
-pyo3-build-config = { path = "pyo3-build-config", version = "=0.21.0-dev", features = ["resolve-config"] }
+pyo3-build-config = { path = "pyo3-build-config", version = "=0.27.0", features = ["resolve-config"] }
 
 [features]
 default = ["macros"]
 
+# Enables support for `async fn` for `#[pyfunction]` and `#[pymethods]`.
+experimental-async = ["macros", "pyo3-macros/experimental-async"]
+
 # Enables pyo3::inspect module and additional type information on FromPyObject
 # and IntoPy traits
-experimental-inspect = []
+experimental-inspect = ["pyo3-macros/experimental-inspect"]
 
 # Enables macros: #[pyclass], #[pymodule], #[pyfunction] etc.
 macros = ["pyo3-macros", "indoc", "unindent"]
@@ -89,16 +117,29 @@ abi3-py38 = ["abi3-py39", "pyo3-build-config/abi3-py38", "pyo3-ffi/abi3-py38"]
 abi3-py39 = ["abi3-py310", "pyo3-build-config/abi3-py39", "pyo3-ffi/abi3-py39"]
 abi3-py310 = ["abi3-py311", "pyo3-build-config/abi3-py310", "pyo3-ffi/abi3-py310"]
 abi3-py311 = ["abi3-py312", "pyo3-build-config/abi3-py311", "pyo3-ffi/abi3-py311"]
-abi3-py312 = ["abi3", "pyo3-build-config/abi3-py312", "pyo3-ffi/abi3-py312"]
+abi3-py312 = ["abi3-py313", "pyo3-build-config/abi3-py312", "pyo3-ffi/abi3-py312"]
+abi3-py313 = ["abi3-py314", "pyo3-build-config/abi3-py313", "pyo3-ffi/abi3-py313"]
+abi3-py314 = ["abi3", "pyo3-build-config/abi3-py314", "pyo3-ffi/abi3-py314"]
 
 # Automatically generates `python3.dll` import libraries for Windows targets.
 generate-import-lib = ["pyo3-ffi/generate-import-lib"]
 
-# Changes `Python::with_gil` to automatically initialize the Python interpreter if needed.
+# Changes `Python::attach` to automatically initialize the Python interpreter if needed.
 auto-initialize = []
 
-# Allows use of the deprecated "GIL Refs" APIs.
-gil-refs = []
+# Enables `Clone`ing references to Python objects `Py<T>` which panics if the
+# thread is not attached to the Python interpreter.
+py-clone = []
+
+# Adds `OnceExt` and `MutexExt` implementations to the `parking_lot` types
+parking_lot = ["dep:parking_lot", "lock_api"]
+arc_lock = ["lock_api", "lock_api/arc_lock", "parking_lot?/arc_lock"]
+
+num-bigint = ["dep:num-bigint", "dep:num-traits"]
+bigdecimal = ["dep:bigdecimal", "num-bigint"]
+
+chrono-local = ["chrono/clock", "dep:iana-time-zone"]
+
 
 # Optimizes PyObject to Vec conversion and so on.
 nightly = []
@@ -107,20 +148,33 @@ nightly = []
 # This is mostly intended for testing purposes - activating *all* of these isn't particularly useful.
 full = [
     "macros",
-    # "multiple-pymethods", # TODO re-add this when MSRV is greater than 1.62
+    # "multiple-pymethods", # Not supported by wasm
+    "anyhow",
+    "arc_lock",
+    "bigdecimal",
+    "bytes",
     "chrono",
+    "chrono-local",
     "chrono-tz",
-    "num-bigint",
-    "num-complex",
-    "hashbrown",
-    "smallvec",
-    "serde",
-    "indexmap",
     "either",
-    "eyre",
-    "anyhow",
+    "experimental-async",
     "experimental-inspect",
+    "eyre",
+    "hashbrown",
+    "indexmap",
+    "jiff-02",
+    "lock_api",
+    "num-bigint",
+    "num-complex",
+    "num-rational",
+    "ordered-float",
+    "parking_lot",
+    "py-clone",
     "rust_decimal",
+    "serde",
+    "smallvec",
+    "time",
+    "uuid",
 ]
 
 [workspace]
@@ -129,9 +183,11 @@ members = [
     "pyo3-build-config",
     "pyo3-macros",
     "pyo3-macros-backend",
+    "pyo3-introspection",
     "pytests",
     "examples",
 ]
+package.rust-version = "1.83"
 
 [package.metadata.docs.rs]
 no-default-features = true
@@ -149,6 +205,9 @@ let_unit_value = "warn"
 manual_assert = "warn"
 manual_ok_or = "warn"
 todo = "warn"
+# TODO: make this "warn"
+# https://github.com/PyO3/pyo3/issues/5487
+undocumented_unsafe_blocks = "allow"
 unnecessary_wraps = "warn"
 useless_transmute = "warn"
 used_underscore_binding = "warn"
@@ -156,9 +215,10 @@ used_underscore_binding = "warn"
 [workspace.lints.rust]
 elided_lifetimes_in_paths = "warn"
 invalid_doc_attributes = "warn"
-rust_2018_idioms = "warn"
+rust_2018_idioms = { level = "warn", priority = -1 }
 rust_2021_prelude_collisions = "warn"
 unused_lifetimes = "warn"
+unsafe_op_in_unsafe_fn = "warn"
 
 [workspace.lints.rustdoc]
 broken_intra_doc_links = "warn"
diff --git a/Contributing.md b/Contributing.md
index 332645542d7..97dda500998 100644
--- a/Contributing.md
+++ b/Contributing.md
@@ -18,24 +18,52 @@ The following sections also contain specific ideas on where to start contributin
 ## Setting up a development environment
 
 To work and develop PyO3, you need Python & Rust installed on your system.
+
 * We encourage the use of [rustup](https://rustup.rs/) to be able to select and choose specific toolchains based on the project.
 * [Pyenv](https://github.com/pyenv/pyenv) is also highly recommended for being able to choose a specific Python version.
 * [virtualenv](https://virtualenv.pypa.io/en/latest/) can also be used with or without Pyenv to use specific installed Python versions.
 * [`nox`][nox] is used to automate many of our CI tasks.
 
-### Caveats
+### Testing, linting, etc. with nox
+
+[`Nox`][nox] is used to automate many of our CI tasks and can be used locally to handle verfication tasks as you code. We recommend running these actions via nox to make use of our prefered configuration options. You can install nox into your global python with pip: `pip install nox` or (recommended) with [`pipx`][pipx] `pip install pipx`, `pipx install nox`
+
+The main nox commands we have implemented are:
+
+* `nox -s test` will run the full suite of recommended rust and python tests (>10 minutes)
+* `nox -s test-rust -- skip-full` will run a short suite of rust tests (2-3 minutes)
+* `nox -s ruff` will check python linting and apply standard formatting rules
+* `nox -s rustfmt` will check basic rust linting and apply standard formatting rules
+* `nox -s rumdl` will check the markdown in the guide
+* `nox -s clippy` will run clippy to make recommendations on rust style
+* `nox -s bench` will benchmark your rust code
+* `nox -s codspeed` will run our suite of rust and python performance tests
+* `nox -s coverage` will analyse test coverage and output `coverage.json` (alternatively: `nox -s coverage lcov` outputs `lcov.info`)
+* `nox -s check-guide` will use [`lychee`][lychee] to check all the links in the guide and doc comments.
+
+Use  `nox -l` to list the full set of subcommands you can run.
+
+#### UI Tests
+
+PyO3 uses [`trybuild`][trybuild] to develop UI tests to capture error messages from the Rust compiler for some of the macro functionality.
+
+Because there are several feature combinations for these UI tests, when updating them all (e.g. for a new Rust compiler version) it may be helpful to use the `update-ui-tests` nox session:
+
+```bash
+nox -s update-ui-tests
+```
 
-* When using pyenv on macOS, installing a Python version using `--enable-shared` is required to make it work. i.e `env PYTHON_CONFIGURE_OPTS="--enable-shared" pyenv install 3.7.12`
+## Ways to help
 
 ### Help users identify bugs
 
-The [PyO3 Gitter channel](https://gitter.im/PyO3/Lobby) is very active with users who are new to PyO3, and often completely new to Rust. Helping them debug is a great way to get experience with the PyO3 codebase.
+The [PyO3 Discord server](https://discord.gg/33kcChzH7f) is very active with users who are new to PyO3, and often completely new to Rust. Helping them debug is a great way to get experience with the PyO3 codebase.
 
 Helping others often reveals bugs, documentation weaknesses, and missing APIs. It's a good idea to open GitHub issues for these immediately so the resolution can be designed and implemented!
 
 ### Implement issues ready for development
 
-Issues where the solution is clear and work is not in progress use the [needs-implementer](https://github.com/PyO3/pyo3/issues?q=is%3Aissue+is%3Aopen+label%3Aneeds-implemeter) label.
+Issues where the solution is clear and work is not in progress use the [needs-implementer](https://github.com/PyO3/pyo3/issues?q=is%3Aissue+is%3Aopen+label%3Aneeds-implementer) label.
 
 Don't be afraid if the solution is not clear to you! The core PyO3 contributors will be happy to mentor you through any questions you have to help you write the solution.
 
@@ -57,19 +85,25 @@ nox -s docs -- open
 #### Doctests
 
 We use lots of code blocks in our docs. Run `cargo test --doc` when making changes to check that
-the doctests still work, or `cargo test` to run all the tests including doctests. See
+the doctests still work, or `cargo test` to run all the Rust tests including doctests. See
 https://doc.rust-lang.org/rustdoc/documentation-tests.html for a guide on doctests.
 
 #### Building the guide
 
 You can preview the user guide by building it locally with `mdbook`.
 
-First, install [`mdbook`][mdbook] and [`nox`][nox]. Then, run
+First, install [`mdbook`][mdbook], the [`mdbook-tabs`][mdbook-tabs] plugin and [`nox`][nox]. Then, run
 
 ```shell
 nox -s build-guide -- --open
 ```
 
+To check all links in the guide are valid, also install [`lychee`][lychee] and use the `check-guide` session instead:
+
+```shell
+nox -s check-guide
+```
+
 ### Help design the next PyO3
 
 Issues which don't yet have a clear solution use the [needs-design](https://github.com/PyO3/pyo3/issues?q=is%3Aissue+is%3Aopen+label%3Aneeds-design) label.
@@ -84,21 +118,18 @@ Everybody is welcome to submit comments on open PRs. Please help ensure new PyO3
 
 Here are a few things to note when you are writing PRs.
 
-### Continuous Integration
-
-The PyO3 repo uses GitHub Actions. PRs are blocked from merging if CI is not successful.
+### Testing and Continuous Integration
 
-Formatting, linting and tests are checked for all Rust and Python code. In addition, all warnings in Rust code are disallowed (using `RUSTFLAGS="-D warnings"`).
+The PyO3 repo uses GitHub Actions.
+PRs are blocked from merging if CI is not successful.
+Formatting, linting and tests are checked for all Rust and Python code (the pipeline will abort early if formatting fails to save resources).
+In addition, all warnings in Rust code are disallowed (using `RUSTFLAGS="-D warnings"`).
 
 Tests run with all supported Python versions with the latest stable Rust compiler, as well as for Python 3.9 with the minimum supported Rust version.
 
 If you are adding a new feature, you should add it to the `full` feature in our *Cargo.toml** so that it is tested in CI.
 
-You can run these tests yourself with
-```nox```
-and
-```nox -l```
-lists further commands you can run.
+You can run the CI pipeline components yourself with `nox`, see [the testing section above](#testing-linting-etc-with-nox).
 
 ### Documenting changes
 
@@ -155,6 +186,20 @@ Below are guidelines on what compatibility all PRs are expected to deliver for e
 
 PyO3 supports all officially supported Python versions, as well as the latest PyPy3 release. All of these versions are tested in CI.
 
+#### Adding support for new CPython versions
+
+If you plan to add support for a pre-release version of CPython, here's a (non-exhaustive) checklist:
+
+ - [ ] Wait until the last alpha release (usually alpha7), since ABI is not guaranteed until the first beta release
+ - [ ] Add prerelease_ver-dev (e.g. `3.14-dev`) to `.github/workflows/ci.yml`, and bump version in `noxfile.py`, `pyo3-ffi/Cargo.toml` under `max-version` within  `[package.metadata.cpython]`, and `max` within `pyo3-ffi/build.rs`
+- [ ] Add a new abi3-prerelease feature for the version (e.g. `abi3-py314`)
+   - In `pyo3-build-config/Cargo.toml`, set abi3-most_current_stable to ["abi3-prerelease"] and abi3-prerelease to ["abi3"]
+   - In `pyo3-ffi/Cargo.toml`, set abi3-most_current_stable to ["abi3-prerelease", "pyo3-build-config/abi3-most_current_stable"] and abi3-prerelease to ["abi3", "pyo3-build-config/abi3-prerelease"]
+   - In `Cargo.toml`, set abi3-most_current_stable to ["abi3-prerelease", "pyo3-ffi/abi3-most_current_stable"] and abi3-prerelease to ["abi3", "pyo3-ffi/abi3-prerelease"]
+ - [ ] Use `#[cfg(Py_prerelease])` (e.g. `#[cfg(Py_3_14)]`) and `#[cfg(not(Py_prerelease]))` to indicate changes between the stable branches of CPython and the pre-release
+ - [ ] Do not add a Rust binding to any function, struct, or global variable prefixed with `_` in CPython's headers
+ - [ ] Ping @ngoldbaum and @davidhewitt for assistance
+
 ### Rust
 
 PyO3 aims to make use of up-to-date Rust language features to keep the implementation as efficient as possible.
@@ -171,15 +216,20 @@ First, there are Rust-based benchmarks located in the `pyo3-benches` subdirector
 
     nox -s bench
 
-Second, there is a Python-based benchmark contained in the `pytests` subdirectory. You can read more about it [here](pytests).
+Second, there is a Python-based benchmark contained in the `pytests` subdirectory. You can read more about it [here](https://github.com/PyO3/pyo3/tree/main/pytests).
 
 ## Code coverage
 
 You can view what code is and isn't covered by PyO3's tests. We aim to have 100% coverage - please check coverage and add tests if you notice a lack of coverage!
 
-- First, generate a `lcov.info` file with
+- First, ensure the llvm-cov cargo plugin is installed. You may need to run the plugin through cargo once before using it with `nox`.
+```shell
+cargo install cargo-llvm-cov
+cargo llvm-cov
+```
+- Then, generate an `lcov.info` file with
 ```shell
-nox -s coverage
+nox -s coverage -- lcov
 ```
 You can install an IDE plugin to view the coverage. For example, if you use VSCode:
 - Add the [coverage-gutters](https://marketplace.visualstudio.com/items?itemName=ryanluker.vscode-coverage-gutters) plugin.
@@ -198,7 +248,7 @@ You can install an IDE plugin to view the coverage. For example, if you use VSCo
 
 ## Sponsor this project
 
-At the moment there is no official organisation that accepts sponsorship on PyO3's behalf. If you're seeking to provide significant funding to the PyO3 ecosystem, please reach out to us on [GitHub](https://github.com/PyO3/pyo3/issues/new) or [Gitter](https://gitter.im/PyO3/Lobby) and we can discuss.
+At the moment there is no official organisation that accepts sponsorship on PyO3's behalf. If you're seeking to provide significant funding to the PyO3 ecosystem, please reach out to us on [GitHub](https://github.com/PyO3/pyo3/issues/new) or [Discord](https://discord.gg/33kcChzH7f) and we can discuss.
 
 In the meanwhile, some of our maintainers have personal GitHub sponsorship pages and would be grateful for your support:
 
@@ -206,4 +256,8 @@ In the meanwhile, some of our maintainers have personal GitHub sponsorship pages
 - [messense](https://github.com/sponsors/messense)
 
 [mdbook]: https://rust-lang.github.io/mdBook/cli/index.html
+[mdbook-tabs]: https://mdbook-plugins.rustforweb.org/tabs.html
+[lychee]: https://github.com/lycheeverse/lychee
 [nox]: https://github.com/theacodes/nox
+[pipx]: https://pipx.pypa.io/stable/
+[trybuild]: https://github.com/dtolnay/trybuild
diff --git a/LICENSE-APACHE b/LICENSE-APACHE
index fca31990733..72207b851d3 100644
--- a/LICENSE-APACHE
+++ b/LICENSE-APACHE
@@ -1,189 +1,178 @@
-   Copyright (c) 2017-present PyO3 Project and Contributors.  https://github.com/PyO3
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
-
-
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
+Copyright (c) 2017-present PyO3 Project and Contributors.  https://github.com/PyO3
+
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
diff --git a/README.md b/README.md
index 21e09157d8d..5b190c921fc 100644
--- a/README.md
+++ b/README.md
@@ -1,11 +1,11 @@
 # PyO3
 
 [![actions status](https://img.shields.io/github/actions/workflow/status/PyO3/pyo3/ci.yml?branch=main&logo=github&style=)](https://github.com/PyO3/pyo3/actions)
-[![benchmark](https://img.shields.io/badge/benchmark-✓-Green?logo=github)](https://pyo3.rs/dev/bench/)
+[![benchmark](https://img.shields.io/endpoint?url=https://codspeed.io/badge.json)](https://codspeed.io/PyO3/pyo3)
 [![codecov](https://img.shields.io/codecov/c/gh/PyO3/pyo3?logo=codecov)](https://codecov.io/gh/PyO3/pyo3)
 [![crates.io](https://img.shields.io/crates/v/pyo3?logo=rust)](https://crates.io/crates/pyo3)
-[![minimum rustc 1.56](https://img.shields.io/badge/rustc-1.56+-blue?logo=rust)](https://rust-lang.github.io/rfcs/2495-min-rust-version.html)
-[![dev chat](https://img.shields.io/gitter/room/PyO3/Lobby?logo=gitter)](https://gitter.im/PyO3/Lobby)
+[![minimum rustc 1.83](https://img.shields.io/badge/rustc-1.83+-blue?logo=rust)](https://rust-lang.github.io/rfcs/2495-min-rust-version.html)
+[![discord server](https://img.shields.io/discord/1209263839632424990?logo=discord)](https://discord.gg/33kcChzH7f)
 [![contributing notes](https://img.shields.io/badge/contribute-on%20github-Green?logo=github)](https://github.com/PyO3/pyo3/blob/main/Contributing.md)
 
 [Rust](https://www.rust-lang.org/) bindings for [Python](https://www.python.org/), including tools for creating native Python extension modules. Running and interacting with Python code from a Rust binary is also supported.
@@ -16,9 +16,12 @@
 
 ## Usage
 
-PyO3 supports the following software versions:
-  - Python 3.7 and up (CPython and PyPy)
-  - Rust 1.56 and up
+Requires Rust 1.83 or greater.
+
+PyO3 supports the following Python distributions:
+  - CPython 3.7 or greater
+  - PyPy 7.3 (Python 3.11+)
+  - GraalPy 25.0 or greater (Python 3.12+)
 
 You can use PyO3 to write a native Python module in Rust, or to embed Python in a Rust binary. The following sections explain each of these in turn.
 
@@ -68,27 +71,24 @@ name = "string_sum"
 crate-type = ["cdylib"]
 
 [dependencies]
-pyo3 = { version = "0.20.2", features = ["extension-module"] }
+pyo3 = { version = "0.27.0", features = ["extension-module"] }
 ```
 
 **`src/lib.rs`**
 
 ```rust
-use pyo3::prelude::*;
-
-/// Formats the sum of two numbers as string.
-#[pyfunction]
-fn sum_as_string(a: usize, b: usize) -> PyResult<String> {
-    Ok((a + b).to_string())
-}
-
-/// A Python module implemented in Rust. The name of this function must match
+/// A Python module implemented in Rust. The name of this module must match
 /// the `lib.name` setting in the `Cargo.toml`, else Python will not be able to
 /// import the module.
-#[pymodule]
-fn string_sum(_py: Python<'_>, m: &PyModule) -> PyResult<()> {
-    m.add_function(wrap_pyfunction!(sum_as_string, m)?)?;
-    Ok(())
+#[pyo3::pymodule]
+mod string_sum {
+  use pyo3::prelude::*;
+
+  /// Formats the sum of two numbers as string.
+  #[pyfunction]
+  fn sum_as_string(a: usize, b: usize) -> PyResult<String> {
+    Ok((a + b).to_string())
+  }
 }
 ```
 
@@ -118,7 +118,7 @@ maturin develop
 
 If you want to be able to run `cargo test` or use this project in a Cargo workspace and are running into linker issues, there are some workarounds in [the FAQ](https://pyo3.rs/latest/faq.html#i-cant-run-cargo-test-or-i-cant-build-in-a-cargo-workspace-im-having-linker-issues-like-symbol-not-found-or-undefined-reference-to-_pyexc_systemerror).
 
-As well as with `maturin`, it is possible to build using [`setuptools-rust`](https://github.com/PyO3/setuptools-rust) or [manually](https://pyo3.rs/latest/building_and_distribution.html#manual-builds). Both offer more flexibility than `maturin` but require more configuration to get started.
+As well as with `maturin`, it is possible to build using [`setuptools-rust`](https://github.com/PyO3/setuptools-rust) or [manually](https://pyo3.rs/latest/building-and-distribution.html#manual-builds). Both offer more flexibility than `maturin` but require more configuration to get started.
 
 ### Using Python from Rust
 
@@ -137,7 +137,7 @@ Start a new project with `cargo new` and add  `pyo3` to the `Cargo.toml` like th
 
 ```toml
 [dependencies.pyo3]
-version = "0.20.2"
+version = "0.27.0"
 features = ["auto-initialize"]
 ```
 
@@ -148,13 +148,13 @@ use pyo3::prelude::*;
 use pyo3::types::IntoPyDict;
 
 fn main() -> PyResult<()> {
-    Python::with_gil(|py| {
-        let sys = py.import_bound("sys")?;
+    Python::attach(|py| {
+        let sys = py.import("sys")?;
         let version: String = sys.getattr("version")?.extract()?;
 
-        let locals = [("os", py.import_bound("os")?)].into_py_dict_bound(py);
-        let code = "os.getenv('USER') or os.getenv('USERNAME') or 'Unknown'";
-        let user: String = py.eval_bound(code, None, Some(&locals))?.extract()?;
+        let locals = [("os", py.import("os")?)].into_py_dict(py)?;
+        let code = c"os.getenv('USER') or os.getenv('USERNAME') or 'Unknown'";
+        let user: String = py.eval(code, None, Some(&locals))?.extract()?;
 
         println!("Hello {}, I'm Python {}", user, version);
         Ok(())
@@ -162,7 +162,7 @@ fn main() -> PyResult<()> {
 }
 ```
 
-The guide has [a section](https://pyo3.rs/latest/python_from_rust.html) with lots of examples
+The guide has [a section](https://pyo3.rs/latest/python-from-rust.html) with lots of examples
 about this topic.
 
 ## Tools and libraries
@@ -174,16 +174,24 @@ about this topic.
 - [dict-derive](https://github.com/gperinazzo/dict-derive) _Derive FromPyObject to automatically transform Python dicts into Rust structs_
 - [pyo3-log](https://github.com/vorner/pyo3-log) _Bridge from Rust to Python logging_
 - [pythonize](https://github.com/davidhewitt/pythonize) _Serde serializer for converting Rust objects to JSON-compatible Python objects_
-- [pyo3-asyncio](https://github.com/awestlake87/pyo3-asyncio) _Utilities for working with Python's Asyncio library and async functions_
+- [pyo3-async-runtimes](https://github.com/PyO3/pyo3-async-runtimes) _Utilities for interoperability with Python's Asyncio library and Rust's async runtimes._
 - [rustimport](https://github.com/mityax/rustimport) _Directly import Rust files or crates from Python, without manual compilation step. Provides pyo3 integration by default and generates pyo3 binding code automatically._
+- [pyo3-arrow](https://crates.io/crates/pyo3-arrow) _Lightweight [Apache Arrow](https://arrow.apache.org/) integration for pyo3._
+- [pyo3-bytes](https://crates.io/crates/pyo3-bytes) _Integration between [`bytes`](https://crates.io/crates/bytes) and pyo3._
+- [pyo3-object_store](https://github.com/developmentseed/obstore/tree/main/pyo3-object_store) _Integration between [`object_store`](https://docs.rs/object_store) and [`pyo3`](https://github.com/PyO3/pyo3)._
 
 ## Examples
 
-- [autopy](https://github.com/autopilot-rs/autopy) _A simple, cross-platform GUI automation library for Python and Rust._
-  - Contains an example of building wheels on TravisCI and appveyor using [cibuildwheel](https://github.com/pypa/cibuildwheel)
-- [ballista-python](https://github.com/apache/arrow-ballista-python) _A Python library that binds to Apache Arrow distributed query engine Ballista._
+- [arro3](https://github.com/kylebarron/arro3) _A minimal Python library for Apache Arrow, connecting to the Rust arrow crate._
+    - [arro3-compute](https://github.com/kylebarron/arro3/tree/main/arro3-compute) _`arro3-compute`_
+    - [arro3-core](https://github.com/kylebarron/arro3/tree/main/arro3-core) _`arro3-core`_
+    - [arro3-io](https://github.com/kylebarron/arro3/tree/main/arro3-io) _`arro3-io`_
 - [bed-reader](https://github.com/fastlmm/bed-reader) _Read and write the PLINK BED format, simply and efficiently._
     - Shows Rayon/ndarray::parallel (including capturing errors, controlling thread num), Python types to Rust generics, Github Actions
+- [blake3-py](https://github.com/oconnor663/blake3-py) _Python bindings for the [BLAKE3](https://github.com/BLAKE3-team/BLAKE3) cryptographic hash function._
+    - Parallelized [builds](https://github.com/oconnor663/blake3-py/blob/master/.github/workflows/dists.yml) on GitHub Actions for MacOS, Linux, Windows, including free-threaded 3.13t wheels.
+- [cellular_raza](https://cellular-raza.com) _A cellular agent-based simulation framework for building complex models from a clean slate._
+- [connector-x](https://github.com/sfu-db/connector-x/tree/main/connectorx-python) _Fastest library to load data from DB to DataFrames in Rust and Python._
 - [cryptography](https://github.com/pyca/cryptography/tree/main/src/rust) _Python cryptography library with some functionality in Rust._
 - [css-inline](https://github.com/Stranger6667/css-inline/tree/master/bindings/python) _CSS inlining for Python implemented in Rust._
 - [datafusion-python](https://github.com/apache/arrow-datafusion-python) _A Python library that binds to Apache Arrow in-memory query engine DataFusion._
@@ -191,35 +199,46 @@ about this topic.
 - [fastbloom](https://github.com/yankun1992/fastbloom) _A fast [bloom filter](https://github.com/yankun1992/fastbloom#BloomFilter) | [counting bloom filter](https://github.com/yankun1992/fastbloom#countingbloomfilter) implemented by Rust for Rust and Python!_
 - [fastuuid](https://github.com/thedrow/fastuuid/) _Python bindings to Rust's UUID library._
 - [feos](https://github.com/feos-org/feos) _Lightning fast thermodynamic modeling in Rust with fully developed Python interface._
+- [finalytics](https://github.com/Nnamdi-sys/finalytics) _Investment Analysis library in Rust | Python._
 - [forust](https://github.com/jinlow/forust) _A lightweight gradient boosted decision tree library written in Rust._
+- [geo-index](https://github.com/kylebarron/geo-index) _A Rust crate and [Python library](https://github.com/kylebarron/geo-index/tree/main/python) for packed, immutable, zero-copy spatial indexes._
+- [granian](https://github.com/emmett-framework/granian) _A Rust HTTP server for Python applications._
 - [haem](https://github.com/BooleanCat/haem) _A Python library for working on Bioinformatics problems._
+- [html2text-rs](https://github.com/deedy5/html2text_rs) _Python library for converting HTML to markup or plain text._
 - [html-py-ever](https://github.com/PyO3/setuptools-rust/tree/main/examples/html-py-ever) _Using [html5ever](https://github.com/servo/html5ever) through [kuchiki](https://github.com/kuchiki-rs/kuchiki) to speed up html parsing and css-selecting._
-- [hyperjson](https://github.com/mre/hyperjson) _A hyper-fast Python module for reading/writing JSON data using Rust's serde-json._
-- [inline-python](https://github.com/fusion-engineering/inline-python) _Inline Python code directly in your Rust code._
+- [hudi-rs](https://github.com/apache/hudi-rs) _The native Rust implementation for Apache Hudi, with C++ & Python API bindings._
+- [inline-python](https://github.com/m-ou-se/inline-python) _Inline Python code directly in your Rust code._
 - [johnnycanencrypt](https://github.com/kushaldas/johnnycanencrypt) OpenPGP library with Yubikey support.
-- [jsonschema-rs](https://github.com/Stranger6667/jsonschema-rs/tree/master/bindings/python) _Fast JSON Schema validation library._
+- [jsonschema](https://github.com/Stranger6667/jsonschema/tree/master/crates/jsonschema-py) _A high-performance JSON Schema validator for Python._
 - [mocpy](https://github.com/cds-astro/mocpy) _Astronomical Python library offering data structures for describing any arbitrary coverage regions on the unit sphere._
+- [obstore](https://github.com/developmentseed/obstore) _The simplest, highest-throughput Python interface to Amazon S3, Google Cloud Storage, Azure Storage, & other S3-compliant APIs, powered by Rust._
 - [opendal](https://github.com/apache/opendal/tree/main/bindings/python) _A data access layer that allows users to easily and efficiently retrieve data from various storage services in a unified way._
 - [orjson](https://github.com/ijl/orjson) _Fast Python JSON library._
 - [ormsgpack](https://github.com/aviramha/ormsgpack) _Fast Python msgpack library._
-- [point-process](https://github.com/ManifoldFR/point-process-rust/tree/master/pylib) _High level API for pointprocesses as a Python library._
-- [polaroid](https://github.com/daggy1234/polaroid) _Hyper Fast and safe image manipulation library for Python written in Rust._
 - [polars](https://github.com/pola-rs/polars) _Fast multi-threaded DataFrame library in Rust | Python | Node.js._
+- [pycrdt](https://github.com/jupyter-server/pycrdt) _Python bindings for the Rust CRDT implementation [Yrs](https://github.com/y-crdt/y-crdt)._
 - [pydantic-core](https://github.com/pydantic/pydantic-core) _Core validation logic for pydantic written in Rust._
-- [pyheck](https://github.com/kevinheavey/pyheck) _Fast case conversion library, built by wrapping [heck](https://github.com/withoutboats/heck)._
-    - Quite easy to follow as there's not much code.
-- [pyre](https://github.com/Project-Dream-Weaver/pyre-http) _Fast Python HTTP server written in Rust._
-- [ril-py](https://github.com/Cryptex-github/ril-py) _A performant and high-level image processing library for Python written in Rust._
+- [primp](https://github.com/deedy5/primp) _The fastest python HTTP client that can impersonate web browsers by mimicking their headers and TLS/JA3/JA4/HTTP2 fingerprints._
+- [rateslib](https://github.com/attack68/rateslib) _A fixed income library for Python using Rust extensions._
 - [river](https://github.com/online-ml/river) _Online machine learning in python, the computationally heavy statistics algorithms are implemented in Rust._
+- [robyn](https://github.com/sparckles/Robyn) A Super Fast Async Python Web Framework with a Rust runtime.
 - [rust-python-coverage](https://github.com/cjermain/rust-python-coverage) _Example PyO3 project with automated test coverage for Rust and Python._
+- [rnet](https://github.com/0x676e67/rnet) Asynchronous Python HTTP Client with Black Magic
+- [sail](https://github.com/lakehq/sail) _Unifying stream, batch, and AI workloads with Apache Spark compatibility._
 - [tiktoken](https://github.com/openai/tiktoken) _A fast BPE tokeniser for use with OpenAI's models._
 - [tokenizers](https://github.com/huggingface/tokenizers/tree/main/bindings/python) _Python bindings to the Hugging Face tokenizers (NLP) written in Rust._
 - [tzfpy](http://github.com/ringsaturn/tzfpy) _A fast package to convert longitude/latitude to timezone name._
 - [utiles](https://github.com/jessekrubin/utiles) _Fast Python web-map tile utilities_
-- [wasmer-python](https://github.com/wasmerio/wasmer-python) _Python library to run WebAssembly binaries._
 
 ## Articles and other media
 
+- [(Video) Using Rust in Free-Threaded vs Regular Python 3.13](https://www.youtube.com/watch?v=J7phN_M4GLM) - Jun 4, 2025
+- [(Video) Techniques learned from five years finding the way for Rust in Python](https://www.youtube.com/watch?v=KTQn_PTHNCw) - Feb 26, 2025
+- [(Podcast) Bridging Python and Rust: An Interview with PyO3 Maintainer David Hewitt](https://www.youtube.com/watch?v=P47JUMSQagU) - Aug 30, 2024
+- [(Video) PyO3: From Python to Rust and Back Again](https://www.youtube.com/watch?v=UmL_CA-v3O8) - Jul 3, 2024
+- [Parsing Python ASTs 20x Faster with Rust](https://www.gauge.sh/blog/parsing-python-asts-20x-faster-with-rust) - Jun 17, 2024
+- [(Video) How Python Harnesses Rust through PyO3](https://www.youtube.com/watch?v=UilujdubqVU) - May 18, 2024
+- [(Video) Combining Rust and Python: The Best of Both Worlds?](https://www.youtube.com/watch?v=lyG6AKzu4ew) - Mar 1, 2024
 - [(Video) Extending Python with Rust using PyO3](https://www.youtube.com/watch?v=T45ZEmSR1-s) - Dec 16, 2023
 - [A Week of PyO3 + rust-numpy (How to Speed Up Your Data Pipeline X Times)](https://terencezl.github.io/blog/2023/06/06/a-week-of-pyo3-rust-numpy/) - Jun 6, 2023
 - [(Podcast) PyO3 with David Hewitt](https://rustacean-station.org/episode/david-hewitt/) - May 19, 2023
@@ -230,14 +249,14 @@ about this topic.
 - [Calling Rust from Python using PyO3](https://saidvandeklundert.net/learn/2021-11-18-calling-rust-from-python-using-pyo3/) - Nov 18, 2021
 - [davidhewitt's 2021 talk at Rust Manchester meetup](https://www.youtube.com/watch?v=-XyWG_klSAw&t=320s) - Aug 19, 2021
 - [Incrementally porting a small Python project to Rust](https://blog.waleedkhan.name/port-python-to-rust/) - Apr 29, 2021
-- [Vortexa - Integrating Rust into Python](https://www.vortexa.com/insight/integrating-rust-into-python) - Apr 12, 2021
+- [Vortexa - Integrating Rust into Python](https://www.vortexa.com/blog/integrating-rust-into-python) - Apr 12, 2021
 - [Writing and publishing a Python module in Rust](https://blog.yossarian.net/2020/08/02/Writing-and-publishing-a-python-module-in-rust) - Aug 2, 2020
 
 ## Contributing
 
 Everyone is welcomed to contribute to PyO3! There are many ways to support the project, such as:
 
-- help PyO3 users with issues on GitHub and Gitter
+- help PyO3 users with issues on GitHub and [Discord](https://discord.gg/33kcChzH7f)
 - improve documentation
 - write features and bugfixes
 - publish blogs and examples of how to use PyO3
diff --git a/Releasing.md b/Releasing.md
index 545783c598c..d3a1b4cf8c4 100644
--- a/Releasing.md
+++ b/Releasing.md
@@ -44,9 +44,10 @@ Wait a couple of days in case anyone wants to hold up the release to add bugfixe
 ## 4. Put live
 
 To put live:
-- 1. run `nox -s publish` to put live on crates.io
-- 2. publish the release on Github
-- 3. merge the release PR
+- 1. merge the release PR
+- 2. publish a release on GitHub targeting the release branch
+
+CI will automatically push to `crates.io`.
 
 ## 5. Tidy the main branch
 
diff --git a/branding/favicon/pyo3_16x16.png b/branding/favicon/pyo3_16x16.png
new file mode 100644
index 00000000000..0d2d77eb151
Binary files /dev/null and b/branding/favicon/pyo3_16x16.png differ
diff --git a/branding/favicon/pyo3_32x32.png b/branding/favicon/pyo3_32x32.png
new file mode 100644
index 00000000000..ff1f97ae269
Binary files /dev/null and b/branding/favicon/pyo3_32x32.png differ
diff --git a/branding/pyo3logo.png b/branding/pyo3logo.png
new file mode 100644
index 00000000000..06cad61734e
Binary files /dev/null and b/branding/pyo3logo.png differ
diff --git a/branding/pyo3logo.svg b/branding/pyo3logo.svg
new file mode 100644
index 00000000000..0315c63e56a
--- /dev/null
+++ b/branding/pyo3logo.svg
@@ -0,0 +1 @@
+<?xml version="1.0" encoding="UTF-8"?><svg xmlns="http://www.w3.org/2000/svg" width="1080" height="1080" viewBox="0 0 1080 1080"><defs><style>.p{fill:#fff;}.q{fill:#5a9fd4;}.r{fill:#ffd43b;}.s{fill:#e43a25;}.t{fill:#030404;}.u{fill:#3e6d90;}.v{fill:#1a1a1a;}</style></defs><g id="a"><rect class="v" width="1080" height="1080"/></g><g id="b"><g id="c"><path class="q" d="M470.1992,170.2002c183.1195-3.4423,368.7289,87.0951,451.4542,255.463,3.7264,7.8904,7.9798,16.9627,11.1247,25.0938,1.6794,4.2844,4.2134,10.3611,5.6123,14.6827,1.2089,3.5004,3.2923,9.5944,4.4559,13.0307,1.1567,3.5621,2.2379,7.5561,3.133,10.8667,25.3786,99.7964,19.2125,209.6855-28.7118,302.0917-89.8475,175.1771-325.4628,261.5867-504.3941,174.0052-.9378-.372-2.7308-1.348-3.6325-1.8014-7.0873-3.7565-15.7297-8.1826-22.2811-12.4553-33.2534-21.2097-62.7693-47.296-88.0664-77.4392-44.995-53.1256-73.9121-121.2598-77.0905-191.2472-5.1268-110.7094,43.8245-216.6098,140.3756-273.929,79.9273-47.6785,183.3157-64.3372,271.5453-30.0944,32.1734,12.7682,61.6289,34.1589,81.6286,62.7829,34.4009,48.2308,46.1475,117.4057,13.0142,169.3145-29.3734,46.4966-83.6013,71.3252-135.6074,81.3171-45.1958,8.336-106.5594,8.624-143.494-23.6-26.7708-23.817-33.0872-66.5725-13.572-96.8889,32.4652-48.0054,114.4256-42.4554,163.6766-31.1086,48.0253,11.5482,96.9553,33.2474,128.2142,73.0777,25.2857,32.4702,30.1323,72.0076,17.3407,110.5293-8.1652,24.6661-22.7548,47.6281-42.5283,64.4565-49.5004,42.6007-131.2154,52.726-192.3812,35.0978-44.4411-13.0305-83.2341-43.1871-108.768-81.3301-4.9598-7.4428-9.4885-15.1876-13.159-23.3322,0,0,.8236-.5673.8236-.5673,61.3908,61.6235,138.0487,93.3511,223.9438,68.8118,34.0447-9.5819,66.0403-29.5225,79.8015-62.4243,6.9608-15.9159,10.5977-34.4516,6.6374-51.346-7.6444-30.8439-38.5743-49.8405-67.5377-61.6926-35.3726-13.7305-75.2487-20.3625-112.8366-15.4416-6.9515,1.0199-13.485,2.619-18.7512,4.6392-3.7501,1.4975-7.7565,3.3577-9.5432,5.8202.078.0449.0322-.0111.0883.0167.079-.0094.0654.052.0367.2646-.3209,1.5235-.2305,4.4593.4112,6.2976.8105,2.1492,1.0628,3.0448,2.7965,4.2313.8112.6038,2.2382,1.5067,4.172,2.3986,3.876,1.8301,9.5817,3.4748,15.8238,4.5084,20.8172,3.2351,42.8435,1.1259,63.8734-3.7723,32.9335-7.7916,79.8646-28.5445,87.2925-64.1346,4.8007-26.327-10.3932-58.1219-31.6862-74.8435-26.0881-19.834-59.7944-24.2033-92.1538-22.447-58.7691,4.171-118.5053,30.5979-156.6319,75.9366-23.4586,28.1706-36.574,63.2723-40.7303,99.6784-2.9288,25.0438-1.808,50.5872,4.5861,74.9208,10.3896,41.2564,35.9388,77.7984,67.3632,106.2914,15.0343,13.4211,31.4966,26.1029,49.5866,34.7971,98.2459,47.0762,224.0064,12.5372,297.2051-65.1348,2.0739-2.0613,5.018-5.434,6.9475-7.6836,1.9995-2.1707,4.7326-5.5634,6.5553-7.9457,3.2348-3.7416,6.3054-8.2929,9.1848-12.3315.5032-.7049,1.7394-2.4365,2.2336-3.1225l.6793-1.0822,5.4612-8.6378c39.1637-65.6316,43.8287-148.2221,25.6387-221.8856-.7198-3.4049-3.296-10.2818-4.3398-13.524-.4323-1.4425-1.2201-3.5227-1.7862-4.9168-1.1377-2.8073-2.6909-6.9741-3.844-9.7495-1.0835-2.3654-3.2295-7.2126-4.2896-9.5931-12.8829-27.3433-30.3804-52.3757-51.0358-74.5277-64.6754-68.9074-158.1879-106.9822-251.7216-114.374-4.1942-.2988-10.1276-.5664-14.3115-.8859-4.9774-.3007-12.4258-.3213-17.2303-.5325,0,.0002-.6015-124.5994-.6015-124.5994h0Z"/></g><g id="d"><path class="u" d="M525.876,392.3208c-.9685,1.695-.519,3.8555,1.0621,5.0006,8.2352,5.9642,28.4158,17.9125,32.9768,24.1895,7.0574,9.7125,12.3291,18.47,15.8714,26.2755,1.4799,3.261,6.2541,2.9056,7.1904-.5509,3.1887-11.7716.141-21.9116-2.3587-27.5324-1.0217-2.2975.3764-4.9269,2.8549-5.3503,5.3774-.9186,13.8798-3.0937,21.1227-8.1682,3.0606-2.1443,1.6373-6.9122-2.0985-7.0074-6.5564-.167-15.1837-1.5665-23.9292-6.4747-8.0407-4.5127-26.9731-16.3022-34.8568-22.6269-1.8419-1.4776-4.5616-.9856-5.7331,1.0646-4.034,7.0602-8.068,14.1203-12.102,21.1805Z"/><path class="u" d="M738.4279,629.9719c-3.0709-5.7035-6.6735-11.2543-10.8439-16.6096-.1912-.2435-.391-.4781-.5835-.7203-2.3684,3.6052-4.8704,7.0928-7.5281,10.4346-2.1123,2.6558-4.3118,5.2296-6.5917,7.7228-2.2799,2.4932-4.6405,4.9061-7.075,7.2401-5.1838,4.9698-10.7115,9.5715-16.5021,13.8429,3.3539,4.7073,6.1138,9.7892,8.1168,15.2762,15.3763-10.3981,29.3158-22.7248,41.0073-37.1866Z"/><path class="u" d="M470.1992,170.2002s.6016,124.5995.6015,124.5994c4.8045.2112,12.253.2318,17.2303.5325,4.1839.3195,10.1173.5871,14.3115.8859,24.4694,1.9338,48.9315,5.9893,72.8813,12.1271,6.7089-35.8959,10.1854-78.5311,8.2295-128.3035-37.2323-7.2228-75.2954-10.555-113.2542-9.8414Z"/><path class="u" d="M362.1785,408.5621c-21.2189,12.5969-40.1271,27.5494-56.6787,44.3748,97.5591,30.605,161.802,21.6932,194.9742,3.0338,17.7859-10.0046,43.007-40.6061,61.0737-94.3199-68.8964-6.4874-140.4964,11.7922-199.3693,46.9113Z"/></g><g id="e"><path class="r" d="M728.646,233.3535c-2.2085,2.5682-.7001,4.7817-1.2302,14.2649-.6437,11.5109-3.1644,13.5895-1.0813,16.5969,2.3533,3.3973,6.8386,1.7161,18.8418,4.8345,6.9363,1.802,12.879,3.358,12.879,3.358,3.2098.8357,6.6195.0124,8.9913-2.1785,2.3828-2.1853,3.3877-5.4111,2.6752-8.5404,0,0-.7104-3.1938-1.6968-7.5859-12.0963-7.9258-24.5636-15.3071-37.3475-22.1412-.7725.2506-1.406.6644-2.0315,1.3918Z"/><path class="r" d="M880.8426,516.2337c-.1501,4.1301,4.4488,5.47,12.1937,15.1558,4.4757,5.5973,8.3028,10.4024,8.3028,10.4024,2.07,2.5916,5.2937,3.9743,8.5052,3.6403,3.217-.323,5.9537-2.3045,7.2571-5.2373,0,0,9.9089-21.9964,12.8071-28.8768.2153-.5109.367-1.3594.1909-2.3862-.6946-4.0494-6.4305-5.0585-14.5202-8.9891-9.8552-4.7884-10.7346-7.8543-14.4028-7.0398-3.3066.7341-3.4243,3.4101-9.5283,10.687-7.4092,8.8328-10.6728,8.9878-10.8057,12.6436Z"/><path class="r" d="M838.9262,795.3444c-3.1075,2.7246-.9268,6.9895-2.6591,19.2695-1.0011,7.0964-1.8708,13.1775-1.8708,13.1775-.465,3.284.7409,6.5779,3.1874,8.6851,2.4423,2.1187,5.7615,2.75,8.7894,1.686,0,0,22.8008-7.8838,29.7946-10.4962.5194-.194,1.2407-.6657,1.8669-1.4983,2.4693-3.2837-.7322-8.1489-3.4233-16.7308-3.2785-10.455-1.6515-13.1982-4.7608-15.308-2.8028-1.9018-4.8303-.1514-14.3122.4009-11.5094.6704-13.8614-1.5975-16.6121.8142Z"/><path class="r" d="M619.9149,926.6034c-4.0945-.5614-5.8865,3.8808-16.2968,10.6207-6.0159,3.8949-11.1789,7.2235-11.1789,7.2235-2.7851,1.8011-4.4826,4.8708-4.4707,8.0996.0004,3.2332,1.699,6.1539,4.4871,7.7435,0,0,20.898,12.0542,27.4549,15.6244.4869.2652,1.316.5008,2.3552.4281,4.0985-.2871,5.6749-5.8937,10.3929-13.5508,5.7478-9.3283,8.8861-9.8974,8.4417-13.6285-.4006-3.3634-3.0514-3.7475-9.683-10.5471-8.0495-8.2535-7.8781-11.5163-11.5024-12.0133Z"/><path class="r" d="M371.4353,824.7067c-.6472-4.0818-5.4179-4.512-14.8814-12.5271-5.4688-4.6318-10.1488-8.611-10.1488-8.611-2.5298-2.145-5.9594-2.8817-9.0466-1.9362-3.0948.9358-5.3992,3.4068-6.1141,6.5355,0,0-5.4925,23.4917-7.0131,30.8011-.113.5428-.0987,1.4046.2716,2.3783,1.4606,3.8402,7.2835,3.727,15.9781,6.028,10.5923,2.8032,12.045,5.6426,15.488,4.1378,3.1036-1.3565,2.7044-4.0051,7.2946-12.3203,5.5717-10.0931,8.7446-10.873,8.1717-14.4861Z"/><path class="r" d="M350.3782,601.5195c3.9575-14.1255,9.4405-27.7554,16.5353-40.5255-6.6313,3.2585-19.3187,9.5123-24.116,12.0096-.4918.2559-1.1501.8123-1.6699,1.7151-2.0497,3.5607,1.7222,7.9984,5.4416,16.1873,2.3421,5.1566,3.131,8.4191,3.809,10.6135Z"/></g></g><g id="f"><path id="g" class="s" d="M512.4227,375.6755c-.7583,1.3271-.4063,3.0186.8316,3.9151,6.4476,4.6695,43.2476,25.0243,46.8186,29.9387,5.5254,7.6042,9.6528,14.4607,12.4262,20.5719,1.1587,2.5531,4.8965,2.2749,5.6296-.4313,2.4965-9.2163.1104-17.1552-1.8467-21.5559-.8-1.7988.2947-3.8574,2.2352-4.1889,4.2102-.7192,10.8669-2.4222,16.5376-6.3951,2.3963-1.6788,1.2819-5.4118-1.643-5.4863-5.1332-.1308-11.8878-1.2265-18.7349-5.0693-6.2953-3.5331-42.118-23.7635-48.2905-28.7153-1.442-1.1569-3.5714-.7717-4.4886.8335-3.1583,5.5276-6.3167,11.0552-9.475,16.5828Z"/><path id="h" class="r" d="M174.8148,380.6682c-1.7461-.969-2.23-9.0428-1.8148-11.6682l-19.2007-20.2723c-2.2474-2.4437-3.1462-5.8382-2.3607-9.0066.7773-3.1541,3.1162-5.6144,6.1848-6.5125l30.2446-8.7554c.8505-2.5101,1.728-5.0103,2.6414-7.4913l-17.299-27.8219c-1.7596-2.8116-1.9907-6.3135-.6127-9.2303,1.3617-2.9211,4.1493-4.8561,7.3481-5.1066l31.488-2.4943c1.3342-2.299,2.6878-4.5774,4.0794-6.8364l-11.7422-30.4749c-1.1922-3.0856-.7487-6.5456,1.1591-9.109,1.9106-2.5788,5.0314-3.9034,8.2439-3.5073l31.5599,3.8371c1.7628-1.9685,3.5417-3.9223,5.3619-5.8509l-5.7736-31.9894c-.5961-3.2551.4941-6.5194,2.8837-8.6482,2.3783-2.1079,5.7137-2.7819,8.8006-1.7677l30.5124,10.0602c2.0901-1.5488,4.2087-3.0838,6.3481-4.5756l.4176-32.3894c.0303-3.2741,1.7402-6.2417,4.4957-7.8299,2.7618-1.5919,6.1816-1.5809,9.0421.027l28.2308,15.877c2.3632-1.1034,4.7426-2.1609,7.1345-3.1955l6.5879-31.4442c.6682-3.1786,2.913-5.7209,5.9384-6.7276,3.0372-1.0073,6.4083-.3063,8.9313,1.8382l24.7781,21.0355c2.5879-.6121,5.1655-1.1776,7.751-1.7071l12.507-29.2366c1.2639-2.9693,3.9745-5.0065,7.1544-5.3679,3.1858-.3724,6.3947.9824,8.4697,3.5592l20.481,25.4379c2.6534-.0724,5.3066-.0945,7.9556-.1004l17.9446-25.9978c1.8252-2.6397,4.8821-4.0789,8.1031-3.7992,3.2176.2679,6.1288,2.225,7.6818,5.1558l15.3964,28.9185c2.6099.4502,5.2178.9415,7.8073,1.4689l22.7416-21.7849c2.3048-2.2066,5.6135-2.994,8.7276-2.0828,3.1282.9127,5.6202,3.3888,6.6051,6.5602l7.2505,24.3384c2.4881.9423,9.6885,7.862,9.8569,9.8546,15.1431,179.1454-42.8569,269.1454-74.8569,287.1454-43.9951,24.7473-147,31-315.1852-62.3318Z"/><path id="i" class="t" d="M416.6517,268.8313s9.1773-41.5786,49.7558-28.6784c0,0,40.4838,25.0557,31.4023,54.4816,0,0-17.3313,43.8615-49.7558,28.6784,0,0-32.8394-7.6867-31.4023-54.4816Z"/><path id="j" class="p" d="M451.2784,262.3353c6.1138,10.6072,4.8179,22.8102-2.8933,27.2548-7.7096,4.4437-18.9185-.5518-25.0323-11.159s-4.8182-22.8108,2.8914-27.2545,18.9206.5519,25.0342,11.1586Z"/><path id="k" class="t" d="M301.3287,325.3925s31.7841-43.492,67.7395-8.0315c0,0,40.5337,42.1237-5.1123,72.1296,0,0-66.9345,23.1212-62.6273-64.0981Z"/><path id="l" class="p" d="M333.2752,331.278c6.3044,10.9379,4.9707,23.5254-2.9834,28.1099s-19.5129-.5718-25.8173-11.5097c-6.3059-10.9405-4.9691-23.5262,2.9818-28.109s19.513.5683,25.8189,11.5088Z"/><g id="m"><path id="n" class="t" d="M457.6063,435.6128s-1.3552,8.2645-9.4633,6.1675c0,0-8.2203-4.4854-6.7533-10.3622,0,0,2.932-8.8006,9.4633-6.1675,0,0,6.5322,1.1564,6.7533,10.3622Z"/><path id="o" class="t" d="M498.6468,412.2641s-5.7744,8.8835-13.2173,2.3059c0,0-8.4137-7.8369.2282-14.2209,0,0,12.8969-5.2608,12.9891,11.9149Z"/></g></g></svg>
\ No newline at end of file
diff --git a/branding/pyotr.png b/branding/pyotr.png
new file mode 100644
index 00000000000..75ab9bb34b8
Binary files /dev/null and b/branding/pyotr.png differ
diff --git a/branding/pyotr.svg b/branding/pyotr.svg
new file mode 100644
index 00000000000..52d478e67c4
--- /dev/null
+++ b/branding/pyotr.svg
@@ -0,0 +1 @@
+<?xml version="1.0" encoding="UTF-8"?><svg xmlns="http://www.w3.org/2000/svg" width="1080" height="1080" viewBox="0 0 1080 1080"><defs><style>.p{fill:#fff;}.q{fill:#5a9fd4;}.r{fill:#ffd43b;}.s{fill:#e43a25;}.t{fill:#030404;}.u{fill:#3e6d90;}.v{fill:#1a1a1a;}</style></defs><g id="a"><rect class="v" width="1080" height="1080"/></g><g id="b"><g id="c"><path class="q" d="M470.1992,170.2002c140.2648-2.5648,282.2545,49.1764,379.6617,152.05,42.1707,44.6778,74.899,98.5985,93.3894,157.4029,28.0162,99.5323,23.6492,210.0918-22.2551,304.1025-17.3741,35.6271-41.0854,68.57-69.0085,96.6582-116.4061,117.8402-311.8488,158.9436-458.4507,74.024-34.9209-21.118-65.6353-48.0825-92.1285-78.9857-44.2956-52.0525-72.9359-115.6509-77.5245-184.3734-6.8541-93.9946,25.6439-189.9315,100.9035-249.6672,84.0959-66.1615,205.9983-86.8043,304.297-41.1946,45.6125,21.289,81.4601,57.3094,104.7376,101.7447,37.2798,69.8445,41.9726,157.0079-4.552,223.7989-27.6397,39.8894-69.6303,69.0195-116.2176,82.0876-34.9037,9.9045-73.4819,10.2288-108.1644-1.5152-11.703-3.8106-22.6418-9.2572-33.1248-15.3554-33.4788-19.4956-62.4994-49.2218-75.2479-86.5194-22.2928-64.4901,6.0814-145.2041,68.5029-175.6444,29.5916-13.9453,66.5414-16.7278,97.6527-6.4616,23.6064,7.765,43.629,24.9383,52.7659,48.2988,13.8873,33.4484,3.3714,74.5204-21.5234,99.1309.0004,0-.8257-.5635-.8257-.5635,6.2627-14.762,10.1991-30.3483,10.2071-46.0897-.2131-22.5477-7.8197-43.1595-24.8902-56.7847-21.2296-16.1751-51.2193-16.8267-76.5045-9.5361-33.1876,9.2462-55.0902,39.0586-61.7813,71.9208-8.7734,41.4375,6.7431,78.1186,41.5081,102.2906,12.9228,9.0329,27.5612,16.8422,42.8364,20.8661,56.1118,14.0549,118.4104-15.1339,148.8361-63.3017,13.754-21.7683,19.6984-47.7195,18.0554-73.3693-2.7718-43.7222-25.5962-89.1167-59.3832-116.9753-74.1693-59.8609-198.0471-31.1359-254.8214,39.6856-30.8904,39.395-40.4606,91.2021-35.4807,140.6621,4.0847,41.9461,22.0432,80.9697,49.4688,113.0022,13.8904,16.3896,30.0619,31.1339,47.4808,43.6973,6.177,4.356,12.4878,8.7047,19.0009,12.1489,113.5095,60.2664,268.6177,6.8057,334.5213-99.9259,41.5134-66.9728,45.9873-153.5518,25.938-229.0895-13.5634-42.8773-38.3435-82.1332-70.3238-114.2228-72.4277-72.547-174.6106-108.128-276.9539-109.3969,0,0-.6016-124.5995-.6016-124.5995h0Z"/></g><g id="d"><path class="u" d="M526.9381,397.3214c8.2352,5.9642,28.4158,17.9125,32.9769,24.1895,7.0574,9.7125,12.329,18.47,15.8714,26.2755,1.4799,3.261,6.2541,2.9056,7.1904-.5509,3.1887-11.7715.1411-21.9116-2.3587-27.5323-1.0217-2.2975.3764-4.9269,2.8549-5.3503,5.3774-.9186,13.8798-3.0937,21.1227-8.1682,3.0605-2.1443,1.6372-6.9122-2.0986-7.0074-6.5564-.167-15.1837-1.5665-23.9292-6.4747-5.0786-2.8502-14.5004-8.6029-22.7406-14.0484-6.9265-.9987-13.8912-1.7329-20.8774-2.2142-3.0247,5.2936-6.0493,10.5873-9.0739,15.8809-.9685,1.6951-.519,3.8555,1.0621,5.0006Z"/><path class="u" d="M470.2316,176.8992c.0045.9412.0095,1.9697.0148,3.0781.0054,1.1084.0111,2.2968.0172,3.5573.0092,1.8908.019,3.9441.0296,6.1343.0071,1.4601.0143,2.9811.022,4.5554.0152,3.1484.0314,6.5098.0484,10.0233.0043.8826.0086,1.7748.0129,2.6757.0087,1.7888.0175,3.6114.0264,5.4606.0179,3.7074.0363,7.5213.0549,11.3808.0093,1.9297.0187,3.871.0281,5.8159s.0188,3.8937.0282,5.8387c.0093,1.9403.0187,3.8768.028,5.8019.0047.9742.0094,1.9455.014,2.9129.0092,1.9072.0184,3.7991.0274,5.6686.0046.9483.0091,1.8909.0136,2.8266.0089,1.8491.0177,3.6718.0264,5.4603.013,2.6937.0256,5.3098.0378,7.8232.0161,3.3376.0314,6.4935.0454,9.4074,0,.007,0,.0142.0001.0212.0564,11.6739.094,19.4562.094,19.4581.0033.0001.007.0003.0103.0004,3.8586.0479,7.7164.1611,11.5729.3067,2.0309.0556,3.9788.1246,5.647.2254.2617.02.548.0392.8225.0588,2.2717.1182,4.5413.2671,6.8108.4193,2.3681.1348,4.7145.2679,6.6782.4078,24.4694,1.9338,48.9315,5.9893,72.8813,12.1271,6.7089-35.8959,10.1854-78.5311,8.2295-128.3035-20.8409-4.043-41.9423-6.8651-63.1398-8.4427-.2734-.0201-.5469-.0396-.8203-.0593-1.8622-.1357-3.7255-.2593-5.5891-.3759-.7231-.0448-1.4463-.0886-2.1696-.1306-1.4073-.0823-2.8151-.1569-4.223-.2282-1.0446-.0524-2.0894-.1044-3.1342-.1508-1.0819-.0485-2.1641-.0906-3.2463-.1326-1.2878-.0496-2.5756-.0988-3.8636-.1392-.838-.0265-1.6762-.0469-2.5143-.0695-1.4706-.0394-2.9413-.0783-4.4122-.1058-.6635-.0125-1.327-.0186-1.9905-.0286-1.6062-.0242-3.2125-.0475-4.8187-.0574-.5552-.0034-1.1104-.0002-1.6656-.0019-1.6803-.0053-3.3607-.0095-5.0408.0007-2.2089.0142-4.4178.0389-6.6262.0804,0,0,.0072,1.4905.02,4.1456.0037.7586.0078,1.6123.0123,2.5534Z"/><path class="u" d="M309.836,454.277c95.1288,28.996,157.9599,20.0751,190.6381,1.6937,15.8222-8.9,37.5245-34.1166,54.8436-77.3873-80.6993-11.4839-166.5547,12.4953-230.5311,62.8281-5.189,4.1186-10.1671,8.4153-14.9506,12.8655Z"/></g><g id="e"><path class="r" d="M728.646,233.3535c-2.2085,2.5682-.7001,4.7817-1.2302,14.2649-.6437,11.5109-3.1644,13.5895-1.0813,16.5969,2.3533,3.3973,6.8386,1.7161,18.8418,4.8345,6.9363,1.802,12.879,3.358,12.879,3.358,3.2098.8357,6.6195.0124,8.9913-2.1785,2.3828-2.1853,3.3877-5.4111,2.6752-8.5404,0,0-.7104-3.1938-1.6968-7.5859-12.0963-7.9258-24.5636-15.3071-37.3475-22.1412-.7725.2506-1.406.6644-2.0315,1.3918Z"/><path class="r" d="M880.8426,516.2337c-.1501,4.1301,4.4488,5.47,12.1937,15.1558,4.4757,5.5973,8.3028,10.4024,8.3028,10.4024,2.07,2.5916,5.2937,3.9743,8.5052,3.6403,3.217-.323,5.9537-2.3045,7.2571-5.2373,0,0,9.9089-21.9964,12.8071-28.8768.2153-.5109.367-1.3594.1909-2.3862-.6946-4.0494-6.4305-5.0585-14.5202-8.9891-9.8552-4.7884-10.7346-7.8543-14.4028-7.0398-3.3066.7341-3.4243,3.4101-9.5283,10.687-7.4092,8.8328-10.6728,8.9878-10.8057,12.6436Z"/><path class="r" d="M838.9262,795.3444c-3.1075,2.7246-.9268,6.9895-2.6591,19.2695-1.0011,7.0964-1.8708,13.1775-1.8708,13.1775-.465,3.284.7409,6.5779,3.1874,8.6851,2.4423,2.1187,5.7615,2.75,8.7894,1.686,0,0,22.8008-7.8838,29.7946-10.4962.5194-.194,1.2407-.6657,1.8669-1.4983,2.4693-3.2837-.7322-8.1489-3.4233-16.7308-3.2785-10.455-1.6515-13.1982-4.7608-15.308-2.8028-1.9018-4.8303-.1514-14.3122.4009-11.5094.6704-13.8614-1.5975-16.6121.8142Z"/><path class="r" d="M619.9149,926.6034c-4.0945-.5614-5.8865,3.8808-16.2968,10.6207-6.0159,3.8949-11.1789,7.2235-11.1789,7.2235-2.7851,1.8011-4.4826,4.8708-4.4707,8.0996.0004,3.2332,1.699,6.1539,4.4871,7.7435,0,0,20.898,12.0542,27.4549,15.6244.4869.2652,1.316.5008,2.3552.4281,4.0985-.2871,5.6749-5.8937,10.3929-13.5508,5.7478-9.3283,8.8861-9.8974,8.4417-13.6285-.4006-3.3634-3.0514-3.7475-9.683-10.5471-8.0495-8.2535-7.8781-11.5163-11.5024-12.0133Z"/><path class="r" d="M371.4353,824.7067c-.6472-4.0818-5.4179-4.512-14.8814-12.5271-5.4688-4.6318-10.1488-8.611-10.1488-8.611-2.5298-2.145-5.9594-2.8817-9.0466-1.9362-3.0948.9358-5.3992,3.4068-6.1141,6.5355,0,0-5.4925,23.4917-7.0131,30.8011-.113.5428-.0987,1.4046.2716,2.3783,1.4606,3.8402,7.2835,3.727,15.9781,6.028,10.5923,2.8032,12.045,5.6426,15.488,4.1378,3.1036-1.3565,2.7044-4.0051,7.2946-12.3203,5.5717-10.0931,8.7446-10.873,8.1717-14.4861Z"/><path class="r" d="M342.7974,573.0036c-.4918.2559-1.1501.8123-1.6699,1.7151-2.0497,3.5607,1.7222,7.9984,5.4416,16.1873.743,1.636,1.317,3.0623,1.7935,4.3434,3.0795-10.7336,7.1102-21.1558,12.1518-31.1047-6.4917,3.2029-14.2099,7.0333-17.717,8.8589Z"/></g></g><g id="f"><path id="g" class="s" d="M512.4227,375.6755c-.7583,1.3271-.4063,3.0186.8316,3.9151,6.4476,4.6695,43.2476,25.0243,46.8186,29.9387,5.5254,7.6042,9.6528,14.4607,12.4262,20.5719,1.1587,2.5531,4.8965,2.2749,5.6296-.4313,2.4965-9.2163.1104-17.1552-1.8467-21.5559-.8-1.7988.2947-3.8574,2.2352-4.1889,4.2102-.7192,10.8669-2.4222,16.5376-6.3951,2.3963-1.6788,1.2819-5.4118-1.643-5.4863-5.1332-.1308-11.8878-1.2265-18.7349-5.0693-6.2953-3.5331-42.118-23.7635-48.2905-28.7153-1.442-1.1569-3.5714-.7717-4.4886.8335-3.1583,5.5276-6.3167,11.0552-9.475,16.5828Z"/><path id="h" class="r" d="M174.8148,380.6682c-1.7461-.969-2.23-9.0428-1.8148-11.6682l-19.2007-20.2723c-2.2474-2.4437-3.1462-5.8382-2.3607-9.0066.7773-3.1541,3.1162-5.6144,6.1848-6.5125l30.2446-8.7554c.8505-2.5101,1.728-5.0103,2.6414-7.4913l-17.299-27.8219c-1.7596-2.8116-1.9907-6.3135-.6127-9.2303,1.3617-2.9211,4.1493-4.8561,7.3481-5.1066l31.488-2.4943c1.3342-2.299,2.6878-4.5774,4.0794-6.8364l-11.7422-30.4749c-1.1922-3.0856-.7487-6.5456,1.1591-9.109,1.9106-2.5788,5.0314-3.9034,8.2439-3.5073l31.5599,3.8371c1.7628-1.9685,3.5417-3.9223,5.3619-5.8509l-5.7736-31.9894c-.5961-3.2551.4941-6.5194,2.8837-8.6482,2.3783-2.1079,5.7137-2.7819,8.8006-1.7677l30.5124,10.0602c2.0901-1.5488,4.2087-3.0838,6.3481-4.5756l.4176-32.3894c.0303-3.2741,1.7402-6.2417,4.4957-7.8299,2.7618-1.5919,6.1816-1.5809,9.0421.027l28.2308,15.877c2.3632-1.1034,4.7426-2.1609,7.1345-3.1955l6.5879-31.4442c.6682-3.1786,2.913-5.7209,5.9384-6.7276,3.0372-1.0073,6.4083-.3063,8.9313,1.8382l24.7781,21.0355c2.5879-.6121,5.1655-1.1776,7.751-1.7071l12.507-29.2366c1.2639-2.9693,3.9745-5.0065,7.1544-5.3679,3.1858-.3724,6.3947.9824,8.4697,3.5592l20.481,25.4379c2.6534-.0724,5.3066-.0945,7.9556-.1004l17.9446-25.9978c1.8252-2.6397,4.8821-4.0789,8.1031-3.7992,3.2176.2679,6.1288,2.225,7.6818,5.1558l15.3964,28.9185c2.6099.4502,5.2178.9415,7.8073,1.4689l22.7416-21.7849c2.3048-2.2066,5.6135-2.994,8.7276-2.0828,3.1282.9127,5.6202,3.3888,6.6051,6.5602l7.2505,24.3384c2.4881.9423,9.6885,7.862,9.8569,9.8546,15.1431,179.1454-42.8569,269.1454-74.8569,287.1454-43.9951,24.7473-147,31-315.1852-62.3318Z"/><path id="i" class="t" d="M416.6517,268.8313s9.1773-41.5786,49.7558-28.6784c0,0,40.4838,25.0557,31.4023,54.4816,0,0-17.3313,43.8615-49.7558,28.6784,0,0-32.8394-7.6867-31.4023-54.4816Z"/><path id="j" class="p" d="M451.2784,262.3353c6.1138,10.6072,4.8179,22.8102-2.8933,27.2548-7.7096,4.4437-18.9185-.5518-25.0323-11.159s-4.8182-22.8108,2.8914-27.2545,18.9206.5519,25.0342,11.1586Z"/><path id="k" class="t" d="M301.3287,325.3925s31.7841-43.492,67.7395-8.0315c0,0,40.5337,42.1237-5.1123,72.1296,0,0-66.9345,23.1212-62.6273-64.0981Z"/><path id="l" class="p" d="M333.2752,331.278c6.3044,10.9379,4.9707,23.5254-2.9834,28.1099s-19.5129-.5718-25.8173-11.5097c-6.3059-10.9405-4.9691-23.5262,2.9818-28.109s19.513.5683,25.8189,11.5088Z"/><g id="m"><path id="n" class="t" d="M457.6063,435.6128s-1.3552,8.2645-9.4633,6.1675c0,0-8.2203-4.4854-6.7533-10.3622,0,0,2.932-8.8006,9.4633-6.1675,0,0,6.5322,1.1564,6.7533,10.3622Z"/><path id="o" class="t" d="M498.6468,412.2641s-5.7744,8.8835-13.2173,2.3059c0,0-8.4137-7.8369.2282-14.2209,0,0,12.8969-5.2608,12.9891,11.9149Z"/></g></g></svg>
\ No newline at end of file
diff --git a/build.rs b/build.rs
index e20206310db..25e3f54e331 100644
--- a/build.rs
+++ b/build.rs
@@ -1,7 +1,9 @@
 use std::env;
 
 use pyo3_build_config::pyo3_build_script_impl::{cargo_env_var, errors::Result};
-use pyo3_build_config::{bail, print_feature_cfgs, InterpreterConfig};
+use pyo3_build_config::{
+    add_python_framework_link_args, bail, print_feature_cfgs, InterpreterConfig,
+};
 
 fn ensure_auto_initialize_ok(interpreter_config: &InterpreterConfig) -> Result<()> {
     if cargo_env_var("CARGO_FEATURE_AUTO_INITIALIZE").is_some() && !interpreter_config.shared {
@@ -16,7 +18,7 @@ fn ensure_auto_initialize_ok(interpreter_config: &InterpreterConfig) -> Result<(
             \n\
             For more information, see \
             https://pyo3.rs/v{pyo3_version}/\
-                building_and_distribution.html#embedding-python-in-rust",
+                building-and-distribution.html#embedding-python-in-rust",
             pyo3_version = env::var("CARGO_PKG_VERSION").unwrap()
         );
     }
@@ -36,16 +38,19 @@ fn configure_pyo3() -> Result<()> {
     ensure_auto_initialize_ok(interpreter_config)?;
 
     for cfg in interpreter_config.build_script_outputs() {
-        println!("{}", cfg)
+        println!("{cfg}")
     }
 
-    // Emit cfgs like `thread_local_const_init`
     print_feature_cfgs();
 
+    // Make `cargo test` etc work on macOS with Xcode bundled Python
+    add_python_framework_link_args();
+
     Ok(())
 }
 
 fn main() {
+    pyo3_build_config::print_expected_cfgs();
     if let Err(e) = configure_pyo3() {
         eprintln!("error: {}", e.report());
         std::process::exit(1)
diff --git a/codecov.yml b/codecov.yml
index d30f0ff47dc..356facdc3ff 100644
--- a/codecov.yml
+++ b/codecov.yml
@@ -5,8 +5,12 @@ coverage:
     project:
       default:
         target: auto
-        # Allow a tiny drop of overall project coverage in PR to reduce spurious failures.
-        threshold: 0.25%
+        # Allow a tiny drop of overall project coverage in PR due to
+        # not all configurations being tested in PR runs.
+        #
+        # (Note that patch coverage will still be required to be at least
+        # the project coverage.)
+        threshold: 1%
 
 ignore:
   - tests/
diff --git a/emscripten/Makefile b/emscripten/Makefile
index af224854c26..54094382c1b 100644
--- a/emscripten/Makefile
+++ b/emscripten/Makefile
@@ -4,7 +4,7 @@ CURDIR=$(abspath .)
 BUILDROOT ?= $(CURDIR)/builddir
 PYMAJORMINORMICRO ?= 3.11.0
 
-EMSCRIPTEN_VERSION=3.1.13
+EMSCRIPTEN_VERSION=3.1.68
 
 export EMSDKDIR = $(BUILDROOT)/emsdk
 
diff --git a/emscripten/pybuilddir.txt b/emscripten/pybuilddir.txt
deleted file mode 100644
index 59f2a4a7546..00000000000
--- a/emscripten/pybuilddir.txt
+++ /dev/null
@@ -1 +0,0 @@
-build/lib.linux-x86_64-3.11
\ No newline at end of file
diff --git a/examples/Cargo.toml b/examples/Cargo.toml
index e54b3b5cde2..68aa8be7a76 100644
--- a/examples/Cargo.toml
+++ b/examples/Cargo.toml
@@ -3,6 +3,7 @@ name = "pyo3-examples"
 version = "0.0.0"
 publish = false
 edition = "2021"
+rust-version = "1.83"
 
 [dev-dependencies]
 pyo3 = { path = "..", features = ["auto-initialize", "extension-module"] }
@@ -10,5 +11,5 @@ pyo3 = { path = "..", features = ["auto-initialize", "extension-module"] }
 [[example]]
 name = "decorator"
 path = "decorator/src/lib.rs"
-crate_type = ["cdylib"]
+crate-type = ["cdylib"]
 doc-scrape-examples = true
diff --git a/examples/README.md b/examples/README.md
index baaa57b650d..3c7cc301399 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -9,9 +9,11 @@ Below is a brief description of each of these:
 | `decorator` | A project showcasing the example from the [Emulating callable objects](https://pyo3.rs/latest/class/call.html) chapter of the guide. |
 | `maturin-starter` | A template project which is configured to use [`maturin`](https://github.com/PyO3/maturin) for development. |
 | `setuptools-rust-starter` | A template project which is configured to use [`setuptools_rust`](https://github.com/PyO3/setuptools-rust/) for development. |
-| `word-count` | A quick performance comparison between word counter implementations written in each of Rust and Python. |
 | `plugin` | Illustrates how to use Python as a scripting language within a Rust application |
-| `sequential` | Illustrates how to use pyo3-ffi to write subinterpreter-safe modules |
+
+Note that there are also other examples in the `pyo3-ffi/examples`
+directory that illustrate how to create rust extensions using raw FFI calls into
+the CPython C API instead of using PyO3's abstractions.
 
 ## Creating new projects from these examples
 
diff --git a/examples/decorator/.template/pre-script.rhai b/examples/decorator/.template/pre-script.rhai
index 12b203c3bb4..10287310615 100644
--- a/examples/decorator/.template/pre-script.rhai
+++ b/examples/decorator/.template/pre-script.rhai
@@ -1,4 +1,4 @@
-variable::set("PYO3_VERSION", "0.20.2");
+variable::set("PYO3_VERSION", "0.27.0");
 file::rename(".template/Cargo.toml", "Cargo.toml");
 file::rename(".template/pyproject.toml", "pyproject.toml");
 file::delete(".template");
diff --git a/examples/decorator/Cargo.toml b/examples/decorator/Cargo.toml
index 3456302a9fd..ef7e5dc2e1c 100644
--- a/examples/decorator/Cargo.toml
+++ b/examples/decorator/Cargo.toml
@@ -2,6 +2,7 @@
 name = "decorator"
 version = "0.1.0"
 edition = "2021"
+rust-version = "1.83"
 
 [lib]
 name = "decorator"
diff --git a/examples/decorator/src/lib.rs b/examples/decorator/src/lib.rs
index fb2f2932dd2..69915ff8256 100644
--- a/examples/decorator/src/lib.rs
+++ b/examples/decorator/src/lib.rs
@@ -1,6 +1,6 @@
 use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyTuple};
-use std::cell::Cell;
+use std::sync::atomic::{AtomicU64, Ordering};
 
 /// A function decorator that keeps track how often it is called.
 ///
@@ -9,8 +9,8 @@ use std::cell::Cell;
 pub struct PyCounter {
     // Keeps track of how many calls have gone through.
     //
-    // See the discussion at the end for why `Cell` is used.
-    count: Cell<u64>,
+    // See the discussion at the end for why `AtomicU64` is used.
+    count: AtomicU64,
 
     // This is the actual function being wrapped.
     wraps: Py<PyAny>,
@@ -26,32 +26,30 @@ impl PyCounter {
     #[new]
     fn __new__(wraps: Py<PyAny>) -> Self {
         PyCounter {
-            count: Cell::new(0),
+            count: AtomicU64::new(0),
             wraps,
         }
     }
 
     #[getter]
     fn count(&self) -> u64 {
-        self.count.get()
+        self.count.load(Ordering::Relaxed)
     }
 
     #[pyo3(signature = (*args, **kwargs))]
     fn __call__(
         &self,
         py: Python<'_>,
-        args: &PyTuple,
-        kwargs: Option<Bound<'_, PyDict>>,
+        args: &Bound<'_, PyTuple>,
+        kwargs: Option<&Bound<'_, PyDict>>,
     ) -> PyResult<Py<PyAny>> {
-        let old_count = self.count.get();
-        let new_count = old_count + 1;
-        self.count.set(new_count);
+        let new_count = self.count.fetch_add(1, Ordering::Relaxed);
         let name = self.wraps.getattr(py, "__name__")?;
 
-        println!("{} has been called {} time(s).", name, new_count);
+        println!("{name} has been called {new_count} time(s).");
 
         // After doing something, we finally forward the call to the wrapped function
-        let ret = self.wraps.call_bound(py, args, kwargs.as_ref())?;
+        let ret = self.wraps.call(py, args, kwargs)?;
 
         // We could do something with the return value of
         // the function before returning it
@@ -60,7 +58,7 @@ impl PyCounter {
 }
 
 #[pymodule]
-pub fn decorator(_py: Python<'_>, module: &PyModule) -> PyResult<()> {
+pub fn decorator(module: &Bound<'_, PyModule>) -> PyResult<()> {
     module.add_class::<PyCounter>()?;
     Ok(())
 }
diff --git a/examples/getitem/Cargo.toml b/examples/getitem/Cargo.toml
index 17020b9bd05..c31047eba24 100644
--- a/examples/getitem/Cargo.toml
+++ b/examples/getitem/Cargo.toml
@@ -2,6 +2,7 @@
 name = "getitem"
 version = "0.1.0"
 edition = "2021"
+rust-version = "1.83"
 
 [lib]
 name = "getitem"
diff --git a/examples/getitem/src/lib.rs b/examples/getitem/src/lib.rs
index 90a3e9fc52f..5739b67eb31 100644
--- a/examples/getitem/src/lib.rs
+++ b/examples/getitem/src/lib.rs
@@ -2,12 +2,11 @@
 use pyo3::exceptions::PyTypeError;
 use pyo3::prelude::*;
 use pyo3::types::PySlice;
-use std::os::raw::c_long;
 
 #[derive(FromPyObject)]
 enum IntOrSlice<'py> {
     Int(i32),
-    Slice(&'py PySlice),
+    Slice(Bound<'py, PySlice>),
 }
 
 #[pyclass]
@@ -23,13 +22,13 @@ impl ExampleContainer {
         ExampleContainer { max_length: 100 }
     }
 
-    fn __getitem__(&self, key: &PyAny) -> PyResult<i32> {
+    fn __getitem__(&self, key: &Bound<'_, PyAny>) -> PyResult<i32> {
         if let Ok(position) = key.extract::<i32>() {
             return Ok(position);
-        } else if let Ok(slice) = key.downcast::<PySlice>() {
+        } else if let Ok(slice) = key.cast::<PySlice>() {
             // METHOD 1 - the use PySliceIndices to help with bounds checking and for cases when only start or end are provided
             // in this case the start/stop/step all filled in to give valid values based on the max_length given
-            let index = slice.indices(self.max_length as c_long).unwrap();
+            let index = slice.indices(self.max_length as isize).unwrap();
             let _delta = index.stop - index.start;
 
             // METHOD 2 - Do the getattr manually really only needed if you have some special cases for stop/_step not being present
@@ -62,8 +61,11 @@ impl ExampleContainer {
     fn __setitem__(&self, idx: IntOrSlice, value: u32) -> PyResult<()> {
         match idx {
             IntOrSlice::Slice(slice) => {
-                let index = slice.indices(self.max_length as c_long).unwrap();
-                println!("Got a slice! {}-{}, step: {}, value: {}", index.start, index.stop, index.step, value);
+                let index = slice.indices(self.max_length as isize).unwrap();
+                println!(
+                    "Got a slice! {}-{}, step: {}, value: {}",
+                    index.start, index.stop, index.step, value
+                );
             }
             IntOrSlice::Int(index) => {
                 println!("Got an index! {} : value: {}", index, value);
@@ -73,9 +75,8 @@ impl ExampleContainer {
     }
 }
 
-#[pymodule]
-#[pyo3(name = "getitem")]
-fn example(_py: Python<'_>, m: &PyModule) -> PyResult<()> {
+#[pymodule(name = "getitem")]
+fn example(m: &Bound<'_, PyModule>) -> PyResult<()> {
     // ? -https://github.com/PyO3/maturin/issues/475
     m.add_class::<ExampleContainer>()?;
     Ok(())
diff --git a/examples/maturin-starter/.template/pre-script.rhai b/examples/maturin-starter/.template/pre-script.rhai
index 12b203c3bb4..10287310615 100644
--- a/examples/maturin-starter/.template/pre-script.rhai
+++ b/examples/maturin-starter/.template/pre-script.rhai
@@ -1,4 +1,4 @@
-variable::set("PYO3_VERSION", "0.20.2");
+variable::set("PYO3_VERSION", "0.27.0");
 file::rename(".template/Cargo.toml", "Cargo.toml");
 file::rename(".template/pyproject.toml", "pyproject.toml");
 file::delete(".template");
diff --git a/examples/maturin-starter/Cargo.toml b/examples/maturin-starter/Cargo.toml
index 257908a4bb0..53e464bbffe 100644
--- a/examples/maturin-starter/Cargo.toml
+++ b/examples/maturin-starter/Cargo.toml
@@ -2,6 +2,7 @@
 name = "maturin-starter"
 version = "0.1.0"
 edition = "2021"
+rust-version = "1.83"
 
 [lib]
 name = "maturin_starter"
diff --git a/examples/maturin-starter/src/lib.rs b/examples/maturin-starter/src/lib.rs
index 96ace0f97d5..5e0be857391 100644
--- a/examples/maturin-starter/src/lib.rs
+++ b/examples/maturin-starter/src/lib.rs
@@ -20,7 +20,7 @@ impl ExampleClass {
 
 /// An example module implemented in Rust using PyO3.
 #[pymodule]
-fn maturin_starter(py: Python<'_>, m: &PyModule) -> PyResult<()> {
+fn maturin_starter(py: Python<'_>, m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_class::<ExampleClass>()?;
     m.add_wrapped(wrap_pymodule!(submodule::submodule))?;
 
@@ -28,7 +28,7 @@ fn maturin_starter(py: Python<'_>, m: &PyModule) -> PyResult<()> {
     // e.g. from maturin_starter.submodule import SubmoduleClass
 
     let sys = PyModule::import(py, "sys")?;
-    let sys_modules: &PyDict = sys.getattr("modules")?.downcast()?;
+    let sys_modules: Bound<'_, PyDict> = sys.getattr("modules")?.cast_into()?;
     sys_modules.set_item("maturin_starter.submodule", m.getattr("submodule")?)?;
 
     Ok(())
diff --git a/examples/maturin-starter/src/submodule.rs b/examples/maturin-starter/src/submodule.rs
index 56540b2e469..f3eb174100b 100644
--- a/examples/maturin-starter/src/submodule.rs
+++ b/examples/maturin-starter/src/submodule.rs
@@ -16,7 +16,7 @@ impl SubmoduleClass {
 }
 
 #[pymodule]
-pub fn submodule(_py: Python<'_>, m: &PyModule) -> PyResult<()> {
+pub fn submodule(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_class::<SubmoduleClass>()?;
     Ok(())
 }
diff --git a/examples/plugin/.template/pre-script.rhai b/examples/plugin/.template/pre-script.rhai
index 72cfe2be91d..bb9d2c4f3b5 100644
--- a/examples/plugin/.template/pre-script.rhai
+++ b/examples/plugin/.template/pre-script.rhai
@@ -1,4 +1,4 @@
-variable::set("PYO3_VERSION", "0.20.2");
+variable::set("PYO3_VERSION", "0.27.0");
 file::rename(".template/Cargo.toml", "Cargo.toml");
 file::rename(".template/plugin_api/Cargo.toml", "plugin_api/Cargo.toml");
 file::delete(".template");
diff --git a/examples/plugin/Cargo.toml b/examples/plugin/Cargo.toml
index 08127b5003f..ab342767f2d 100644
--- a/examples/plugin/Cargo.toml
+++ b/examples/plugin/Cargo.toml
@@ -2,11 +2,11 @@
 name = "plugin_example"
 version = "0.1.0"
 edition = "2021"
-
+rust-version = "1.83"
 
 [dependencies]
-pyo3={path="../../", features=["macros"]}
-plugin_api={path="plugin_api"}
+pyo3 = { path = "../../", features = ["macros"] }
+plugin_api = { path = "plugin_api" }
 
 
 [workspace]
diff --git a/examples/plugin/plugin_api/src/lib.rs b/examples/plugin/plugin_api/src/lib.rs
index 59aae55699d..580c85a8c8e 100644
--- a/examples/plugin/plugin_api/src/lib.rs
+++ b/examples/plugin/plugin_api/src/lib.rs
@@ -26,7 +26,7 @@ impl Gadget {
 
 /// A Python module for plugin interface types
 #[pymodule]
-pub fn plugin_api(_py: Python<'_>, m: &PyModule) -> PyResult<()> {
+pub fn plugin_api(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_class::<Gadget>()?;
     Ok(())
 }
diff --git a/examples/plugin/src/main.rs b/examples/plugin/src/main.rs
index b50b54548e5..677d9e37b53 100644
--- a/examples/plugin/src/main.rs
+++ b/examples/plugin/src/main.rs
@@ -7,13 +7,13 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     //"export" our API module to the python runtime
     pyo3::append_to_inittab!(pylib_module);
     //spawn runtime
-    pyo3::prepare_freethreaded_python();
+    Python::initialize();
     //import path for python
     let path = Path::new("./python_plugin/");
     //do useful work
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         //add the current directory to import path of Python (do not use this in production!)
-        let syspath: &PyList = py.import("sys")?.getattr("path")?.extract()?;
+        let syspath: Bound<PyList> = py.import("sys")?.getattr("path")?.extract()?;
         syspath.insert(0, &path)?;
         println!("Import path is: {:?}", syspath);
 
diff --git a/examples/sequential/Cargo.toml b/examples/sequential/Cargo.toml
deleted file mode 100644
index 4500c69b597..00000000000
--- a/examples/sequential/Cargo.toml
+++ /dev/null
@@ -1,13 +0,0 @@
-[package]
-name = "sequential"
-version = "0.1.0"
-edition = "2021"
-
-[lib]
-name = "sequential"
-crate-type = ["cdylib", "lib"]
-
-[dependencies]
-pyo3-ffi = { path = "../../pyo3-ffi", features = ["extension-module"] }
-
-[workspace]
diff --git a/examples/setuptools-rust-starter/.template/pre-script.rhai b/examples/setuptools-rust-starter/.template/pre-script.rhai
index 78a656558f8..f6c8aca02a9 100644
--- a/examples/setuptools-rust-starter/.template/pre-script.rhai
+++ b/examples/setuptools-rust-starter/.template/pre-script.rhai
@@ -1,4 +1,4 @@
-variable::set("PYO3_VERSION", "0.20.2");
+variable::set("PYO3_VERSION", "0.27.0");
 file::rename(".template/Cargo.toml", "Cargo.toml");
 file::rename(".template/setup.cfg", "setup.cfg");
 file::delete(".template");
diff --git a/examples/setuptools-rust-starter/Cargo.toml b/examples/setuptools-rust-starter/Cargo.toml
index 5777cbbcd78..e7ae56a7612 100644
--- a/examples/setuptools-rust-starter/Cargo.toml
+++ b/examples/setuptools-rust-starter/Cargo.toml
@@ -2,6 +2,7 @@
 name = "setuptools-rust-starter"
 version = "0.1.0"
 edition = "2021"
+rust-version = "1.83"
 
 [lib]
 name = "setuptools_rust_starter"
diff --git a/examples/setuptools-rust-starter/noxfile.py b/examples/setuptools-rust-starter/noxfile.py
index 9edab96254b..d3579912ea7 100644
--- a/examples/setuptools-rust-starter/noxfile.py
+++ b/examples/setuptools-rust-starter/noxfile.py
@@ -1,10 +1,11 @@
 import nox
+import sys
 
 
 @nox.session
 def python(session: nox.Session):
-    session.install("-rrequirements-dev.txt")
-    session.run_always(
-        "pip", "install", "-e", ".", "--no-build-isolation", env={"BUILD_DEBUG": "1"}
-    )
+    if sys.version_info < (3, 9):
+        session.skip("Python 3.9 or later is required for setuptools-rust 1.11")
+    session.env["SETUPTOOLS_RUST_CARGO_PROFILE"] = "dev"
+    session.install(".[dev]")
     session.run("pytest")
diff --git a/examples/setuptools-rust-starter/pyproject.toml b/examples/setuptools-rust-starter/pyproject.toml
index d82653c1701..bc4c7d2bc98 100644
--- a/examples/setuptools-rust-starter/pyproject.toml
+++ b/examples/setuptools-rust-starter/pyproject.toml
@@ -1,2 +1,25 @@
 [build-system]
-requires = ["setuptools>=41.0.0", "wheel", "setuptools_rust>=1.0.0"]
+requires = ["setuptools>=62.4", "setuptools_rust>=1.11"]
+
+[project]
+name = "setuptools-rust-starter"
+version = "0.1.0"
+classifiers = [
+    "License :: OSI Approved :: MIT License",
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python",
+    "Programming Language :: Rust",
+    "Operating System :: POSIX",
+    "Operating System :: MacOS :: MacOS X",
+]
+
+[project.optional-dependencies]
+dev = ["pytest"]
+
+[tool.setuptools.packages.find]
+include = ["setuptools_rust_starter"]
+
+[[tool.setuptools-rust.ext-modules]]
+target = "setuptools_rust_starter._setuptools_rust_starter"
+path = "Cargo.toml"
diff --git a/examples/setuptools-rust-starter/setup.cfg b/examples/setuptools-rust-starter/setup.cfg
deleted file mode 100644
index 95caeb757e6..00000000000
--- a/examples/setuptools-rust-starter/setup.cfg
+++ /dev/null
@@ -1,17 +0,0 @@
-[metadata]
-name = setuptools-rust-starter
-version = 0.1.0
-classifiers =
-    License :: OSI Approved :: MIT License
-    Development Status :: 3 - Alpha
-    Intended Audience :: Developers
-    Programming Language :: Python
-    Programming Language :: Rust
-    Operating System :: POSIX
-    Operating System :: MacOS :: MacOS X
-
-[options]
-packages =
-    setuptools_rust_starter
-include_package_data = True
-zip_safe = False
diff --git a/examples/setuptools-rust-starter/setup.py b/examples/setuptools-rust-starter/setup.py
deleted file mode 100644
index 85d9e21d3a4..00000000000
--- a/examples/setuptools-rust-starter/setup.py
+++ /dev/null
@@ -1,13 +0,0 @@
-import os
-
-from setuptools import setup
-from setuptools_rust import RustExtension
-
-setup(
-    rust_extensions=[
-        RustExtension(
-            "setuptools_rust_starter._setuptools_rust_starter",
-            debug=os.environ.get("BUILD_DEBUG") == "1",
-        )
-    ],
-)
diff --git a/examples/setuptools-rust-starter/src/lib.rs b/examples/setuptools-rust-starter/src/lib.rs
index fbfeccc1555..e4ff036d850 100644
--- a/examples/setuptools-rust-starter/src/lib.rs
+++ b/examples/setuptools-rust-starter/src/lib.rs
@@ -20,7 +20,7 @@ impl ExampleClass {
 
 /// An example module implemented in Rust using PyO3.
 #[pymodule]
-fn _setuptools_rust_starter(py: Python<'_>, m: &PyModule) -> PyResult<()> {
+fn _setuptools_rust_starter(py: Python<'_>, m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_class::<ExampleClass>()?;
     m.add_wrapped(wrap_pymodule!(submodule::submodule))?;
 
@@ -28,7 +28,7 @@ fn _setuptools_rust_starter(py: Python<'_>, m: &PyModule) -> PyResult<()> {
     // e.g. from setuptools_rust_starter.submodule import SubmoduleClass
 
     let sys = PyModule::import(py, "sys")?;
-    let sys_modules: &PyDict = sys.getattr("modules")?.downcast()?;
+    let sys_modules: Bound<'_, PyDict> = sys.getattr("modules")?.cast_into()?;
     sys_modules.set_item("setuptools_rust_starter.submodule", m.getattr("submodule")?)?;
 
     Ok(())
diff --git a/examples/setuptools-rust-starter/src/submodule.rs b/examples/setuptools-rust-starter/src/submodule.rs
index 56540b2e469..f3eb174100b 100644
--- a/examples/setuptools-rust-starter/src/submodule.rs
+++ b/examples/setuptools-rust-starter/src/submodule.rs
@@ -16,7 +16,7 @@ impl SubmoduleClass {
 }
 
 #[pymodule]
-pub fn submodule(_py: Python<'_>, m: &PyModule) -> PyResult<()> {
+pub fn submodule(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_class::<SubmoduleClass>()?;
     Ok(())
 }
diff --git a/examples/string-sum/Cargo.toml b/examples/string-sum/Cargo.toml
deleted file mode 100644
index 4a48b221c60..00000000000
--- a/examples/string-sum/Cargo.toml
+++ /dev/null
@@ -1,13 +0,0 @@
-[package]
-name = "string_sum"
-version = "0.1.0"
-edition = "2021"
-
-[lib]
-name = "string_sum"
-crate-type = ["cdylib"]
-
-[dependencies]
-pyo3-ffi = { path = "../../pyo3-ffi", features = ["extension-module"] }
-
-[workspace]
diff --git a/examples/word-count/.template/pre-script.rhai b/examples/word-count/.template/pre-script.rhai
index 12b203c3bb4..10287310615 100644
--- a/examples/word-count/.template/pre-script.rhai
+++ b/examples/word-count/.template/pre-script.rhai
@@ -1,4 +1,4 @@
-variable::set("PYO3_VERSION", "0.20.2");
+variable::set("PYO3_VERSION", "0.27.0");
 file::rename(".template/Cargo.toml", "Cargo.toml");
 file::rename(".template/pyproject.toml", "pyproject.toml");
 file::delete(".template");
diff --git a/examples/word-count/Cargo.toml b/examples/word-count/Cargo.toml
index cfb3444d5fe..816e3dd9a34 100644
--- a/examples/word-count/Cargo.toml
+++ b/examples/word-count/Cargo.toml
@@ -2,6 +2,7 @@
 name = "word-count"
 version = "0.1.0"
 edition = "2021"
+rust-version = "1.83"
 
 [lib]
 name = "word_count"
diff --git a/examples/word-count/noxfile.py b/examples/word-count/noxfile.py
index d64f210f3e5..c9dd6fce159 100644
--- a/examples/word-count/noxfile.py
+++ b/examples/word-count/noxfile.py
@@ -12,6 +12,5 @@ def test(session: nox.Session):
 
 @nox.session
 def bench(session: nox.Session):
-    session.env["MATURIN_PEP517_ARGS"] = "--profile=dev"
     session.install(".[dev]")
     session.run("pytest", "--benchmark-enable")
diff --git a/examples/word-count/src/lib.rs b/examples/word-count/src/lib.rs
index b7d3a8033a6..baa9cf18e57 100644
--- a/examples/word-count/src/lib.rs
+++ b/examples/word-count/src/lib.rs
@@ -17,8 +17,8 @@ fn search_sequential(contents: &str, needle: &str) -> usize {
 }
 
 #[pyfunction]
-fn search_sequential_allow_threads(py: Python<'_>, contents: &str, needle: &str) -> usize {
-    py.allow_threads(|| search_sequential(contents, needle))
+fn search_sequential_detached(py: Python<'_>, contents: &str, needle: &str) -> usize {
+    py.detach(|| search_sequential(contents, needle))
 }
 
 /// Count the occurrences of needle in line, case insensitive
@@ -33,10 +33,10 @@ fn count_line(line: &str, needle: &str) -> usize {
 }
 
 #[pymodule]
-fn word_count(_py: Python<'_>, m: &PyModule) -> PyResult<()> {
+fn word_count(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(search, m)?)?;
     m.add_function(wrap_pyfunction!(search_sequential, m)?)?;
-    m.add_function(wrap_pyfunction!(search_sequential_allow_threads, m)?)?;
+    m.add_function(wrap_pyfunction!(search_sequential_detached, m)?)?;
 
     Ok(())
 }
diff --git a/examples/word-count/tests/test_word_count.py b/examples/word-count/tests/test_word_count.py
index 5991e4ae1de..5b665d8e29c 100644
--- a/examples/word-count/tests/test_word_count.py
+++ b/examples/word-count/tests/test_word_count.py
@@ -50,12 +50,8 @@ def test_word_count_python_sequential(benchmark, contents):
 def run_rust_sequential_twice(
     executor: ThreadPoolExecutor, contents: str, needle: str
 ) -> int:
-    future_1 = executor.submit(
-        word_count.search_sequential_allow_threads, contents, needle
-    )
-    future_2 = executor.submit(
-        word_count.search_sequential_allow_threads, contents, needle
-    )
+    future_1 = executor.submit(word_count.search_sequential_detached, contents, needle)
+    future_2 = executor.submit(word_count.search_sequential_detached, contents, needle)
     result_1 = future_1.result()
     result_2 = future_2.result()
     return result_1 + result_2
diff --git a/examples/word-count/word_count/__init__.py b/examples/word-count/word_count/__init__.py
index 8ce7a175471..4a7f1b5ee5e 100644
--- a/examples/word-count/word_count/__init__.py
+++ b/examples/word-count/word_count/__init__.py
@@ -1,10 +1,10 @@
-from .word_count import search, search_sequential, search_sequential_allow_threads
+from .word_count import search, search_sequential, search_sequential_detached
 
 __all__ = [
     "search_py",
     "search",
     "search_sequential",
-    "search_sequential_allow_threads",
+    "search_sequential_detached",
 ]
 
 
diff --git a/guide/book.toml b/guide/book.toml
index 31fa4bb1587..be682a64eab 100644
--- a/guide/book.toml
+++ b/guide/book.toml
@@ -6,7 +6,11 @@ author = "PyO3 Project and Contributors"
 [preprocessor.pyo3_version]
 command = "python3 guide/pyo3_version.py"
 
+[preprocessor.tabs]
+
 [output.html]
 git-repository-url = "https://github.com/PyO3/pyo3/tree/main/guide"
 edit-url-template = "https://github.com/PyO3/pyo3/edit/main/guide/%7Bpath%7D"
-playground.runnable = false
\ No newline at end of file
+playground.runnable = false
+additional-css = ["theme/tabs.css"]
+additional-js = ["theme/tabs.js"]
diff --git a/guide/pyclass_parameters.md b/guide/pyclass-parameters.md
similarity index 59%
rename from guide/pyclass_parameters.md
rename to guide/pyclass-parameters.md
index 35c54147df5..2c9efe5c259 100644
--- a/guide/pyclass_parameters.md
+++ b/guide/pyclass-parameters.md
@@ -2,21 +2,30 @@
 
 |  Parameter  |  Description |
 | :-  | :- |
+| `constructor` | This is currently only allowed on [variants of complex enums][params-constructor]. It allows customization of the generated class constructor for each variant. It uses the same syntax and supports the same options as the `signature` attribute of functions and methods. |
 | <span style="white-space: pre">`crate = "some::path"`</span>  | Path to import the `pyo3` crate, if it's not accessible at `::pyo3`. |
 | `dict` | Gives instances of this class an empty `__dict__` to store custom attributes. |
+| `eq` | Implements `__eq__` using the `PartialEq` implementation of the underlying Rust datatype. |
+| `eq_int` | Implements `__eq__` using `__int__` for simple enums. |
 | <span style="white-space: pre">`extends = BaseType`</span>  | Use a custom baseclass. Defaults to [`PyAny`][params-1] |
 | <span style="white-space: pre">`freelist = N`</span> |  Implements a [free list][params-2] of size N. This can improve performance for types that are often created and deleted in quick succession. Profile your code to see whether `freelist` is right for you.  |
+| `from_py_object` | Implement `FromPyObject` for this pyclass. Requires the pyclass to be `Clone`. |
 | <span style="white-space: pre">`frozen`</span> | Declares that your pyclass is immutable. It removes the borrow checker overhead when retrieving a shared reference to the Rust struct, but disables the ability to get a mutable reference. |
+| `generic` | Implements runtime parametrization for the class following [PEP 560](https://peps.python.org/pep-0560/). |
 | `get_all` | Generates getters for all fields of the pyclass. |
+| `hash` | Implements `__hash__` using the `Hash` implementation of the underlying Rust datatype. *Requires `eq` and `frozen`* |
+| `immutable_type` | Makes the type object immutable. Supported on 3.14+ with the `abi3` feature active, or 3.10+ otherwise. |
 | `mapping` |  Inform PyO3 that this class is a [`Mapping`][params-mapping], and so leave its implementation of sequence C-API slots empty. |
 | <span style="white-space: pre">`module = "module_name"`</span> |  Python code will see the class as being defined in this module. Defaults to `builtins`. |
 | <span style="white-space: pre">`name = "python_name"`</span> | Sets the name that Python sees this class as. Defaults to the name of the Rust struct. |
+| `ord` | Implements `__lt__`, `__gt__`, `__le__`, & `__ge__` using the `PartialOrd` implementation of the underlying Rust datatype. *Requires `eq`* |
 | `rename_all = "renaming_rule"` | Applies renaming rules to every getters and setters of a struct, or every variants of an enum. Possible values are: "camelCase", "kebab-case", "lowercase", "PascalCase", "SCREAMING-KEBAB-CASE", "SCREAMING_SNAKE_CASE", "snake_case", "UPPERCASE". |
 | `sequence` |  Inform PyO3 that this class is a [`Sequence`][params-sequence], and so leave its C-API mapping length slot empty. |
 | `set_all` | Generates setters for all fields of the pyclass. |
+| `skip_from_py_object` | Prevents this PyClass from participating in the `FromPyObject: PyClass + Clone` blanket implementation. This allows a custom `FromPyObject` impl, even if `self` is `Clone`. |
+| `str` | Implements `__str__` using the `Display` implementation of the underlying Rust datatype or by passing an optional format string `str="<format string>"`. *Note: The optional format string is only allowed for structs.  `name` and `rename_all` are incompatible with the optional format string.  Additional details can be found in the discussion on this [PR](https://github.com/PyO3/pyo3/pull/4233).* |
 | `subclass` | Allows other Python classes and `#[pyclass]` to inherit from this class. Enums cannot be subclassed. |
-| <span style="white-space: pre">`text_signature = "(arg1, arg2, ...)"`</span> |  Sets the text signature for the Python class' `__new__` method. |
-| `unsendable` | Required if your struct is not [`Send`][params-3]. Rather than using `unsendable`, consider implementing your struct in a threadsafe way by e.g. substituting [`Rc`][params-4] with [`Arc`][params-5]. By using `unsendable`, your class will panic when accessed by another thread. Also note the Python's GC is multi-threaded and while unsendable classes will not be traversed on foreign threads to avoid UB, this can lead to memory leaks. |
+| `unsendable` | Required if your struct is not [`Send`][params-3]. Rather than using `unsendable`, consider implementing your struct in a thread-safe way by e.g. substituting [`Rc`][params-4] with [`Arc`][params-5]. By using `unsendable`, your class will panic when accessed by another thread. Also note the Python's GC is multi-threaded and while unsendable classes will not be traversed on foreign threads to avoid UB, this can lead to memory leaks. |
 | `weakref` | Allows this class to be [weakly referenceable][params-6]. |
 
 All of these parameters can either be passed directly on the `#[pyclass(...)]` annotation, or as one or
@@ -33,11 +42,12 @@ struct MyClass {}
 struct MyClass {}
 ```
 
-[params-1]: https://docs.rs/pyo3/latest/pyo3/struct.PyAny.html
+[params-1]: https://docs.rs/pyo3/latest/pyo3/types/struct.PyAny.html
 [params-2]: https://en.wikipedia.org/wiki/Free_list
 [params-3]: https://doc.rust-lang.org/std/marker/trait.Send.html
 [params-4]: https://doc.rust-lang.org/std/rc/struct.Rc.html
 [params-5]: https://doc.rust-lang.org/std/sync/struct.Arc.html
 [params-6]: https://docs.python.org/3/library/weakref.html
+[params-constructor]: https://pyo3.rs/latest/class.html#complex-enums
 [params-mapping]: https://pyo3.rs/latest/class/protocols.html#mapping--sequence-types
 [params-sequence]: https://pyo3.rs/latest/class/protocols.html#mapping--sequence-types
diff --git a/guide/src/SUMMARY.md b/guide/src/SUMMARY.md
index 34775a0d185..2f863231984 100644
--- a/guide/src/SUMMARY.md
+++ b/guide/src/SUMMARY.md
@@ -4,41 +4,47 @@
 
 ---
 
-- [Getting started](getting_started.md)
-- [Python modules](module.md)
-- [Python functions](function.md)
-  - [Function signatures](function/signature.md)
-  - [Error handling](function/error_handling.md)
-- [Python classes](class.md)
-  - [Class customizations](class/protocols.md)
-    - [Basic object customization](class/object.md)
-    - [Emulating numeric types](class/numeric.md)
-    - [Emulating callable objects](class/call.md)
+- [Getting started](getting-started.md)
+- [Using Rust from Python](rust-from-python.md)
+  - [Python modules](module.md)
+  - [Python functions](function.md)
+    - [Function signatures](function/signature.md)
+    - [Error handling](function/error-handling.md)
+  - [Python classes](class.md)
+    - [Class customizations](class/protocols.md)
+      - [Basic object customization](class/object.md)
+      - [Emulating numeric types](class/numeric.md)
+      - [Emulating callable objects](class/call.md)
+    - [Thread safety](class/thread-safety.md)
+- [Calling Python from Rust](python-from-rust.md)
+  - [Python object types](types.md)
+  - [Python exceptions](exception.md)
+  - [Calling Python functions](python-from-rust/function-calls.md)
+  - [Executing existing Python code](python-from-rust/calling-existing-code.md)
 - [Type conversions](conversions.md)
   - [Mapping of Rust types to Python types](conversions/tables.md)
   - [Conversion traits](conversions/traits.md)
-- [Python exceptions](exception.md)
-- [Calling Python from Rust](python_from_rust.md)
 - [Using `async` and `await`](async-await.md)
-- [GIL, mutability and object types](types.md)
 - [Parallelism](parallelism.md)
+- [Supporting Free-Threaded Python](free-threading.md)
 - [Debugging](debugging.md)
 - [Features reference](features.md)
-- [Memory management](memory.md)
 - [Performance](performance.md)
+- [Type stub generation and introspection](type-stub.md)
 - [Advanced topics](advanced.md)
-- [Building and distribution](building_and_distribution.md)
-  - [Supporting multiple Python versions](building_and_distribution/multiple_python_versions.md)
+- [Building and distribution](building-and-distribution.md)
+  - [Supporting multiple Python versions](building-and-distribution/multiple-python-versions.md)
 - [Useful crates](ecosystem.md)
   - [Logging](ecosystem/logging.md)
+  - [Tracing](ecosystem/tracing.md)
   - [Using `async` and `await`](ecosystem/async-await.md)
 - [FAQ and troubleshooting](faq.md)
 
 ---
 
 [Appendix A: Migration guide](migration.md)
-[Appendix B: Trait bounds](trait_bounds.md)
-[Appendix C: Python typing hints](python_typing_hints.md)
+[Appendix B: Trait bounds](trait-bounds.md)
+[Appendix C: Python typing hints](python-typing-hints.md)
 [CHANGELOG](changelog.md)
 
 ---
diff --git a/guide/src/advanced.md b/guide/src/advanced.md
index 8264c14dd17..cd630c4f9da 100644
--- a/guide/src/advanced.md
+++ b/guide/src/advanced.md
@@ -4,11 +4,5 @@
 
 PyO3 exposes much of Python's C API through the `ffi` module.
 
-The C API is naturally unsafe and requires you to manage reference counts, errors and specific invariants yourself. Please refer to the [C API Reference Manual](https://docs.python.org/3/c-api/) and [The Rustonomicon](https://doc.rust-lang.org/nightly/nomicon/ffi.html) before using any function from that API.
-
-## Memory management
-
-PyO3's `&PyAny` "owned references" and `Py<PyAny>` smart pointers are used to
-access memory stored in Python's heap.  This memory sometimes lives for longer
-than expected because of differences in Rust and Python's memory models.  See
-the chapter on [memory management](./memory.md) for more information.
+The C API is naturally unsafe and requires you to manage reference counts, errors and specific invariants yourself.
+Please refer to the [C API Reference Manual](https://docs.python.org/3/c-api/) and [The Rustonomicon](https://doc.rust-lang.org/nightly/nomicon/ffi.html) before using any function from that API.
diff --git a/guide/src/async-await.md b/guide/src/async-await.md
index c14b5d93d84..c6a6c9a00e9 100644
--- a/guide/src/async-await.md
+++ b/guide/src/async-await.md
@@ -4,14 +4,16 @@
 
 `#[pyfunction]` and `#[pymethods]` attributes also support `async fn`.
 
-```rust
+```rust,no_run
 # #![allow(dead_code)]
+# #[cfg(feature = "experimental-async")] {
 use std::{thread, time::Duration};
 use futures::channel::oneshot;
 use pyo3::prelude::*;
 
 #[pyfunction]
-async fn sleep(seconds: f64, result: Option<PyObject>) -> Option<PyObject> {
+#[pyo3(signature=(seconds, result=None))]
+async fn sleep(seconds: f64, result: Option<Py<PyAny>>) -> Option<Py<PyAny>> {
     let (tx, rx) = oneshot::channel();
     thread::spawn(move || {
         thread::sleep(Duration::from_secs_f64(seconds));
@@ -20,32 +22,41 @@ async fn sleep(seconds: f64, result: Option<PyObject>) -> Option<PyObject> {
     rx.await.unwrap();
     result
 }
+# }
 ```
 
-*Python awaitables instantiated with this method can only be awaited in *asyncio* context. Other Python async runtime may be supported in the future.*
+*Python awaitables instantiated with this method can only be awaited in `asyncio` context. Other Python async runtime may be supported in the future.*
 
 ## `Send + 'static` constraint
 
 Resulting future of an `async fn` decorated by `#[pyfunction]` must be `Send + 'static` to be embedded in a Python object.
 
-As a consequence, `async fn` parameters and return types must also be `Send + 'static`, so it is not possible to have a signature like `async fn does_not_compile(arg: &PyAny, py: Python<'_>) -> &PyAny`.
+As a consequence, `async fn` parameters and return types must also be `Send + 'static`, so it is not possible to have a signature like `async fn does_not_compile<'py>(arg: Bound<'py, PyAny>) -> Bound<'py, PyAny>`.
 
-However, there is an exception for method receiver, so async methods can accept `&self`/`&mut self`. Note that this means that the class instance is borrowed for as long as the returned future is not completed, even across yield points and while waiting for I/O operations to complete. Hence, other methods cannot obtain exclusive borrows while the future is still being polled. This is the same as how async methods in Rust generally work but it is more problematic for Rust code interfacing with Python code due to pervasive shared mutability. This strongly suggests to prefer shared borrows `&self` to exclusive ones `&mut self` to avoid racy borrow check failures at runtime.
+However, there is an exception for method receivers, so async methods can accept `&self`/ `&mut self`.
+Note that this means that the class instance is borrowed for as long as the returned future is not completed, even across yield points and while waiting for I/O operations to complete.
+Hence, other methods cannot obtain exclusive borrows while the future is still being polled.
+This is the same as how async methods in Rust generally work but it is more problematic for Rust code interfacing with Python code due to pervasive shared mutability.
+This strongly suggests to prefer shared borrows `&self` over exclusive ones `&mut self` to avoid racy borrow check failures at runtime.
 
-## Implicit GIL holding
+## Implicitly attached to the interpreter
 
-Even if it is not possible to pass a `py: Python<'_>` parameter to `async fn`, the GIL is still held during the execution of the future – it's also the case for regular `fn` without `Python<'_>`/`&PyAny` parameter, yet the GIL is held.
+Even if it is not possible to pass a `py: Python<'py>` token to an `async fn`, we're still attached to the interpreter during the execution of the future – the same as for a regular `fn` without `Python<'py>`/`Bound<'py, PyAny>` parameter
 
-It is still possible to get a `Python` marker using [`Python::with_gil`]({{#PYO3_DOCS_URL}}/pyo3/struct.Python.html#method.with_gil); because `with_gil` is reentrant and optimized, the cost will be negligible.
+It is still possible to get a `Python` marker using [`Python::attach`]({{#PYO3_DOCS_URL}}/pyo3/marker/struct.Python.html#method.attach); because `attach` is reentrant and optimized, the cost will be negligible.
 
-## Release the GIL across `.await`
+## Detaching from the interpreter across `.await`
 
-There is currently no simple way to release the GIL when awaiting a future, *but solutions are currently in development*.
+There is currently no simple way to detach from the interpreter when awaiting a future, *but solutions are currently in development*.
 
 Here is the advised workaround for now:
 
 ```rust,ignore
-use std::{future::Future, pin::{Pin, pin}, task::{Context, Poll}};
+use std::{
+    future::Future,
+    pin::{Pin, pin},
+    task::{Context, Poll},
+};
 use pyo3::prelude::*;
 
 struct AllowThreads<F>(F);
@@ -59,8 +70,8 @@ where
 
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         let waker = cx.waker();
-        Python::with_gil(|gil| {
-            gil.allow_threads(|| pin!(&mut self.0).poll(&mut Context::from_waker(waker)))
+        Python::attach(|py| {
+            py.detach(|| pin!(&mut self.0).poll(&mut Context::from_waker(waker)))
         })
     }
 }
@@ -68,10 +79,11 @@ where
 
 ## Cancellation
 
-Cancellation on the Python side can be caught using [`CancelHandle`]({{#PYO3_DOCS_URL}}/pyo3/coroutine/struct.CancelHandle.html) type, by annotating a function parameter with `#[pyo3(cancel_handle)].
+Cancellation on the Python side can be caught using [`CancelHandle`]({{#PYO3_DOCS_URL}}/pyo3/coroutine/struct.CancelHandle.html) type, by annotating a function parameter with `#[pyo3(cancel_handle)]`.
 
-```rust
+```rust,no_run
 # #![allow(dead_code)]
+# #[cfg(feature = "experimental-async")] {
 use futures::FutureExt;
 use pyo3::prelude::*;
 use pyo3::coroutine::CancelHandle;
@@ -83,12 +95,14 @@ async fn cancellable(#[pyo3(cancel_handle)] mut cancel: CancelHandle) {
         _ = cancel.cancelled().fuse() => println!("cancelled"),
     }
 }
+# }
 ```
 
 ## The `Coroutine` type
 
-To make a Rust future awaitable in Python, PyO3 defines a [`Coroutine`]({{#PYO3_DOCS_URL}}/pyo3/coroutine/struct.Coroutine.html) type, which implements the Python [coroutine protocol](https://docs.python.org/3/library/collections.abc.html#collections.abc.Coroutine). 
+To make a Rust future awaitable in Python, PyO3 defines a [`Coroutine`]({{#PYO3_DOCS_URL}}/pyo3/coroutine/struct.Coroutine.html) type, which implements the Python [coroutine protocol](https://docs.python.org/3/library/collections.abc.html#collections.abc.Coroutine).
 
-Each `coroutine.send` call is translated to a `Future::poll` call. If a [`CancelHandle`]({{#PYO3_DOCS_URL}}/pyo3/coroutine/struct.CancelHandle.html) parameter is declared, the exception passed to `coroutine.throw` call is stored in it and can be retrieved with [`CancelHandle::cancelled`]({{#PYO3_DOCS_URL}}/pyo3/coroutine/struct.CancelHandle.html#method.cancelled); otherwise, it cancels the Rust future, and the exception is reraised;
+Each `coroutine.send` call is translated to a `Future::poll` call.
+If a [`CancelHandle`]({{#PYO3_DOCS_URL}}/pyo3/coroutine/struct.CancelHandle.html) parameter is declared, the exception passed to `coroutine.throw` call is stored in it and can be retrieved with [`CancelHandle::cancelled`]({{#PYO3_DOCS_URL}}/pyo3/coroutine/struct.CancelHandle.html#method.cancelled); otherwise, it cancels the Rust future, and the exception is reraised;
 
 *The type does not yet have a public constructor until the design is finalized.*
diff --git a/guide/src/building_and_distribution.md b/guide/src/building-and-distribution.md
similarity index 51%
rename from guide/src/building_and_distribution.md
rename to guide/src/building-and-distribution.md
index 97e77d24c34..e12dc18803b 100644
--- a/guide/src/building_and_distribution.md
+++ b/guide/src/building-and-distribution.md
@@ -1,23 +1,30 @@
 # Building and distribution
 
-This chapter of the guide goes into detail on how to build and distribute projects using PyO3. The way to achieve this is very different depending on whether the project is a Python module implemented in Rust, or a Rust binary embedding Python. For both types of project there are also common problems such as the Python version to build for and the [linker](https://en.wikipedia.org/wiki/Linker_(computing)) arguments to use.
+This chapter of the guide goes into detail on how to build and distribute projects using PyO3.
+The way to achieve this is very different depending on whether the project is a Python module implemented in Rust, or a Rust binary embedding Python.
+For both types of project there are also common problems such as the Python version to build for and the [linker](https://en.wikipedia.org/wiki/Linker_(computing)) arguments to use.
 
-The material in this chapter is intended for users who have already read the PyO3 [README](./index.md). It covers in turn the choices that can be made for Python modules and for Rust binaries. There is also a section at the end about cross-compiling projects using PyO3.
+The material in this chapter is intended for users who have already read the PyO3 [README](./index.md).
+It covers in turn the choices that can be made for Python modules and for Rust binaries.
+There is also a section at the end about cross-compiling projects using PyO3.
 
-There is an additional sub-chapter dedicated to [supporting multiple Python versions](./building_and_distribution/multiple_python_versions.html).
+There is an additional sub-chapter dedicated to [supporting multiple Python versions](./building-and-distribution/multiple-python-versions.md).
 
 ## Configuring the Python version
 
-PyO3 uses a build script (backed by the [`pyo3-build-config`] crate) to determine the Python version and set the correct linker arguments. By default it will attempt to use the following in order:
- - Any active Python virtualenv.
- - The `python` executable (if it's a Python 3 interpreter).
- - The `python3` executable.
+PyO3 uses a build script (backed by the [`pyo3-build-config`] crate) to determine the Python version and set the correct linker arguments.
+By default it will attempt to use the following in order:
+
+- Any active Python virtualenv.
+- The `python` executable (if it's a Python 3 interpreter).
+- The `python3` executable.
 
 You can override the Python interpreter by setting the `PYO3_PYTHON` environment variable, e.g. `PYO3_PYTHON=python3.7`, `PYO3_PYTHON=/usr/bin/python3.9`, or even a PyPy interpreter `PYO3_PYTHON=pypy3`.
 
 Once the Python interpreter is located, `pyo3-build-config` executes it to query the information in the `sysconfig` module which is needed to configure the rest of the compilation.
 
-To validate the configuration which PyO3 will use, you can run a compilation with the environment variable `PYO3_PRINT_CONFIG=1` set. An example output of doing this is shown below:
+To validate the configuration which PyO3 will use, you can run a compilation with the environment variable `PYO3_PRINT_CONFIG=1` set.
+An example output of doing this is shown below:
 
 ```console
 $ PYO3_PRINT_CONFIG=1 cargo build
@@ -51,27 +58,40 @@ The `PYO3_ENVIRONMENT_SIGNATURE` environment variable can be used to trigger reb
 
 If you save the above output config from `PYO3_PRINT_CONFIG` to a file, it is possible to manually override the contents and feed it back into PyO3 using the `PYO3_CONFIG_FILE` env var.
 
-If your build environment is unusual enough that PyO3's regular configuration detection doesn't work, using a config file like this will give you the flexibility to make PyO3 work for you. To see the full set of options supported, see the documentation for the [`InterpreterConfig` struct](https://docs.rs/pyo3-build-config/{{#PYO3_DOCS_VERSION}}/pyo3_build_config/struct.InterpreterConfig.html).
+If your build environment is unusual enough that PyO3's regular configuration detection doesn't work, using a config file like this will give you the flexibility to make PyO3 work for you.
+To see the full set of options supported, see the documentation for the [`InterpreterConfig` struct](https://docs.rs/pyo3-build-config/{{#PYO3_DOCS_VERSION}}/pyo3_build_config/struct.InterpreterConfig.html).
 
 ## Building Python extension modules
 
-Python extension modules need to be compiled differently depending on the OS (and architecture) that they are being compiled for. As well as multiple OSes (and architectures), there are also many different Python versions which are actively supported. Packages uploaded to [PyPI](https://pypi.org/) usually want to upload prebuilt "wheels" covering many OS/arch/version combinations so that users on all these different platforms don't have to compile the package themselves. Package vendors can opt-in to the "abi3" limited Python API which allows their wheels to be used on multiple Python versions, reducing the number of wheels they need to compile, but restricts the functionality they can use.
+Python extension modules need to be compiled differently depending on the OS (and architecture) that they are being compiled for.
+As well as multiple OSes (and architectures), there are also many different Python versions which are actively supported.
+Packages uploaded to [PyPI](https://pypi.org/) usually want to upload prebuilt "wheels" covering many OS/arch/version combinations so that users on all these different platforms don't have to compile the package themselves.
+Package vendors can opt-in to the "abi3" limited Python API which allows their wheels to be used on multiple Python versions, reducing the number of wheels they need to compile, but restricts the functionality they can use.
 
-There are many ways to go about this: it is possible to use `cargo` to build the extension module (along with some manual work, which varies with OS). The PyO3 ecosystem has two packaging tools, [`maturin`] and [`setuptools-rust`], which abstract over the OS difference and also support building wheels for PyPI upload.
+There are many ways to go about this: it is possible to use `cargo` to build the extension module (along with some manual work, which varies with OS).
+The PyO3 ecosystem has two packaging tools, [`maturin`] and [`setuptools-rust`], which abstract over the OS difference and also support building wheels for PyPI upload.
 
 PyO3 has some Cargo features to configure projects for building Python extension modules:
- - The `extension-module` feature, which must be enabled when building Python extension modules.
- - The `abi3` feature and its version-specific `abi3-pyXY` companions, which are used to opt-in to the limited Python API in order to support multiple Python versions in a single wheel.
 
-This section describes each of these packaging tools before describing how to build manually without them. It then proceeds with an explanation of the `extension-module` feature. Finally, there is a section describing PyO3's `abi3` features.
+- The `extension-module` feature, which must be enabled when building Python extension modules.
+- The `abi3` feature and its version-specific `abi3-pyXY` companions, which are used to opt-in to the limited Python API in order to support multiple Python versions in a single wheel.
+
+This section describes each of these packaging tools before describing how to build manually without them.
+It then proceeds with an explanation of the `extension-module` feature.
+Finally, there is a section describing PyO3's `abi3` features.
 
 ### Packaging tools
 
 The PyO3 ecosystem has two main choices to abstract the process of developing Python extension modules:
-- [`maturin`] is a command-line tool to build, package and upload Python modules. It makes opinionated choices about project layout meaning it needs very little configuration. This makes it a great choice for users who are building a Python extension from scratch and don't need flexibility.
-- [`setuptools-rust`] is an add-on for `setuptools` which adds extra keyword arguments to the `setup.py` configuration file. It requires more configuration than `maturin`, however this gives additional flexibility for users adding Rust to an existing Python package that can't satisfy `maturin`'s constraints.
 
-Consult each project's documentation for full details on how to get started using them and how to upload wheels to PyPI. It should be noted that while `maturin` is able to build [manylinux](https://github.com/pypa/manylinux)-compliant wheels out-of-the-box, `setuptools-rust` requires a bit more effort, [relying on Docker](https://setuptools-rust.readthedocs.io/en/latest/building_wheels.html) for this purpose.
+- [`maturin`] is a command-line tool to build, package and upload Python modules.
+  It makes opinionated choices about project layout meaning it needs very little configuration.
+  This makes it a great choice for users who are building a Python extension from scratch and don't need flexibility.
+- [`setuptools-rust`] is an add-on for `setuptools` which adds extra keyword arguments to the `setup.py` configuration file.
+  It requires more configuration than `maturin`, however this gives additional flexibility for users adding Rust to an existing Python package that can't satisfy `maturin`'s constraints.
+
+Consult each project's documentation for full details on how to get started using them and how to upload wheels to PyPI.
+It should be noted that while `maturin` is able to build [manylinux](https://github.com/pypa/manylinux)-compliant wheels out-of-the-box, `setuptools-rust` requires a bit more effort, [relying on Docker](https://setuptools-rust.readthedocs.io/en/latest/building_wheels.html) for this purpose.
 
 There are also [`maturin-starter`] and [`setuptools-rust-starter`] examples in the PyO3 repository.
 
@@ -80,32 +100,40 @@ There are also [`maturin-starter`] and [`setuptools-rust-starter`] examples in t
 To build a PyO3-based Python extension manually, start by running `cargo build` as normal in a library project which uses PyO3's `extension-module` feature and has the [`cdylib` crate type](https://doc.rust-lang.org/cargo/reference/cargo-targets.html#the-crate-type-field).
 
 Once built, symlink (or copy) and rename the shared library from Cargo's `target/` directory to your desired output directory:
+
 - on macOS, rename `libyour_module.dylib` to `your_module.so`.
 - on Windows, rename  `libyour_module.dll` to `your_module.pyd`.
 - on Linux, rename `libyour_module.so` to `your_module.so`.
 
 You can then open a Python shell in the output directory and you'll be able to run `import your_module`.
 
-If you're packaging your library for redistribution, you should indicated the Python interpreter your library is compiled for by including the [platform tag](#platform-tags) in its name. This prevents incompatible interpreters from trying to import your library. If you're compiling for PyPy you *must* include the platform tag, or PyPy will ignore the module.
+If you're packaging your library for redistribution, you should indicate the Python interpreter your library is compiled for by including the [platform tag](#platform-tags) in its name.
+This prevents incompatible interpreters from trying to import your library.
+If you're compiling for PyPy you *must* include the platform tag, or PyPy will ignore the module.
 
 #### Bazel builds
 
-To use PyO3 with bazel one needs to manually configure PyO3, PyO3-ffi and PyO3-macros. In particular, one needs to make sure that it is compiled with the right python flags for the version you intend to use.
+To use PyO3 with bazel one needs to manually configure PyO3, PyO3-ffi and PyO3-macros.
+In particular, one needs to make sure that it is compiled with the right python flags for the version you intend to use.
 For example see:
-1. https://github.com/OliverFM/pytorch_with_gazelle -- for a minimal example of a repo that can use PyO3, PyTorch and Gazelle to generate python Build files.
-2. https://github.com/TheButlah/rules_pyo3 -- which has more extensive support, but is outdated.
+
+1. [github.com/abrisco/rules_pyo3](https://github.com/abrisco/rules_pyo3) -- General rules for building extension modules.
+2. [github.com/OliverFM/pytorch_with_gazelle](https://github.com/OliverFM/pytorch_with_gazelle) -- for a minimal example of a repo that can use PyO3, PyTorch and Gazelle to generate python Build files.
+3. [github.com/TheButlah/rules_pyo3](https://github.com/TheButlah/rules_pyo3) -- is somewhat dated.
 
 #### Platform tags
 
-Rather than using just the `.so` or `.pyd` extension suggested above (depending on OS), you can prefix the shared library extension with a platform tag to indicate the interpreter it is compatible with. You can query your interpreter's platform tag from the `sysconfig` module. Some example outputs of this are seen below:
+Rather than using just the `.so` or `.pyd` extension suggested above (depending on OS), you can prefix the shared library extension with a platform tag to indicate the interpreter it is compatible with.
+You can query your interpreter's platform tag from the `sysconfig` module.
+Some example outputs of this are seen below:
 
 ```bash
 # CPython 3.10 on macOS
 .cpython-310-darwin.so
 
-# PyPy 7.3 (Python 3.8) on Linux
+# PyPy 7.3 (Python 3.9) on Linux
 $ python -c 'import sysconfig; print(sysconfig.get_config_var("EXT_SUFFIX"))'
-.pypy38-pp73-x86_64-linux-gnu.so
+.pypy39-pp73-x86_64-linux-gnu.so
 ```
 
 So, for example, a valid module library name on CPython 3.10 for macOS is `your_module.cpython-310-darwin.so`, and its equivalent when compiled for PyPy 7.3 on Linux would be `your_module.pypy38-pp73-x86_64-linux-gnu.so`.
@@ -142,7 +170,17 @@ rustflags = [
 ]
 ```
 
-Using the MacOS system python3 (`/usr/bin/python3`, as opposed to python installed via homebrew, pyenv, nix, etc.) may result in runtime errors such as `Library not loaded: @rpath/Python3.framework/Versions/3.8/Python3`. These can be resolved with another addition to `.cargo/config.toml`:
+Using the MacOS system python3 (`/usr/bin/python3`, as opposed to python installed via homebrew, pyenv, nix, etc.) may result in runtime errors such as `Library not loaded: @rpath/Python3.framework/Versions/3.8/Python3`.
+
+The easiest way to set the correct linker arguments is to add a `build.rs` with the following content:
+
+```rust,ignore
+fn main() {
+    pyo3_build_config::add_python_framework_link_args();
+}
+```
+
+Alternatively it can be resolved with another addition to `.cargo/config.toml`:
 
 ```toml
 [build]
@@ -151,56 +189,61 @@ rustflags = [
 ]
 ```
 
-Alternatively, on rust >= 1.56, one can include in `build.rs`:
-
-```rust
-fn main() {
-    println!(
-        "cargo:rustc-link-arg=-Wl,-rpath,/Library/Developer/CommandLineTools/Library/Frameworks"
-    );
-}
-```
-
 For more discussion on and workarounds for MacOS linking problems [see this issue](https://github.com/PyO3/pyo3/issues/1800#issuecomment-906786649).
 
-Finally, don't forget that on MacOS the `extension-module` feature will cause `cargo test` to fail without the `--no-default-features` flag (see [the FAQ](https://pyo3.rs/main/faq.html#i-cant-run-cargo-test-im-having-linker-issues-like-symbol-not-found-or-undefined-reference-to-_pyexc_systemerror)).
+Finally, don't forget that on MacOS the `extension-module` feature will cause `cargo test` to fail without the `--no-default-features` flag (see [the FAQ](https://pyo3.rs/main/faq.html#i-cant-run-cargo-test-or-i-cant-build-in-a-cargo-workspace-im-having-linker-issues-like-symbol-not-found-or-undefined-reference-to-_pyexc_systemerror)).
 
 ### The `extension-module` feature
 
 PyO3's `extension-module` feature is used to disable [linking](https://en.wikipedia.org/wiki/Linker_(computing)) to `libpython` on Unix targets.
 
-This is necessary because by default PyO3 links to `libpython`. This makes binaries, tests, and examples "just work". However, Python extensions on Unix must not link to libpython for [manylinux](https://www.python.org/dev/peps/pep-0513/) compliance.
+This is necessary because by default PyO3 links to `libpython`.
+This makes binaries, tests, and examples "just work".
+However, Python extensions on Unix must not link to libpython for [manylinux](https://www.python.org/dev/peps/pep-0513/) compliance.
 
-The downside of not linking to `libpython` is that binaries, tests, and examples (which usually embed Python) will fail to build. If you have an extension module as well as other outputs in a single project, you need to use optional Cargo features to disable the `extension-module` when you're not building the extension module. See [the FAQ](faq.md#i-cant-run-cargo-test-or-i-cant-build-in-a-cargo-workspace-im-having-linker-issues-like-symbol-not-found-or-undefined-reference-to-_pyexc_systemerror) for an example workaround.
+The downside of not linking to `libpython` is that binaries, tests, and examples (which usually embed Python) will fail to build.
+If you have an extension module as well as other outputs in a single project, you need to use optional Cargo features to disable the `extension-module` when you're not building the extension module.
+See [the FAQ](faq.md#i-cant-run-cargo-test-or-i-cant-build-in-a-cargo-workspace-im-having-linker-issues-like-symbol-not-found-or-undefined-reference-to-_pyexc_systemerror) for an example workaround.
 
 ### `Py_LIMITED_API`/`abi3`
 
-By default, Python extension modules can only be used with the same Python version they were compiled against. For example, an extension module built for Python 3.5 can't be imported in Python 3.8. [PEP 384](https://www.python.org/dev/peps/pep-0384/) introduced the idea of the limited Python API, which would have a stable ABI enabling extension modules built with it to be used against multiple Python versions. This is also known as `abi3`.
+By default, Python extension modules can only be used with the same Python version they were compiled against.
+For example, an extension module built for Python 3.5 can't be imported in Python 3.8. [PEP 384](https://www.python.org/dev/peps/pep-0384/) introduced the idea of the limited Python API, which would have a stable ABI enabling extension modules built with it to be used against multiple Python versions.
+This is also known as `abi3`.
 
-The advantage of building extension modules using the limited Python API is that package vendors only need to build and distribute a single copy (for each OS / architecture), and users can install it on all Python versions from the [minimum version](#minimum-python-version-for-abi3) and up. The downside of this is that PyO3 can't use optimizations which rely on being compiled against a known exact Python version. It's up to you to decide whether this matters for your extension module. It's also possible to design your extension module such that you can distribute `abi3` wheels but allow users compiling from source to benefit from additional optimizations - see the [support for multiple python versions](./building_and_distribution/multiple_python_versions.html) section of this guide, in particular the `#[cfg(Py_LIMITED_API)]` flag.
+The advantage of building extension modules using the limited Python API is that package vendors only need to build and distribute a single copy (for each OS / architecture), and users can install it on all Python versions from the [minimum version](#minimum-python-version-for-abi3) and up.
+The downside of this is that PyO3 can't use optimizations which rely on being compiled against a known exact Python version.
+It's up to you to decide whether this matters for your extension module.
+It's also possible to design your extension module such that you can distribute `abi3` wheels but allow users compiling from source to benefit from additional optimizations - see the [support for multiple python versions](./building-and-distribution/multiple-python-versions.md) section of this guide, in particular the `#[cfg(Py_LIMITED_API)]` flag.
 
 There are three steps involved in making use of `abi3` when building Python packages as wheels:
 
-1. Enable the `abi3` feature in `pyo3`. This ensures `pyo3` only calls Python C-API functions which are part of the stable API, and on Windows also ensures that the project links against the correct shared object (no special behavior is required on other platforms):
+1. Enable the `abi3` feature in `pyo3`.
+   This ensures `pyo3` only calls Python C-API functions which are part of the stable API, and on Windows also ensures that the project links against the correct shared object (no special behavior is required on other platforms):
 
-```toml
-[dependencies]
-pyo3 = { {{#PYO3_CRATE_VERSION}}, features = ["abi3"] }
-```
+   ```toml
+   [dependencies]
+   pyo3 = { {{#PYO3_CRATE_VERSION}}, features = ["abi3"] }
+   ```
 
-2. Ensure that the built shared objects are correctly marked as `abi3`. This is accomplished by telling your build system that you're using the limited API. [`maturin`] >= 0.9.0 and [`setuptools-rust`] >= 0.11.4 support `abi3` wheels.
-See the [corresponding](https://github.com/PyO3/maturin/pull/353) [PRs](https://github.com/PyO3/setuptools-rust/pull/82) for more.
+2. Ensure that the built shared objects are correctly marked as `abi3`.
+   This is accomplished by telling your build system that you're using the limited API. [`maturin`] >= 0.9.0 and [`setuptools-rust`] >= 0.11.4 support `abi3` wheels.
 
-3. Ensure that the `.whl` is correctly marked as `abi3`. For projects using `setuptools`, this is accomplished by passing `--py-limited-api=cp3x` (where `x` is the minimum Python version supported by the wheel, e.g. `--py-limited-api=cp35` for Python 3.5) to `setup.py bdist_wheel`.
+   See the [corresponding](https://github.com/PyO3/maturin/pull/353) [PRs](https://github.com/PyO3/setuptools-rust/pull/82) for more.
+
+3. Ensure that the `.whl` is correctly marked as `abi3`.
+   For projects using `setuptools`, this is accomplished by passing `--py-limited-api=cp3x` (where `x` is the minimum Python version supported by the wheel, e.g. `--py-limited-api=cp35` for Python 3.5) to `setup.py bdist_wheel`.
 
 #### Minimum Python version for `abi3`
 
 Because a single `abi3` wheel can be used with many different Python versions, PyO3 has feature flags `abi3-py37`, `abi3-py38`, `abi3-py39` etc. to set the minimum required Python version for your `abi3` wheel.
 For example, if you set the `abi3-py37` feature, your extension wheel can be used on all Python 3 versions from Python 3.7 and up. `maturin` and `setuptools-rust` will give the wheel a name like `my-extension-1.0-cp37-abi3-manylinux2020_x86_64.whl`.
 
-As your extension module may be run with multiple different Python versions you may occasionally find you need to check the Python version at runtime to customize behavior. See [the relevant section of this guide](./building_and_distribution/multiple_python_versions.html#checking-the-python-version-at-runtime) on supporting multiple Python versions at runtime.
+As your extension module may be run with multiple different Python versions you may occasionally find you need to check the Python version at runtime to customize behavior.
+See [the relevant section of this guide](./building-and-distribution/multiple-python-versions.md#checking-the-python-version-at-runtime) on supporting multiple Python versions at runtime.
 
-PyO3 is only able to link your extension module to abi3 version up to and including your host Python version. E.g., if you set `abi3-py38` and try to compile the crate with a host of Python 3.7, the build will fail.
+PyO3 is only able to link your extension module to abi3 version up to and including your host Python version.
+E.g., if you set `abi3-py38` and try to compile the crate with a host of Python 3.7, the build will fail.
 
 > Note: If you set more that one of these `abi3` version feature flags the lowest version always wins. For example, with both `abi3-py37` and `abi3-py38` set, PyO3 would build a wheel which supports Python 3.7 and up.
 
@@ -220,8 +263,8 @@ the automatic import library generation feature to work.
 
 #### Missing features
 
-Due to limitations in the Python API, there are a few `pyo3` features that do
-not work when compiling for `abi3`. These are:
+Due to limitations in the Python API, there are a few `pyo3` features that do not work when compiling for `abi3`.
+These are:
 
 - `#[pyo3(text_signature = "...")]` does not work on classes until Python 3.10 or greater.
 - The `dict` and `weakref` options on classes are not supported until Python 3.9 or greater.
@@ -230,35 +273,49 @@ not work when compiling for `abi3`. These are:
 
 ## Embedding Python in Rust
 
-If you want to embed the Python interpreter inside a Rust program, there are two modes in which this can be done: dynamically and statically. We'll cover each of these modes in the following sections. Each of them affect how you must distribute your program. Instead of learning how to do this yourself, you might want to consider using a project like [PyOxidizer] to ship your application and all of its dependencies in a single file.
+If you want to embed the Python interpreter inside a Rust program, there are two modes in which this can be done: dynamically and statically.
+We'll cover each of these modes in the following sections.
+Each of them affect how you must distribute your program.
+Instead of learning how to do this yourself, you might want to consider using a project like [PyOxidizer] to ship your application and all of its dependencies in a single file.
 
-PyO3 automatically switches between the two linking modes depending on whether the Python distribution you have configured PyO3 to use ([see above](#python-version)) contains a shared library or a static library. The static library is most often seen in Python distributions compiled from source without the `--enable-shared` configuration option. For example, this is the default for `pyenv` on macOS.
+PyO3 automatically switches between the two linking modes depending on whether the Python distribution you have configured PyO3 to use ([see above](#configuring-the-python-version)) contains a shared library or a static library.
+The static library is most often seen in Python distributions compiled from source without the `--enable-shared` configuration option.
 
 ### Dynamically embedding the Python interpreter
 
-Embedding the Python interpreter dynamically is much easier than doing so statically. This is done by linking your program against a Python shared library (such as `libpython.3.9.so` on UNIX, or `python39.dll` on Windows). The implementation of the Python interpreter resides inside the shared library. This means that when the OS runs your Rust program it also needs to be able to find the Python shared library.
+Embedding the Python interpreter dynamically is much easier than doing so statically.
+This is done by linking your program against a Python shared library (such as `libpython.3.9.so` on UNIX, or `python39.dll` on Windows).
+The implementation of the Python interpreter resides inside the shared library.
+This means that when the OS runs your Rust program it also needs to be able to find the Python shared library.
 
-This mode of embedding works well for Rust tests which need access to the Python interpreter. It is also great for Rust software which is installed inside a Python virtualenv, because the virtualenv sets up appropriate environment variables to locate the correct Python shared library.
+This mode of embedding works well for Rust tests which need access to the Python interpreter.
+It is also great for Rust software which is installed inside a Python virtualenv, because the virtualenv sets up appropriate environment variables to locate the correct Python shared library.
 
 For distributing your program to non-technical users, you will have to consider including the Python shared library in your distribution as well as setting up wrapper scripts to set the right environment variables (such as `LD_LIBRARY_PATH` on UNIX, or `PATH` on Windows).
 
-Note that PyPy cannot be embedded in Rust (or any other software). Support for this is tracked on the [PyPy issue tracker](https://foss.heptapod.net/pypy/pypy/-/issues/3286).
+Note that PyPy cannot be embedded in Rust (or any other software).
+Support for this is tracked on the [PyPy issue tracker](https://github.com/pypy/pypy/issues/3836).
 
 ### Statically embedding the Python interpreter
 
-Embedding the Python interpreter statically means including the contents of a Python static library directly inside your Rust binary. This means that to distribute your program you only need to ship your binary file: it contains the Python interpreter inside the binary!
+Embedding the Python interpreter statically means including the contents of a Python static library directly inside your Rust binary.
+This means that to distribute your program you only need to ship your binary file: it contains the Python interpreter inside the binary!
 
-On Windows static linking is almost never done, so Python distributions don't usually include a static library. The information below applies only to UNIX.
+On Windows static linking is almost never done, so Python distributions don't usually include a static library.
+The information below applies only to UNIX.
 
 The Python static library is usually called `libpython.a`.
 
-Static linking has a lot of complications, listed below. For these reasons PyO3 does not yet have first-class support for this embedding mode. See [issue 416 on PyO3's GitHub](https://github.com/PyO3/pyo3/issues/416) for more information and to discuss any issues you encounter.
+Static linking has a lot of complications, listed below.
+For these reasons PyO3 does not yet have first-class support for this embedding mode.
+See [issue 416 on PyO3's GitHub](https://github.com/PyO3/pyo3/issues/416) for more information and to discuss any issues you encounter.
 
 The [`auto-initialize`](features.md#auto-initialize) feature is deliberately disabled when embedding the interpreter statically because this is often unintentionally done by new users to PyO3 running test programs. Trying out PyO3 is much easier using dynamic embedding.
 
 The known complications are:
-  - To import compiled extension modules (such as other Rust extension modules, or those written in C), your binary must have the correct linker flags set during compilation to export the original contents of `libpython.a` so that extensions can use them (e.g. `-Wl,--export-dynamic`).
-  - The C compiler and flags which were used to create `libpython.a` must be compatible with your Rust compiler and flags, else you will experience compilation failures.
+
+- To import compiled extension modules (such as other Rust extension modules, or those written in C), your binary must have the correct linker flags set during compilation to export the original contents of `libpython.a` so that extensions can use them (e.g. `-Wl,--export-dynamic`).
+- The C compiler and flags which were used to create `libpython.a` must be compatible with your Rust compiler and flags, else you will experience compilation failures.
 
     Significantly different compiler versions may see errors like this:
 
@@ -272,41 +329,43 @@ The known complications are:
     /usr/bin/ld: /usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu/libpython3.9.a(zlibmodule.o): relocation R_X86_64_32 against `.data' can not be used when making a PIE object; recompile with -fPIE
     ```
 
-If you encounter these or other complications when linking the interpreter statically, discuss them on [issue 416 on PyO3's GitHub](https://github.com/PyO3/pyo3/issues/416). It is hoped that eventually that discussion will contain enough information and solutions that PyO3 can offer first-class support for static embedding.
+If you encounter these or other complications when linking the interpreter statically, discuss them on [issue 416 on PyO3's GitHub](https://github.com/PyO3/pyo3/issues/416).
+It is hoped that eventually that discussion will contain enough information and solutions that PyO3 can offer first-class support for static embedding.
 
 ### Import your module when embedding the Python interpreter
 
-When you run your Rust binary with an embedded interpreter, any `#[pymodule]` created modules won't be accessible to import unless added to a table called `PyImport_Inittab` before the embedded interpreter is initialized. This will cause Python statements in your embedded interpreter such as `import your_new_module` to fail. You can call the macro [`append_to_inittab`]({{#PYO3_DOCS_URL}}/pyo3/macro.append_to_inittab.html) with your module before initializing the Python interpreter to add the module function into that table. (The Python interpreter will be initialized by calling `prepare_freethreaded_python`, `with_embedded_python_interpreter`, or `Python::with_gil` with the [`auto-initialize`](features.md#auto-initialize) feature enabled.)
+When you run your Rust binary with an embedded interpreter, any `#[pymodule]` created modules won't be accessible to import unless added to a table called `PyImport_Inittab` before the embedded interpreter is initialized.
+This will cause Python statements in your embedded interpreter such as `import your_new_module` to fail.
+You can call the macro [`append_to_inittab`]({{#PYO3_DOCS_URL}}/pyo3/macro.append_to_inittab.html) with your module before initializing the Python interpreter to add the module function into that table. (The Python interpreter will be initialized by calling `Python::initialize`, `with_embedded_python_interpreter`, or `Python::attach` with the [`auto-initialize`](features.md#auto-initialize) feature enabled.)
 
 ## Cross Compiling
 
-Thanks to Rust's great cross-compilation support, cross-compiling using PyO3 is relatively straightforward. To get started, you'll need a few pieces of software:
+Thanks to Rust's great cross-compilation support, cross-compiling using PyO3 is relatively straightforward.
+To get started, you'll need a few pieces of software:
 
-* A toolchain for your target.
-* The appropriate options in your Cargo `.config` for the platform you're targeting and the toolchain you are using.
-* A Python interpreter that's already been compiled for your target (optional when building "abi3" extension modules).
-* A Python interpreter that is built for your host and available through the `PATH` or setting the [`PYO3_PYTHON`](#python-version) variable (optional when building "abi3" extension modules).
+- A toolchain for your target.
+- The appropriate options in your Cargo `.config` for the platform you're targeting and the toolchain you are using.
+- A Python interpreter that's already been compiled for your target (optional when building "abi3" extension modules).
+- A Python interpreter that is built for your host and available through the `PATH` or setting the [`PYO3_PYTHON`](#configuring-the-python-version) variable (optional when building "abi3" extension modules).
 
-After you've obtained the above, you can build a cross-compiled PyO3 module by using Cargo's `--target` flag. PyO3's build script will detect that you are attempting a cross-compile based on your host machine and the desired target.
+After you've obtained the above, you can build a cross-compiled PyO3 module by using Cargo's `--target` flag.
+PyO3's build script will detect that you are attempting a cross-compile based on your host machine and the desired target.
 
 When cross-compiling, PyO3's build script cannot execute the target Python interpreter to query the configuration, so there are a few additional environment variables you may need to set:
 
-* `PYO3_CROSS`: If present this variable forces PyO3 to configure as a cross-compilation.
-* `PYO3_CROSS_LIB_DIR`: This variable can be set to the directory containing the target's libpython DSO and the associated `_sysconfigdata*.py` file for Unix-like targets, or the Python DLL import libraries for the Windows target. This variable is only needed when the output binary must link to libpython explicitly (e.g. when targeting Windows and Android or embedding a Python interpreter), or when it is absolutely required to get the interpreter configuration from `_sysconfigdata*.py`.
-* `PYO3_CROSS_PYTHON_VERSION`: Major and minor version (e.g. 3.9) of the target Python installation. This variable is only needed if PyO3 cannot determine the version to target from `abi3-py3*` features, or if `PYO3_CROSS_LIB_DIR` is not set, or if there are multiple versions of Python present in `PYO3_CROSS_LIB_DIR`.
-* `PYO3_CROSS_PYTHON_IMPLEMENTATION`: Python implementation name ("CPython" or "PyPy") of the target Python installation. CPython is assumed by default when this variable is not set, unless `PYO3_CROSS_LIB_DIR` is set for a Unix-like target and PyO3 can get the interpreter configuration from `_sysconfigdata*.py`.
-
-An experimental `pyo3` crate feature `generate-import-lib` enables the user to cross-compile
-extension modules for Windows targets without setting the `PYO3_CROSS_LIB_DIR` environment
-variable or providing any Windows Python library files. It uses an external [`python3-dll-a`] crate
-to generate import libraries for the Python DLL for MinGW-w64 and MSVC compile targets.
-`python3-dll-a` uses the binutils `dlltool` program to generate DLL import libraries for MinGW-w64 targets.
-It is possible to override the default `dlltool` command name for the cross target
-by setting `PYO3_MINGW_DLLTOOL` environment variable.
-*Note*: MSVC targets require LLVM binutils or MSVC build tools to be available on the host system.
-More specifically, `python3-dll-a` requires `llvm-dlltool` or `lib.exe` executable to be present in `PATH` when
-targeting `*-pc-windows-msvc`. The Zig compiler executable can be used in place of `llvm-dlltool` when the `ZIG_COMMAND`
-environment variable is set to the installed Zig program name (`"zig"` or `"python -m ziglang"`).
+- `PYO3_CROSS`: If present this variable forces PyO3 to configure as a cross-compilation.
+- `PYO3_CROSS_LIB_DIR`: This variable can be set to the directory containing the target's libpython DSO and the associated `_sysconfigdata*.py` file for Unix-like targets, or the Python DLL import libraries for the Windows target.
+  This variable is only needed when the output binary must link to libpython explicitly (e.g. when targeting Windows and Android or embedding a Python interpreter), or when it is absolutely required to get the interpreter configuration from `_sysconfigdata*.py`.
+- `PYO3_CROSS_PYTHON_VERSION`: Major and minor version (e.g. 3.9) of the target Python installation.
+  This variable is only needed if PyO3 cannot determine the version to target from `abi3-py3*` features, or if `PYO3_CROSS_LIB_DIR` is not set, or if there are multiple versions of Python present in `PYO3_CROSS_LIB_DIR`.
+- `PYO3_CROSS_PYTHON_IMPLEMENTATION`: Python implementation name ("CPython" or "PyPy") of the target Python installation.
+  CPython is assumed by default when this variable is not set, unless `PYO3_CROSS_LIB_DIR` is set for a Unix-like target and PyO3 can get the interpreter configuration from `_sysconfigdata*.py`.
+
+An experimental `pyo3` crate feature `generate-import-lib` enables the user to cross-compile extension modules for Windows targets without setting the `PYO3_CROSS_LIB_DIR` environment variable or providing any Windows Python library files.
+It uses an external [`python3-dll-a`] crate to generate import libraries for the Python DLL for MinGW-w64 and MSVC compile targets. `python3-dll-a` uses the binutils `dlltool` program to generate DLL import libraries for MinGW-w64 targets.
+It is possible to override the default `dlltool` command name for the cross target by setting `PYO3_MINGW_DLLTOOL` environment variable. *Note*: MSVC targets require LLVM binutils or MSVC build tools to be available on the host system.
+More specifically, `python3-dll-a` requires `llvm-dlltool` or `lib.exe` executable to be present in `PATH` when targeting `*-pc-windows-msvc`.
+The Zig compiler executable can be used in place of `llvm-dlltool` when the `ZIG_COMMAND` environment variable is set to the installed Zig program name (`"zig"` or `"python -m ziglang"`).
 
 An example might look like the following (assuming your target's sysroot is at `/home/pyo3/cross/sysroot` and that your target is `armv7`):
 
@@ -317,6 +376,7 @@ cargo build --target armv7-unknown-linux-gnueabihf
 ```
 
 If there are multiple python versions at the cross lib directory and you cannot set a more precise location to include both the `libpython` DSO and `_sysconfigdata*.py` files, you can set the required version:
+
 ```sh
 export PYO3_CROSS_PYTHON_VERSION=3.8
 export PYO3_CROSS_LIB_DIR="/home/pyo3/cross/sysroot/usr/lib"
@@ -325,6 +385,7 @@ cargo build --target armv7-unknown-linux-gnueabihf
 ```
 
 Or another example with the same sys root but building for Windows:
+
 ```sh
 export PYO3_CROSS_PYTHON_VERSION=3.9
 export PYO3_CROSS_LIB_DIR="/home/pyo3/cross/sysroot/usr/lib"
@@ -339,8 +400,9 @@ or when cross compiling extension modules for Windows and the experimental `gene
 crate feature is enabled.
 
 The following resources may also be useful for cross-compiling:
- - [github.com/japaric/rust-cross](https://github.com/japaric/rust-cross) is a primer on cross compiling Rust.
- - [github.com/rust-embedded/cross](https://github.com/rust-embedded/cross) uses Docker to make Rust cross-compilation easier.
+
+- [github.com/japaric/rust-cross](https://github.com/japaric/rust-cross) is a primer on cross compiling Rust.
+- [github.com/rust-embedded/cross](https://github.com/rust-embedded/cross) uses Docker to make Rust cross-compilation easier.
 
 [`pyo3-build-config`]: https://github.com/PyO3/pyo3/tree/main/pyo3-build-config
 [`maturin-starter`]: https://github.com/PyO3/pyo3/tree/main/examples/maturin-starter
diff --git a/guide/src/building_and_distribution/multiple_python_versions.md b/guide/src/building-and-distribution/multiple-python-versions.md
similarity index 63%
rename from guide/src/building_and_distribution/multiple_python_versions.md
rename to guide/src/building-and-distribution/multiple-python-versions.md
index 43203686fc8..961c13b7d9c 100644
--- a/guide/src/building_and_distribution/multiple_python_versions.md
+++ b/guide/src/building-and-distribution/multiple-python-versions.md
@@ -1,14 +1,19 @@
 # Supporting multiple Python versions
 
-PyO3 supports all actively-supported Python 3 and PyPy versions. As much as possible, this is done internally to PyO3 so that your crate's code does not need to adapt to the differences between each version. However, as Python features grow and change between versions, PyO3 cannot a completely identical API for every Python version. This may require you to add conditional compilation to your crate or runtime checks for the Python version.
+PyO3 supports all actively-supported Python 3 and PyPy versions.
+As much as possible, this is done internally to PyO3 so that your crate's code does not need to adapt to the differences between each version.
+However, as Python features grow and change between versions, PyO3 cannot offer a completely identical API for every Python version.
+This may require you to add conditional compilation to your crate or runtime checks for the Python version.
 
 This section of the guide first introduces the `pyo3-build-config` crate, which you can use as a `build-dependency` to add additional `#[cfg]` flags which allow you to support multiple Python versions at compile-time.
 
-Second, we'll show how to check the Python version at runtime. This can be useful when building for multiple versions with the `abi3` feature, where the Python API compiled against is not always the same as the one in use.
+Second, we'll show how to check the Python version at runtime.
+This can be useful when building for multiple versions with the `abi3` feature, where the Python API compiled against is not always the same as the one in use.
 
 ## Conditional compilation for different Python versions
 
-The `pyo3-build-config` exposes multiple [`#[cfg]` flags](https://doc.rust-lang.org/rust-by-example/attribute/cfg.html) which can be used to conditionally compile code for a given Python version. PyO3 itself depends on this crate, so by using it you can be sure that you are configured correctly for the Python version PyO3 is building against.
+The `pyo3-build-config` exposes multiple [`#[cfg]` flags](https://doc.rust-lang.org/rust-by-example/attribute/cfg.html) which can be used to conditionally compile code for a given Python version.
+PyO3 itself depends on this crate, so by using it you can be sure that you are configured correctly for the Python version PyO3 is building against.
 
 This allows us to write code like the following
 
@@ -51,13 +56,15 @@ After these steps you are ready to annotate your code!
 
 ### Common usages of `pyo3-build-cfg` flags
 
-The `#[cfg]` flags added by `pyo3-build-cfg` can be combined with all of Rust's logic in the `#[cfg]` attribute to create very precise conditional code generation. The following are some common patterns implemented using these flags:
+The `#[cfg]` flags added by `pyo3-build-cfg` can be combined with all of Rust's logic in the `#[cfg]` attribute to create very precise conditional code generation.
+The following are some common patterns implemented using these flags:
 
 ```text
 #[cfg(Py_3_7)]
 ```
 
-This `#[cfg]` marks code that will only be present on Python 3.7 and upwards. There are similar options `Py_3_8`, `Py_3_9`, `Py_3_10` and so on for each minor version.
+This `#[cfg]` marks code that will only be present on Python 3.7 and upwards.
+There are similar options `Py_3_8`, `Py_3_9`, `Py_3_10` and so on for each minor version.
 
 ```text
 #[cfg(not(Py_3_7))]
@@ -69,13 +76,15 @@ This `#[cfg]` marks code that will only be present on Python versions before (bu
 #[cfg(not(Py_LIMITED_API))]
 ```
 
-This `#[cfg]` marks code that is only available when building for the unlimited Python API (i.e. PyO3's `abi3` feature is not enabled). This might be useful if you want to ship your extension module as an `abi3` wheel and also allow users to compile it from source to make use of optimizations only possible with the unlimited API.
+This `#[cfg]` marks code that is only available when building for the unlimited Python API (i.e. PyO3's `abi3` feature is not enabled).
+This might be useful if you want to ship your extension module as an `abi3` wheel and also allow users to compile it from source to make use of optimizations only possible with the unlimited API.
 
 ```text
 #[cfg(any(Py_3_9, not(Py_LIMITED_API)))]
 ```
 
-This `#[cfg]` marks code which is available when running Python 3.9 or newer, or when using the unlimited API with an older Python version. Patterns like this are commonly seen on Python APIs which were added to the limited Python API in a specific minor version.
+This `#[cfg]` marks code which is available when running Python 3.9 or newer, or when using the unlimited API with an older Python version.
+Patterns like this are commonly seen on Python APIs which were added to the limited Python API in a specific minor version.
 
 ```text
 #[cfg(PyPy)]
@@ -85,24 +94,26 @@ This `#[cfg]` marks code which is running on PyPy.
 
 ## Checking the Python version at runtime
 
-When building with PyO3's `abi3` feature, your extension module will be compiled against a specific [minimum version](../building_and_distribution.html#minimum-python-version-for-abi3) of Python, but may be running on newer Python versions.
+When building with PyO3's `abi3` feature, your extension module will be compiled against a specific [minimum version](../building-and-distribution.md#minimum-python-version-for-abi3) of Python, but may be running on newer Python versions.
 
-For example with PyO3's `abi3-py38` feature, your extension will be compiled as if it were for Python 3.8. If you were using `pyo3-build-config`, `#[cfg(Py_3_8)]` would be present. Your user could freely install and run your abi3 extension on Python 3.9.
+For example with PyO3's `abi3-py38` feature, your extension will be compiled as if it were for Python 3.8.
+If you were using `pyo3-build-config`, `#[cfg(Py_3_8)]` would be present.
+Your user could freely install and run your abi3 extension on Python 3.9.
 
 There's no way to detect your user doing that at compile time, so instead you need to fall back to runtime checks.
 
-PyO3 provides the APIs [`Python::version()`] and [`Python::version_info()`] to query the running Python version. This allows you to do the following, for example:
-
+PyO3 provides the APIs [`Python::version()`] and [`Python::version_info()`] to query the running Python version.
+This allows you to do the following, for example:
 
 ```rust
 use pyo3::Python;
 
-Python::with_gil(|py| {
+Python::attach(|py| {
     // PyO3 supports Python 3.7 and up.
     assert!(py.version_info() >= (3, 7));
     assert!(py.version_info() >= (3, 7, 0));
 });
 ```
 
-[`Python::version()`]: {{#PYO3_DOCS_URL}}/pyo3/struct.Python.html#method.version
-[`Python::version_info()`]: {{#PYO3_DOCS_URL}}/pyo3/struct.Python.html#method.version_info
+[`Python::version()`]: {{#PYO3_DOCS_URL}}/pyo3/marker/struct.Python.html#method.version
+[`Python::version_info()`]: {{#PYO3_DOCS_URL}}/pyo3/marker/struct.Python.html#method.version_info
diff --git a/guide/src/class.md b/guide/src/class.md
index 6ca582ed963..ecc68f3a8a6 100644
--- a/guide/src/class.md
+++ b/guide/src/class.md
@@ -2,9 +2,11 @@
 
 PyO3 exposes a group of attributes powered by Rust's proc macro system for defining Python classes as Rust structs.
 
-The main attribute is `#[pyclass]`, which is placed upon a Rust `struct` or `enum` to generate a Python type for it. They will usually also have *one* `#[pymethods]`-annotated `impl` block for the struct, which is used to define Python methods and constants for the generated Python type. (If the [`multiple-pymethods`] feature is enabled, each `#[pyclass]` is allowed to have multiple `#[pymethods]` blocks.) `#[pymethods]` may also have implementations for Python magic methods such as `__str__`.
+The main attribute is `#[pyclass]`, which is placed upon a Rust `struct` or `enum` to generate a Python type for it.
+They will usually also have *one* `#[pymethods]`-annotated `impl` block for the struct, which is used to define Python methods and constants for the generated Python type. (If the [`multiple-pymethods`] feature is enabled, each `#[pyclass]` is allowed to have multiple `#[pymethods]` blocks.) `#[pymethods]` may also have implementations for Python magic methods such as `__str__`.
 
-This chapter will discuss the functionality and configuration these attributes offer. Below is a list of links to the relevant section of this chapter for each:
+This chapter will discuss the functionality and configuration these attributes offer.
+Below is a list of links to the relevant section of this chapter for each:
 
 - [`#[pyclass]`](#defining-a-new-class)
   - [`#[pyo3(get, set)]`](#object-properties-using-pyo3get-set)
@@ -16,12 +18,13 @@ This chapter will discuss the functionality and configuration these attributes o
   - [`#[classmethod]`](#class-methods)
   - [`#[classattr]`](#class-attributes)
   - [`#[args]`](#method-arguments)
-- [Magic methods and slots](class/protocols.html)
+- [Magic methods and slots](class/protocols.md)
 - [Classes as function arguments](#classes-as-function-arguments)
 
 ## Defining a new class
 
 To define a custom Python class, add the `#[pyclass]` attribute to a Rust struct or enum.
+
 ```rust
 # #![allow(dead_code)]
 use pyo3::prelude::*;
@@ -37,14 +40,16 @@ struct Number(i32);
 
 // PyO3 supports unit-only enums (which contain only unit variants)
 // These simple enums behave similarly to Python's enumerations (enum.Enum)
-#[pyclass]
+#[pyclass(eq, eq_int)]
+#[derive(PartialEq)]
 enum MyEnum {
     Variant,
     OtherVariant = 30, // PyO3 supports custom discriminants.
 }
 
 // PyO3 supports custom discriminants in unit-only enums
-#[pyclass]
+#[pyclass(eq, eq_int)]
+#[derive(PartialEq)]
 enum HttpResponse {
     Ok = 200,
     NotFound = 404,
@@ -52,44 +57,55 @@ enum HttpResponse {
     // ...
 }
 
-// PyO3 also supports enums with non-unit variants
-// These complex enums have sligtly different behavior from the simple enums above
+// PyO3 also supports enums with Struct and Tuple variants
+// These complex enums have slightly different behavior from the simple enums above
 // They are meant to work with instance checks and match statement patterns
+// The variants can be mixed and matched
+// Struct variants have named fields while tuple enums generate generic names for fields in order _0, _1, _2, ...
+// Apart from this both types are functionally identical
 #[pyclass]
 enum Shape {
     Circle { radius: f64 },
     Rectangle { width: f64, height: f64 },
-    RegularPolygon { side_count: u32, radius: f64 },
-    Nothing { },
+    RegularPolygon(u32, f64),
+    Nothing(),
 }
 ```
 
-The above example generates implementations for [`PyTypeInfo`] and [`PyClass`] for `MyClass`, `Number`, `MyEnum`, `HttpResponse`, and `Shape`. To see these generated implementations, refer to the [implementation details](#implementation-details) at the end of this chapter.
+The above example generates implementations for [`PyTypeInfo`] and [`PyClass`] for `MyClass`, `Number`, `MyEnum`, `HttpResponse`, and `Shape`.
+To see these generated implementations, refer to the [implementation details](#implementation-details) at the end of this chapter.
 
 ### Restrictions
 
-To integrate Rust types with Python, PyO3 needs to place some restrictions on the types which can be annotated with `#[pyclass]`. In particular, they must have no lifetime parameters, no generic parameters, and must implement `Send`. The reason for each of these is explained below.
+To integrate Rust types with Python, PyO3 needs to place some restrictions on the types which can be annotated with `#[pyclass]`.
+In particular, they must have no lifetime parameters, no generic parameters, and must be thread-safe.
+The reason for each of these is explained below.
 
 #### No lifetime parameters
 
-Rust lifetimes are used by the Rust compiler to reason about a program's memory safety. They are a compile-time only concept; there is no way to access Rust lifetimes at runtime from a dynamic language like Python.
+Rust lifetimes are used by the Rust compiler to reason about a program's memory safety.
+They are a compile-time only concept; there is no way to access Rust lifetimes at runtime from a dynamic language like Python.
 
-As soon as Rust data is exposed to Python, there is no guarantee that the Rust compiler can make on how long the data will live. Python is a reference-counted language and those references can be held for an arbitrarily long time which is untraceable by the Rust compiler. The only possible way to express this correctly is to require that any `#[pyclass]` does not borrow data for any lifetime shorter than the `'static` lifetime, i.e. the `#[pyclass]` cannot have any lifetime parameters.
+As soon as Rust data is exposed to Python, there is no guarantee that the Rust compiler can make on how long the data will live.
+Python is a reference-counted language and those references can be held for an arbitrarily long time which is untraceable by the Rust compiler.
+The only possible way to express this correctly is to require that any `#[pyclass]` does not borrow data for any lifetime shorter than the `'static` lifetime, i.e. the `#[pyclass]` cannot have any lifetime parameters.
 
-When you need to share ownership of data between Python and Rust, instead of using borrowed references with lifetimes consider using reference-counted smart pointers such as [`Arc`] or [`Py`].
+When you need to share ownership of data between Python and Rust, instead of using borrowed references with lifetimes consider using reference-counted smart pointers such as [`Arc`] or [`Py`][`Py<T>`].
 
 #### No generic parameters
 
-A Rust `struct Foo<T>` with a generic parameter `T` generates new compiled implementations each time it is used with a different concrete type for `T`. These new implementations are generated by the compiler at each usage site. This is incompatible with wrapping `Foo` in Python, where there needs to be a single compiled implementation of `Foo` which is integrated with the Python interpreter.
+A Rust `struct Foo<T>` with a generic parameter `T` generates new compiled implementations each time it is used with a different concrete type for `T`.
+These new implementations are generated by the compiler at each usage site.
+This is incompatible with wrapping `Foo` in Python, where there needs to be a single compiled implementation of `Foo` which is integrated with the Python interpreter.
 
-Currently, the best alternative is to write a macro which expands to a new #[pyclass] for each instantiation you want:
+Currently, the best alternative is to write a macro which expands to a new `#[pyclass]` for each instantiation you want:
 
 ```rust
 # #![allow(dead_code)]
 use pyo3::prelude::*;
 
 struct GenericClass<T> {
-   data: T
+    data: T,
 }
 
 macro_rules! create_interface {
@@ -102,7 +118,9 @@ macro_rules! create_interface {
         impl $name {
             #[new]
             pub fn new(data: $type) -> Self {
-                Self { inner: GenericClass { data: data } }
+                Self {
+                    inner: GenericClass { data: data },
+                }
             }
         }
     };
@@ -112,15 +130,22 @@ create_interface!(IntClass, i64);
 create_interface!(FloatClass, String);
 ```
 
-#### Must be Send
+#### Must be thread-safe
+
+Python objects are freely shared between threads by the Python interpreter.
+This means that:
+
+- Python objects may be created and destroyed by different Python threads; therefore `#[pyclass]` objects must be `Send`.
+- Python objects may be accessed by multiple Python threads simultaneously; therefore `#[pyclass]` objects must be `Sync`.
 
-Because Python objects are freely shared between threads by the Python interpreter, there is no guarantee which thread will eventually drop the object. Therefore all types annotated with `#[pyclass]` must implement `Send` (unless annotated with [`#[pyclass(unsendable)]`](#customizing-the-class)).
+For now, don't worry about these requirements; simple classes will already be thread-safe.
+There is a [detailed discussion on thread-safety](./class/thread-safety.md) later in the guide.
 
 ## Constructor
 
 By default, it is not possible to create an instance of a custom class from Python code.
-To declare a constructor, you need to define a method and annotate it with the `#[new]`
-attribute. Only Python's `__new__` method can be specified, `__init__` is not available.
+To declare a constructor, you need to define a method and annotate it with the `#[new]` attribute.
+Only Python's `__new__` method can be specified, `__init__` is not available.
 
 ```rust
 # #![allow(dead_code)]
@@ -172,41 +197,43 @@ For arguments, see the [`Method arguments`](#method-arguments) section below.
 
 ## Adding the class to a module
 
-The next step is to create the module initializer and add our class to it:
+The next step is to create the Python module and add our class to it:
 
 ```rust
 # #![allow(dead_code)]
 # use pyo3::prelude::*;
+# fn main() {}
 # #[pyclass]
 # struct Number(i32);
 #
 #[pymodule]
-fn my_module(_py: Python<'_>, m: &PyModule) -> PyResult<()> {
-    m.add_class::<Number>()?;
-    Ok(())
+mod my_module {
+    #[pymodule_export]
+    use super::Number;
 }
 ```
 
-## PyCell and interior mutability
+## Bound<T> and interior mutability
 
-You sometimes need to convert your `pyclass` into a Python object and access it
-from Rust code (e.g., for testing it).
-[`PyCell`] is the primary interface for that.
+It is often useful to turn a `#[pyclass]` type `T` into a Python object and access it from Rust code.
+The [`Py<T>`] and [`Bound<'py, T>`] smart pointers are the ways to represent a Python object in PyO3's API.
+More detail can be found about them [in the Python objects](./types.md#pyo3s-smart-pointers) section of the guide.
 
-`PyCell<T: PyClass>` is always allocated in the Python heap, so Rust doesn't have ownership of it.
-In other words, Rust code can only extract a `&PyCell<T>`, not a `PyCell<T>`.
+Most Python objects do not offer exclusive (`&mut`) access (see the [section on Python's memory model](./python-from-rust.md#pythons-memory-model)).
+However, Rust structs wrapped as Python objects (called `pyclass` types) often *do* need `&mut` access.
+However, the Rust borrow checker cannot reason about `&mut` references once an object's ownership has been passed to the Python interpreter.
 
-Thus, to mutate data behind `&PyCell` safely, PyO3 employs the
-[Interior Mutability Pattern](https://doc.rust-lang.org/book/ch15-05-interior-mutability.html)
-like [`RefCell`].
+To solve this, PyO3 does borrow checking at runtime using a scheme very similar to `std::cell::RefCell<T>`.
+This is known as [interior mutability](https://doc.rust-lang.org/book/ch15-05-interior-mutability.html).
 
-Users who are familiar with `RefCell` can use `PyCell` just like `RefCell`.
+Users who are familiar with `RefCell<T>` can use `Py<T>` and `Bound<'py, T>` just like `RefCell<T>`.
+
+For users who are not very familiar with `RefCell<T>`, here is a reminder of Rust's rules of borrowing:
 
-For users who are not very familiar with `RefCell`, here is a reminder of Rust's rules of borrowing:
 - At any given time, you can have either (but not both of) one mutable reference or any number of immutable references.
-- References must always be valid.
+- References can never outlast the data they refer to.
 
-`PyCell`, like `RefCell`, ensures these borrowing rules by tracking references at runtime.
+`Py<T>` and `Bound<'py, T>`, like `RefCell<T>`, ensure these borrowing rules by tracking references at runtime.
 
 ```rust
 # use pyo3::prelude::*;
@@ -215,8 +242,8 @@ struct MyClass {
     #[pyo3(get)]
     num: i32,
 }
-Python::with_gil(|py| {
-    let obj = PyCell::new(py, MyClass { num: 3 }).unwrap();
+Python::attach(|py| {
+    let obj = Bound::new(py, MyClass { num: 3 }).unwrap();
     {
         let obj_ref = obj.borrow(); // Get PyRef
         assert_eq!(obj_ref.num, 3);
@@ -231,15 +258,13 @@ Python::with_gil(|py| {
         assert!(obj.try_borrow_mut().is_err());
     }
 
-    // You can convert `&PyCell` to a Python object
+    // You can convert `Bound` to a Python object
     pyo3::py_run!(py, obj, "assert obj.num == 5");
 });
 ```
 
-`&PyCell<T>` is bounded by the same lifetime as a [`GILGuard`].
-To make the object longer lived (for example, to store it in a struct on the
-Rust side), you can use `Py<T>`, which stores an object longer than the GIL
-lifetime, and therefore needs a `Python<'_>` token to access.
+A `Bound<'py, T>` is restricted to the Python lifetime `'py`.
+To make the object longer lived (for example, to store it in a struct on the Rust side), use `Py<T>`. `Py<T>` needs a `Python<'_>` token to allow access:
 
 ```rust
 # use pyo3::prelude::*;
@@ -249,23 +274,25 @@ struct MyClass {
 }
 
 fn return_myclass() -> Py<MyClass> {
-    Python::with_gil(|py| Py::new(py, MyClass { num: 1 }).unwrap())
+    Python::attach(|py| Py::new(py, MyClass { num: 1 }).unwrap())
 }
 
 let obj = return_myclass();
 
-Python::with_gil(|py| {
-    let cell = obj.as_ref(py); // Py<MyClass>::as_ref returns &PyCell<MyClass>
-    let obj_ref = cell.borrow(); // Get PyRef<T>
+Python::attach(move |py| {
+    let bound = obj.bind(py); // Py<MyClass>::bind returns &Bound<'py, MyClass>
+    let obj_ref = bound.borrow(); // Get PyRef<T>
     assert_eq!(obj_ref.num, 1);
 });
 ```
 
 ### frozen classes: Opting out of interior mutability
 
-As detailed above, runtime borrow checking is currently enabled by default. But a class can opt of out it by declaring itself `frozen`. It can still use interior mutability via standard Rust types like `RefCell` or `Mutex`, but it is not bound to the implementation provided by PyO3 and can choose the most appropriate strategy on field-by-field basis.
+As detailed above, runtime borrow checking is currently enabled by default.
+But a class can opt of out it by declaring itself `frozen`.
+It can still use interior mutability via standard Rust types like `RefCell` or `Mutex`, but it is not bound to the implementation provided by PyO3 and can choose the most appropriate strategy on field-by-field basis.
 
-Classes which are `frozen` and also `Sync`, e.g. they do use `Mutex` but not `RefCell`, can be accessed without needing the Python GIL via the `PyCell::get` and `Py::get` methods:
+Classes which are `frozen` and also `Sync`, e.g. they do use `Mutex` but not `RefCell`, can be accessed without needing a `Python` token via the `Bound::get` and `Py::get` methods:
 
 ```rust
 use std::sync::atomic::{AtomicUsize, Ordering};
@@ -276,7 +303,7 @@ struct FrozenCounter {
     value: AtomicUsize,
 }
 
-let py_counter: Py<FrozenCounter> = Python::with_gil(|py| {
+let py_counter: Py<FrozenCounter> = Python::attach(|py| {
     let counter = FrozenCounter {
         value: AtomicUsize::new(0),
     };
@@ -285,13 +312,16 @@ let py_counter: Py<FrozenCounter> = Python::with_gil(|py| {
 });
 
 py_counter.get().value.fetch_add(1, Ordering::Relaxed);
+
+Python::attach(move |_py| drop(py_counter));
 ```
 
-Frozen classes are likely to become the default thereby guiding the PyO3 ecosystem towards a more deliberate application of interior mutability. Eventually, this should enable further optimizations of PyO3's internals and avoid downstream code paying the cost of interior mutability when it is not actually required.
+Frozen classes are likely to become the default thereby guiding the PyO3 ecosystem towards a more deliberate application of interior mutability.
+Eventually, this should enable further optimizations of PyO3's internals and avoid downstream code paying the cost of interior mutability when it is not actually required.
 
 ## Customizing the class
 
-{{#include ../pyclass_parameters.md}}
+{{#include ../pyclass-parameters.md}}
 
 These parameters are covered in various sections of this guide.
 
@@ -311,22 +341,18 @@ Consult the table below to determine which type your constructor should return:
 
 ## Inheritance
 
-By default, `object`, i.e. `PyAny` is used as the base class. To override this default,
-use the `extends` parameter for `pyclass` with the full path to the base class.
-Currently, only classes defined in Rust and builtins provided by PyO3 can be inherited
-from; inheriting from other classes defined in Python is not yet supported
-([#991](https://github.com/PyO3/pyo3/issues/991)).
-
+By default, `object`, i.e. `PyAny` is used as the base class.
+To override this default, use the `extends` parameter for `pyclass` with the full path to the base class.
+Currently, only classes defined in Rust and builtins provided by PyO3 can be inherited from; inheriting from other classes defined in Python is not yet supported ([#991](https://github.com/PyO3/pyo3/issues/991)).
 
 For convenience, `(T, U)` implements `Into<PyClassInitializer<T>>` where `U` is the
 base class of `T`.
 But for a more deeply nested inheritance, you have to return `PyClassInitializer<T>`
 explicitly.
 
-To get a parent class from a child, use [`PyRef`] instead of `&self` for methods,
-or [`PyRefMut`] instead of `&mut self`.
-Then you can access a parent class by `self_.as_ref()` as `&Self::BaseClass`,
-or by `self_.into_super()` as `PyRef<Self::BaseClass>`.
+To get a parent class from a child, use [`PyRef`] instead of `&self` for methods, or [`PyRefMut`] instead of `&mut self`.
+Then you can access a parent class by `self_.as_super()` as `&PyRef<Self::BaseClass>`, or by `self_.into_super()` as `PyRef<Self::BaseClass>` (and similar for the `PyRefMut` case).
+For convenience, `self_.as_ref()` can also be used to get `&Self::BaseClass` directly; however, this approach does not let you access base classes higher in the inheritance hierarchy, for which you would need to chain multiple `as_super` or `into_super` calls.
 
 ```rust
 # use pyo3::prelude::*;
@@ -343,7 +369,7 @@ impl BaseClass {
         BaseClass { val1: 10 }
     }
 
-    pub fn method(&self) -> PyResult<usize> {
+    pub fn method1(&self) -> PyResult<usize> {
         Ok(self.val1)
     }
 }
@@ -361,8 +387,8 @@ impl SubClass {
     }
 
     fn method2(self_: PyRef<'_, Self>) -> PyResult<usize> {
-        let super_ = self_.as_ref(); // Get &BaseClass
-        super_.method().map(|x| x * self_.val2)
+        let super_ = self_.as_super(); // Get &PyRef<BaseClass>
+        super_.method1().map(|x| x * self_.val2)
     }
 }
 
@@ -379,26 +405,49 @@ impl SubSubClass {
     }
 
     fn method3(self_: PyRef<'_, Self>) -> PyResult<usize> {
+        let base = self_.as_super().as_super(); // Get &PyRef<'_, BaseClass>
+        base.method1().map(|x| x * self_.val3)
+    }
+
+    fn method4(self_: PyRef<'_, Self>) -> PyResult<usize> {
         let v = self_.val3;
         let super_ = self_.into_super(); // Get PyRef<'_, SubClass>
         SubClass::method2(super_).map(|x| x * v)
     }
 
+      fn get_values(self_: PyRef<'_, Self>) -> (usize, usize, usize) {
+          let val1 = self_.as_super().as_super().val1;
+          let val2 = self_.as_super().val2;
+          (val1, val2, self_.val3)
+      }
+
+    fn double_values(mut self_: PyRefMut<'_, Self>) {
+        self_.as_super().as_super().val1 *= 2;
+        self_.as_super().val2 *= 2;
+        self_.val3 *= 2;
+    }
+
     #[staticmethod]
-    fn factory_method(py: Python<'_>, val: usize) -> PyResult<PyObject> {
+    fn factory_method(py: Python<'_>, val: usize) -> PyResult<Py<PyAny>> {
         let base = PyClassInitializer::from(BaseClass::new());
         let sub = base.add_subclass(SubClass { val2: val });
         if val % 2 == 0 {
-            Ok(Py::new(py, sub)?.to_object(py))
+            Ok(Py::new(py, sub)?.into_any())
         } else {
             let sub_sub = sub.add_subclass(SubSubClass { val3: val });
-            Ok(Py::new(py, sub_sub)?.to_object(py))
+            Ok(Py::new(py, sub_sub)?.into_any())
         }
     }
 }
-# Python::with_gil(|py| {
-#     let subsub = pyo3::PyCell::new(py, SubSubClass::new()).unwrap();
-#     pyo3::py_run!(py, subsub, "assert subsub.method3() == 3000");
+# Python::attach(|py| {
+#     let subsub = pyo3::Py::new(py, SubSubClass::new()).unwrap();
+#     pyo3::py_run!(py, subsub, "assert subsub.method1() == 10");
+#     pyo3::py_run!(py, subsub, "assert subsub.method2() == 150");
+#     pyo3::py_run!(py, subsub, "assert subsub.method3() == 200");
+#     pyo3::py_run!(py, subsub, "assert subsub.method4() == 3000");
+#     pyo3::py_run!(py, subsub, "assert subsub.get_values() == (10, 15, 20)");
+#     pyo3::py_run!(py, subsub, "assert subsub.double_values() == None");
+#     pyo3::py_run!(py, subsub, "assert subsub.get_values() == (20, 30, 40)");
 #     let subsub = SubSubClass::factory_method(py, 2).unwrap();
 #     let subsubsub = SubSubClass::factory_method(py, 3).unwrap();
 #     let cls = py.get_type::<SubSubClass>();
@@ -411,8 +460,8 @@ You can inherit native types such as `PyDict`, if they implement
 [`PySizedLayout`]({{#PYO3_DOCS_URL}}/pyo3/type_object/trait.PySizedLayout.html).
 This is not supported when building for the Python limited API (aka the `abi3` feature of PyO3).
 
-However, because of some technical problems, we don't currently provide safe upcasting methods for types
-that inherit native types. Even in such cases, you can unsafely get a base class by raw pointer conversion.
+To convert between the Rust type and its native base class, you can take `slf` as a Python object.
+To access the Rust fields use `slf.borrow()` or `slf.borrow_mut()`, and to access the base class use `slf.cast::<BaseClass>()`.
 
 ```rust
 # #[cfg(not(Py_LIMITED_API))] {
@@ -433,21 +482,21 @@ impl DictWithCounter {
         Self::default()
     }
 
-    fn set(mut self_: PyRefMut<'_, Self>, key: String, value: &PyAny) -> PyResult<()> {
-        self_.counter.entry(key.clone()).or_insert(0);
-        let py = self_.py();
-        let dict: &PyDict = unsafe { py.from_borrowed_ptr_or_err(self_.as_ptr())? };
+    fn set(slf: &Bound<'_, Self>, key: String, value: Bound<'_, PyAny>) -> PyResult<()> {
+        slf.borrow_mut().counter.entry(key.clone()).or_insert(0);
+        let dict = slf.cast::<PyDict>()?;
         dict.set_item(key, value)
     }
 }
-# Python::with_gil(|py| {
-#     let cnt = pyo3::PyCell::new(py, DictWithCounter::new()).unwrap();
+# Python::attach(|py| {
+#     let cnt = pyo3::Py::new(py, DictWithCounter::new()).unwrap();
 #     pyo3::py_run!(py, cnt, "cnt.set('abc', 10); assert cnt['abc'] == 10")
 # });
 # }
 ```
 
 If `SubClass` does not provide a base class initialization, the compilation fails.
+
 ```rust,compile_fail
 # use pyo3::prelude::*;
 
@@ -490,13 +539,13 @@ struct MyDict {
 impl MyDict {
     #[new]
     #[pyo3(signature = (*args, **kwargs))]
-    fn new(args: &PyAny, kwargs: Option<&PyAny>) -> Self {
+    fn new(args: &Bound<'_, PyAny>, kwargs: Option<&Bound<'_, PyAny>>) -> Self {
         Self { private: 0 }
     }
 
     // some custom methods that use `private` here...
 }
-# Python::with_gil(|py| {
+# Python::attach(|py| {
 #     let cls = py.get_type::<MyDict>();
 #     pyo3::py_run!(py, cls, "cls(a=1, b=2)")
 # });
@@ -509,6 +558,7 @@ initial items, such as `MyDict(item_sequence)` or `MyDict(a=1, b=2)`.
 ## Object properties
 
 PyO3 supports two ways to add properties to your `#[pyclass]`:
+
 - For simple struct fields with no side effects, a `#[pyo3(get, set)]` attribute can be added directly to the field definition in the `#[pyclass]`.
 - For properties which require computation you can define `#[getter]` and `#[setter]` functions in the [`#[pymethods]`](#instance-methods) block.
 
@@ -520,6 +570,7 @@ For simple cases where a member variable is just read and written with no side e
 
 ```rust
 # use pyo3::prelude::*;
+# #[allow(dead_code)]
 #[pyclass]
 struct MyClass {
     #[pyo3(get, set)]
@@ -527,15 +578,18 @@ struct MyClass {
 }
 ```
 
-The above would make the `num` field available for reading and writing as a `self.num` Python property. To expose the property with a different name to the field, specify this alongside the rest of the options, e.g. `#[pyo3(get, set, name = "custom_name")]`.
+The above would make the `num` field available for reading and writing as a `self.num` Python property.
+To expose the property with a different name to the field, specify this alongside the rest of the options, e.g. `#[pyo3(get, set, name = "custom_name")]`.
 
 Properties can be readonly or writeonly by using just `#[pyo3(get)]` or `#[pyo3(set)]` respectively.
 
 To use these annotations, your field type must implement some conversion traits:
-- For `get` the field type must implement both `IntoPy<PyObject>` and `Clone`.
+
+- For `get` the field type `T` must implement either `&T: IntoPyObject` or `T: IntoPyObject + Clone`.
 - For `set` the field type must implement `FromPyObject`.
 
-For example, implementations of those traits are provided for the `Cell` type, if the inner type also implements the trait. This means you can use `#[pyo3(get, set)]` on fields wrapped in a `Cell`.
+For example, implementations of those traits are provided for the `Cell` type, if the inner type also implements the trait.
+This means you can use `#[pyo3(get, set)]` on fields wrapped in a `Cell`.
 
 ### Object properties using `#[getter]` and `#[setter]`
 
@@ -559,14 +613,11 @@ impl MyClass {
 }
 ```
 
-A getter or setter's function name is used as the property name by default. There are several
-ways how to override the name.
+A getter or setter's function name is used as the property name by default.
+There are several ways how to override the name.
 
-If a function name starts with `get_` or `set_` for getter or setter respectively,
-the descriptor name becomes the function name with this prefix removed. This is also useful in case of
-Rust keywords like `type`
-([raw identifiers](https://doc.rust-lang.org/edition-guide/rust-2018/module-system/raw-identifiers.html)
-can be used since Rust 2018).
+If a function name starts with `get_` or `set_` for getter or setter respectively, the descriptor name becomes the function name with this prefix removed.
+This is also useful in case of Rust keywords like `type` ([raw identifiers](https://doc.rust-lang.org/edition-guide/rust-2018/module-system/raw-identifiers.html) can be used since Rust 2018).
 
 ```rust
 # use pyo3::prelude::*;
@@ -617,19 +668,16 @@ impl MyClass {
 
 In this case, the property `number` is defined and available from Python code as `self.number`.
 
-Attributes defined by `#[setter]` or `#[pyo3(set)]` will always raise `AttributeError` on `del`
-operations. Support for defining custom `del` behavior is tracked in
-[#1778](https://github.com/PyO3/pyo3/issues/1778).
+Attributes defined by `#[setter]` or `#[pyo3(set)]` will always raise `AttributeError` on `del` operations.
+Support for defining custom `del` behavior is tracked in [#1778](https://github.com/PyO3/pyo3/issues/1778).
 
 ## Instance methods
 
-To define a Python compatible method, an `impl` block for your struct has to be annotated with the
-`#[pymethods]` attribute. PyO3 generates Python compatible wrappers for all functions in this
-block with some variations, like descriptors, class method static methods, etc.
+To define a Python compatible method, an `impl` block for your struct has to be annotated with the `#[pymethods]` attribute.
+PyO3 generates Python compatible wrappers for all functions in this block with some variations, like descriptors, class method static methods, etc.
 
-Since Rust allows any number of `impl` blocks, you can easily split methods
-between those accessible to Python (and Rust) and those accessible only to Rust. However to have multiple
-`#[pymethods]`-annotated `impl` blocks for the same struct you must enable the [`multiple-pymethods`] feature of PyO3.
+Since Rust allows any number of `impl` blocks, you can easily split methods between those accessible to Python (and Rust) and those accessible only to Rust.
+However to have multiple `#[pymethods]`-annotated `impl` blocks for the same struct you must enable the [`multiple-pymethods`] feature of PyO3.
 
 ```rust
 # use pyo3::prelude::*;
@@ -650,8 +698,9 @@ impl MyClass {
 }
 ```
 
-Calls to these methods are protected by the GIL, so both `&self` and `&mut self` can be used.
-The return type must be `PyResult<T>` or `T` for some `T` that implements `IntoPy<PyObject>`;
+Both `&self` and `&mut self` can be used, due to the use of [runtime borrow checking](#bound-and-interior-mutability).
+
+The return type must be `PyResult<T>` or `T` for some `T` that implements `IntoPyObject`;
 the latter is allowed if the method cannot raise Python exceptions.
 
 A `Python` parameter can be specified as part of method signature, in this case the `py` argument
@@ -699,21 +748,22 @@ impl MyClass {
 
 Declares a class method callable from Python.
 
-* The first parameter is the type object of the class on which the method is called.
+- The first parameter is the type object of the class on which the method is called.
   This may be the type object of a derived class.
-* The first parameter implicitly has type `&PyType`.
-* For details on `parameter-list`, see the documentation of `Method arguments` section.
-* The return type must be `PyResult<T>` or `T` for some `T` that implements `IntoPy<PyObject>`.
+- The first parameter implicitly has type `&Bound<'_, PyType>`.
+- For details on `parameter-list`, see the documentation of `Method arguments` section.
+- The return type must be `PyResult<T>` or `T` for some `T` that implements `IntoPyObject`.
 
 ### Constructors which accept a class argument
 
 To create a constructor which takes a positional class argument, you can combine the `#[classmethod]` and `#[new]` modifiers:
+
 ```rust
 # #![allow(dead_code)]
 # use pyo3::prelude::*;
 # use pyo3::types::PyType;
 # #[pyclass]
-# struct BaseClass(PyObject);
+# struct BaseClass(Py<PyAny>);
 #
 #[pymethods]
 impl BaseClass {
@@ -729,9 +779,8 @@ impl BaseClass {
 
 ## Static methods
 
-To create a static method for a custom class, the method needs to be annotated with the
-`#[staticmethod]` attribute. The return type must be `T` or `PyResult<T>` for some `T` that implements
-`IntoPy<PyObject>`.
+To create a static method for a custom class, the method needs to be annotated with the `#[staticmethod]` attribute.
+The return type must be `T` or `PyResult<T>` for some `T` that implements `IntoPyObject`.
 
 ```rust
 # use pyo3::prelude::*;
@@ -754,7 +803,7 @@ impl MyClass {
 To create a class attribute (also called [class variable][classattr]), a method without
 any arguments can be annotated with the `#[classattr]` attribute.
 
-```rust
+```rust,no_run
 # use pyo3::prelude::*;
 # #[pyclass]
 # struct MyClass {}
@@ -766,7 +815,7 @@ impl MyClass {
     }
 }
 
-Python::with_gil(|py| {
+Python::attach(|py| {
     let my_class = py.get_type::<MyClass>();
     pyo3::py_run!(py, my_class, "assert my_class.my_attribute == 'hello'")
 });
@@ -775,10 +824,12 @@ Python::with_gil(|py| {
 > Note: if the method has a `Result` return type and returns an `Err`, PyO3 will panic during
 class creation.
 
+> Note: `#[classattr]` does not work with [`#[pyo3(warn(...))]`](./function.md#warn) attribute.
+
 If the class attribute is defined with `const` code only, one can also annotate associated
 constants:
 
-```rust
+```rust,no_run
 # use pyo3::prelude::*;
 # #[pyclass]
 # struct MyClass {}
@@ -791,9 +842,15 @@ impl MyClass {
 
 ## Classes as function arguments
 
-Free functions defined using `#[pyfunction]` interact with classes through the same mechanisms as the self parameters of instance methods, i.e. they can take GIL-bound references, GIL-bound reference wrappers or GIL-indepedent references:
+Class objects can be used as arguments to `#[pyfunction]`s and `#[pymethods]` in the same way as the self parameters of instance methods, i.e. they can be passed as:
 
-```rust
+- `Py<T>` or `Bound<'py, T>` smart pointers to the class Python object,
+- `&T` or `&mut T` references to the Rust data contained in the Python object, or
+- `PyRef<T>` and `PyRefMut<T>` reference wrappers.
+
+Examples of each of these below:
+
+```rust,no_run
 # #![allow(dead_code)]
 # use pyo3::prelude::*;
 #[pyclass]
@@ -801,29 +858,30 @@ struct MyClass {
     my_field: i32,
 }
 
-// Take a GIL-bound reference when the underlying `PyCell` is irrelevant.
+// Take a reference to Rust data when the Python object is irrelevant.
 #[pyfunction]
 fn increment_field(my_class: &mut MyClass) {
     my_class.my_field += 1;
 }
 
-// Take a GIL-bound reference wrapper when borrowing should be automatic,
-// but interaction with the underlying `PyCell` is desired.
+// Take a reference wrapper when borrowing should be automatic,
+// but access to the Python object is still needed
 #[pyfunction]
-fn print_field(my_class: PyRef<'_, MyClass>) {
+fn print_field_and_return_me(my_class: PyRef<'_, MyClass>) -> PyRef<'_, MyClass> {
     println!("{}", my_class.my_field);
+    my_class
 }
 
-// Take a GIL-bound reference to the underlying cell
-// when borrowing needs to be managed manually.
+// Take (a reference to) a Python object smart pointer when borrowing needs to be managed manually.
 #[pyfunction]
-fn increment_then_print_field(my_class: &PyCell<MyClass>) {
+fn increment_then_print_field(my_class: &Bound<'_, MyClass>) {
     my_class.borrow_mut().my_field += 1;
 
     println!("{}", my_class.borrow().my_field);
 }
 
-// Take a GIL-indepedent reference when you want to store the reference elsewhere.
+// When the Python object smart pointer needs to be stored elsewhere prefer `Py<T>` over `Bound<'py, T>`
+// to avoid the lifetime restrictions.
 #[pyfunction]
 fn print_refcnt(my_class: Py<MyClass>, py: Python<'_>) {
     println!("{}", my_class.get_refcnt(py));
@@ -832,7 +890,7 @@ fn print_refcnt(my_class: Py<MyClass>, py: Python<'_>) {
 
 Classes can also be passed by value if they can be cloned, i.e. they automatically implement `FromPyObject` if they implement `Clone`, e.g. via `#[derive(Clone)]`:
 
-```rust
+```rust,no_run
 # #![allow(dead_code)]
 # use pyo3::prelude::*;
 #[pyclass]
@@ -842,7 +900,7 @@ struct MyClass {
 }
 
 #[pyfunction]
-fn dissamble_clone(my_class: MyClass) {
+fn disassemble_clone(my_class: MyClass) {
     let MyClass { mut my_field } = my_class;
     *my_field += 1;
 }
@@ -852,11 +910,13 @@ Note that `#[derive(FromPyObject)]` on a class is usually not useful as it tries
 
 ## Method arguments
 
-Similar to `#[pyfunction]`, the `#[pyo3(signature = (...))]` attribute can be used to specify the way that `#[pymethods]` accept arguments. Consult the documentation for [`function signatures`](./function/signature.md) to see the parameters this attribute accepts.
+Similar to `#[pyfunction]`, the `#[pyo3(signature = (...))]` attribute can be used to specify the way that `#[pymethods]` accept arguments.
+Consult the documentation for [`function signatures`](./function/signature.md) to see the parameters this attribute accepts.
 
-The following example defines a class `MyClass` with a method `method`. This method has a signature that sets default values for `num` and `name`, and indicates that `py_args` should collect all extra positional arguments and `py_kwargs` all extra keyword arguments:
+The following example defines a class `MyClass` with a method `method`.
+This method has a signature that sets default values for `num` and `name`, and indicates that `py_args` should collect all extra positional arguments and `py_kwargs` all extra keyword arguments:
 
-```rust
+```rust,no_run
 # use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyTuple};
 #
@@ -876,9 +936,9 @@ impl MyClass {
     fn method(
         &mut self,
         num: i32,
-        py_args: &PyTuple,
+        py_args: &Bound<'_, PyTuple>,
         name: &str,
-        py_kwargs: Option<&PyDict>,
+        py_kwargs: Option<&Bound<'_, PyDict>>,
     ) -> String {
         let num_before = self.num;
         self.num = num;
@@ -901,9 +961,7 @@ py_args=('World', 666), py_kwargs=Some({'x': 44, 'y': 55}), name=Hello, num=44,
 py_args=(), py_kwargs=None, name=World, num=-1, num_before=44
 ```
 
-## Making class method signatures available to Python
-
-The [`text_signature = "..."`](./function.md#text_signature) option for `#[pyfunction]` also works for `#[pymethods]`:
+The [`#[pyo3(text_signature = "...")`](./function/signature.md#overriding-the-generated-signature) option for `#[pyfunction]` also works for `#[pymethods]`.
 
 ```rust
 # #![allow(dead_code)]
@@ -939,7 +997,7 @@ impl MyClass {
 }
 #
 # fn main() -> PyResult<()> {
-#     Python::with_gil(|py| {
+#     Python::attach(|py| {
 #         let inspect = PyModule::import(py, "inspect")?.getattr("signature")?;
 #         let module = PyModule::new(py, "my_module")?;
 #         module.add_class::<MyClass>()?;
@@ -950,7 +1008,7 @@ impl MyClass {
 #             assert_eq!(doc, "");
 #
 #             let sig: String = inspect
-#                 .call1((class,))?
+#                 .call1((&class,))?
 #                 .call_method0("__str__")?
 #                 .extract()?;
 #             assert_eq!(sig, "(c, d)");
@@ -958,7 +1016,7 @@ impl MyClass {
 #             let doc: String = class.getattr("__doc__")?.extract()?;
 #             assert_eq!(doc, "");
 #
-#             inspect.call1((class,)).expect_err("`text_signature` on classes is not compatible with compilation in `abi3` mode until Python 3.10 or greater");
+#             inspect.call1((&class,)).expect_err("`text_signature` on classes is not compatible with compilation in `abi3` mode until Python 3.10 or greater");
 #          }
 #
 #         {
@@ -1005,25 +1063,68 @@ impl MyClass {
 Note that `text_signature` on `#[new]` is not compatible with compilation in
 `abi3` mode until Python 3.10 or greater.
 
-## #[pyclass] enums
+### Method receivers and lifetime elision
+
+PyO3 supports writing instance methods using the normal method receivers for shared `&self` and unique `&mut self` references.
+This interacts with [lifetime elision][lifetime-elision] insofar as the lifetime of a such a receiver is assigned to all elided output lifetime parameters.
+
+This is a good default for general Rust code where return values are more likely to borrow from the receiver than from the other arguments, if they contain any lifetimes at all.
+However, when returning bound references `Bound<'py, T>` in PyO3-based code, the Python lifetime `'py` should usually be derived from a `py: Python<'py>` token passed as an argument instead of the receiver.
+
+Specifically, signatures like
+
+```rust,ignore
+fn frobnicate(&self, py: Python) -> Bound<Foo>;
+```
+
+will not work as they are inferred as
+
+```rust,ignore
+fn frobnicate<'a, 'py>(&'a self, py: Python<'py>) -> Bound<'a, Foo>;
+```
+
+instead of the intended
+
+```rust,ignore
+fn frobnicate<'a, 'py>(&'a self, py: Python<'py>) -> Bound<'py, Foo>;
+```
+
+and should usually be written as
+
+```rust,ignore
+fn frobnicate<'py>(&self, py: Python<'py>) -> Bound<'py, Foo>;
+```
+
+The same problem does not exist for `#[pyfunction]`s as the special case for receiver lifetimes does not apply and indeed a signature like
+
+```rust,ignore
+fn frobnicate(bar: &Bar, py: Python) -> Bound<Foo>;
+```
+
+will yield compiler error [E0106 "missing lifetime specifier"][compiler-error-e0106].
+
+## `#[pyclass]` enums
 
 Enum support in PyO3 comes in two flavors, depending on what kind of variants the enum has: simple and complex.
 
 ### Simple enums
 
-A simple enum (a.k.a. C-like enum) has only unit variants.
+A simple enum (a.k.a.
+C-like enum) has only unit variants.
 
-PyO3 adds a class attribute for each variant, so you can access them in Python without defining `#[new]`. PyO3 also provides default implementations of `__richcmp__` and `__int__`, so they can be compared using `==`:
+PyO3 adds a class attribute for each variant, so you can access them in Python without defining `#[new]`.
+PyO3 also provides default implementations of `__richcmp__` and `__int__`, so they can be compared using `==`:
 
 ```rust
 # use pyo3::prelude::*;
-#[pyclass]
+#[pyclass(eq, eq_int)]
+#[derive(PartialEq)]
 enum MyEnum {
     Variant,
     OtherVariant,
 }
 
-Python::with_gil(|py| {
+Python::attach(|py| {
     let x = Py::new(py, MyEnum::Variant).unwrap();
     let y = Py::new(py, MyEnum::OtherVariant).unwrap();
     let cls = py.get_type::<MyEnum>();
@@ -1039,20 +1140,19 @@ You can also convert your simple enums into `int`:
 
 ```rust
 # use pyo3::prelude::*;
-#[pyclass]
+#[pyclass(eq, eq_int)]
+#[derive(PartialEq)]
 enum MyEnum {
     Variant,
     OtherVariant = 10,
 }
 
-Python::with_gil(|py| {
+Python::attach(|py| {
     let cls = py.get_type::<MyEnum>();
     let x = MyEnum::Variant as i32; // The exact value is assigned by the compiler.
     pyo3::py_run!(py, cls x, r#"
         assert int(cls.Variant) == x
         assert int(cls.OtherVariant) == 10
-        assert cls.OtherVariant == 10  # You can also compare against int.
-        assert 10 == cls.OtherVariant
     "#)
 })
 ```
@@ -1061,13 +1161,14 @@ PyO3 also provides `__repr__` for enums:
 
 ```rust
 # use pyo3::prelude::*;
-#[pyclass]
+#[pyclass(eq, eq_int)]
+#[derive(PartialEq)]
 enum MyEnum{
     Variant,
     OtherVariant,
 }
 
-Python::with_gil(|py| {
+Python::attach(|py| {
     let cls = py.get_type::<MyEnum>();
     let x = Py::new(py, MyEnum::Variant).unwrap();
     pyo3::py_run!(py, cls x, r#"
@@ -1077,11 +1178,13 @@ Python::with_gil(|py| {
 })
 ```
 
-All methods defined by PyO3 can be overridden. For example here's how you override `__repr__`:
+All methods defined by PyO3 can be overridden.
+For example here's how you override `__repr__`:
 
 ```rust
 # use pyo3::prelude::*;
-#[pyclass]
+#[pyclass(eq, eq_int)]
+#[derive(PartialEq)]
 enum MyEnum {
     Answer = 42,
 }
@@ -1093,7 +1196,7 @@ impl MyEnum {
     }
 }
 
-Python::with_gil(|py| {
+Python::attach(|py| {
     let cls = py.get_type::<MyEnum>();
     pyo3::py_run!(py, cls, "assert repr(cls.Answer) == '42'")
 })
@@ -1103,13 +1206,14 @@ Enums and their variants can also be renamed using `#[pyo3(name)]`.
 
 ```rust
 # use pyo3::prelude::*;
-#[pyclass(name = "RenamedEnum")]
+#[pyclass(eq, eq_int, name = "RenamedEnum")]
+#[derive(PartialEq)]
 enum MyEnum {
     #[pyo3(name = "UPPERCASE")]
     Variant,
 }
 
-Python::with_gil(|py| {
+Python::attach(|py| {
     let x = Py::new(py, MyEnum::Variant).unwrap();
     let cls = py.get_type::<MyEnum>();
     pyo3::py_run!(py, x cls, r#"
@@ -1119,6 +1223,32 @@ Python::with_gil(|py| {
 })
 ```
 
+Ordering of enum variants is optionally added using `#[pyo3(ord)]`.
+*Note: Implementation of the `PartialOrd` trait is required when passing the `ord` argument.  If not implemented, a compile time error is raised.*
+
+```rust
+# use pyo3::prelude::*;
+#[pyclass(eq, ord)]
+#[derive(PartialEq, PartialOrd)]
+enum MyEnum{
+    A,
+    B,
+    C,
+}
+
+Python::attach(|py| {
+    let cls = py.get_type::<MyEnum>();
+    let a = Py::new(py, MyEnum::A).unwrap();
+    let b = Py::new(py, MyEnum::B).unwrap();
+    let c = Py::new(py, MyEnum::C).unwrap();
+    pyo3::py_run!(py, cls a b c, r#"
+        assert (a < b) == True
+        assert (c <= b) == False
+        assert (c > a) == True
+    "#)
+})
+```
+
 You may not use enums as a base class or let enums inherit from other classes.
 
 ```rust,compile_fail
@@ -1147,9 +1277,11 @@ enum BadSubclass {
 
 An enum is complex if it has any non-unit (struct or tuple) variants.
 
-Currently PyO3 supports only struct variants in a complex enum. Support for unit and tuple variants is planned.
+PyO3 supports only struct and tuple variants in a complex enum.
+Unit variants aren't supported at present (the recommendation is to use an empty tuple enum instead).
 
-PyO3 adds a class attribute for each variant, which may be used to construct values and in match patterns. PyO3 also provides getter methods for all fields of each variant.
+PyO3 adds a class attribute for each variant, which may be used to construct values and in match patterns.
+PyO3 also provides getter methods for all fields of each variant.
 
 ```rust
 # use pyo3::prelude::*;
@@ -1157,14 +1289,14 @@ PyO3 adds a class attribute for each variant, which may be used to construct val
 enum Shape {
     Circle { radius: f64 },
     Rectangle { width: f64, height: f64 },
-    RegularPolygon { side_count: u32, radius: f64 },
+    RegularPolygon(u32, f64),
     Nothing { },
 }
 
 # #[cfg(Py_3_10)]
-Python::with_gil(|py| {
-    let circle = Shape::Circle { radius: 10.0 }.into_py(py);
-    let square = Shape::RegularPolygon { side_count: 4, radius: 10.0 }.into_py(py);
+Python::attach(|py| {
+    let circle = Shape::Circle { radius: 10.0 }.into_pyobject(py)?;
+    let square = Shape::RegularPolygon(4, 10.0).into_pyobject(py)?;
     let cls = py.get_type::<Shape>();
     pyo3::py_run!(py, circle square cls, r#"
         assert isinstance(circle, cls)
@@ -1173,8 +1305,8 @@ Python::with_gil(|py| {
 
         assert isinstance(square, cls)
         assert isinstance(square, cls.RegularPolygon)
-        assert square.side_count == 4
-        assert square.radius == 10.0
+        assert square[0] == 4 # Gets _0 field
+        assert square[1] == 10.0 # Gets _1 field
 
         def count_vertices(cls, shape):
             match shape:
@@ -1182,18 +1314,22 @@ Python::with_gil(|py| {
                     return 0
                 case cls.Rectangle():
                     return 4
-                case cls.RegularPolygon(side_count=n):
+                case cls.RegularPolygon(n):
                     return n
                 case cls.Nothing():
                     return 0
 
         assert count_vertices(cls, circle) == 0
         assert count_vertices(cls, square) == 4
-    "#)
+    "#);
+#   Ok::<_, PyErr>(())
 })
+# .unwrap();
 ```
 
-WARNING: `Py::new` and `.into_py` are currently inconsistent. Note how the constructed value is _not_ an instance of the specific variant. For this reason, constructing values is only recommended using `.into_py`.
+WARNING: `Py::new` and `.into_pyobject` are currently inconsistent.
+Note how the constructed value is _not_ an instance of the specific variant.
+For this reason, constructing values is only recommended using `.into_pyobject`.
 
 ```rust
 # use pyo3::prelude::*;
@@ -1202,7 +1338,7 @@ enum MyEnum {
     Variant { i: i32 },
 }
 
-Python::with_gil(|py| {
+Python::attach(|py| {
     let x = Py::new(py, MyEnum::Variant { i: 42 }).unwrap();
     let cls = py.get_type::<MyEnum>();
     pyo3::py_run!(py, x cls, r#"
@@ -1212,34 +1348,86 @@ Python::with_gil(|py| {
 })
 ```
 
+The constructor of each generated class can be customized using the `#[pyo3(constructor = (...))]` attribute.
+This uses the same syntax as the [`#[pyo3(signature = (...))]`](function/signature.md) attribute on function and methods and supports the same options.
+To apply this attribute simply place it on top of a variant in a `#[pyclass]` complex enum as shown below:
+
+```rust
+# use pyo3::prelude::*;
+#[pyclass]
+enum Shape {
+    #[pyo3(constructor = (radius=1.0))]
+    Circle { radius: f64 },
+    #[pyo3(constructor = (*, width, height))]
+    Rectangle { width: f64, height: f64 },
+    #[pyo3(constructor = (side_count, radius=1.0))]
+    RegularPolygon { side_count: u32, radius: f64 },
+    Nothing { },
+}
+
+# #[cfg(Py_3_10)]
+Python::attach(|py| {
+    let cls = py.get_type::<Shape>();
+    pyo3::py_run!(py, cls, r#"
+        circle = cls.Circle()
+        assert isinstance(circle, cls)
+        assert isinstance(circle, cls.Circle)
+        assert circle.radius == 1.0
+
+        square = cls.Rectangle(width = 1, height = 1)
+        assert isinstance(square, cls)
+        assert isinstance(square, cls.Rectangle)
+        assert square.width == 1
+        assert square.height == 1
+
+        hexagon = cls.RegularPolygon(6)
+        assert isinstance(hexagon, cls)
+        assert isinstance(hexagon, cls.RegularPolygon)
+        assert hexagon.side_count == 6
+        assert hexagon.radius == 1
+    "#)
+})
+```
+
 ## Implementation details
 
 The `#[pyclass]` macros rely on a lot of conditional code generation: each `#[pyclass]` can optionally have a `#[pymethods]` block.
 
-To support this flexibility the `#[pyclass]` macro expands to a blob of boilerplate code which sets up the structure for ["dtolnay specialization"](https://github.com/dtolnay/case-studies/blob/master/autoref-specialization/README.md). This implementation pattern enables the Rust compiler to use `#[pymethods]` implementations when they are present, and fall back to default (empty) definitions when they are not.
+To support this flexibility the `#[pyclass]` macro expands to a blob of boilerplate code which sets up the structure for ["dtolnay specialization"](https://github.com/dtolnay/case-studies/blob/master/autoref-specialization/README.md).
+This implementation pattern enables the Rust compiler to use `#[pymethods]` implementations when they are present, and fall back to default (empty) definitions when they are not.
 
-This simple technique works for the case when there is zero or one implementations. To support multiple `#[pymethods]` for a `#[pyclass]` (in the [`multiple-pymethods`] feature), a registry mechanism provided by the [`inventory`](https://github.com/dtolnay/inventory) crate is used instead. This collects `impl`s at library load time, but isn't supported on all platforms. See [inventory: how it works](https://github.com/dtolnay/inventory#how-it-works) for more details.
+This simple technique works for the case when there is zero or one implementations.
+To support multiple `#[pymethods]` for a `#[pyclass]` (in the [`multiple-pymethods`] feature), a registry mechanism provided by the [`inventory`](https://github.com/dtolnay/inventory) crate is used instead.
+This collects `impl`s at library load time, but isn't supported on all platforms. See [inventory: how it works](https://github.com/dtolnay/inventory#how-it-works) for more details.
 
-The `#[pyclass]` macro expands to roughly the code seen below. The `PyClassImplCollector` is the type used internally by PyO3 for dtolnay specialization:
+The `#[pyclass]` macro expands to roughly the code seen below.
+The `PyClassImplCollector` is the type used internally by PyO3 for dtolnay specialization:
 
 ```rust
 # #[cfg(not(feature = "multiple-pymethods"))] {
 # use pyo3::prelude::*;
 // Note: the implementation differs slightly with the `multiple-pymethods` feature enabled.
+# #[allow(dead_code)]
 struct MyClass {
     # #[allow(dead_code)]
     num: i32,
 }
-unsafe impl pyo3::type_object::HasPyGilRef for MyClass {
-    type AsRefTarget = pyo3::PyCell<Self>;
-}
+
+impl pyo3::types::DerefToPyAny for MyClass {}
+
 unsafe impl pyo3::type_object::PyTypeInfo for MyClass {
     const NAME: &'static str = "MyClass";
     const MODULE: ::std::option::Option<&'static str> = ::std::option::Option::None;
+
     #[inline]
     fn type_object_raw(py: pyo3::Python<'_>) -> *mut pyo3::ffi::PyTypeObject {
         <Self as pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
-            .get_or_init(py)
+            .get_or_try_init(py)
+            .unwrap_or_else(|e| pyo3::impl_::pyclass::type_object_init_failed(
+                py,
+                e,
+                <Self as pyo3::type_object::PyTypeInfo>::NAME
+            ))
             .as_type_ptr()
     }
 }
@@ -1248,35 +1436,11 @@ impl pyo3::PyClass for MyClass {
     type Frozen = pyo3::pyclass::boolean_struct::False;
 }
 
-impl<'a, 'py> pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py> for &'a MyClass
-{
-    type Holder = ::std::option::Option<pyo3::PyRef<'py, MyClass>>;
-
-    #[inline]
-    fn extract(obj: &'py pyo3::PyAny, holder: &'a mut Self::Holder) -> pyo3::PyResult<Self> {
-        pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
-    }
-}
-
-impl<'a, 'py> pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py> for &'a mut MyClass
-{
-    type Holder = ::std::option::Option<pyo3::PyRefMut<'py, MyClass>>;
-
-    #[inline]
-    fn extract(obj: &'py pyo3::PyAny, holder: &'a mut Self::Holder) -> pyo3::PyResult<Self> {
-        pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
-    }
-}
-
-impl pyo3::IntoPy<PyObject> for MyClass {
-    fn into_py(self, py: pyo3::Python<'_>) -> pyo3::PyObject {
-        pyo3::IntoPy::into_py(pyo3::Py::new(py, self).unwrap(), py)
-    }
-}
-
 impl pyo3::impl_::pyclass::PyClassImpl for MyClass {
     const IS_BASETYPE: bool = false;
     const IS_SUBCLASS: bool = false;
+    const IS_MAPPING: bool = false;
+    const IS_SEQUENCE: bool = false;
     type BaseType = PyAny;
     type ThreadChecker = pyo3::impl_::pyclass::SendablePyClass<MyClass>;
     type PyClassMutability = <<pyo3::PyAny as pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as pyo3::impl_::pycell::PyClassMutability>::MutableChild;
@@ -1284,6 +1448,9 @@ impl pyo3::impl_::pyclass::PyClassImpl for MyClass {
     type WeakRef = pyo3::impl_::pyclass::PyClassDummySlot;
     type BaseNativeType = pyo3::PyAny;
 
+    const RAW_DOC: &'static std::ffi::CStr = c"...";
+    const DOC: &'static std::ffi::CStr = c"...";
+
     fn items_iter() -> pyo3::impl_::pyclass::PyClassItemsIter {
         use pyo3::impl_::pyclass::*;
         let collector = PyClassImplCollector::<MyClass>::new();
@@ -1296,38 +1463,29 @@ impl pyo3::impl_::pyclass::PyClassImpl for MyClass {
         static TYPE_OBJECT: LazyTypeObject<MyClass> = LazyTypeObject::new();
         &TYPE_OBJECT
     }
-
-    fn doc(py: Python<'_>) -> pyo3::PyResult<&'static ::std::ffi::CStr> {
-        use pyo3::impl_::pyclass::*;
-        static DOC: pyo3::sync::GILOnceCell<::std::borrow::Cow<'static, ::std::ffi::CStr>> = pyo3::sync::GILOnceCell::new();
-        DOC.get_or_try_init(py, || {
-            let collector = PyClassImplCollector::<Self>::new();
-            build_pyclass_doc(<MyClass as pyo3::PyTypeInfo>::NAME, "", None.or_else(|| collector.new_text_signature()))
-        }).map(::std::ops::Deref::deref)
-    }
 }
 
-# Python::with_gil(|py| {
+# Python::attach(|py| {
 #     let cls = py.get_type::<MyClass>();
 #     pyo3::py_run!(py, cls, "assert cls.__name__ == 'MyClass'")
 # });
 # }
 ```
 
-
-[`GILGuard`]: {{#PYO3_DOCS_URL}}/pyo3/struct.GILGuard.html
 [`PyTypeInfo`]: {{#PYO3_DOCS_URL}}/pyo3/type_object/trait.PyTypeInfo.html
 
-[`Py`]: {{#PYO3_DOCS_URL}}/pyo3/struct.Py.html
-[`PyCell`]: {{#PYO3_DOCS_URL}}/pyo3/pycell/struct.PyCell.html
+[`Py<T>`]: {{#PYO3_DOCS_URL}}/pyo3/struct.Py.html
+[`Bound<'py, T>`]: {{#PYO3_DOCS_URL}}/pyo3/struct.Bound.html
 [`PyClass`]: {{#PYO3_DOCS_URL}}/pyo3/pyclass/trait.PyClass.html
 [`PyRef`]: {{#PYO3_DOCS_URL}}/pyo3/pycell/struct.PyRef.html
 [`PyRefMut`]: {{#PYO3_DOCS_URL}}/pyo3/pycell/struct.PyRefMut.html
 [`PyClassInitializer<T>`]: {{#PYO3_DOCS_URL}}/pyo3/pyclass_init/struct.PyClassInitializer.html
 
 [`Arc`]: https://doc.rust-lang.org/std/sync/struct.Arc.html
-[`RefCell`]: https://doc.rust-lang.org/std/cell/struct.RefCell.html
 
 [classattr]: https://docs.python.org/3/tutorial/classes.html#class-and-instance-variables
 
 [`multiple-pymethods`]: features.md#multiple-pymethods
+
+[lifetime-elision]: https://doc.rust-lang.org/reference/lifetime-elision.html
+[compiler-error-e0106]: https://doc.rust-lang.org/error_codes/E0106.html
diff --git a/guide/src/class/call.md b/guide/src/class/call.md
index 3b20986239b..0f08bb53ce7 100644
--- a/guide/src/class/call.md
+++ b/guide/src/class/call.md
@@ -6,11 +6,10 @@ This allows instances of a class to behave similar to functions.
 This method's signature must look like `__call__(<self>, ...) -> object` - here,
  any argument list can be defined as for normal pymethods
 
-### Example: Implementing a call counter
+## Example: Implementing a call counter
 
-The following pyclass is a basic decorator - its constructor takes a Python object
-as argument and calls that object when called. An equivalent Python implementation
-is linked at the end.
+The following pyclass is a basic decorator - its constructor takes a Python object as argument and calls that object when called.
+An equivalent Python implementation is linked at the end.
 
 An example crate containing this pyclass can be found [here](https://github.com/PyO3/pyo3/tree/main/examples/decorator)
 
@@ -66,7 +65,7 @@ def Counter(wraps):
     return call
 ```
 
-### What is the `Cell` for?
+### What is the `AtomicU64` for?
 
 A [previous implementation] used a normal `u64`, which meant it required a `&mut self` receiver to update the count:
 
@@ -75,8 +74,8 @@ A [previous implementation] used a normal `u64`, which meant it required a `&mut
 fn __call__(
     &mut self,
     py: Python<'_>,
-    args: &PyTuple,
-    kwargs: Option<&PyDict>,
+    args: &Bound<'_, PyTuple>,
+    kwargs: Option<&Bound<'_, PyDict>>,
 ) -> PyResult<Py<PyAny>> {
     self.count += 1;
     let name = self.wraps.getattr(py, "__name__")?;
@@ -92,9 +91,9 @@ fn __call__(
 }
 ```
 
-The problem with this is that the `&mut self` receiver means PyO3 has to borrow it exclusively,
- and hold this borrow across the`self.wraps.call(py, args, kwargs)` call. This call returns control to the user's Python code
- which is free to call arbitrary things, *including* the decorated function. If that happens PyO3 is unable to create a second unique borrow and will be forced to raise an exception.
+The problem with this is that the `&mut self` receiver means PyO3 has to borrow it exclusively, and hold this borrow across the `self.wraps.call(py, args, kwargs)` call.
+This call returns control to the user's Python code which is free to call arbitrary things, *including* the decorated function.
+If that happens PyO3 is unable to create a second unique borrow and will be forced to raise an exception.
 
 As a result, something innocent like this will raise an exception:
 
@@ -108,14 +107,18 @@ say_hello()
 # RuntimeError: Already borrowed
 ```
 
-The implementation in this chapter fixes that by never borrowing exclusively; all the methods take `&self` as receivers, of which multiple may exist simultaneously. This requires a shared counter and the easiest way to do that is to use [`Cell`], so that's what is used here.
+The implementation in this chapter fixes that by never borrowing exclusively; all the methods take `&self` as receivers, of which multiple may exist simultaneously.
+This requires a shared counter and the most straightforward way to implement thread-safe interior mutability (e.g. the type does not need to accept `&mut self` to modify the "interior" state) for a `u64` is to use [`AtomicU64`], so that's what is used here.
 
 This shows the dangers of running arbitrary Python code - note that "running arbitrary Python code" can be far more subtle than the example above:
+
 - Python's asynchronous executor may park the current thread in the middle of Python code, even in Python code that *you* control, and let other Python code run.
 - Dropping arbitrary Python objects may invoke destructors defined in Python (`__del__` methods).
 - Calling Python's C-api (most PyO3 apis call C-api functions internally) may raise exceptions, which may allow Python code in signal handlers to run.
+- On the free-threaded build, users might use Python's `threading` module to work with your types simultaneously from multiple OS threads.
 
-This is especially important if you are writing unsafe code; Python code must never be able to cause undefined behavior. You must ensure that your Rust code is in a consistent state before doing any of the above things.
+This is especially important if you are writing unsafe code; Python code must never be able to cause undefined behavior.
+You must ensure that your Rust code is in a consistent state before doing any of the above things.
 
-[previous implementation]: https://github.com/PyO3/pyo3/discussions/2598 "Thread Safe Decorator <Help Wanted> · Discussion #2598 · PyO3/pyo3"
-[`Cell`]: https://doc.rust-lang.org/std/cell/struct.Cell.html "Cell in std::cell - Rust"
+[previous implementation]: <https://github.com/PyO3/pyo3/discussions/2598> "Thread Safe Decorator <Help Wanted> · Discussion #2598 · PyO3/pyo3"
+[`AtomicU64`]: <https://doc.rust-lang.org/std/sync/atomic/struct.AtomicU64.html> "AtomicU64 in std::sync::atomic - Rust"
diff --git a/guide/src/class/numeric.md b/guide/src/class/numeric.md
index c6b6a65b711..d7801b45f1a 100644
--- a/guide/src/class/numeric.md
+++ b/guide/src/class/numeric.md
@@ -2,14 +2,17 @@
 
 At this point we have a `Number` class that we can't actually do any math on!
 
-Before proceeding, we should think about how we want to handle overflows. There are three obvious solutions:
-- We can have infinite precision just like Python's `int`. However that would be quite boring - we'd
- be reinventing the wheel.
+Before proceeding, we should think about how we want to handle overflows.
+There are three obvious solutions:
+
+- We can have infinite precision just like Python's `int`.
+  However that would be quite boring - we'd be reinventing the wheel.
 - We can raise exceptions whenever `Number` overflows, but that makes the API painful to use.
-- We can wrap around the boundary of `i32`. This is the approach we'll take here. To do that we'll just forward to `i32`'s
- `wrapping_*` methods.
+- We can wrap around the boundary of `i32`.
+  This is the approach we'll take here.
+  To do that we'll just forward to `i32`'s `wrapping_*` methods.
 
-### Fixing our constructor
+## Fixing our constructor
 
 Let's address the first overflow, in `Number`'s constructor:
 
@@ -26,29 +29,28 @@ Traceback (most recent call last):
 OverflowError: Python int too large to convert to C long
 ```
 
-Instead of relying on the default [`FromPyObject`] extraction to parse arguments, we can specify our
-own extraction function, using the `#[pyo3(from_py_with = "...")]` attribute. Unfortunately PyO3
-doesn't provide a way to wrap Python integers out of the box, but we can do a Python call to mask it
-and cast it to an `i32`.
+Instead of relying on the default [`FromPyObject`] extraction to parse arguments, we can specify our own extraction function, using the `#[pyo3(from_py_with = ...)]` attribute.
+Unfortunately PyO3 doesn't provide a way to wrap Python integers out of the box, but we can do a Python call to mask it and cast it to an `i32`.
 
-```rust
+```rust,no_run
 # #![allow(dead_code)]
 use pyo3::prelude::*;
 
-fn wrap(obj: &PyAny) -> Result<i32, PyErr> {
+fn wrap(obj: &Bound<'_, PyAny>) -> PyResult<i32> {
     let val = obj.call_method1("__and__", (0xFFFFFFFF_u32,))?;
     let val: u32 = val.extract()?;
     //     👇 This intentionally overflows!
     Ok(val as i32)
 }
 ```
+
 We also add documentation, via `///` comments, which are visible to Python users.
 
-```rust
+```rust,no_run
 # #![allow(dead_code)]
 use pyo3::prelude::*;
 
-fn wrap(obj: &PyAny) -> Result<i32, PyErr> {
+fn wrap(obj: &Bound<'_, PyAny>) -> PyResult<i32> {
     let val = obj.call_method1("__and__", (0xFFFFFFFF_u32,))?;
     let val: u32 = val.extract()?;
     Ok(val as i32)
@@ -62,15 +64,15 @@ struct Number(i32);
 #[pymethods]
 impl Number {
     #[new]
-    fn new(#[pyo3(from_py_with = "wrap")] value: i32) -> Self {
+    fn new(#[pyo3(from_py_with = wrap)] value: i32) -> Self {
         Self(value)
     }
 }
 ```
 
-
 With that out of the way, let's implement some operators:
-```rust
+
+```rust,no_run
 use pyo3::exceptions::{PyZeroDivisionError, PyValueError};
 
 # use pyo3::prelude::*;
@@ -124,7 +126,7 @@ impl Number {
 
 ### Unary arithmetic operations
 
-```rust
+```rust,no_run
 # use pyo3::prelude::*;
 #
 # #[pyclass]
@@ -150,9 +152,9 @@ impl Number {
 }
 ```
 
-### Support for the `complex()`, `int()` and `float()` built-in functions.
+### Support for the `complex()`, `int()` and `float()` built-in functions
 
-```rust
+```rust,no_run
 # use pyo3::prelude::*;
 #
 # #[pyclass]
@@ -171,7 +173,7 @@ impl Number {
     }
 
     fn __complex__<'py>(&self, py: Python<'py>) -> Bound<'py, PyComplex> {
-        PyComplex::from_doubles_bound(py, self.0 as f64, 0.0)
+        PyComplex::from_doubles(py, self.0 as f64, 0.0)
     }
 }
 ```
@@ -206,14 +208,13 @@ assert hash_djb2('l50_50') == Number(-1152549421)
 ```rust
 use std::collections::hash_map::DefaultHasher;
 use std::hash::{Hash, Hasher};
-use std::convert::TryInto;
 
 use pyo3::exceptions::{PyValueError, PyZeroDivisionError};
 use pyo3::prelude::*;
 use pyo3::class::basic::CompareOp;
-use pyo3::types::PyComplex;
+use pyo3::types::{PyComplex, PyString};
 
-fn wrap(obj: &PyAny) -> Result<i32, PyErr> {
+fn wrap(obj: &Bound<'_, PyAny>) -> PyResult<i32> {
     let val = obj.call_method1("__and__", (0xFFFFFFFF_u32,))?;
     let val: u32 = val.extract()?;
     Ok(val as i32)
@@ -226,13 +227,13 @@ struct Number(i32);
 #[pymethods]
 impl Number {
     #[new]
-    fn new(#[pyo3(from_py_with = "wrap")] value: i32) -> Self {
+    fn new(#[pyo3(from_py_with = wrap)] value: i32) -> Self {
         Self(value)
     }
 
-    fn __repr__(slf: &PyCell<Self>) -> PyResult<String> {
+    fn __repr__(slf: &Bound<'_, Self>) -> PyResult<String> {
        // Get the class name dynamically in case `Number` is subclassed
-       let class_name: String = slf.get_type().qualname()?;
+       let class_name: Bound<'_, PyString> = slf.get_type().qualname()?;
         Ok(format!("{}({})", class_name, slf.borrow().0))
     }
 
@@ -322,16 +323,16 @@ impl Number {
     }
 
     fn __complex__<'py>(&self, py: Python<'py>) -> Bound<'py, PyComplex> {
-        PyComplex::from_doubles_bound(py, self.0 as f64, 0.0)
+        PyComplex::from_doubles(py, self.0 as f64, 0.0)
     }
 }
 
 #[pymodule]
-fn my_module(_py: Python<'_>, m: &PyModule) -> PyResult<()> {
-    m.add_class::<Number>()?;
-    Ok(())
+mod my_module {
+    #[pymodule_export]
+    use super::Number;
 }
-# const SCRIPT: &'static str = r#"
+# const SCRIPT: &'static std::ffi::CStr = cr#"
 # def hash_djb2(s: str):
 #     n = Number(0)
 #     five = Number(5)
@@ -386,11 +387,11 @@ fn my_module(_py: Python<'_>, m: &PyModule) -> PyResult<()> {
 # use pyo3::PyTypeInfo;
 #
 # fn main() -> PyResult<()> {
-#     Python::with_gil(|py| -> PyResult<()> {
-#         let globals = PyModule::import(py, "__main__")?.dict().as_borrowed();
-#         globals.set_item("Number", Number::type_object_bound(py))?;
+#     Python::attach(|py| -> PyResult<()> {
+#         let globals = PyModule::import(py, "__main__")?.dict();
+#         globals.set_item("Number", Number::type_object(py))?;
 #
-#         py.run_bound(SCRIPT, Some(&globals), None)?;
+#         py.run(SCRIPT, Some(&globals), None)?;
 #         Ok(())
 #     })
 # }
@@ -398,31 +399,35 @@ fn my_module(_py: Python<'_>, m: &PyModule) -> PyResult<()> {
 
 ## Appendix: Writing some unsafe code
 
-At the beginning of this chapter we said that PyO3 doesn't provide a way to wrap Python integers out
-of the box but that's a half truth. There's not a PyO3 API for it, but there's a Python C API
-function that does:
+At the beginning of this chapter we said that PyO3 doesn't provide a way to wrap Python integers out of the box but that's a half truth.
+There's not a PyO3 API for it, but there's a Python C API function that does:
 
 ```c
 unsigned long PyLong_AsUnsignedLongMask(PyObject *obj)
 ```
 
-We can call this function from Rust by using [`pyo3::ffi::PyLong_AsUnsignedLongMask`]. This is an *unsafe*
-function, which means we have to use an unsafe block to call it and take responsibility for upholding
-the contracts of this function. Let's review those contracts:
-- The GIL must be held. If it's not, calling this function causes a data race.
+We can call this function from Rust by using [`pyo3::ffi::PyLong_AsUnsignedLongMask`].
+This is an *unsafe* function, which means we have to use an unsafe block to call it and take responsibility for upholding the contracts of this function.
+Let's review those contracts:
+
+- We must be attached to the interpreter.
+  If we're not, calling this function causes a data race.
 - The pointer must be valid, i.e. it must be properly aligned and point to a valid Python object.
 
-Let's create that helper function. The signature has to be `fn(&PyAny) -> PyResult<T>`.
-- `&PyAny` represents a checked borrowed reference, so the pointer derived from it is valid (and not null).
-- Whenever we have borrowed references to Python objects in scope, it is guaranteed that the GIL is held. This reference is also where we can get a [`Python`] token to use in our call to [`PyErr::take`].
+Let's create that helper function.
+The signature has to be `fn(&Bound<'_, PyAny>) -> PyResult<T>`.
 
-```rust
+- `&Bound<'_, PyAny>` represents a checked bound reference, so the pointer derived from it is valid (and not null).
+- Whenever we have bound references to Python objects in scope, it is guaranteed that we're attached to the interpreter.
+  This reference is also where we can get a [`Python`] token to use in our call to [`PyErr::take`].
+
+```rust,no_run
 # #![allow(dead_code)]
-use std::os::raw::c_ulong;
+use std::ffi::c_ulong;
 use pyo3::prelude::*;
 use pyo3::ffi;
 
-fn wrap(obj: &PyAny) -> Result<i32, PyErr> {
+fn wrap(obj: &Bound<'_, PyAny>) -> Result<i32, PyErr> {
     let py: Python<'_> = obj.py();
 
     unsafe {
@@ -441,6 +446,6 @@ fn wrap(obj: &PyAny) -> Result<i32, PyErr> {
 ```
 
 [`PyErr::take`]: {{#PYO3_DOCS_URL}}/pyo3/prelude/struct.PyErr.html#method.take
-[`Python`]: {{#PYO3_DOCS_URL}}/pyo3/struct.Python.html
+[`Python`]: {{#PYO3_DOCS_URL}}/pyo3/marker/struct.Python.html
 [`FromPyObject`]: {{#PYO3_DOCS_URL}}/pyo3/conversion/trait.FromPyObject.html
 [`pyo3::ffi::PyLong_AsUnsignedLongMask`]: {{#PYO3_DOCS_URL}}/pyo3/ffi/fn.PyLong_AsUnsignedLongMask.html
diff --git a/guide/src/class/object.md b/guide/src/class/object.md
index 5d4f53a17d4..12f3dd7f06b 100644
--- a/guide/src/class/object.md
+++ b/guide/src/class/object.md
@@ -2,8 +2,9 @@
 
 Recall the `Number` class from the previous chapter:
 
-```rust
+```rust,no_run
 # #![allow(dead_code)]
+# fn main() {}
 use pyo3::prelude::*;
 
 #[pyclass]
@@ -18,9 +19,9 @@ impl Number {
 }
 
 #[pymodule]
-fn my_module(_py: Python<'_>, m: &PyModule) -> PyResult<()> {
-    m.add_class::<Number>()?;
-    Ok(())
+mod my_module {
+    #[pymodule_export]
+    use super::Number;
 }
 ```
 
@@ -38,13 +39,13 @@ print(n)
 <builtins.Number object at 0x000002B4D185D7D0>
 ```
 
-### String representations
+## String representations
 
-It can't even print an user-readable representation of itself! We can fix that by defining the
-`__repr__` and `__str__` methods inside a `#[pymethods]` block. We do this by accessing the value
-contained inside `Number`.
+It can't even print an user-readable representation of itself!
+We can fix that by defining the `__repr__` and `__str__` methods inside a `#[pymethods]` block.
+We do this by accessing the value contained inside `Number`.
 
-```rust
+```rust,no_run
 # use pyo3::prelude::*;
 #
 # #[pyclass]
@@ -70,26 +71,69 @@ impl Number {
 }
 ```
 
-#### Accessing the class name
+To automatically generate the `__str__` implementation using a `Display` trait implementation, pass the `str` argument to `pyclass`.
 
-In the `__repr__`, we used a hard-coded class name. This is sometimes not ideal,
-because if the class is subclassed in Python, we would like the repr to reflect
-the subclass name. This is typically done in Python code by accessing
-`self.__class__.__name__`. In order to be able to access the Python type information
-*and* the Rust struct, we need to use a `PyCell` as the `self` argument.
+```rust,no_run
+# use std::fmt::{Display, Formatter};
+# use pyo3::prelude::*;
+#
+# #[allow(dead_code)]
+#[pyclass(str)]
+struct Coordinate {
+    x: i32,
+    y: i32,
+    z: i32,
+}
 
-```rust
+impl Display for Coordinate {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "({}, {}, {})", self.x, self.y, self.z)
+    }
+}
+```
+
+For convenience, a shorthand format string can be passed to `str` as `str="<format string>"` for **structs only**.  It expands and is passed into the `format!` macro in the following ways:
+
+- `"{x}"` -> `"{}", self.x`
+- `"{0}"` -> `"{}", self.0`
+- `"{x:?}"` -> `"{:?}", self.x`
+
+*Note: Depending upon the format string you use, this may require implementation of the `Display` or `Debug` traits for the given Rust types.*
+*Note: the pyclass args `name` and `rename_all` are incompatible with the shorthand format string and will raise a compile time error.*
+
+```rust,no_run
+# use pyo3::prelude::*;
+#
+# #[allow(dead_code)]
+#[pyclass(str="({x}, {y}, {z})")]
+struct Coordinate {
+    x: i32,
+    y: i32,
+    z: i32,
+}
+```
+
+### Accessing the class name
+
+In the `__repr__`, we used a hard-coded class name.
+This is sometimes not ideal, because if the class is subclassed in Python, we would like the repr to reflect the subclass name.
+This is typically done in Python code by accessing `self.__class__.__name__`.
+In order to be able to access the Python type information *and* the Rust struct, we need to use a `Bound` as the `self` argument.
+
+```rust,no_run
 # use pyo3::prelude::*;
+# use pyo3::types::PyString;
 #
+# #[allow(dead_code)]
 # #[pyclass]
 # struct Number(i32);
 #
 #[pymethods]
 impl Number {
-    fn __repr__(slf: &PyCell<Self>) -> PyResult<String> {
+    fn __repr__(slf: &Bound<'_, Self>) -> PyResult<String> {
         // This is the equivalent of `self.__class__.__name__` in Python.
-        let class_name: String = slf.get_type().qualname()?;
-        // To access fields of the Rust struct, we need to borrow the `PyCell`.
+        let class_name: Bound<'_, PyString> = slf.get_type().qualname()?;
+        // To access fields of the Rust struct, we need to borrow from the Bound object.
         Ok(format!("{}({})", class_name, slf.borrow().0))
     }
 }
@@ -97,11 +141,12 @@ impl Number {
 
 ### Hashing
 
+Let's also implement hashing.
+We'll just hash the `i32`.
+For that we need a [`Hasher`].
+The one provided by `std` is [`DefaultHasher`], which uses the [SipHash] algorithm.
 
-Let's also implement hashing. We'll just hash the `i32`. For that we need a [`Hasher`]. The one
-provided by `std` is [`DefaultHasher`], which uses the [SipHash] algorithm.
-
-```rust
+```rust,no_run
 use std::collections::hash_map::DefaultHasher;
 
 // Required to call the `.hash` and `.finish` methods, which are defined on traits.
@@ -109,6 +154,7 @@ use std::hash::{Hash, Hasher};
 
 # use pyo3::prelude::*;
 #
+# #[allow(dead_code)]
 # #[pyclass]
 # struct Number(i32);
 #
@@ -122,6 +168,22 @@ impl Number {
 }
 ```
 
+To implement `__hash__` using the Rust [`Hash`] trait implementation, the `hash` option can be used.
+This option is only available for `frozen` classes to prevent accidental hash changes from mutating the object.
+If you need an `__hash__` implementation for a mutable class, use the manual method from above.
+This option also requires `eq`: According to the [Python docs](https://docs.python.org/3/reference/datamodel.html#object.__hash__) "If a class does not define an `__eq__()` method it should not define a `__hash__()` operation either"
+
+```rust,no_run
+# use pyo3::prelude::*;
+#
+# #[allow(dead_code)]
+#[pyclass(frozen, eq, hash)]
+#[derive(PartialEq, Hash)]
+struct Number(i32);
+```
+
+<!-- rumdl-disable MD052 - code block in quote confusing rumdl -->
+
 > **Note**: When implementing `__hash__` and comparisons, it is important that the following property holds:
 >
 > ```text
@@ -136,7 +198,7 @@ impl Number {
 > Types which should not be hashable can override this by setting `__hash__` to None.
 > This is the same mechanism as for a pure-Python class. This is done like so:
 >
-> ```rust
+> ```rust,no_run
 > # use pyo3::prelude::*;
 > #[pyclass]
 > struct NotHashable {}
@@ -148,17 +210,20 @@ impl Number {
 > }
 > ```
 
+<!-- rumdl-enable MD052 -->
+
 ### Comparisons
 
-PyO3 supports the usual magic comparison methods available in Python such as `__eq__`, `__lt__`
-and so on. It is also possible to support all six operations at once with `__richcmp__`.
+PyO3 supports the usual magic comparison methods available in Python such as `__eq__`, `__lt__` and so on.
+It is also possible to support all six operations at once with `__richcmp__`.
 This method will be called with a value of `CompareOp` depending on the operation.
 
-```rust
+```rust,no_run
 use pyo3::class::basic::CompareOp;
 
 # use pyo3::prelude::*;
 #
+# #[allow(dead_code)]
 # #[pyclass]
 # struct Number(i32);
 #
@@ -180,11 +245,12 @@ impl Number {
 If you obtain the result by comparing two Rust values, as in this example, you
 can take a shortcut using `CompareOp::matches`:
 
-```rust
+```rust,no_run
 use pyo3::class::basic::CompareOp;
 
 # use pyo3::prelude::*;
 #
+# #[allow(dead_code)]
 # #[pyclass]
 # struct Number(i32);
 #
@@ -201,7 +267,6 @@ the given `CompareOp`.
 
 Alternatively, you can implement just equality using `__eq__`:
 
-
 ```rust
 # use pyo3::prelude::*;
 #
@@ -216,9 +281,9 @@ impl Number {
 }
 
 # fn main() -> PyResult<()> {
-#     Python::with_gil(|py| {
-#         let x = PyCell::new(py, Number(4))?;
-#         let y = PyCell::new(py, Number(4))?;
+#     Python::attach(|py| {
+#         let x = &Bound::new(py, Number(4))?;
+#         let y = &Bound::new(py, Number(4))?;
 #         assert!(x.eq(y)?);
 #         assert!(!x.ne(y)?);
 #         Ok(())
@@ -226,13 +291,36 @@ impl Number {
 # }
 ```
 
+To implement `__eq__` using the Rust [`PartialEq`] trait implementation, the `eq` option can be used.
+
+```rust,no_run
+# use pyo3::prelude::*;
+#
+# #[allow(dead_code)]
+#[pyclass(eq)]
+#[derive(PartialEq)]
+struct Number(i32);
+```
+
+To implement `__lt__`, `__le__`, `__gt__`, & `__ge__` using the Rust `PartialOrd` trait implementation, the `ord` option can be used. *Note: Requires `eq`.*
+
+```rust,no_run
+# use pyo3::prelude::*;
+#
+# #[allow(dead_code)]
+#[pyclass(eq, ord)]
+#[derive(PartialEq, PartialOrd)]
+struct Number(i32);
+```
+
 ### Truthyness
 
 We'll consider `Number` to be `True` if it is nonzero:
 
-```rust
+```rust,no_run
 # use pyo3::prelude::*;
 #
+# #[allow(dead_code)]
 # #[pyclass]
 # struct Number(i32);
 #
@@ -246,12 +334,14 @@ impl Number {
 
 ### Final code
 
-```rust
+```rust,no_run
+# fn main() {}
 use std::collections::hash_map::DefaultHasher;
 use std::hash::{Hash, Hasher};
 
 use pyo3::prelude::*;
 use pyo3::class::basic::CompareOp;
+use pyo3::types::PyString;
 
 #[pyclass]
 struct Number(i32);
@@ -263,8 +353,8 @@ impl Number {
         Self(value)
     }
 
-    fn __repr__(slf: &PyCell<Self>) -> PyResult<String> {
-        let class_name: String = slf.get_type().qualname()?;
+    fn __repr__(slf: &Bound<'_, Self>) -> PyResult<String> {
+        let class_name: Bound<'_, PyString> = slf.get_type().qualname()?;
         Ok(format!("{}({})", class_name, slf.borrow().0))
     }
 
@@ -295,9 +385,9 @@ impl Number {
 }
 
 #[pymodule]
-fn my_module(_py: Python<'_>, m: &PyModule) -> PyResult<()> {
-    m.add_class::<Number>()?;
-    Ok(())
+mod my_module {
+    #[pymodule_export]
+    use super::Number;
 }
 ```
 
@@ -305,3 +395,4 @@ fn my_module(_py: Python<'_>, m: &PyModule) -> PyResult<()> {
 [`Hasher`]: https://doc.rust-lang.org/std/hash/trait.Hasher.html
 [`DefaultHasher`]: https://doc.rust-lang.org/std/collections/hash_map/struct.DefaultHasher.html
 [SipHash]: https://en.wikipedia.org/wiki/SipHash
+[`PartialEq`]: https://doc.rust-lang.org/stable/std/cmp/trait.PartialEq.html
diff --git a/guide/src/class/protocols.md b/guide/src/class/protocols.md
index 411978f0567..aa99ea95554 100644
--- a/guide/src/class/protocols.md
+++ b/guide/src/class/protocols.md
@@ -1,50 +1,64 @@
-# Magic methods and slots
+# Class customizations
 
-Python's object model defines several protocols for different object behavior, such as the sequence, mapping, and number protocols. You may be familiar with implementing these protocols in Python classes by "magic" methods, such as `__str__` or `__repr__`. Because of the double-underscores surrounding their name, these are also known as "dunder" methods.
+Python's object model defines several protocols for different object behavior, such as the sequence, mapping, and number protocols.
+Python classes support these protocols by implementing "magic" methods, such as `__str__` or `__repr__`.
+Because of the double-underscores surrounding their name, these are also known as "dunder" methods.
 
-In the Python C-API which PyO3 is implemented upon, many of these magic methods have to be placed into special "slots" on the class type object, as covered in the previous section.
+PyO3 makes it possible for every magic method to be implemented in `#[pymethods]` just as they would be done in a regular Python class, with a few notable differences:
 
-If a function name in `#[pymethods]` is a recognised magic method, it will be automatically placed into the correct slot in the Python type object. The function name is taken from the usual rules for naming `#[pymethods]`: the `#[pyo3(name = "...")]` attribute is used if present, otherwise the Rust function name is used.
+- `__new__` and `__init__` are replaced by the [`#[new]` attribute](../class.md#constructor).
+- `__del__` is not yet supported, but may be in the future.
+- `__buffer__` and `__release_buffer__` are currently not supported and instead PyO3 supports [`__getbuffer__` and `__releasebuffer__`](#buffer-objects) methods (these predate [PEP 688](https://peps.python.org/pep-0688/#python-level-buffer-protocol)), again this may change in the future.
+- PyO3 adds [`__traverse__` and `__clear__`](#garbage-collector-integration) methods for controlling garbage collection.
+- The Python C-API which PyO3 is implemented upon requires many magic methods to have a specific function signature in C and be placed into special "slots" on the class type object.
+  This limits the allowed argument and return types for these methods.
+  They are listed in detail in the section below.
 
-The magic methods handled by PyO3 are very similar to the standard Python ones on [this page](https://docs.python.org/3/reference/datamodel.html#special-method-names) - in particular they are the the subset which have slots as [defined here](https://docs.python.org/3/c-api/typeobj.html). Some of the slots do not have a magic method in Python, which leads to a few additional magic methods defined only in PyO3:
- - Magic methods for garbage collection
- - Magic methods for the buffer protocol
+If a magic method is not on the list above (for example `__init_subclass__`), then it should just work in PyO3.
+If this is not the case, please file a bug report.
+
+## Magic Methods handled by PyO3
+
+If a function name in `#[pymethods]` is a magic method which is known to need special handling, it will be automatically placed into the correct slot in the Python type object.
+The function name is taken from the usual rules for naming `#[pymethods]`: the `#[pyo3(name = "...")]` attribute is used if present, otherwise the Rust function name is used.
+
+The magic methods handled by PyO3 are very similar to the standard Python ones on [this page](https://docs.python.org/3/reference/datamodel.html#special-method-names) - in particular they are the subset which have slots as [defined here](https://docs.python.org/3/c-api/typeobj.html).
 
 When PyO3 handles a magic method, a couple of changes apply compared to other `#[pymethods]`:
- - The Rust function signature is restricted to match the magic method.
- - The `#[pyo3(signature = (...)]` and `#[pyo3(text_signature = "...")]` attributes are not allowed.
 
-The following sections list of all magic methods PyO3 currently handles.  The
+- The Rust function signature is restricted to match the magic method.
+- The `#[pyo3(signature = (...)]` and `#[pyo3(text_signature = "...")]` attributes are not allowed.
+
+The following sections list all magic methods for which PyO3 implements the necessary special handling.  The
 given signatures should be interpreted as follows:
- - All methods take a receiver as first argument, shown as `<self>`. It can be
-   `&self`, `&mut self` or a `PyCell` reference like `self_: PyRef<'_, Self>` and
-   `self_: PyRefMut<'_, Self>`, as described [here](../class.md#inheritance).
- - An optional `Python<'py>` argument is always allowed as the first argument.
- - Return values can be optionally wrapped in `PyResult`.
- - `object` means that any type is allowed that can be extracted from a Python
+
+- All methods take a receiver as first argument, shown as `<self>`.
+   It can be `&self`, `&mut self` or a `Bound` reference like `self_: PyRef<'_, Self>` and `self_: PyRefMut<'_, Self>`, as described [here](../class.md#inheritance).
+- An optional `Python<'py>` argument is always allowed as the first argument.
+- Return values can be optionally wrapped in `PyResult`.
+- `object` means that any type is allowed that can be extracted from a Python
    object (if argument) or converted to a Python object (if return value).
- - Other types must match what's given, e.g. `pyo3::basic::CompareOp` for
+- Other types must match what's given, e.g. `pyo3::basic::CompareOp` for
    `__richcmp__`'s second argument.
- - For the comparison and arithmetic methods, extraction errors are not
+- For the comparison and arithmetic methods, extraction errors are not
    propagated as exceptions, but lead to a return of `NotImplemented`.
- - For some magic methods, the return values are not restricted by PyO3, but
-   checked by the Python interpreter. For example, `__str__` needs to return a
-   string object.  This is indicated by `object (Python type)`.
-
+- For some magic methods, the return values are not restricted by PyO3, but checked by the Python interpreter.
+   For example, `__str__` needs to return a string object.  This is indicated by `object (Python type)`.
 
 ### Basic object customization
 
-  - `__str__(<self>) -> object (str)`
-  - `__repr__(<self>) -> object (str)`
+- `__str__(<self>) -> object (str)`
+- `__repr__(<self>) -> object (str)`
 
-  - `__hash__(<self>) -> isize`
+- `__hash__(<self>) -> isize`
 
     Objects that compare equal must have the same hash value. Any type up to 64 bits may be returned instead of `isize`, PyO3 will convert to an isize automatically (wrapping unsigned types like `u64` and `usize`).
     <details>
     <summary>Disabling Python's default hash</summary>
+
     By default, all `#[pyclass]` types have a default hash implementation from Python. Types which should not be hashable can override this by setting `__hash__` to `None`. This is the same mechanism as for a pure-Python class. This is done like so:
 
-    ```rust
+    ```rust,no_run
     # use pyo3::prelude::*;
     #
     #[pyclass]
@@ -53,17 +67,18 @@ given signatures should be interpreted as follows:
     #[pymethods]
     impl NotHashable {
         #[classattr]
-        const __hash__: Option<PyObject> = None;
+        const __hash__: Option<Py<PyAny>> = None;
     }
     ```
+
     </details>
 
-  - `__lt__(<self>, object) -> object`
-  - `__le__(<self>, object) -> object`
-  - `__eq__(<self>, object) -> object`
-  - `__ne__(<self>, object) -> object`
-  - `__gt__(<self>, object) -> object`
-  - `__ge__(<self>, object) -> object`
+- `__lt__(<self>, object) -> object`
+- `__le__(<self>, object) -> object`
+- `__eq__(<self>, object) -> object`
+- `__ne__(<self>, object) -> object`
+- `__gt__(<self>, object) -> object`
+- `__ge__(<self>, object) -> object`
 
     The implementations of Python's "rich comparison" operators `<`, `<=`, `==`, `!=`, `>` and `>=` respectively.
 
@@ -73,7 +88,7 @@ given signatures should be interpreted as follows:
     The return type will normally be `bool` or `PyResult<bool>`, however any Python object can be returned.
     </details>
 
-  - `__richcmp__(<self>, object, pyo3::basic::CompareOp) -> object`
+- `__richcmp__(<self>, object, pyo3::basic::CompareOp) -> object`
 
     Implements Python comparison operations (`==`, `!=`, `<`, `<=`, `>`, and `>=`) in a single method.
     The `CompareOp` argument indicates the comparison operation being performed. You can use
@@ -89,21 +104,23 @@ given signatures should be interpreted as follows:
     If you want to leave some operations unimplemented, you can return `py.NotImplemented()`
     for some of the operations:
 
-    ```rust
+    ```rust,no_run
     use pyo3::class::basic::CompareOp;
+    use pyo3::types::PyNotImplemented;
 
     # use pyo3::prelude::*;
+    # use pyo3::BoundObject;
     #
     # #[pyclass]
     # struct Number(i32);
     #
     #[pymethods]
     impl Number {
-        fn __richcmp__(&self, other: &Self, op: CompareOp, py: Python<'_>) -> PyObject {
+        fn __richcmp__<'py>(&self, other: &Self, op: CompareOp, py: Python<'py>) -> PyResult<Borrowed<'py, 'py, PyAny>> {
             match op {
-                CompareOp::Eq => (self.0 == other.0).into_py(py),
-                CompareOp::Ne => (self.0 != other.0).into_py(py),
-                _ => py.NotImplemented(),
+                CompareOp::Eq => Ok((self.0 == other.0).into_pyobject(py)?.into_any()),
+                CompareOp::Ne => Ok((self.0 != other.0).into_pyobject(py)?.into_any()),
+                _ => Ok(PyNotImplemented::get(py).into_any()),
             }
         }
     }
@@ -113,8 +130,8 @@ given signatures should be interpreted as follows:
     signature, the generated code will automatically `return NotImplemented`.
     </details>
 
-  - `__getattr__(<self>, object) -> object`
-  - `__getattribute__(<self>, object) -> object`
+- `__getattr__(<self>, object) -> object`
+- `__getattribute__(<self>, object) -> object`
     <details>
     <summary>Differences between `__getattr__` and `__getattribute__`</summary>
     As in Python, `__getattr__` is only called if the attribute is not found
@@ -124,35 +141,37 @@ given signatures should be interpreted as follows:
     infinite recursion, and use `baseclass.__getattribute__()`.
     </details>
 
-  - `__setattr__(<self>, value: object) -> ()`
-  - `__delattr__(<self>, object) -> ()`
+- `__setattr__(<self>, value: object) -> ()`
+- `__delattr__(<self>, object) -> ()`
 
     Overrides attribute access.
 
-  - `__bool__(<self>) -> bool`
+- `__bool__(<self>) -> bool`
 
     Determines the "truthyness" of an object.
 
-  - `__call__(<self>, ...) -> object` - here, any argument list can be defined
+- `__call__(<self>, ...) -> object` - here, any argument list can be defined
     as for normal `pymethods`
 
 ### Iterable objects
 
 Iterators can be defined using these methods:
 
-  - `__iter__(<self>) -> object`
-  - `__next__(<self>) -> Option<object> or IterNextOutput` ([see details](#returning-a-value-from-iteration))
+- `__iter__(<self>) -> object`
+- `__next__(<self>) -> Option<object> or IterNextOutput` ([see details](#returning-a-value-from-iteration))
 
 Returning `None` from `__next__` indicates that that there are no further items.
 
 Example:
 
-```rust
+```rust,no_run
 use pyo3::prelude::*;
 
+use std::sync::Mutex;
+
 #[pyclass]
 struct MyIterator {
-    iter: Box<dyn Iterator<Item = PyObject> + Send>,
+    iter: Mutex<Box<dyn Iterator<Item = Py<PyAny>> + Send>>,
 }
 
 #[pymethods]
@@ -160,18 +179,17 @@ impl MyIterator {
     fn __iter__(slf: PyRef<'_, Self>) -> PyRef<'_, Self> {
         slf
     }
-    fn __next__(mut slf: PyRefMut<'_, Self>) -> Option<PyObject> {
-        slf.iter.next()
+    fn __next__(slf: PyRefMut<'_, Self>) -> Option<Py<PyAny>> {
+        slf.iter.lock().unwrap().next()
     }
 }
 ```
 
-In many cases you'll have a distinction between the type being iterated over
-(i.e. the *iterable*) and the iterator it provides. In this case, the iterable
-only needs to implement `__iter__()` while the iterator must implement both
-`__iter__()` and `__next__()`. For example:
+In many cases you'll have a distinction between the type being iterated over (i.e. the *iterable*) and the iterator it provides.
+In this case, the iterable only needs to implement `__iter__()` while the iterator must implement both `__iter__()` and `__next__()`.
+For example:
 
-```rust
+```rust,no_run
 # use pyo3::prelude::*;
 
 #[pyclass]
@@ -205,9 +223,9 @@ impl Container {
     }
 }
 
-# Python::with_gil(|py| {
+# Python::attach(|py| {
 #     let container = Container { iter: vec![1, 2, 3, 4] };
-#     let inst = pyo3::PyCell::new(py, container).unwrap();
+#     let inst = pyo3::Py::new(py, container).unwrap();
 #     pyo3::py_run!(py, inst, "assert list(inst) == [1, 2, 3, 4]");
 #     pyo3::py_run!(py, inst, "assert list(iter(iter(inst))) == [1, 2, 3, 4]");
 # });
@@ -218,38 +236,46 @@ documentation](https://docs.python.org/library/stdtypes.html#iterator-types).
 
 #### Returning a value from iteration
 
-This guide has so far shown how to use `Option<T>` to implement yielding values
-during iteration.  In Python a generator can also return a value. To express
-this in Rust, PyO3 provides the [`IterNextOutput`] enum to both `Yield` values
-and `Return` a final value - see its docs for further details and an example.
+This guide has so far shown how to use `Option<T>` to implement yielding values during iteration.  In Python a generator can also return a value.
+This is done by raising a `StopIteration` exception.
+To express this in Rust, return `PyResult::Err` with a `PyStopIteration` as the error.
 
 ### Awaitable objects
 
-  - `__await__(<self>) -> object`
-  - `__aiter__(<self>) -> object`
-  - `__anext__(<self>) -> Option<object> or IterANextOutput`
+- `__await__(<self>) -> object`
+- `__aiter__(<self>) -> object`
+- `__anext__(<self>) -> Option<object>`
 
 ### Mapping & Sequence types
 
-The magic methods in this section can be used to implement Python container types. They are two main categories of container in Python: "mappings" such as `dict`, with arbitrary keys, and "sequences" such as `list` and `tuple`, with integer keys.
+The magic methods in this section can be used to implement Python container types.
+They are two main categories of container in Python: "mappings" such as `dict`, with arbitrary keys, and "sequences" such as `list` and `tuple`, with integer keys.
+
+The Python C-API which PyO3 is built upon has separate "slots" for sequences and mappings.
+When writing a `class` in pure Python, there is no such distinction in the implementation - a `__getitem__` implementation will fill the slots for both the mapping and sequence forms, for example.
 
-The Python C-API which PyO3 is built upon has separate "slots" for sequences and mappings. When writing a `class` in pure Python, there is no such distinction in the implementation - a `__getitem__` implementation will fill the slots for both the mapping and sequence forms, for example.
+By default PyO3 reproduces the Python behaviour of filling both mapping and sequence slots.
+This makes sense for the "simple" case which matches Python, and also for sequences, where the mapping slot is used anyway to implement slice indexing.
 
-By default PyO3 reproduces the Python behaviour of filling both mapping and sequence slots. This makes sense for the "simple" case which matches Python, and also for sequences, where the mapping slot is used anyway to implement slice indexing.
+Mapping types usually will not want the sequence slots filled.
+Having them filled will lead to outcomes which may be unwanted, such as:
 
-Mapping types usually will not want the sequence slots filled. Having them filled will lead to outcomes which may be unwanted, such as:
-- The mapping type will successfully cast to [`PySequence`]. This may lead to consumers of the type handling it incorrectly.
-- Python provides a default implementation of `__iter__` for sequences, which calls `__getitem__` with consecutive positive integers starting from 0 until an `IndexError` is returned. Unless the mapping only contains consecutive positive integer keys, this `__iter__` implementation will likely not be the intended behavior.
+- The mapping type will successfully cast to [`PySequence`].
+  This may lead to consumers of the type handling it incorrectly.
+- Python provides a default implementation of `__iter__` for sequences, which calls `__getitem__` with consecutive positive integers starting from 0 until an `IndexError` is returned.
+  Unless the mapping only contains consecutive positive integer keys, this `__iter__` implementation will likely not be the intended behavior.
 
-Use the `#[pyclass(mapping)]` annotation to instruct PyO3 to only fill the mapping slots, leaving the sequence ones empty. This will apply to `__getitem__`, `__setitem__`, and `__delitem__`.
+Use the `#[pyclass(mapping)]` annotation to instruct PyO3 to only fill the mapping slots, leaving the sequence ones empty.
+This will apply to `__getitem__`, `__setitem__`, and `__delitem__`.
 
-Use the `#[pyclass(sequence)]` annotation to instruct PyO3 to fill the `sq_length` slot instead of the `mp_length` slot for `__len__`. This will help libraries such as `numpy` recognise the class as a sequence, however will also cause CPython to automatically add the sequence length to any negative indices before passing them to `__getitem__`. (`__getitem__`, `__setitem__` and `__delitem__` mapping slots are still used for sequences, for slice operations.)
+Use the `#[pyclass(sequence)]` annotation to instruct PyO3 to fill the `sq_length` slot instead of the `mp_length` slot for `__len__`.
+This will help libraries such as `numpy` recognise the class as a sequence, however will also cause CPython to automatically add the sequence length to any negative indices before passing them to `__getitem__`. (`__getitem__`, `__setitem__` and `__delitem__` mapping slots are still used for sequences, for slice operations.)
 
-  - `__len__(<self>) -> usize`
+- `__len__(<self>) -> usize`
 
     Implements the built-in function `len()`.
 
-  - `__contains__(<self>, object) -> bool`
+- `__contains__(<self>, object) -> bool`
 
     Implements membership test operators.
     Should return true if `item` is in `self`, false otherwise.
@@ -264,7 +290,7 @@ Use the `#[pyclass(sequence)]` annotation to instruct PyO3 to fill the `sq_lengt
     can override this by setting `__contains__` to `None`. This is the same
     mechanism as for a pure-Python class. This is done like so:
 
-    ```rust
+    ```rust,no_run
     # use pyo3::prelude::*;
     #
     #[pyclass]
@@ -273,12 +299,13 @@ Use the `#[pyclass(sequence)]` annotation to instruct PyO3 to fill the `sq_lengt
     #[pymethods]
     impl NoContains {
         #[classattr]
-        const __contains__: Option<PyObject> = None;
+        const __contains__: Option<Py<PyAny>> = None;
     }
     ```
+
     </details>
 
-  - `__getitem__(<self>, object) -> object`
+- `__getitem__(<self>, object) -> object`
 
     Implements retrieval of the `self[a]` element.
 
@@ -287,39 +314,39 @@ Use the `#[pyclass(sequence)]` annotation to instruct PyO3 to fill the `sq_lengt
     accessed via `PySequence::get_item`, the underlying C API already adjusts
     the index to be positive.
 
-  - `__setitem__(<self>, object, object) -> ()`
+- `__setitem__(<self>, object, object) -> ()`
 
     Implements assignment to the `self[a]` element.
     Should only be implemented if elements can be replaced.
 
     Same behavior regarding negative indices as for `__getitem__`.
 
-  - `__delitem__(<self>, object) -> ()`
+- `__delitem__(<self>, object) -> ()`
 
     Implements deletion of the `self[a]` element.
     Should only be implemented if elements can be deleted.
 
     Same behavior regarding negative indices as for `__getitem__`.
 
-  * `fn __concat__(&self, other: impl FromPyObject) -> PyResult<impl ToPyObject>`
+- `fn __concat__(&self, other: impl FromPyObject) -> PyResult<impl ToPyObject>`
 
     Concatenates two sequences.
     Used by the `+` operator, after trying the numeric addition via
     the `__add__` and `__radd__` methods.
 
-  * `fn __repeat__(&self, count: isize) -> PyResult<impl ToPyObject>`
+- `fn __repeat__(&self, count: isize) -> PyResult<impl ToPyObject>`
 
     Repeats the sequence `count` times.
     Used by the `*` operator, after trying the numeric multiplication via
     the `__mul__` and `__rmul__` methods.
 
-  * `fn __inplace_concat__(&self, other: impl FromPyObject) -> PyResult<impl ToPyObject>`
+- `fn __inplace_concat__(&self, other: impl FromPyObject) -> PyResult<impl ToPyObject>`
 
     Concatenates two sequences.
     Used by the `+=` operator, after trying the numeric addition via
     the `__iadd__` method.
 
-  * `fn __inplace_repeat__(&self, count: isize) -> PyResult<impl ToPyObject>`
+- `fn __inplace_repeat__(&self, count: isize) -> PyResult<impl ToPyObject>`
 
     Concatenates two sequences.
     Used by the `*=` operator, after trying the numeric multiplication via
@@ -327,9 +354,9 @@ Use the `#[pyclass(sequence)]` annotation to instruct PyO3 to fill the `sq_lengt
 
 ### Descriptors
 
-  - `__get__(<self>, object, object) -> object`
-  - `__set__(<self>, object, object) -> ()`
-  - `__delete__(<self>, object) -> ()`
+- `__get__(<self>, object, object) -> object`
+- `__set__(<self>, object, object) -> ()`
+- `__delete__(<self>, object) -> ()`
 
 ### Numeric types
 
@@ -339,103 +366,97 @@ Binary arithmetic operations (`+`, `-`, `*`, `@`, `/`, `//`, `%`, `divmod()`,
 (If the `object` is not of the type specified in the signature, the generated code
 will automatically `return NotImplemented`.)
 
-  - `__add__(<self>, object) -> object`
-  - `__radd__(<self>, object) -> object`
-  - `__sub__(<self>, object) -> object`
-  - `__rsub__(<self>, object) -> object`
-  - `__mul__(<self>, object) -> object`
-  - `__rmul__(<self>, object) -> object`
-  - `__matmul__(<self>, object) -> object`
-  - `__rmatmul__(<self>, object) -> object`
-  - `__floordiv__(<self>, object) -> object`
-  - `__rfloordiv__(<self>, object) -> object`
-  - `__truediv__(<self>, object) -> object`
-  - `__rtruediv__(<self>, object) -> object`
-  - `__divmod__(<self>, object) -> object`
-  - `__rdivmod__(<self>, object) -> object`
-  - `__mod__(<self>, object) -> object`
-  - `__rmod__(<self>, object) -> object`
-  - `__lshift__(<self>, object) -> object`
-  - `__rlshift__(<self>, object) -> object`
-  - `__rshift__(<self>, object) -> object`
-  - `__rrshift__(<self>, object) -> object`
-  - `__and__(<self>, object) -> object`
-  - `__rand__(<self>, object) -> object`
-  - `__xor__(<self>, object) -> object`
-  - `__rxor__(<self>, object) -> object`
-  - `__or__(<self>, object) -> object`
-  - `__ror__(<self>, object) -> object`
-  - `__pow__(<self>, object, object) -> object`
-  - `__rpow__(<self>, object, object) -> object`
+- `__add__(<self>, object) -> object`
+- `__radd__(<self>, object) -> object`
+- `__sub__(<self>, object) -> object`
+- `__rsub__(<self>, object) -> object`
+- `__mul__(<self>, object) -> object`
+- `__rmul__(<self>, object) -> object`
+- `__matmul__(<self>, object) -> object`
+- `__rmatmul__(<self>, object) -> object`
+- `__floordiv__(<self>, object) -> object`
+- `__rfloordiv__(<self>, object) -> object`
+- `__truediv__(<self>, object) -> object`
+- `__rtruediv__(<self>, object) -> object`
+- `__divmod__(<self>, object) -> object`
+- `__rdivmod__(<self>, object) -> object`
+- `__mod__(<self>, object) -> object`
+- `__rmod__(<self>, object) -> object`
+- `__lshift__(<self>, object) -> object`
+- `__rlshift__(<self>, object) -> object`
+- `__rshift__(<self>, object) -> object`
+- `__rrshift__(<self>, object) -> object`
+- `__and__(<self>, object) -> object`
+- `__rand__(<self>, object) -> object`
+- `__xor__(<self>, object) -> object`
+- `__rxor__(<self>, object) -> object`
+- `__or__(<self>, object) -> object`
+- `__ror__(<self>, object) -> object`
+- `__pow__(<self>, object, object) -> object`
+- `__rpow__(<self>, object, object) -> object`
 
 In-place assignment operations (`+=`, `-=`, `*=`, `@=`, `/=`, `//=`, `%=`,
 `**=`, `<<=`, `>>=`, `&=`, `^=`, `|=`):
 
-  - `__iadd__(<self>, object) -> ()`
-  - `__isub__(<self>, object) -> ()`
-  - `__imul__(<self>, object) -> ()`
-  - `__imatmul__(<self>, object) -> ()`
-  - `__itruediv__(<self>, object) -> ()`
-  - `__ifloordiv__(<self>, object) -> ()`
-  - `__imod__(<self>, object) -> ()`
-  - `__ipow__(<self>, object, object) -> ()`
-  - `__ilshift__(<self>, object) -> ()`
-  - `__irshift__(<self>, object) -> ()`
-  - `__iand__(<self>, object) -> ()`
-  - `__ixor__(<self>, object) -> ()`
-  - `__ior__(<self>, object) -> ()`
+- `__iadd__(<self>, object) -> ()`
+- `__isub__(<self>, object) -> ()`
+- `__imul__(<self>, object) -> ()`
+- `__imatmul__(<self>, object) -> ()`
+- `__itruediv__(<self>, object) -> ()`
+- `__ifloordiv__(<self>, object) -> ()`
+- `__imod__(<self>, object) -> ()`
+- `__ipow__(<self>, object, object) -> ()`
+- `__ilshift__(<self>, object) -> ()`
+- `__irshift__(<self>, object) -> ()`
+- `__iand__(<self>, object) -> ()`
+- `__ixor__(<self>, object) -> ()`
+- `__ior__(<self>, object) -> ()`
 
 Unary operations (`-`, `+`, `abs()` and `~`):
 
-  - `__pos__(<self>) -> object`
-  - `__neg__(<self>) -> object`
-  - `__abs__(<self>) -> object`
-  - `__invert__(<self>) -> object`
+- `__pos__(<self>) -> object`
+- `__neg__(<self>) -> object`
+- `__abs__(<self>) -> object`
+- `__invert__(<self>) -> object`
 
 Coercions:
 
-  - `__index__(<self>) -> object (int)`
-  - `__int__(<self>) -> object (int)`
-  - `__float__(<self>) -> object (float)`
+- `__index__(<self>) -> object (int)`
+- `__int__(<self>) -> object (int)`
+- `__float__(<self>) -> object (float)`
 
 ### Buffer objects
 
-  - `__getbuffer__(<self>, *mut ffi::Py_buffer, flags) -> ()`
-  - `__releasebuffer__(<self>, *mut ffi::Py_buffer) -> ()`
-    Errors returned from `__releasebuffer__` will be sent to `sys.unraiseablehook`. It is strongly advised to never return an error from `__releasebuffer__`, and if it really is necessary, to make best effort to perform any required freeing operations before returning. `__releasebuffer__` will not be called a second time; anything not freed will be leaked.
+- `__getbuffer__(<self>, *mut ffi::Py_buffer, flags) -> ()`
+- `__releasebuffer__(<self>, *mut ffi::Py_buffer) -> ()` Errors returned from `__releasebuffer__` will be sent to `sys.unraiseablehook`.
+    It is strongly advised to never return an error from `__releasebuffer__`, and if it really is necessary, to make best effort to perform any required freeing operations before returning. `__releasebuffer__` will not be called a second time; anything not freed will be leaked.
 
 ### Garbage Collector Integration
 
-If your type owns references to other Python objects, you will need to integrate
-with Python's garbage collector so that the GC is aware of those references.  To
-do this, implement the two methods `__traverse__` and `__clear__`.  These
-correspond to the slots `tp_traverse` and `tp_clear` in the Python C API.
-`__traverse__` must call `visit.call()` for each reference to another Python
-object.  `__clear__` must clear out any mutable references to other Python
-objects (thus breaking reference cycles). Immutable references do not have to be
-cleared, as every cycle must contain at least one mutable reference.
+If your type owns references to other Python objects, you will need to integrate with Python's garbage collector so that the GC is aware of those references.  To do this, implement the two methods `__traverse__` and `__clear__`.  These correspond to the slots `tp_traverse` and `tp_clear` in the Python C API. `__traverse__` must call `visit.call()` for each reference to another Python object.  `__clear__` must clear out any mutable references to other Python objects (thus breaking reference cycles).
+Immutable references do not have to be cleared, as every cycle must contain at least one mutable reference.
+
+- `__traverse__(<self>, pyo3::class::gc::PyVisit<'_>) -> Result<(), pyo3::class::gc::PyTraverseError>`
+- `__clear__(<self>) -> ()`
 
-  - `__traverse__(<self>, pyo3::class::gc::PyVisit<'_>) -> Result<(), pyo3::class::gc::PyTraverseError>`
-  - `__clear__(<self>) -> ()`
+> Note: `__traverse__` does not work with [`#[pyo3(warn(...))]`](../function.md#warn).
 
 Example:
 
-```rust
+```rust,no_run
 use pyo3::prelude::*;
 use pyo3::PyTraverseError;
 use pyo3::gc::PyVisit;
 
 #[pyclass]
 struct ClassWithGCSupport {
-    obj: Option<PyObject>,
+    obj: Option<Py<PyAny>>,
 }
 
 #[pymethods]
 impl ClassWithGCSupport {
     fn __traverse__(&self, visit: PyVisit<'_>) -> Result<(), PyTraverseError> {
-        if let Some(obj) = &self.obj {
-            visit.call(obj)?
-        }
+        visit.call(&self.obj)?;
         Ok(())
     }
 
@@ -447,11 +468,11 @@ impl ClassWithGCSupport {
 ```
 
 Usually, an implementation of `__traverse__` should do nothing but calls to `visit.call`.
-Most importantly, safe access to the GIL is prohibited inside implementations of `__traverse__`,
-i.e. `Python::with_gil` will panic.
+Most importantly, safe access to the interpreter is prohibited inside implementations of `__traverse__`,
+i.e. `Python::attach` will panic.
 
-> Note: these methods are part of the C API, PyPy does not necessarily honor them. If you are building for PyPy you should measure memory consumption to make sure you do not have runaway memory growth. See [this issue on the PyPy bug tracker](https://foss.heptapod.net/pypy/pypy/-/issues/3899).
+> Note: these methods are part of the C API, PyPy does not necessarily honor them. If you are building for PyPy you should measure memory consumption to make sure you do not have runaway memory growth. See [this issue on the PyPy bug tracker](https://github.com/pypy/pypy/issues/3848).
 
-[`IterNextOutput`]: {{#PYO3_DOCS_URL}}/pyo3/pyclass/enum.IterNextOutput.html
 [`PySequence`]: {{#PYO3_DOCS_URL}}/pyo3/types/struct.PySequence.html
+<!-- rumdl-disable-next-line MD053 - false positive -->
 [`CompareOp::matches`]: {{#PYO3_DOCS_URL}}/pyo3/pyclass/enum.CompareOp.html#method.matches
diff --git a/guide/src/class/thread-safety.md b/guide/src/class/thread-safety.md
new file mode 100644
index 00000000000..eb2b029617f
--- /dev/null
+++ b/guide/src/class/thread-safety.md
@@ -0,0 +1,121 @@
+# `#[pyclass]` thread safety
+
+Python objects are freely shared between threads by the Python interpreter.
+This means that:
+
+- there is no control which thread might eventually drop the `#[pyclass]` object, meaning `Send` is required.
+- multiple threads can potentially be reading the `#[pyclass]` data simultaneously, meaning `Sync` is required.
+
+This section of the guide discusses various data structures which can be used to make types satisfy these requirements.
+
+In special cases where it is known that your Python application is never going to use threads (this is rare!), these thread-safety requirements can be opted-out with [`#[pyclass(unsendable)]`](../class.md#customizing-the-class), at the cost of making concurrent access to the Rust data be runtime errors.
+This is only for very specific use cases; it is almost always better to make proper thread-safe types.
+
+## Making `#[pyclass]` types thread-safe
+
+The general challenge with thread-safety is to make sure that two threads cannot produce a data race, i.e. unsynchronized writes to the same data at the same time.
+A data race produces an unpredictable result and is forbidden by Rust.
+
+By default, `#[pyclass]` employs an ["interior mutability" pattern](../class.md#bound-and-interior-mutability) to allow for either multiple `&T` references or a single exclusive `&mut T` reference to access the data.
+This allows for simple `#[pyclass]` types to be thread-safe automatically, at the cost of runtime checking for concurrent access.
+Errors will be raised if the usage overlaps.
+
+For example, the below simple class is thread-safe:
+
+```rust,no_run
+# use pyo3::prelude::*;
+
+#[pyclass]
+struct MyClass {
+    x: i32,
+    y: i32,
+}
+
+#[pymethods]
+impl MyClass {
+    fn get_x(&self) -> i32 {
+        self.x
+    }
+
+    fn set_y(&mut self, value: i32) {
+        self.y = value;
+    }
+}
+```
+
+In the above example, if calls to `get_x` and `set_y` overlap (from two different threads) then at least one of those threads will experience a runtime error indicating that the data was "already borrowed".
+
+To avoid these errors, you can take control of the interior mutability yourself in one of the following ways.
+
+### Using atomic data structures
+
+To remove the possibility of having overlapping `&self` and `&mut self` references produce runtime errors, consider using `#[pyclass(frozen)]` and use [atomic data structures](https://doc.rust-lang.org/std/sync/atomic/) to control modifications directly.
+
+For example, a thread-safe version of the above `MyClass` using atomic integers would be as follows:
+
+```rust,no_run
+# use pyo3::prelude::*;
+use std::sync::atomic::{AtomicI32, Ordering};
+
+#[pyclass(frozen)]
+struct MyClass {
+    x: AtomicI32,
+    y: AtomicI32,
+}
+
+#[pymethods]
+impl MyClass {
+    fn get_x(&self) -> i32 {
+        self.x.load(Ordering::Relaxed)
+    }
+
+    fn set_y(&self, value: i32) {
+        self.y.store(value, Ordering::Relaxed)
+    }
+}
+```
+
+### Using locks
+
+An alternative to atomic data structures is to use [locks](https://doc.rust-lang.org/std/sync/struct.Mutex.html) to make threads wait for access to shared data.
+
+For example, a thread-safe version of the above `MyClass` using locks would be as follows:
+
+```rust,no_run
+# use pyo3::prelude::*;
+use std::sync::Mutex;
+
+struct MyClassInner {
+    x: i32,
+    y: i32,
+}
+
+#[pyclass(frozen)]
+struct MyClass {
+    inner: Mutex<MyClassInner>
+}
+
+#[pymethods]
+impl MyClass {
+    fn get_x(&self) -> i32 {
+        self.inner.lock().expect("lock not poisoned").x
+    }
+
+    fn set_y(&self, value: i32) {
+        self.inner.lock().expect("lock not poisoned").y = value;
+    }
+}
+```
+
+If you need to lock around state stored in the Python interpreter or otherwise call into the Python C API while a lock is held, you might find the `MutexExt` trait useful.
+It provides a `lock_py_attached` method for `std::sync::Mutex` that avoids deadlocks with the GIL or other global synchronization events in the interpreter.
+Additionally, support for the `parking_lot` and `lock_api` synchronization libraries is gated behind the `parking_lot` and `lock_api` features.
+You can also enable the `arc_lock` feature if you need the `arc_lock` features of either library.
+
+### Wrapping unsynchronized data
+
+In some cases, the data structures stored within a `#[pyclass]` may themselves not be thread-safe.
+Rust will therefore not implement `Send` and `Sync` on the `#[pyclass]` type.
+
+To achieve thread-safety, a manual `Send` and `Sync` implementation is required which is `unsafe` and should only be done following careful review of the soundness of the implementation.
+Doing this for PyO3 types is no different than for any other Rust code, [the Rustonomicon](https://doc.rust-lang.org/nomicon/send-and-sync.html) has a great discussion on this.
diff --git a/guide/src/conversions.md b/guide/src/conversions.md
index 991c2061042..ee8dfddebb0 100644
--- a/guide/src/conversions.md
+++ b/guide/src/conversions.md
@@ -1,3 +1,5 @@
 # Type conversions
 
 In this portion of the guide we'll talk about the mapping of Python types to Rust types offered by PyO3, as well as the traits available to perform conversions between them.
+
+See also the conversion [tables](conversions/tables.md) and [traits](conversions/traits.md).
diff --git a/guide/src/conversions/tables.md b/guide/src/conversions/tables.md
index b0582431156..1cec2767447 100644
--- a/guide/src/conversions/tables.md
+++ b/guide/src/conversions/tables.md
@@ -1,10 +1,10 @@
-## Mapping of Rust types to Python types
+# Mapping of Rust types to Python types
 
-When writing functions callable from Python (such as a `#[pyfunction]` or in a `#[pymethods]` block), the trait `FromPyObject` is required for function arguments, and `IntoPy<PyObject>` is required for function return values.
+When writing functions callable from Python (such as a `#[pyfunction]` or in a `#[pymethods]` block), the trait `FromPyObject` is required for function arguments, and `IntoPyObject` is required for function return values.
 
 Consult the tables in the following section to find the Rust types provided by PyO3 which implement these traits.
 
-### Argument Types
+## Argument Types
 
 When accepting a function argument, it is possible to either use Rust library types or PyO3's Python-native types. (See the next section for discussion on when to use each.)
 
@@ -12,71 +12,79 @@ The table below contains the Python type and the corresponding function argument
 
 | Python        | Rust                            | Rust (Python-native) |
 | ------------- |:-------------------------------:|:--------------------:|
-| `object`      | -                               | `&PyAny`             |
-| `str`         | `String`, `Cow<str>`, `&str`, `char`, `OsString`, `PathBuf`, `Path` | `&PyString`, `&PyUnicode` |
-| `bytes`       | `Vec<u8>`, `&[u8]`, `Cow<[u8]>` | `&PyBytes`           |
-| `bool`        | `bool`                          | `&PyBool`            |
-| `int`         | `i8`, `u8`, `i16`, `u16`, `i32`, `u32`, `i64`, `u64`, `i128`, `u128`, `isize`, `usize`, `num_bigint::BigInt`[^1], `num_bigint::BigUint`[^1] | `&PyLong` |
-| `float`       | `f32`, `f64`                    | `&PyFloat`           |
-| `complex`     | `num_complex::Complex`[^2]      | `&PyComplex`         |
-| `list[T]`     | `Vec<T>`                        | `&PyList`            |
-| `dict[K, V]`  | `HashMap<K, V>`, `BTreeMap<K, V>`, `hashbrown::HashMap<K, V>`[^3], `indexmap::IndexMap<K, V>`[^4] | `&PyDict` |
-| `tuple[T, U]` | `(T, U)`, `Vec<T>`              | `&PyTuple`           |
-| `set[T]`      | `HashSet<T>`, `BTreeSet<T>`, `hashbrown::HashSet<T>`[^3] | `&PySet` |
-| `frozenset[T]` | `HashSet<T>`, `BTreeSet<T>`, `hashbrown::HashSet<T>`[^3] | `&PyFrozenSet` |
-| `bytearray`   | `Vec<u8>`, `Cow<[u8]>`          | `&PyByteArray`       |
-| `slice`       | -                               | `&PySlice`           |
-| `type`        | -                               | `&PyType`            |
-| `module`      | -                               | `&PyModule`          |
+| `object`      | -                               | `PyAny`             |
+| `str`         | `String`, `Cow<str>`, `&str`, `char`, `OsString`, `PathBuf`, `Path` | `PyString` |
+| `bytes`       | `Vec<u8>`, `&[u8]`, `Cow<[u8]>` | `PyBytes`           |
+| `bool`        | `bool`                          | `PyBool`            |
+| `int`         | `i8`, `u8`, `i16`, `u16`, `i32`, `u32`, `i64`, `u64`, `i128`, `u128`, `isize`, `usize`, `num_bigint::BigInt`[^1], `num_bigint::BigUint`[^1] | `PyInt` |
+| `float`       | `f32`, `f64`, `ordered_float::NotNan`[^10], `ordered_float::OrderedFloat`[^10]                    | `PyFloat`           |
+| `complex`     | `num_complex::Complex`[^2]      | `PyComplex`         |
+| `fractions.Fraction`| `num_rational::Ratio`[^8] | -         |
+| `list[T]`     | `Vec<T>`                        | `PyList`            |
+| `dict[K, V]`  | `HashMap<K, V>`, `BTreeMap<K, V>`, `hashbrown::HashMap<K, V>`[^3], `indexmap::IndexMap<K, V>`[^4] | `PyDict` |
+| `tuple[T, U]` | `(T, U)`, `Vec<T>`              | `PyTuple`           |
+| `set[T]`      | `HashSet<T>`, `BTreeSet<T>`, `hashbrown::HashSet<T>`[^3] | `PySet` |
+| `frozenset[T]` | `HashSet<T>`, `BTreeSet<T>`, `hashbrown::HashSet<T>`[^3] | `PyFrozenSet` |
+| `bytearray`   | `Vec<u8>`, `Cow<[u8]>`          | `PyByteArray`       |
+| `slice`       | -                               | `PySlice`           |
+| `type`        | -                               | `PyType`            |
+| `module`      | -                               | `PyModule`          |
 | `collections.abc.Buffer` | -                    | `PyBuffer<T>`        |
-| `datetime.datetime` | `SystemTime`, `chrono::DateTime<Tz>`[^5], `chrono::NaiveDateTime`[^5] | `&PyDateTime`        |
-| `datetime.date` | `chrono::NaiveDate`[^5]       | `&PyDate`            |
-| `datetime.time` | `chrono::NaiveTime`[^5]       | `&PyTime`            |
-| `datetime.tzinfo` | `chrono::FixedOffset`[^5], `chrono::Utc`[^5], `chrono_tz::TimeZone`[^6] | `&PyTzInfo`          |
-| `datetime.timedelta` | `Duration`, `chrono::Duration`[^5] | `&PyDelta`           |
+| `datetime.datetime` | `SystemTime`, `chrono::DateTime<Tz>`[^5], `chrono::NaiveDateTime`[^5] | `PyDateTime`        |
+| `datetime.date` | `chrono::NaiveDate`[^5]       | `PyDate`            |
+| `datetime.time` | `chrono::NaiveTime`[^5]       | `PyTime`            |
+| `datetime.tzinfo` | `chrono::FixedOffset`[^5], `chrono::Utc`[^5], `chrono_tz::TimeZone`[^6] | `PyTzInfo`          |
+| `datetime.timedelta` | `Duration`, `chrono::Duration`[^5] | `PyDelta`           |
 | `decimal.Decimal` | `rust_decimal::Decimal`[^7] | -                    |
-| `ipaddress.IPv4Address` | `std::net::IpAddr`, `std::net::IpV4Addr` | - |
-| `ipaddress.IPv6Address` | `std::net::IpAddr`, `std::net::IpV6Addr` | - |
-| `os.PathLike ` | `PathBuf`, `Path`              | `&PyString`, `&PyUnicode` |
-| `pathlib.Path` | `PathBuf`, `Path`              | `&PyString`, `&PyUnicode` |
+| `decimal.Decimal` | `bigdecimal::BigDecimal`[^9] | -                   |
+| `ipaddress.IPv4Address` | `std::net::IpAddr`, `std::net::Ipv4Addr` | - |
+| `ipaddress.IPv6Address` | `std::net::IpAddr`, `std::net::Ipv6Addr` | - |
+| `os.PathLike` | `PathBuf`, `Path`              | `PyString` |
+| `pathlib.Path` | `PathBuf`, `Path`              | `PyString` |
 | `typing.Optional[T]` | `Option<T>`              | -                    |
-| `typing.Sequence[T]` | `Vec<T>`                 | `&PySequence`        |
+| `typing.Sequence[T]` | `Vec<T>`                 | `PySequence`        |
 | `typing.Mapping[K, V]` | `HashMap<K, V>`, `BTreeMap<K, V>`, `hashbrown::HashMap<K, V>`[^3], `indexmap::IndexMap<K, V>`[^4] | `&PyMapping` |
-| `typing.Iterator[Any]` | -                      | `&PyIterator`        |
-| `typing.Union[...]` | See [`#[derive(FromPyObject)]`](traits.html#deriving-a-hrefhttpsdocsrspyo3latestpyo3conversiontraitfrompyobjecthtmlfrompyobjecta-for-enums) | - |
+| `typing.Iterator[Any]` | -                      | `PyIterator`        |
+| `typing.Union[...]` | See [`#[derive(FromPyObject)]`](traits.md#deriving-frompyobject-for-enums) | - |
 
-There are also a few special types related to the GIL and Rust-defined `#[pyclass]`es which may come in useful:
+It is also worth remembering the following special types:
 
-| What          | Description |
-| ------------- | ------------------------------------- |
-| `Python`      | A GIL token, used to pass to PyO3 constructors to prove ownership of the GIL |
-| `Py<T>`       | A Python object isolated from the GIL lifetime. This can be sent to other threads. |
-| `PyObject`    | An alias for `Py<PyAny>`              |
-| `&PyCell<T>`  | A `#[pyclass]` value owned by Python. |
-| `PyRef<T>`    | A `#[pyclass]` borrowed immutably.    |
-| `PyRefMut<T>` | A `#[pyclass]` borrowed mutably.      |
+| What             | Description                           |
+| ---------------- | ------------------------------------- |
+| `Python<'py>`    | A token used to prove attachment to the Python interpreter. |
+| `Bound<'py, T>`  | A Python object with a lifetime which binds it to the attachment to the Python interpreter. This provides access to most of PyO3's APIs. |
+| `Py<T>`          | A Python object not connected to any lifetime of attachment to the Python interpreter. This can be sent to other threads. |
+| `PyRef<T>`       | A `#[pyclass]` borrowed immutably.    |
+| `PyRefMut<T>`    | A `#[pyclass]` borrowed mutably.      |
 
 For more detail on accepting `#[pyclass]` values as function arguments, see [the section of this guide on Python Classes](../class.md).
 
-#### Using Rust library types vs Python-native types
+### Using Rust library types vs Python-native types
 
-Using Rust library types as function arguments will incur a conversion cost compared to using the Python-native types. Using the Python-native types is almost zero-cost (they just require a type check similar to the Python builtin function `isinstance()`).
+Using Rust library types as function arguments will incur a conversion cost compared to using the Python-native types.
+Using the Python-native types is almost zero-cost (they just require a type check similar to the Python builtin function `isinstance()`).
 
 However, once that conversion cost has been paid, the Rust standard library types offer a number of benefits:
+
 - You can write functionality in native-speed Rust code (free of Python's runtime costs).
 - You get better interoperability with the rest of the Rust ecosystem.
-- You can use `Python::allow_threads` to release the Python GIL and let other Python threads make progress while your Rust code is executing.
-- You also benefit from stricter type checking. For example you can specify `Vec<i32>`, which will only accept a Python `list` containing integers. The Python-native equivalent, `&PyList`, would accept a Python `list` containing Python objects of any type.
+- You can use `Python::detach` to detach from the interpreter and let other Python threads make progress while your Rust code is executing.
+- You also benefit from stricter type checking.
+  For example you can specify `Vec<i32>`, which will only accept a Python `list` containing integers.
+  The Python-native equivalent, `&PyList`, would accept a Python `list` containing Python objects of any type.
 
-For most PyO3 usage the conversion cost is worth paying to get these benefits. As always, if you're not sure it's worth it in your case, benchmark it!
+For most PyO3 usage the conversion cost is worth paying to get these benefits.
+As always, if you're not sure it's worth it in your case, benchmark it!
 
-### Returning Rust values to Python
+## Returning Rust values to Python
 
-When returning values from functions callable from Python, Python-native types (`&PyAny`, `&PyDict` etc.) can be used with zero cost.
+When returning values from functions callable from Python, [PyO3's smart pointers](../types.md#pyo3s-smart-pointers) (`Py<T>`, `Bound<'py, T>`, and `Borrowed<'a, 'py, T>`) can be used with zero cost.
 
-Because these types are references, in some situations the Rust compiler may ask for lifetime annotations. If this is the case, you should use `Py<PyAny>`, `Py<PyDict>` etc. instead - which are also zero-cost. For all of these Python-native types `T`, `Py<T>` can be created from `T` with an `.into()` conversion.
+Because `Bound<'py, T>` and `Borrowed<'a, 'py, T>` have lifetime parameters, the Rust compiler may ask for lifetime annotations to be added to your function.
+See the [section of the guide dedicated to this](../types.md#function-argument-lifetimes).
 
-If your function is fallible, it should return `PyResult<T>` or `Result<T, E>` where `E` implements `From<E> for PyErr`. This will raise a `Python` exception if the `Err` variant is returned.
+If your function is fallible, it should return `PyResult<T>` or `Result<T, E>` where `E` implements `From<E> for PyErr`.
+This will raise a `Python` exception if the `Err` variant is returned.
 
 Finally, the following Rust types are also able to convert to Python as return values:
 
@@ -95,7 +103,8 @@ Finally, the following Rust types are also able to convert to Python as return v
 | `BTreeMap<K, V>` | `Dict[K, V]`                 |
 | `HashSet<T>`  | `Set[T]`                        |
 | `BTreeSet<T>` | `Set[T]`                        |
-| `&PyCell<T: PyClass>` | `T`                     |
+| `Py<T>` | `T`                                   |
+| `Bound<T>` | `T`                                |
 | `PyRef<T: PyClass>` | `T`                       |
 | `PyRefMut<T: PyClass>` | `T`                    |
 
@@ -107,8 +116,14 @@ Finally, the following Rust types are also able to convert to Python as return v
 
 [^4]: Requires the `indexmap` optional feature.
 
-[^5]: Requires the `chrono` optional feature.
+[^5]: Requires the `chrono` (and maybe `chrono-local`) optional feature(s).
 
 [^6]: Requires the `chrono-tz` optional feature.
 
 [^7]: Requires the `rust_decimal` optional feature.
+
+[^8]: Requires the `num-rational` optional feature.
+
+[^9]: Requires the `bigdecimal` optional feature.
+
+[^10]: Requires the `ordered-float` optional feature.
diff --git a/guide/src/conversions/traits.md b/guide/src/conversions/traits.md
index b46e5c02f4c..d1cacf73591 100644
--- a/guide/src/conversions/traits.md
+++ b/guide/src/conversions/traits.md
@@ -1,8 +1,8 @@
-## Conversion traits
+# Conversion traits
 
 PyO3 provides some handy traits to convert between Python types and Rust types.
 
-### `.extract()` and the `FromPyObject` trait
+## `.extract()` and the `FromPyObject` trait
 
 The easiest way to convert a Python object to a Rust value is using
 `.extract()`.  It returns a `PyResult` with a type error if the conversion
@@ -12,8 +12,8 @@ fails, so usually you will use something like
 # use pyo3::prelude::*;
 # use pyo3::types::PyList;
 # fn main() -> PyResult<()> {
-#     Python::with_gil(|py| {
-#         let list = PyList::new_bound(py, b"foo");
+#     Python::attach(|py| {
+#         let list = PyList::new(py, b"foo")?;
 let v: Vec<i32> = list.extract()?;
 #         assert_eq!(&v, &[102, 111, 111]);
 #         Ok(())
@@ -32,14 +32,13 @@ mutable references, you have to extract the PyO3 reference wrappers [`PyRef`]
 and [`PyRefMut`].  They work like the reference wrappers of
 `std::cell::RefCell` and ensure (at runtime) that Rust borrows are allowed.
 
-#### Deriving [`FromPyObject`]
+### Deriving [`FromPyObject`]
 
-[`FromPyObject`] can be automatically derived for many kinds of structs and enums
-if the member types themselves implement `FromPyObject`. This even includes members
-with a generic type `T: FromPyObject`. Derivation for empty enums, enum variants and
-structs is not supported.
+[`FromPyObject`] can be automatically derived for many kinds of structs and enums if the member types themselves implement `FromPyObject`.
+This even includes members with a generic type `T: FromPyObject`.
+Derivation for empty enums, enum variants and structs is not supported.
 
-#### Deriving [`FromPyObject`] for structs
+### Deriving [`FromPyObject`] for structs
 
 The derivation generates code that will attempt to access the attribute  `my_string` on
 the Python object, i.e. `obj.getattr("my_string")`, and call `extract()` on the attribute.
@@ -53,14 +52,14 @@ struct RustyStruct {
 }
 #
 # fn main() -> PyResult<()> {
-#     Python::with_gil(|py| -> PyResult<()> {
+#     Python::attach(|py| -> PyResult<()> {
 #         let module = PyModule::from_code(
 #             py,
-#             "class Foo:
+#             c"class Foo:
 #             def __init__(self):
 #                 self.my_string = 'test'",
-#             "",
-#             "",
+#             c"<string>",
+#             c"",
 #         )?;
 #
 #         let class = module.getattr("Foo")?;
@@ -85,8 +84,8 @@ struct RustyStruct {
 #
 # use pyo3::types::PyDict;
 # fn main() -> PyResult<()> {
-#     Python::with_gil(|py| -> PyResult<()> {
-#         let dict = PyDict::new_bound(py);
+#     Python::attach(|py| -> PyResult<()> {
+#         let dict = PyDict::new(py);
 #         dict.set_item("my_string", "test")?;
 #
 #         let rustystruct: RustyStruct = dict.extract()?;
@@ -110,15 +109,15 @@ struct RustyStruct {
 }
 #
 # fn main() -> PyResult<()> {
-#     Python::with_gil(|py| -> PyResult<()> {
+#     Python::attach(|py| -> PyResult<()> {
 #         let module = PyModule::from_code(
 #             py,
-#             "class Foo(dict):
+#             c"class Foo(dict):
 #             def __init__(self):
 #                 self.name = 'test'
 #                 self['key'] = 'test2'",
-#             "",
-#             "",
+#             c"<string>",
+#             c"",
 #         )?;
 #
 #         let class = module.getattr("Foo")?;
@@ -132,10 +131,8 @@ struct RustyStruct {
 # }
 ```
 
-This tries to extract `string_attr` from the attribute `name` and `string_in_mapping`
-from a mapping with the key `"key"`. The arguments for `attribute` are restricted to
-non-empty string literals while `item` can take any valid literal that implements
-`ToBorrowedObject`.
+This tries to extract `string_attr` from the attribute `name` and `string_in_mapping` from a mapping with the key `"key"`.
+The arguments for `attribute` are restricted to non-empty string literals while `item` can take any valid literal that implements `ToBorrowedObject`.
 
 You can use `#[pyo3(from_item_all)]` on a struct to extract every field with `get_item` method.
 In this case, you can't use `#[pyo3(attribute)]` or barely use `#[pyo3(item)]` on any field.
@@ -154,8 +151,8 @@ struct RustyStruct {
 }
 #
 # fn main() -> PyResult<()> {
-#     Python::with_gil(|py| -> PyResult<()> {
-#         let py_dict = py.eval_bound("{'foo': 'foo', 'bar': 'bar', 'foobar': 'foobar'}", None, None)?;
+#     Python::attach(|py| -> PyResult<()> {
+#         let py_dict = py.eval(c"{'foo': 'foo', 'bar': 'bar', 'foobar': 'foobar'}", None, None)?;
 #         let rustystruct: RustyStruct = py_dict.extract()?;
 # 		  assert_eq!(rustystruct.foo, "foo");
 #         assert_eq!(rustystruct.bar, "bar");
@@ -166,11 +163,10 @@ struct RustyStruct {
 # }
 ```
 
-#### Deriving [`FromPyObject`] for tuple structs
+### Deriving [`FromPyObject`] for tuple structs
 
-Tuple structs are also supported but do not allow customizing the extraction. The input is
-always assumed to be a Python tuple with the same length as the Rust type, the `n`th field
-is extracted from the `n`th item in the Python tuple.
+Tuple structs are also supported but do not allow customizing the extraction.
+The input is always assumed to be a Python tuple with the same length as the Rust type, the `n`th field is extracted from the `n`th item in the Python tuple.
 
 ```rust
 use pyo3::prelude::*;
@@ -180,8 +176,8 @@ struct RustyTuple(String, String);
 
 # use pyo3::types::PyTuple;
 # fn main() -> PyResult<()> {
-#     Python::with_gil(|py| -> PyResult<()> {
-#         let tuple = PyTuple::new_bound(py, vec!["test", "test2"]);
+#     Python::attach(|py| -> PyResult<()> {
+#         let tuple = PyTuple::new(py, vec!["test", "test2"])?;
 #
 #         let rustytuple: RustyTuple = tuple.extract()?;
 #         assert_eq!(rustytuple.0, "test");
@@ -192,9 +188,9 @@ struct RustyTuple(String, String);
 # }
 ```
 
-Tuple structs with a single field are treated as wrapper types which are described in the
-following section. To override this behaviour and ensure that the input is in fact a tuple,
-specify the struct as
+Tuple structs with a single field are treated as wrapper types which are described in the following section.
+To override this behaviour and ensure that the input is in fact a tuple, specify the struct as
+
 ```rust
 use pyo3::prelude::*;
 
@@ -203,8 +199,8 @@ struct RustyTuple((String,));
 
 # use pyo3::types::PyTuple;
 # fn main() -> PyResult<()> {
-#     Python::with_gil(|py| -> PyResult<()> {
-#         let tuple = PyTuple::new_bound(py, vec!["test"]);
+#     Python::attach(|py| -> PyResult<()> {
+#         let tuple = PyTuple::new(py, vec!["test"])?;
 #
 #         let rustytuple: RustyTuple = tuple.extract()?;
 #         assert_eq!((rustytuple.0).0, "test");
@@ -214,12 +210,11 @@ struct RustyTuple((String,));
 # }
 ```
 
-#### Deriving [`FromPyObject`] for wrapper types
+### Deriving [`FromPyObject`] for wrapper types
 
-The `pyo3(transparent)` attribute can be used on structs with exactly one field. This results
-in extracting directly from the input object, i.e. `obj.extract()`, rather than trying to access
-an item or attribute. This behaviour is enabled per default for newtype structs and tuple-variants
-with a single field.
+The `pyo3(transparent)` attribute can be used on structs with exactly one field.
+This results in extracting directly from the input object, i.e. `obj.extract()`, rather than trying to access an item or attribute.
+This behaviour is enabled per default for newtype structs and tuple-variants with a single field.
 
 ```rust
 use pyo3::prelude::*;
@@ -235,8 +230,8 @@ struct RustyTransparentStruct {
 
 # use pyo3::types::PyString;
 # fn main() -> PyResult<()> {
-#     Python::with_gil(|py| -> PyResult<()> {
-#         let s = PyString::new_bound(py, "test");
+#     Python::attach(|py| -> PyResult<()> {
+#         let s = PyString::new(py, "test");
 #
 #         let tup: RustyTransparentTupleStruct = s.extract()?;
 #         assert_eq!(tup.0, "test");
@@ -249,23 +244,21 @@ struct RustyTransparentStruct {
 # }
 ```
 
-#### Deriving [`FromPyObject`] for enums
+### Deriving [`FromPyObject`] for enums
 
-The `FromPyObject` derivation for enums generates code that tries to extract the variants in the
-order of the fields. As soon as a variant can be extracted successfully, that variant is returned.
+The `FromPyObject` derivation for enums generates code that tries to extract the variants in the order of the fields.
+As soon as a variant can be extracted successfully, that variant is returned.
 This makes it possible to extract Python union types like `str | int`.
 
-The same customizations and restrictions described for struct derivations apply to enum variants,
-i.e. a tuple variant assumes that the input is a Python tuple, and a struct variant defaults to
-extracting fields as attributes but can be configured in the same manner. The `transparent`
-attribute can be applied to single-field-variants.
+The same customizations and restrictions described for struct derivations apply to enum variants, i.e. a tuple variant assumes that the input is a Python tuple, and a struct variant defaults to extracting fields as attributes but can be configured in the same manner.
+The `transparent` attribute can be applied to single-field-variants.
 
 ```rust
 use pyo3::prelude::*;
 
 #[derive(FromPyObject)]
 # #[derive(Debug)]
-enum RustyEnum<'a> {
+enum RustyEnum<'py> {
     Int(usize),                    // input is a positive int
     String(String),                // input is a string
     IntTuple(usize, usize),        // input is a 2-tuple with positive ints
@@ -284,15 +277,15 @@ enum RustyEnum<'a> {
         b: usize,
     },
     #[pyo3(transparent)]
-    CatchAll(&'a PyAny), // This extraction never fails
+    CatchAll(Bound<'py, PyAny>), // This extraction never fails
 }
 #
 # use pyo3::types::{PyBytes, PyString};
 # fn main() -> PyResult<()> {
-#     Python::with_gil(|py| -> PyResult<()> {
+#     Python::attach(|py| -> PyResult<()> {
 #         {
-#             let thing = 42_u8.to_object(py);
-#             let rust_thing: RustyEnum<'_> = thing.extract(py)?;
+#             let thing = 42_u8.into_pyobject(py)?;
+#             let rust_thing: RustyEnum<'_> = thing.extract()?;
 #
 #             assert_eq!(
 #                 42,
@@ -303,7 +296,7 @@ enum RustyEnum<'a> {
 #             );
 #         }
 #         {
-#             let thing = PyString::new_bound(py, "text");
+#             let thing = PyString::new(py, "text");
 #             let rust_thing: RustyEnum<'_> = thing.extract()?;
 #
 #             assert_eq!(
@@ -315,8 +308,8 @@ enum RustyEnum<'a> {
 #             );
 #         }
 #         {
-#             let thing = (32_u8, 73_u8).to_object(py);
-#             let rust_thing: RustyEnum<'_> = thing.extract(py)?;
+#             let thing = (32_u8, 73_u8).into_pyobject(py)?;
+#             let rust_thing: RustyEnum<'_> = thing.extract()?;
 #
 #             assert_eq!(
 #                 (32, 73),
@@ -327,8 +320,8 @@ enum RustyEnum<'a> {
 #             );
 #         }
 #         {
-#             let thing = ("foo", 73_u8).to_object(py);
-#             let rust_thing: RustyEnum<'_> = thing.extract(py)?;
+#             let thing = ("foo", 73_u8).into_pyobject(py)?;
+#             let rust_thing: RustyEnum<'_> = thing.extract()?;
 #
 #             assert_eq!(
 #                 (String::from("foo"), 73),
@@ -341,13 +334,13 @@ enum RustyEnum<'a> {
 #         {
 #             let module = PyModule::from_code(
 #                 py,
-#                 "class Foo(dict):
+#                 c"class Foo(dict):
 #             def __init__(self):
 #                 self.x = 0
 #                 self.y = 1
 #                 self.z = 2",
-#                 "",
-#                 "",
+#                 c"<string>",
+#                 c"",
 #             )?;
 #
 #             let class = module.getattr("Foo")?;
@@ -366,12 +359,12 @@ enum RustyEnum<'a> {
 #         {
 #             let module = PyModule::from_code(
 #                 py,
-#                 "class Foo(dict):
+#                 c"class Foo(dict):
 #             def __init__(self):
 #                 self.x = 3
 #                 self.y = 4",
-#                 "",
-#                 "",
+#                 c"<string>",
+#                 c"",
 #             )?;
 #
 #             let class = module.getattr("Foo")?;
@@ -388,13 +381,13 @@ enum RustyEnum<'a> {
 #         }
 #
 #         {
-#             let thing = PyBytes::new_bound(py, b"text");
+#             let thing = PyBytes::new(py, b"text");
 #             let rust_thing: RustyEnum<'_> = thing.extract()?;
 #
 #             assert_eq!(
 #                 b"text",
 #                 match rust_thing {
-#                     RustyEnum::CatchAll(i) => i.downcast::<PyBytes>()?.as_bytes(),
+#                     RustyEnum::CatchAll(ref i) => i.cast::<PyBytes>()?.as_bytes(),
 #                     other => unreachable!("Error extracting: {:?}", other),
 #                 }
 #             );
@@ -404,10 +397,8 @@ enum RustyEnum<'a> {
 # }
 ```
 
-If none of the enum variants match, a `PyTypeError` containing the names of the
-tested variants is returned. The names reported in the error message can be customized
-through the `#[pyo3(annotation = "name")]` attribute, e.g. to use conventional Python type
-names:
+If none of the enum variants match, a `PyTypeError` containing the names of the tested variants is returned.
+The names reported in the error message can be customized through the `#[pyo3(annotation = "name")]` attribute, e.g. to use conventional Python type names:
 
 ```rust
 use pyo3::prelude::*;
@@ -422,10 +413,10 @@ enum RustyEnum {
 }
 #
 # fn main() -> PyResult<()> {
-#     Python::with_gil(|py| -> PyResult<()> {
+#     Python::attach(|py| -> PyResult<()> {
 #         {
-#             let thing = 42_u8.to_object(py);
-#             let rust_thing: RustyEnum = thing.extract(py)?;
+#             let thing = 42_u8.into_pyobject(py)?;
+#             let rust_thing: RustyEnum = thing.extract()?;
 #
 #             assert_eq!(
 #                 42,
@@ -437,8 +428,8 @@ enum RustyEnum {
 #         }
 #
 #         {
-#             let thing = "foo".to_object(py);
-#             let rust_thing: RustyEnum = thing.extract(py)?;
+#             let thing = "foo".into_pyobject(py)?;
+#             let rust_thing: RustyEnum = thing.extract()?;
 #
 #             assert_eq!(
 #                 "foo",
@@ -450,8 +441,8 @@ enum RustyEnum {
 #         }
 #
 #         {
-#             let thing = b"foo".to_object(py);
-#             let error = thing.extract::<RustyEnum>(py).unwrap_err();
+#             let thing = b"foo".into_pyobject(py)?;
+#             let error = thing.extract::<RustyEnum>().unwrap_err();
 #             assert!(error.is_instance_of::<pyo3::exceptions::PyTypeError>(py));
 #         }
 #
@@ -461,64 +452,324 @@ enum RustyEnum {
 ```
 
 If the input is neither a string nor an integer, the error message will be:
-`"'<INPUT_TYPE>' cannot be converted to 'str | int'"`.
+`"'<INPUT_TYPE>' cannot be cast as 'str | int'"`.
+
+### `#[derive(FromPyObject)]` Container Attributes
 
-#### `#[derive(FromPyObject)]` Container Attributes
 - `pyo3(transparent)`
-    - extract the field directly from the object as `obj.extract()` instead of `get_item()` or
+  - extract the field directly from the object as `obj.extract()` instead of `get_item()` or
       `getattr()`
-    - Newtype structs and tuple-variants are treated as transparent per default.
-    - only supported for single-field structs and enum variants
+  - Newtype structs and tuple-variants are treated as transparent per default.
+  - only supported for single-field structs and enum variants
 - `pyo3(annotation = "name")`
-    - changes the name of the failed variant in the generated error message in case of failure.
-    - e.g. `pyo3("int")` reports the variant's type as `int`.
-    - only supported for enum variants
+  - changes the name of the failed variant in the generated error message in case of failure.
+  - e.g. `pyo3("int")` reports the variant's type as `int`.
+  - only supported for enum variants
+- `pyo3(rename_all = "...")`
+  - renames all attributes/item keys according to the specified renaming rule
+  - Possible values are: "camelCase", "kebab-case", "lowercase", "PascalCase", "SCREAMING-KEBAB-CASE", "SCREAMING_SNAKE_CASE", "snake_case", "UPPERCASE".
+  - fields with an explicit renaming via `attribute(...)`/`item(...)` are not affected
+
+### `#[derive(FromPyObject)]` Field Attributes
 
-#### `#[derive(FromPyObject)]` Field Attributes
 - `pyo3(attribute)`, `pyo3(attribute("name"))`
-    - retrieve the field from an attribute, possibly with a custom name specified as an argument
-    - argument must be a string-literal.
+  - retrieve the field from an attribute, possibly with a custom name specified as an argument
+  - argument must be a string-literal.
 - `pyo3(item)`, `pyo3(item("key"))`
-    - retrieve the field from a mapping, possibly with the custom key specified as an argument.
-    - can be any literal that implements `ToBorrowedObject`
-- `pyo3(from_py_with = "...")`
-    - apply a custom function to convert the field from Python the desired Rust type.
-    - the argument must be the name of the function as a string.
-    - the function signature must be `fn(&PyAny) -> PyResult<T>` where `T` is the Rust type of the argument.
+  - retrieve the field from a mapping, possibly with the custom key specified as an argument.
+  - can be any literal that implements `ToBorrowedObject`
+- `pyo3(from_py_with = ...)`
+  - apply a custom function to convert the field from Python the desired Rust type.
+  - the argument must be the path to the function.
+  - the function signature must be `fn(&Bound<PyAny>) -> PyResult<T>` where `T` is the Rust type of the argument.
+- `pyo3(default)`, `pyo3(default = ...)`
+  - if the argument is set, uses the given default value.
+  - in this case, the argument must be a Rust expression returning a value of the desired Rust type.
+  - if the argument is not set, [`Default::default`](https://doc.rust-lang.org/std/default/trait.Default.html#tymethod.default) is used.
+  - note that the default value is only used if the field is not set.
+    If the field is set and the conversion function from Python to Rust fails, an exception is raised and the default value is not used.
+  - this attribute is only supported on named fields.
+
+For example, the code below applies the given conversion function on the `"value"` dict item to compute its length or fall back to the type default value (0):
+
+```rust
+use pyo3::prelude::*;
+
+#[derive(FromPyObject)]
+struct RustyStruct {
+    #[pyo3(item("value"), default, from_py_with = Bound::<'_, PyAny>::len)]
+    len: usize,
+    #[pyo3(item)]
+    other: usize,
+}
+#
+# use pyo3::types::PyDict;
+# fn main() -> PyResult<()> {
+#     Python::attach(|py| -> PyResult<()> {
+#         // Filled case
+#         let dict = PyDict::new(py);
+#         dict.set_item("value", (1,)).unwrap();
+#         dict.set_item("other", 1).unwrap();
+#         let result = dict.extract::<RustyStruct>()?;
+#         assert_eq!(result.len, 1);
+#         assert_eq!(result.other, 1);
+#
+#         // Empty case
+#         let dict = PyDict::new(py);
+#         dict.set_item("other", 1).unwrap();
+#         let result = dict.extract::<RustyStruct>()?;
+#         assert_eq!(result.len, 0);
+#         assert_eq!(result.other, 1);
+#         Ok(())
+#     })
+# }
+```
 
-### `IntoPy<T>`
+### ⚠ Phase-Out of `FromPyObject` blanket implementation for cloneable PyClasses ⚠
 
-This trait defines the to-python conversion for a Rust type. It is usually implemented as
-`IntoPy<PyObject>`, which is the trait needed for returning a value from `#[pyfunction]` and
-`#[pymethods]`.
+Historically PyO3 has provided a blanket implementation for `#[pyclass]` types that also implement `Clone`, to allow extraction of such types by value.
+Over time this has turned out problematic for a few reasons, the major one being the prevention of custom conversions by downstream crates if their type is `Clone`.
+Over the next few releases the blanket implementation is gradually phased out, and eventually replaced by an opt-in option.
+As a first step of this migration a new `skip_from_py_object` option for `#[pyclass]` was introduced, to opt-out of the blanket implementation and allow downstream users to provide their own implementation:
 
+```rust
+# #![allow(dead_code)]
+# use pyo3::prelude::*;
+
+#[pyclass(skip_from_py_object)] // opt-out of the PyO3 FromPyObject blanket
+#[derive(Clone)]
+struct Number(i32);
+
+impl<'py> FromPyObject<'_, 'py> for Number {
+    type Error = PyErr;
+
+    fn extract(obj: pyo3::Borrowed<'_, 'py, pyo3::PyAny>) -> Result<Self, Self::Error> {
+        if let Ok(obj) = obj.cast::<Self>() { // first try extraction via class object
+            Ok(obj.borrow().clone())
+        } else {
+            obj.extract::<i32>().map(Self) // otherwise try integer directly
+        }
+    }
+}
+```
+
+As a second step the `from_py_object` option was introduced.
+This option also opts-out of the blanket implementation and instead generates a custom `FromPyObject` implementation for the pyclass which is functionally equivalent to the blanket.
+
+## `IntoPyObject`
+
+The [`IntoPyObject`] trait defines the to-python conversion for a Rust type.
 All types in PyO3 implement this trait, as does a `#[pyclass]` which doesn't use `extends`.
 
+This trait defines a single method, `into_pyobject()`, which returns a [`Result`] with `Ok` and `Err` types depending on the input value.
+For convenience, there is a companion [`IntoPyObjectExt`] trait which adds methods such as `into_py_any()` which converts the `Ok` and `Err` types to commonly used types (in the case of `into_py_any()`, `Py<PyAny>` and `PyErr` respectively).
+
 Occasionally you may choose to implement this for custom types which are mapped to Python types
-_without_ having a unique python type.
+*without* having a unique python type.
 
-```rust
-use pyo3::prelude::*;
+### derive macro
+
+`IntoPyObject` can be implemented using our derive macro.
+Both `struct`s and `enum`s are supported.
 
-struct MyPyObjectWrapper(PyObject);
+`struct`s will turn into a `PyDict` using the field names as keys, tuple `struct`s will turn convert
+into `PyTuple` with the fields in declaration order.
+
+```rust,no_run
+# #![allow(dead_code)]
+# use pyo3::prelude::*;
+# use std::collections::HashMap;
+# use std::hash::Hash;
+
+// structs convert into `PyDict` with field names as keys
+#[derive(IntoPyObject)]
+struct Struct {
+    count: usize,
+    obj: Py<PyAny>,
+}
+
+// tuple structs convert into `PyTuple`
+// lifetimes and generics are supported, the impl will be bounded by
+// `K: IntoPyObject, V: IntoPyObject`
+#[derive(IntoPyObject)]
+struct Tuple<'a, K: Hash + Eq, V>(&'a str, HashMap<K, V>);
+```
 
-impl IntoPy<PyObject> for MyPyObjectWrapper {
-    fn into_py(self, py: Python<'_>) -> PyObject {
-        self.0
+For structs with a single field (newtype pattern) the `#[pyo3(transparent)]` option can be used to
+forward the implementation to the inner type.
+
+```rust,no_run
+# #![allow(dead_code)]
+# use pyo3::prelude::*;
+
+// newtype tuple structs are implicitly `transparent`
+#[derive(IntoPyObject)]
+struct TransparentTuple(Py<PyAny>);
+
+#[derive(IntoPyObject)]
+#[pyo3(transparent)]
+struct TransparentStruct<'py> {
+    inner: Bound<'py, PyAny>, // `'py` lifetime will be used as the Python lifetime
+}
+```
+
+For `enum`s each variant is converted according to the rules for `struct`s above.
+
+```rust,no_run
+# #![allow(dead_code)]
+# use pyo3::prelude::*;
+# use std::collections::HashMap;
+# use std::hash::Hash;
+
+#[derive(IntoPyObject)]
+enum Enum<'a, 'py, K: Hash + Eq, V> { // enums are supported and convert using the same
+    TransparentTuple(Py<PyAny>),       // rules on the variants as the structs above
+    #[pyo3(transparent)]
+    TransparentStruct { inner: Bound<'py, PyAny> },
+    Tuple(&'a str, HashMap<K, V>),
+    Struct { count: usize, obj: Py<PyAny> }
+}
+```
+
+Additionally `IntoPyObject` can be derived for a reference to a struct or enum using the `IntoPyObjectRef` derive macro.
+All the same rules from above apply as well.
+
+#### `#[derive(IntoPyObject)]`/`#[derive(IntoPyObjectRef)]` Field Attributes
+
+- `pyo3(into_py_with = ...)`
+  - apply a custom function to convert the field from Rust into Python.
+  - the argument must be the function identifier
+  - the function signature must be `fn(Cow<'_, T>, Python<'py>) -> PyResult<Bound<'py, PyAny>>` where `T` is the Rust type of the argument.
+    - `#[derive(IntoPyObject)]` will invoke the function with `Cow::Owned`
+    - `#[derive(IntoPyObjectRef)]` will invoke the function with `Cow::Borrowed`
+
+    ```rust,no_run
+    # use pyo3::prelude::*;
+    # use pyo3::IntoPyObjectExt;
+    # use std::borrow::Cow;
+    #[derive(Clone)]
+    struct NotIntoPy(usize);
+
+    #[derive(IntoPyObject, IntoPyObjectRef)]
+    struct MyStruct {
+        #[pyo3(into_py_with = convert)]
+        not_into_py: NotIntoPy,
+    }
+
+    /// Convert `NotIntoPy` into Python
+    fn convert<'py>(not_into_py: Cow<'_, NotIntoPy>, py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {
+        not_into_py.0.into_bound_py_any(py)
+    }
+    ```
+
+### manual implementation
+
+If the derive macro is not suitable for your use case, `IntoPyObject` can be implemented manually as
+demonstrated below.
+
+```rust,no_run
+# use pyo3::prelude::*;
+# #[allow(dead_code)]
+struct MyPyObjectWrapper(Py<PyAny>);
+
+impl<'py> IntoPyObject<'py> for MyPyObjectWrapper {
+    type Target = PyAny; // the Python type
+    type Output = Bound<'py, Self::Target>; // in most cases this will be `Bound`
+    type Error = std::convert::Infallible; // the conversion error type, has to be convertible to `PyErr`
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        Ok(self.0.into_bound(py))
+    }
+}
+
+// equivalent to former `ToPyObject` implementations
+impl<'a, 'py> IntoPyObject<'py> for &'a MyPyObjectWrapper {
+    type Target = PyAny;
+    type Output = Borrowed<'a, 'py, Self::Target>; // `Borrowed` can be used to optimized reference counting
+    type Error = std::convert::Infallible;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        Ok(self.0.bind_borrowed(py))
     }
 }
 ```
 
-### The `ToPyObject` trait
+### `BoundObject` for conversions that may be `Bound` or `Borrowed`
+
+`IntoPyObject::into_py_object` returns either `Bound` or `Borrowed` depending on the implementation for a concrete type.
+For example, the `IntoPyObject` implementation for `u32` produces a `Bound<'py, PyInt>` and the `bool` implementation produces a `Borrowed<'py, 'py, PyBool>`:
+
+```rust,no_run
+use pyo3::prelude::*;
+use pyo3::IntoPyObject;
+use pyo3::types::{PyBool, PyInt};
+
+let ints: Vec<u32> = vec![1, 2, 3, 4];
+let bools = vec![true, false, false, true];
+
+Python::attach(|py| {
+    let ints_as_pyint: Vec<Bound<'_, PyInt>> = ints
+        .iter()
+        .map(|x| Ok(x.into_pyobject(py)?))
+        .collect::<PyResult<_>>()
+        .unwrap();
+
+    let bools_as_pybool: Vec<Borrowed<'_, '_, PyBool>> = bools
+        .iter()
+        .map(|x| Ok(x.into_pyobject(py)?))
+        .collect::<PyResult<_>>()
+        .unwrap();
+});
+```
+
+In this example if we wanted to combine `ints_as_pyints` and `bools_as_pybool` into a single `Vec<Py<PyAny>>` to return from the `Python::attach` closure, we would have to manually convert the concrete types for the smart pointers and the python types.
+
+Instead, we can write a function that generically converts vectors of either integers or bools into a vector of `Py<PyAny>` using the [`BoundObject`] trait:
+
+```rust,no_run
+# use pyo3::prelude::*;
+# use pyo3::BoundObject;
+# use pyo3::IntoPyObject;
+
+# let bools = vec![true, false, false, true];
+# let ints = vec![1, 2, 3, 4];
+
+fn convert_to_vec_of_pyobj<'py, T>(py: Python<'py>, the_vec: Vec<T>) -> PyResult<Vec<Py<PyAny>>>
+where
+   T: IntoPyObject<'py> + Copy
+{
+    the_vec.iter()
+        .map(|x| {
+            Ok(
+                // Note: the below is equivalent to `x.into_py_any()`
+                // from the `IntoPyObjectExt` trait
+                x.into_pyobject(py)
+                .map_err(Into::into)?
+                .into_any()
+                .unbind()
+            )
+        })
+        .collect()
+}
 
-[`ToPyObject`] is a conversion trait that allows various objects to be
-converted into [`PyObject`]. `IntoPy<PyObject>` serves the
-same purpose, except that it consumes `self`.
+let vec_of_pyobjs: Vec<Py<PyAny>> = Python::attach(|py| {
+    let mut bools_as_pyany = convert_to_vec_of_pyobj(py, bools).unwrap();
+    let mut ints_as_pyany = convert_to_vec_of_pyobj(py, ints).unwrap();
+    let mut result: Vec<Py<PyAny>> = vec![];
+    result.append(&mut bools_as_pyany);
+    result.append(&mut ints_as_pyany);
+    result
+});
+```
+
+In the example above we used `BoundObject::into_any` and `BoundObject::unbind` to manipulate the python types and smart pointers into the result type we wanted to produce from the function.
 
-[`IntoPy`]: {{#PYO3_DOCS_URL}}/pyo3/conversion/trait.IntoPy.html
 [`FromPyObject`]: {{#PYO3_DOCS_URL}}/pyo3/conversion/trait.FromPyObject.html
-[`ToPyObject`]: {{#PYO3_DOCS_URL}}/pyo3/conversion/trait.ToPyObject.html
-[`PyObject`]: {{#PYO3_DOCS_URL}}/pyo3/type.PyObject.html
+[`IntoPyObject`]: {{#PYO3_DOCS_URL}}/pyo3/conversion/trait.IntoPyObject.html
+[`IntoPyObjectExt`]: {{#PYO3_DOCS_URL}}/pyo3/conversion/trait.IntoPyObjectExt.html
 
 [`PyRef`]: {{#PYO3_DOCS_URL}}/pyo3/pycell/struct.PyRef.html
 [`PyRefMut`]: {{#PYO3_DOCS_URL}}/pyo3/pycell/struct.PyRefMut.html
+[`BoundObject`]: {{#PYO3_DOCS_URL}}/pyo3/instance/trait.BoundObject.html
+
+[`Result`]: https://doc.rust-lang.org/stable/std/result/enum.Result.html
diff --git a/guide/src/debugging.md b/guide/src/debugging.md
index 00c22631c3b..2b6b8d062f9 100644
--- a/guide/src/debugging.md
+++ b/guide/src/debugging.md
@@ -2,7 +2,8 @@
 
 ## Macros
 
-PyO3's attributes (`#[pyclass]`, `#[pymodule]`, etc.) are [procedural macros](https://doc.rust-lang.org/reference/procedural-macros.html), which means that they rewrite the source of the annotated item. You can view the generated source with the following command, which also expands a few other things:
+PyO3's attributes (`#[pyclass]`, `#[pymodule]`, etc.) are [procedural macros](https://doc.rust-lang.org/reference/procedural-macros.html), which means that they rewrite the source of the annotated item.
+You can view the generated source with the following command, which also expands a few other things:
 
 ```bash
 cargo rustc --profile=check -- -Z unstable-options --pretty=expanded > expanded.rs; rustfmt expanded.rs
@@ -16,15 +17,18 @@ You can also debug classic `!`-macros by adding `-Z trace-macros`:
 cargo rustc --profile=check -- -Z unstable-options --pretty=expanded -Z trace-macros > expanded.rs; rustfmt expanded.rs
 ```
 
-Note that those commands require using the nightly build of rust and may occasionally have bugs. See [cargo expand](https://github.com/dtolnay/cargo-expand) for a more elaborate and stable version of those commands.
+Note that those commands require using the nightly build of rust and may occasionally have bugs.
+See [cargo expand](https://github.com/dtolnay/cargo-expand) for a more elaborate and stable version of those commands.
 
 ## Running with Valgrind
 
 Valgrind is a tool to detect memory management bugs such as memory leaks.
 
-You first need to install a debug build of Python, otherwise Valgrind won't produce usable results. In Ubuntu there's e.g. a `python3-dbg` package.
+You first need to install a debug build of Python, otherwise Valgrind won't produce usable results.
+In Ubuntu there's e.g. a `python3-dbg` package.
 
-Activate an environment with the debug interpreter and recompile. If you're on Linux, use `ldd` with the name of your binary and check that you're linking e.g. `libpython3.7d.so.1.0` instead of `libpython3.7.so.1.0`.
+Activate an environment with the debug interpreter and recompile.
+If you're on Linux, use `ldd` with the name of your binary and check that you're linking e.g. `libpython3.7d.so.1.0` instead of `libpython3.7.so.1.0`.
 
 [Download the suppressions file for CPython](https://raw.githubusercontent.com/python/cpython/master/Misc/valgrind-python.supp).
 
@@ -32,16 +36,360 @@ Run Valgrind with `valgrind --suppressions=valgrind-python.supp ./my-command --w
 
 ## Getting a stacktrace
 
-The best start to investigate a crash such as an segmentation fault is a backtrace. You can set `RUST_BACKTRACE=1` as an environment variable to get the stack trace on a `panic!`. Alternatively you can use a debugger such as `gdb` to explore the issue. Rust provides a wrapper, `rust-gdb`, which has pretty-printers for inspecting Rust variables. Since PyO3 uses `cdylib` for Python shared objects, it does not receive the pretty-print debug hooks in `rust-gdb` ([rust-lang/rust#96365](https://github.com/rust-lang/rust/issues/96365)). The mentioned issue contains a workaround for enabling pretty-printers in this case.
+The best start to investigate a crash such as an segmentation fault is a backtrace.
+You can set `RUST_BACKTRACE=1` as an environment variable to get the stack trace on a `panic!`.
+Alternatively you can use a debugger such as `gdb` to explore the issue.
+Rust provides a wrapper, `rust-gdb`, which has pretty-printers for inspecting Rust variables.
+Since PyO3 uses `cdylib` for Python shared objects, it does not receive the pretty-print debug hooks in `rust-gdb` ([rust-lang/rust#96365](https://github.com/rust-lang/rust/issues/96365)).
+The mentioned issue contains a workaround for enabling pretty-printers in this case.
 
- * Link against a debug build of python as described in the previous chapter
- * Run `rust-gdb <my-binary>`
- * Set a breakpoint (`b`) on `rust_panic` if you are investigating a `panic!`
- * Enter `r` to run
- * After the crash occurred, enter `bt` or `bt full` to print the stacktrace
+- Link against a debug build of python as described in the previous chapter
+- Run `rust-gdb <my-binary>`
+- Set a breakpoint (`b`) on `rust_panic` if you are investigating a `panic!`
+- Enter `r` to run
+- After the crash occurred, enter `bt` or `bt full` to print the stacktrace
 
  Often it is helpful to run a small piece of Python code to exercise a section of Rust.
 
  ```console
  rust-gdb --args python -c "import my_package; my_package.sum_to_string(1, 2)"
  ```
+
+## Setting breakpoints in your Rust code
+
+One of the preferred ways by developers to debug their code is by setting breakpoints.
+This can be achieved in PyO3 by using a debugger like `rust-gdb` or `rust-lldb` with your Python interpreter.
+
+For more information about how to use both `lldb` and `gdb` you can read the [gdb to lldb command map](https://lldb.llvm.org/use/map.html) from the lldb documentation.
+
+### Common setup
+
+1. Compile your extension with debug symbols:
+
+   ```bash
+   # Debug is the default for maturin, but you can explicitly ensure debug symbols with:
+   RUSTFLAGS="-g" maturin develop
+
+   # For setuptools-rust users:
+   pip install -e .
+   ```
+
+   > **Note**: When using debuggers, make sure that `python` resolves to an actual Python binary or symlink and not a shim script.
+   Some tools like pyenv use shim scripts which can interfere with debugging.
+
+### Debugger specific setup
+
+Depending on your OS and your preferences you can use two different debuggers, `rust-gdb` or `rust-lldb`.
+
+{{#tabs }}
+{{#tab name="Using rust-gdb" }}
+
+1. Launch rust-gdb with the Python interpreter:
+
+   ```bash
+   rust-gdb --args python
+   ```
+
+2. Once in gdb, set a breakpoint in your Rust code:
+
+   ```bash
+   (gdb) break your_module.rs:42
+   ```
+
+3. Run your Python script that imports and uses your Rust extension:
+
+   ```bash
+   # Option 1: Run an inline Python command
+   (gdb) run -c "import your_module; your_module.your_function()"
+
+   # Option 2: Run a Python script
+   (gdb) run your_script.py
+
+   # Option 3: Run pytest tests
+   (gdb) run -m pytest tests/test_something.py::TestName
+   ```
+
+{{#endtab }}
+{{#tab name="Using rust-lldb (for macOS users)" }}
+
+1. Start rust-lldb with Python:
+
+   ```bash
+   rust-lldb -- python
+   ```
+
+2. Set breakpoints in your Rust code:
+
+   ```bash
+   (lldb) breakpoint set --file your_module.rs --line 42
+   ```
+
+3. Run your Python script:
+
+   ```bash
+   # Option 1: Run an inline Python command
+   (lldb) run -c "import your_module; your_module.your_function()"
+
+   # Option 2: Run a Python script
+   (lldb) run your_script.py
+
+   # Option 3: Run pytest tests
+   (lldb) run -m pytest tests/test_something.py::TestName
+   ```
+
+{{#endtab }}
+{{#endtabs }}
+
+### Using VS Code
+
+VS Code with the Rust and Python extensions provides an integrated debugging experience:
+
+1. First, install the necessary VS Code extensions:
+
+   - [Rust Analyzer](https://marketplace.visualstudio.com/items?itemName=rust-lang.rust-analyzer)
+   - [CodeLLDB](https://marketplace.visualstudio.com/items?itemName=vadimcn.vscode-lldb)
+   - [Python](https://marketplace.visualstudio.com/items?itemName=ms-python.python)
+
+2. Create a `.vscode/launch.json` file with a configuration that uses the LLDB Debug Launcher:
+
+   ```json
+   {
+       "version": "0.2.0",
+       "configurations": [
+           {
+               "name": "Debug PyO3",
+               "type": "lldb",
+               "request": "attach",
+               "program": "${workspaceFolder}/.venv/bin/python",
+               "pid": "${command:pickProcess}",
+               "sourceLanguages": [
+                   "rust"
+               ]
+           },
+           {
+               "name": "Launch Python with PyO3",
+               "type": "lldb",
+               "request": "launch",
+               "program": "${workspaceFolder}/.venv/bin/python",
+               "args": ["${file}"],
+               "cwd": "${workspaceFolder}",
+               "sourceLanguages": ["rust"]
+           },
+           {
+               "name": "Debug PyO3 with Args",
+               "type": "lldb",
+               "request": "launch",
+               "program": "${workspaceFolder}/.venv/bin/python",
+               "args": ["path/to/your/script.py", "arg1", "arg2"],
+               "cwd": "${workspaceFolder}",
+               "sourceLanguages": ["rust"]
+           },
+           {
+               "name": "Debug PyO3 Tests",
+               "type": "lldb",
+               "request": "launch",
+               "program": "${workspaceFolder}/.venv/bin/python",
+               "args": ["-m", "pytest", "tests/your_test.py::test_function", "-v"],
+               "cwd": "${workspaceFolder}",
+               "sourceLanguages": ["rust"]
+           }
+        ]
+   }
+   ```
+
+   This configuration supports multiple debugging scenarios:
+
+   - Attaching to a running Python process
+   - Launching the currently open Python file
+   - Running a specific script with command-line arguments
+   - Running pytest tests
+
+<!-- rumdl-disable MD029 - nested lists & code blocks false positive -->
+
+3. Set breakpoints in your Rust code by clicking in the gutter next to line numbers.
+
+4. Start debugging:
+   - For attaching to a running Python process: First start the process, then select the "Debug PyO3" configuration and click Start Debugging (F5).
+     You'll be prompted to select the Python process to attach to.
+   - For launching a Python script: Open your Python script, select the "Launch Python with PyO3" configuration and click Start Debugging (F5).
+   - For running with arguments: Select "Debug PyO3 with Args" (remember to edit the configuration with your actual script path and arguments).
+   - For running tests: Select "Debug PyO3 Tests" (edit the test path as needed).
+
+5. When debugging PyO3 code:
+   - You can inspect Rust variables and data structures
+   - Use the debug console to evaluate expressions
+   - Step through Rust code line by line using the step controls
+   - Set conditional breakpoints for more complex debugging scenarios
+
+<!-- rumdl-enable MD029 -->
+
+### Advanced Debugging Configurations
+
+For advanced debugging scenarios, you might want to add environment variables or enable specific Rust debug flags:
+
+```json
+{
+    "name": "Debug PyO3 with Environment",
+    "type": "lldb",
+    "request": "launch",
+    "program": "${workspaceFolder}/.venv/bin/python",
+    "args": ["${file}"],
+    "env": {
+        "RUST_BACKTRACE": "1",
+        "PYTHONPATH": "${workspaceFolder}"
+    },
+    "sourceLanguages": ["rust"]
+}
+```
+
+### Debugging from Jupyter Notebooks
+
+For Jupyter Notebooks run from VS Code, you can use the following helper functions to automate the launch configuration:
+
+```python
+from pathlib import Path
+import os
+import json
+import sys
+
+
+def update_launch_json(vscode_config_file_path=None):
+    """Update VSCode launch.json with the correct Jupyter kernel PID.
+
+    Args:
+        vscode_config_file_path (str, optional): Path to the .vscode/launch.json file.
+            If not provided, will use the current working directory.
+    """
+    pid = get_jupyter_kernel_pid()
+    if not pid:
+        print("Could not determine Jupyter kernel PID.")
+        return
+
+    # Determine launch.json path
+    if vscode_config_file_path:
+        launch_json_path = vscode_config_file_path
+    else:
+        launch_json_path = os.path.join(Path(os.getcwd()), ".vscode", "launch.json")
+
+    # Get Python interpreter path
+    python_path = sys.executable
+
+    # Default debugger config
+    debug_config = {
+        "version": "0.2.0",
+        "configurations": [
+            {
+                "name": "Debug PyO3 (Jupyter)",
+                "type": "lldb",
+                "request": "attach",
+                "program": python_path,
+                "pid": pid,
+                "sourceLanguages": ["rust"],
+            },
+            {
+                "name": "Launch Python with PyO3",
+                "type": "lldb",
+                "request": "launch",
+                "program": python_path,
+                "args": ["${file}"],
+                "cwd": "${workspaceFolder}",
+                "sourceLanguages": ["rust"]
+            }
+        ],
+    }
+
+    # Create .vscode directory if it doesn't exist
+    try:
+        os.makedirs(os.path.dirname(launch_json_path), exist_ok=True)
+
+        # If launch.json already exists, try to update it instead of overwriting
+        if os.path.exists(launch_json_path):
+            try:
+                with open(launch_json_path, "r") as f:
+                    existing_config = json.load(f)
+
+                # Check if our configuration already exists
+                config_exists = False
+                for config in existing_config.get("configurations", []):
+                    if config.get("name") == "Debug PyO3 (Jupyter)":
+                        config["pid"] = pid
+                        config["program"] = python_path
+                        config_exists = True
+
+                if not config_exists:
+                    existing_config.setdefault("configurations", []).append(debug_config["configurations"][0])
+
+                debug_config = existing_config
+            except Exception:
+                # If reading fails, we'll just overwrite with our new configuration
+                pass
+
+        with open(launch_json_path, "w") as f:
+            json.dump(debug_config, f, indent=4)
+        print(f"Updated launch.json with PID: {pid} at {launch_json_path}")
+    except Exception as e:
+        print(f"Error updating launch.json: {e}")
+
+
+def get_jupyter_kernel_pid():
+    """Find the process ID (PID) of the running Jupyter kernel.
+
+    Returns:
+        int: The process ID of the Jupyter kernel, or None if not found.
+    """
+    # Check if we're running in a Jupyter environment
+    if 'ipykernel' in sys.modules:
+        pid = os.getpid()
+        print(f"Jupyter kernel PID: {pid}")
+        return pid
+    else:
+        print("Not running in a Jupyter environment.")
+        return None
+```
+
+To use these functions:
+
+1. Run the cell containing these functions in your Jupyter notebook
+2. Run `update_launch_json()` in a cell
+3. In VS Code, select the "Debug PyO3 (Jupyter)" configuration and start debugging
+
+## Thread Safety and Compiler Sanitizers
+
+PyO3 attempts to match the Rust language-level guarantees for thread safety, but that does not preclude other code outside of the control of PyO3 or buggy code managed by a PyO3 extension from creating a thread safety issue.
+Analyzing whether or not a piece of Rust code that uses the CPython C API is thread safe can be quite complicated, since many Python operations can lead to arbitrary Python code execution.
+Automated ways to discover thread safety issues can often be more fruitful than code analysis.
+
+[ThreadSanitizer](https://clang.llvm.org/docs/ThreadSanitizer.html) is a thread safety checking runtime that can be used to detect data races triggered by thread safety bugs or incorrect use of thread-unsafe data structures.
+While it can only detect data races triggered by code at runtime, if it does detect something the reports often point to exactly where the problem is happening.
+
+To use `ThreadSanitizer` with a library that depends on PyO3, you will need to
+install a nightly Rust toolchain, along with the `rust-src` component, since you
+will need to compile the Rust standard library:
+
+```bash
+rustup install nightly
+rustup override set nightly
+rustup component add rust-src
+```
+
+You will also need a version of CPython compiled using LLVM/Clang with the same major version of LLVM as is currently used to compile nightly Rust.
+As of March 2025, Rust nightly uses LLVM 20.
+
+The [cpython_sanity docker images](https://github.com/nascheme/cpython_sanity)
+contain a development environment with a pre-compiled version of CPython 3.13 or
+3.14 as well as optionally NumPy and SciPy, all compiled using LLVM 20 and
+ThreadSanitizer.
+
+After activating a nightly Rust toolchain, you can build your project using
+`ThreadSanitizer` with the following command:
+
+```bash
+RUSTFLAGS="-Zsanitizer=thread" maturin develop -Zbuild-std --target x86_64-unknown-linux-gnu
+```
+
+If you are not running on an x86_64 Linux machine, you should replace `x86_64-unknown-linux-gnu` with the [target triple](https://doc.rust-lang.org/rustc/platform-support.html#tier-1-with-host-tools) that is appropriate for your system.
+You can also replace `maturin develop` with `cargo test` to run `cargo` tests.
+Note that `cargo` runs tests in a thread pool, so `cargo` tests can be a good way to find thread safety issues.
+
+You can also replace `-Zsanitizer=thread` with `-Zsanitizer=address` or any of the other sanitizers that are [supported by Rust](https://doc.rust-lang.org/beta/unstable-book/compiler-flags/sanitizer.html).
+Note that you'll need to build CPython from source with the appropriate [configure script flags](https://docs.python.org/3/using/configure.html#cmdoption-with-address-sanitizer) to use the same sanitizer environment as you want to use for your Rust code.
diff --git a/guide/src/ecosystem/async-await.md b/guide/src/ecosystem/async-await.md
index f537ab90df1..2e421428889 100644
--- a/guide/src/ecosystem/async-await.md
+++ b/guide/src/ecosystem/async-await.md
@@ -2,557 +2,13 @@
 
 *`async`/`await` support is currently being integrated in PyO3. See the [dedicated documentation](../async-await.md)*
 
-If you are working with a Python library that makes use of async functions or wish to provide
-Python bindings for an async Rust library, [`pyo3-asyncio`](https://github.com/awestlake87/pyo3-asyncio)
-likely has the tools you need. It provides conversions between async functions in both Python and
-Rust and was designed with first-class support for popular Rust runtimes such as
-[`tokio`](https://tokio.rs/) and [`async-std`](https://async.rs/). In addition, all async Python
-code runs on the default `asyncio` event loop, so `pyo3-asyncio` should work just fine with existing
-Python libraries.
-
-In the following sections, we'll give a general overview of `pyo3-asyncio` explaining how to call
-async Python functions with PyO3, how to call async Rust functions from Python, and how to configure
-your codebase to manage the runtimes of both.
-
-## Quickstart
-
-Here are some examples to get you started right away! A more detailed breakdown
-of the concepts in these examples can be found in the following sections.
-
-### Rust Applications
-Here we initialize the runtime, import Python's `asyncio` library and run the given future to completion using Python's default `EventLoop` and `async-std`. Inside the future, we convert `asyncio` sleep into a Rust future and await it.
-
-
-```toml
-# Cargo.toml dependencies
-[dependencies]
-pyo3 = { version = "0.14" }
-pyo3-asyncio = { version = "0.14", features = ["attributes", "async-std-runtime"] }
-async-std = "1.9"
-```
-
-```rust
-//! main.rs
-
-use pyo3::prelude::*;
-
-#[pyo3_asyncio::async_std::main]
-async fn main() -> PyResult<()> {
-    let fut = Python::with_gil(|py| {
-        let asyncio = py.import("asyncio")?;
-        // convert asyncio.sleep into a Rust Future
-        pyo3_asyncio::async_std::into_future(asyncio.call_method1("sleep", (1.into_py(py),))?)
-    })?;
-
-    fut.await?;
-
-    Ok(())
-}
-```
-
-The same application can be written to use `tokio` instead using the `#[pyo3_asyncio::tokio::main]`
-attribute.
-
-```toml
-# Cargo.toml dependencies
-[dependencies]
-pyo3 = { version = "0.14" }
-pyo3-asyncio = { version = "0.14", features = ["attributes", "tokio-runtime"] }
-tokio = "1.4"
-```
-
-```rust
-//! main.rs
-
-use pyo3::prelude::*;
-
-#[pyo3_asyncio::tokio::main]
-async fn main() -> PyResult<()> {
-    let fut = Python::with_gil(|py| {
-        let asyncio = py.import("asyncio")?;
-        // convert asyncio.sleep into a Rust Future
-        pyo3_asyncio::tokio::into_future(asyncio.call_method1("sleep", (1.into_py(py),))?)
-    })?;
-
-    fut.await?;
-
-    Ok(())
-}
-```
-
-More details on the usage of this library can be found in the [API docs](https://awestlake87.github.io/pyo3-asyncio/master/doc) and the primer below.
-
-### PyO3 Native Rust Modules
-
-PyO3 Asyncio can also be used to write native modules with async functions.
-
-Add the `[lib]` section to `Cargo.toml` to make your library a `cdylib` that Python can import.
-```toml
-[lib]
-name = "my_async_module"
-crate-type = ["cdylib"]
-```
-
-Make your project depend on `pyo3` with the `extension-module` feature enabled and select your
-`pyo3-asyncio` runtime:
-
-For `async-std`:
-```toml
-[dependencies]
-pyo3 = { version = "0.14", features = ["extension-module"] }
-pyo3-asyncio = { version = "0.14", features = ["async-std-runtime"] }
-async-std = "1.9"
-```
-
-For `tokio`:
-```toml
-[dependencies]
-pyo3 = { version = "0.14", features = ["extension-module"] }
-pyo3-asyncio = { version = "0.14", features = ["tokio-runtime"] }
-tokio = "1.4"
-```
-
-Export an async function that makes use of `async-std`:
-
-```rust
-//! lib.rs
-
-use pyo3::{prelude::*, wrap_pyfunction};
-
-#[pyfunction]
-fn rust_sleep(py: Python<'_>) -> PyResult<&PyAny> {
-    pyo3_asyncio::async_std::future_into_py(py, async {
-        async_std::task::sleep(std::time::Duration::from_secs(1)).await;
-        Ok(Python::with_gil(|py| py.None()))
-    })
-}
-
-#[pymodule]
-fn my_async_module(py: Python<'_>, m: &PyModule) -> PyResult<()> {
-    m.add_function(wrap_pyfunction!(rust_sleep, m)?)?;
-
-    Ok(())
-}
-```
-
-If you want to use `tokio` instead, here's what your module should look like:
-
-```rust
-//! lib.rs
-
-use pyo3::{prelude::*, wrap_pyfunction};
-
-#[pyfunction]
-fn rust_sleep(py: Python<'_>) -> PyResult<&PyAny> {
-    pyo3_asyncio::tokio::future_into_py(py, async {
-        tokio::time::sleep(std::time::Duration::from_secs(1)).await;
-        Ok(Python::with_gil(|py| py.None()))
-    })
-}
-
-#[pymodule]
-fn my_async_module(py: Python<'_>, m: &PyModule) -> PyResult<()> {
-    m.add_function(wrap_pyfunction!(rust_sleep, m)?)?;
-    Ok(())
-}
-```
-
-You can build your module with maturin (see the [Using Rust in Python](https://pyo3.rs/main/#using-rust-from-python) section in the PyO3 guide for setup instructions). After that you should be able to run the Python REPL to try it out.
-
-```bash
-maturin develop && python3
-🔗 Found pyo3 bindings
-🐍 Found CPython 3.8 at python3
-    Finished dev [unoptimized + debuginfo] target(s) in 0.04s
-Python 3.8.5 (default, Jan 27 2021, 15:41:15)
-[GCC 9.3.0] on linux
-Type "help", "copyright", "credits" or "license" for more information.
->>> import asyncio
->>>
->>> from my_async_module import rust_sleep
->>>
->>> async def main():
->>>     await rust_sleep()
->>>
->>> # should sleep for 1s
->>> asyncio.run(main())
->>>
-```
-
-## Awaiting an Async Python Function in Rust
-
-Let's take a look at a dead simple async Python function:
-
-```python
-# Sleep for 1 second
-async def py_sleep():
-    await asyncio.sleep(1)
-```
-
-**Async functions in Python are simply functions that return a `coroutine` object**. For our purposes,
-we really don't need to know much about these `coroutine` objects. The key factor here is that calling
-an `async` function is _just like calling a regular function_, the only difference is that we have
-to do something special with the object that it returns.
-
-Normally in Python, that something special is the `await` keyword, but in order to await this
-coroutine in Rust, we first need to convert it into Rust's version of a `coroutine`: a `Future`.
-That's where `pyo3-asyncio` comes in.
-[`pyo3_asyncio::into_future`](https://docs.rs/pyo3-asyncio/latest/pyo3_asyncio/fn.into_future.html)
-performs this conversion for us.
-
-The following example uses `into_future` to call the `py_sleep` function shown above and then await the
-coroutine object returned from the call:
-
-```rust
-use pyo3::prelude::*;
-
-#[pyo3_asyncio::tokio::main]
-async fn main() -> PyResult<()> {
-    let future = Python::with_gil(|py| -> PyResult<_> {
-        // import the module containing the py_sleep function
-        let example = py.import("example")?;
-
-        // calling the py_sleep method like a normal function
-        // returns a coroutine
-        let coroutine = example.call_method0("py_sleep")?;
-
-        // convert the coroutine into a Rust future using the
-        // tokio runtime
-        pyo3_asyncio::tokio::into_future(coroutine)
-    })?;
-
-    // await the future
-    future.await?;
-
-    Ok(())
-}
-```
-
-Alternatively, the below example shows how to write a `#[pyfunction]` which uses `into_future` to receive and await
-a coroutine argument:
-
-```rust
-#[pyfunction]
-fn await_coro(coro: &PyAny) -> PyResult<()> {
-    // convert the coroutine into a Rust future using the
-    // async_std runtime
-    let f = pyo3_asyncio::async_std::into_future(coro)?;
-
-    pyo3_asyncio::async_std::run_until_complete(coro.py(), async move {
-        // await the future
-        f.await?;
-        Ok(())
-    })
-}
-```
-
-This could be called from Python as:
-
-```python
-import asyncio
-
-async def py_sleep():
-    asyncio.sleep(1)
-
-await_coro(py_sleep())
-```
-
-If for you wanted to pass a callable function to the `#[pyfunction]` instead, (i.e. the last line becomes `await_coro(py_sleep))`, then the above example needs to be tweaked to first call the callable to get the coroutine:
-
-```rust
-#[pyfunction]
-fn await_coro(callable: &PyAny) -> PyResult<()> {
-    // get the coroutine by calling the callable
-    let coro = callable.call0()?;
-
-    // convert the coroutine into a Rust future using the
-    // async_std runtime
-    let f = pyo3_asyncio::async_std::into_future(coro)?;
-
-    pyo3_asyncio::async_std::run_until_complete(coro.py(), async move {
-        // await the future
-        f.await?;
-        Ok(())
-    })
-}
-```
-
-This can be particularly helpful where you need to repeatedly create and await a coroutine. Trying to await the same coroutine multiple times will raise an error:
-
-```python
-RuntimeError: cannot reuse already awaited coroutine
-```
-
-> If you're interested in learning more about `coroutines` and `awaitables` in general, check out the
-> [Python 3 `asyncio` docs](https://docs.python.org/3/library/asyncio-task.html) for more information.
-
-## Awaiting a Rust Future in Python
-
-Here we have the same async function as before written in Rust using the
-[`async-std`](https://async.rs/) runtime:
-
-```rust
-/// Sleep for 1 second
-async fn rust_sleep() {
-    async_std::task::sleep(std::time::Duration::from_secs(1)).await;
-}
-```
-
-Similar to Python, Rust's async functions also return a special object called a
-`Future`:
-
-```rust
-let future = rust_sleep();
-```
-
-We can convert this `Future` object into Python to make it `awaitable`. This tells Python that you
-can use the `await` keyword with it. In order to do this, we'll call
-[`pyo3_asyncio::async_std::future_into_py`](https://docs.rs/pyo3-asyncio/latest/pyo3_asyncio/async_std/fn.future_into_py.html):
-
-```rust
-use pyo3::prelude::*;
-
-async fn rust_sleep() {
-    async_std::task::sleep(std::time::Duration::from_secs(1)).await;
-}
-
-#[pyfunction]
-fn call_rust_sleep(py: Python<'_>) -> PyResult<&PyAny> {
-    pyo3_asyncio::async_std::future_into_py(py, async move {
-        rust_sleep().await;
-        Ok(Python::with_gil(|py| py.None()))
-    })
-}
-```
-
-In Python, we can call this pyo3 function just like any other async function:
-
-```python
-from example import call_rust_sleep
-
-async def rust_sleep():
-    await call_rust_sleep()
-```
-
-## Managing Event Loops
-
-Python's event loop requires some special treatment, especially regarding the main thread. Some of
-Python's `asyncio` features, like proper signal handling, require control over the main thread, which
-doesn't always play well with Rust.
-
-Luckily, Rust's event loops are pretty flexible and don't _need_ control over the main thread, so in
-`pyo3-asyncio`, we decided the best way to handle Rust/Python interop was to just surrender the main
-thread to Python and run Rust's event loops in the background. Unfortunately, since most event loop
-implementations _prefer_ control over the main thread, this can still make some things awkward.
-
-### PyO3 Asyncio Initialization
-
-Because Python needs to control the main thread, we can't use the convenient proc macros from Rust
-runtimes to handle the `main` function or `#[test]` functions. Instead, the initialization for PyO3 has to be done from the `main` function and the main
-thread must block on [`pyo3_asyncio::run_forever`](https://docs.rs/pyo3-asyncio/latest/pyo3_asyncio/fn.run_forever.html) or [`pyo3_asyncio::async_std::run_until_complete`](https://docs.rs/pyo3-asyncio/latest/pyo3_asyncio/async_std/fn.run_until_complete.html).
-
-Because we have to block on one of those functions, we can't use [`#[async_std::main]`](https://docs.rs/async-std/latest/async_std/attr.main.html) or [`#[tokio::main]`](https://docs.rs/tokio/1.1.0/tokio/attr.main.html)
-since it's not a good idea to make long blocking calls during an async function.
-
-> Internally, these `#[main]` proc macros are expanded to something like this:
-> ```rust
-> fn main() {
->     // your async main fn
->     async fn _main_impl() { /* ... */ }
->     Runtime::new().block_on(_main_impl());
-> }
-> ```
-> Making a long blocking call inside the `Future` that's being driven by `block_on` prevents that
-> thread from doing anything else and can spell trouble for some runtimes (also this will actually
-> deadlock a single-threaded runtime!). Many runtimes have some sort of `spawn_blocking` mechanism
-> that can avoid this problem, but again that's not something we can use here since we need it to
-> block on the _main_ thread.
-
-For this reason, `pyo3-asyncio` provides its own set of proc macros to provide you with this
-initialization. These macros are intended to mirror the initialization of `async-std` and `tokio`
-while also satisfying the Python runtime's needs.
-
-Here's a full example of PyO3 initialization with the `async-std` runtime:
-```rust
-use pyo3::prelude::*;
-
-#[pyo3_asyncio::async_std::main]
-async fn main() -> PyResult<()> {
-    // PyO3 is initialized - Ready to go
-
-    let fut = Python::with_gil(|py| -> PyResult<_> {
-        let asyncio = py.import("asyncio")?;
-
-        // convert asyncio.sleep into a Rust Future
-        pyo3_asyncio::async_std::into_future(
-            asyncio.call_method1("sleep", (1.into_py(py),))?
-        )
-    })?;
-
-    fut.await?;
-
-    Ok(())
-}
-```
-
-### A Note About `asyncio.run`
-
-In Python 3.7+, the recommended way to run a top-level coroutine with `asyncio`
-is with `asyncio.run`. In `v0.13` we recommended against using this function due to initialization issues, but in `v0.14` it's perfectly valid to use this function... with a caveat.
-
-Since our Rust <--> Python conversions require a reference to the Python event loop, this poses a problem. Imagine we have a PyO3 Asyncio module that defines
-a `rust_sleep` function like in previous examples. You might rightfully assume that you can call pass this directly into `asyncio.run` like this:
-
-```python
-import asyncio
-
-from my_async_module import rust_sleep
-
-asyncio.run(rust_sleep())
-```
-
-You might be surprised to find out that this throws an error:
-```bash
-Traceback (most recent call last):
-  File "example.py", line 5, in <module>
-    asyncio.run(rust_sleep())
-RuntimeError: no running event loop
-```
-
-What's happening here is that we are calling `rust_sleep` _before_ the future is
-actually running on the event loop created by `asyncio.run`. This is counter-intuitive, but expected behaviour, and unfortunately there doesn't seem to be a good way of solving this problem within PyO3 Asyncio itself.
-
-However, we can make this example work with a simple workaround:
-
-```python
-import asyncio
-
-from my_async_module import rust_sleep
-
-# Calling main will just construct the coroutine that later calls rust_sleep.
-# - This ensures that rust_sleep will be called when the event loop is running,
-#   not before.
-async def main():
-    await rust_sleep()
-
-# Run the main() coroutine at the top-level instead
-asyncio.run(main())
-```
-
-### Non-standard Python Event Loops
-
-Python allows you to use alternatives to the default `asyncio` event loop. One
-popular alternative is `uvloop`. In `v0.13` using non-standard event loops was
-a bit of an ordeal, but in `v0.14` it's trivial.
-
-#### Using `uvloop` in a PyO3 Asyncio Native Extensions
-
-```toml
-# Cargo.toml
-
-[lib]
-name = "my_async_module"
-crate-type = ["cdylib"]
-
-[dependencies]
-pyo3 = { version = "0.14", features = ["extension-module"] }
-pyo3-asyncio = { version = "0.14", features = ["tokio-runtime"] }
-async-std = "1.9"
-tokio = "1.4"
-```
-
-```rust
-//! lib.rs
-
-use pyo3::{prelude::*, wrap_pyfunction};
-
-#[pyfunction]
-fn rust_sleep(py: Python<'_>) -> PyResult<&PyAny> {
-    pyo3_asyncio::tokio::future_into_py(py, async {
-        tokio::time::sleep(std::time::Duration::from_secs(1)).await;
-        Ok(Python::with_gil(|py| py.None()))
-    })
-}
-
-#[pymodule]
-fn my_async_module(_py: Python<'_>, m: &PyModule) -> PyResult<()> {
-    m.add_function(wrap_pyfunction!(rust_sleep, m)?)?;
-
-    Ok(())
-}
-```
-
-```bash
-$ maturin develop && python3
-🔗 Found pyo3 bindings
-🐍 Found CPython 3.8 at python3
-    Finished dev [unoptimized + debuginfo] target(s) in 0.04s
-Python 3.8.8 (default, Apr 13 2021, 19:58:26)
-[GCC 7.3.0] :: Anaconda, Inc. on linux
-Type "help", "copyright", "credits" or "license" for more information.
->>> import asyncio
->>> import uvloop
->>>
->>> import my_async_module
->>>
->>> uvloop.install()
->>>
->>> async def main():
-...     await my_async_module.rust_sleep()
-...
->>> asyncio.run(main())
->>>
-```
-
-#### Using `uvloop` in Rust Applications
-
-Using `uvloop` in Rust applications is a bit trickier, but it's still possible
-with relatively few modifications.
-
-Unfortunately, we can't make use of the `#[pyo3_asyncio::<runtime>::main]` attribute with non-standard event loops. This is because the `#[pyo3_asyncio::<runtime>::main]` proc macro has to interact with the Python
-event loop before we can install the `uvloop` policy.
-
-```toml
-[dependencies]
-async-std = "1.9"
-pyo3 = "0.14"
-pyo3-asyncio = { version = "0.14", features = ["async-std-runtime"] }
-```
-
-```rust
-//! main.rs
-
-use pyo3::{prelude::*, types::PyType};
-
-fn main() -> PyResult<()> {
-    pyo3::prepare_freethreaded_python();
-
-    Python::with_gil(|py| {
-        let uvloop = py.import("uvloop")?;
-        uvloop.call_method0("install")?;
-
-        // store a reference for the assertion
-        let uvloop = PyObject::from(uvloop);
-
-        pyo3_asyncio::async_std::run(py, async move {
-            // verify that we are on a uvloop.Loop
-            Python::with_gil(|py| -> PyResult<()> {
-                assert!(pyo3_asyncio::async_std::get_current_loop(py)?.is_instance(
-                    uvloop
-                        .as_ref(py)
-                        .getattr("Loop")?
-                )?);
-                Ok(())
-            })?;
-
-            async_std::task::sleep(std::time::Duration::from_secs(1)).await;
-
-            Ok(())
-        })
-    })
-}
-```
+If you are working with a Python library that makes use of async functions or wish to provide Python bindings for an async Rust library, [`pyo3-async-runtimes`](https://github.com/PyO3/pyo3-async-runtimes) likely has the tools you need.
+It provides conversions between async functions in both Python and Rust and was designed with first-class support for popular Rust runtimes such as [`tokio`](https://tokio.rs/) and [`async-std`](https://async.rs/).
+In addition, all async Python code runs on the default `asyncio` event loop, so `pyo3-async-runtimes` should work just fine with existing Python libraries.
 
 ## Additional Information
-- Managing event loop references can be tricky with pyo3-asyncio. See [Event Loop References](https://docs.rs/pyo3-asyncio/#event-loop-references) in the API docs to get a better intuition for how event loop references are managed in this library.
-- Testing pyo3-asyncio libraries and applications requires a custom test harness since Python requires control over the main thread. You can find a testing guide in the [API docs for the `testing` module](https://docs.rs/pyo3-asyncio/latest/pyo3_asyncio/testing)
+
+- Managing event loop references can be tricky with `pyo3-async-runtimes`.
+  See [Event Loop References](https://docs.rs/pyo3-async-runtimes/#event-loop-references-and-contextvars) in the API docs to get a better intuition for how event loop references are managed in this library.
+- Testing `pyo3-async-runtimes` libraries and applications requires a custom test harness since Python requires control over the main thread.
+  You can find a testing guide in the [API docs for the `testing` module](https://docs.rs/pyo3-async-runtimes/latest/pyo3_async_runtimes/testing)
diff --git a/guide/src/ecosystem/logging.md b/guide/src/ecosystem/logging.md
index 2e7d4a087c6..fa97c9bc7dd 100644
--- a/guide/src/ecosystem/logging.md
+++ b/guide/src/ecosystem/logging.md
@@ -3,39 +3,36 @@
 It is desirable if both the Python and Rust parts of the application end up
 logging using the same configuration into the same place.
 
-This section of the guide briefly discusses how to connect the two languages'
-logging ecosystems together. The recommended way for Python extension modules is
-to configure Rust's logger to send log messages to Python using the `pyo3-log`
-crate. For users who want to do the opposite and send Python log messages to
-Rust, see the note at the end of this guide.
+This section of the guide briefly discusses how to connect the two languages' logging ecosystems together.
+The recommended way for Python extension modules is to configure Rust's logger to send log messages to Python using the `pyo3-log` crate.
+For users who want to do the opposite and send Python log messages to Rust, see the note at the end of this guide.
 
 ## Using `pyo3-log` to send Rust log messages to Python
 
-The [pyo3-log] crate allows sending the messages from the Rust side to Python's
-[logging] system. This is mostly suitable for writing native extensions for
-Python programs.
+The [pyo3-log] crate allows sending the messages from the Rust side to Python's [logging] system.
+This is mostly suitable for writing native extensions for Python programs.
 
 Use [`pyo3_log::init`][init] to install the logger in its default configuration.
 It's also possible to tweak its configuration (mostly to tune its performance).
 
-```rust
-use log::info;
-use pyo3::prelude::*;
-
-#[pyfunction]
-fn log_something() {
-    // This will use the logger installed in `my_module` to send the `info`
-    // message to the Python logging facilities.
-    info!("Something!");
-}
-
-#[pymodule]
-fn my_module(_py: Python<'_>, m: &PyModule) -> PyResult<()> {
-    // A good place to install the Rust -> Python logger.
-    pyo3_log::init();
-
-    m.add_function(wrap_pyfunction!(log_something))?;
-    Ok(())
+```rust,no_run
+#[pyo3::pymodule]
+mod my_module {
+    use log::info;
+    use pyo3::prelude::*;
+
+    #[pyfunction]
+    fn log_something() {
+        // This will use the logger installed in `my_module` to send the `info`
+        // message to the Python logging facilities.
+        info!("Something!");
+    }
+
+    #[pymodule_init]
+    fn init(m: &Bound<'_, PyModule>) -> PyResult<()> {
+        // A good place to install the Rust -> Python logger.
+        pyo3_log::init();
+    }
 }
 ```
 
@@ -51,9 +48,8 @@ logging.getLogger().setLevel(logging.INFO)
 my_module.log_something()
 ```
 
-It is important to initialize the Python loggers first, before calling any Rust
-functions that may log. This limitation can be worked around if it is not
-possible to satisfy, read the documentation about [caching].
+It is important to initialize the Python loggers first, before calling any Rust functions that may log.
+This limitation can be worked around if it is not possible to satisfy, read the documentation about [caching].
 
 ## The Python to Rust direction
 
@@ -61,7 +57,7 @@ To have python logs be handled by Rust, one need only register a rust function t
 
 This has been implemented within the [pyo3-pylogger] crate.
 
-```rust
+```rust,no_run
 use log::{info, warn};
 use pyo3::prelude::*;
 
@@ -78,7 +74,7 @@ fn main() -> PyResult<()> {
     warn!("Something spooky happened!");
 
     // Log some messages from Python
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         py.run(
             "
 import logging
diff --git a/guide/src/ecosystem/tracing.md b/guide/src/ecosystem/tracing.md
new file mode 100644
index 00000000000..34beb03ed05
--- /dev/null
+++ b/guide/src/ecosystem/tracing.md
@@ -0,0 +1,106 @@
+# Tracing
+
+Python projects that write extension modules for performance reasons may want to
+tap into [Rust's `tracing` ecosystem] to gain insight into the performance of
+their extension module.
+
+This section of the guide describes a few crates that provide ways to do that.
+They build on [`tracing_subscriber`][tracing-subscriber] and require code changes in both Python and Rust to integrate.
+Note that each extension module must configure its own `tracing` integration; one extension module will not see `tracing` data from a different module.
+
+## `pyo3-tracing-subscriber` ([documentation][pyo3-tracing-subscriber-docs])
+
+[`pyo3-tracing-subscriber`][pyo3-tracing-subscriber] provides a way for Python projects to configure `tracing_subscriber`.
+It exposes a few `tracing_subscriber` layers:
+
+- `tracing_subscriber::fmt` for writing human-readable output to file or stdout
+- `opentelemetry-stdout` for writing OTLP output to file or stdout
+- `opentelemetry-otlp` for writing OTLP output to an OTLP endpoint
+
+The extension module must call [`pyo3_tracing_subscriber::add_submodule`][add-submodule]
+to export the Python classes needed to configure and initialize `tracing`.
+
+On the Python side, use the `Tracing` context manager to initialize tracing and
+run Rust code inside the context manager's block. `Tracing` takes a
+`GlobalTracingConfig` instance describing the layers to be used.
+
+See [the README on crates.io][pyo3-tracing-subscriber]
+for example code.
+
+## `pyo3-python-tracing-subscriber` ([documentation][pyo3-python-tracing-subscriber-docs])
+
+The similarly-named [`pyo3-python-tracing-subscriber`][pyo3-python-tracing-subscriber]
+implements a shim in Rust that forwards `tracing` data to a `Layer`
+implementation defined in and passed in from Python.
+
+There are many ways an extension module could integrate `pyo3-python-tracing-subscriber`
+but a simple one may look something like this:
+
+```rust,no_run
+#[tracing::instrument]
+#[pyfunction]
+fn fibonacci(index: usize, use_memoized: bool) -> PyResult<usize> {
+    // ...
+}
+
+#[pyfunction]
+pub fn initialize_tracing(py_impl: Bound<'_, PyAny>) {
+    tracing_subscriber::registry()
+        .with(pyo3_python_tracing_subscriber::PythonCallbackLayerBridge::new(py_impl))
+        .init();
+}
+```
+
+The extension module must provide some way for Python to pass in one or more Python objects that implement [the `Layer` interface].
+Then it should construct [`pyo3_python_tracing_subscriber::PythonCallbackLayerBridge`][PythonCallbackLayerBridge] instances with each of those Python objects and initialize `tracing_subscriber` as shown above.
+
+The Python objects implement a modified version of the `Layer` interface:
+
+- `on_new_span()` may return some state that will stored inside the Rust span
+- other callbacks will be given that state as an additional positional argument
+
+A dummy `Layer` implementation may look like this:
+
+```python
+import rust_extension
+
+class MyPythonLayer:
+    def __init__(self):
+        pass
+
+    # `on_new_span` can return some state
+    def on_new_span(self, span_attrs: str, span_id: str) -> int:
+        print(f"[on_new_span]: {span_attrs} | {span_id}")
+        return random.randint(1, 1000)
+
+    # The state from `on_new_span` is passed back into other trait methods
+    def on_event(self, event: str, state: int):
+        print(f"[on_event]: {event} | {state}")
+
+    def on_close(self, span_id: str, state: int):
+        print(f"[on_close]: {span_id} | {state}")
+
+    def on_record(self, span_id: str, values: str, state: int):
+        print(f"[on_record]: {span_id} | {values} | {state}")
+
+def main():
+    rust_extension.initialize_tracing(MyPythonLayer())
+
+    print("10th fibonacci number: ", rust_extension.fibonacci(10, True))
+```
+
+`pyo3-python-tracing-subscriber` has [working examples]
+showing both the Rust side and the Python side of an integration.
+
+[pyo3-tracing-subscriber]: https://crates.io/crates/pyo3-tracing-subscriber
+[pyo3-tracing-subscriber-docs]: https://docs.rs/pyo3-tracing-subscriber
+[add-submodule]: https://docs.rs/pyo3-tracing-subscriber/*/pyo3_tracing_subscriber/fn.add_submodule.html
+
+[pyo3-python-tracing-subscriber]: https://crates.io/crates/pyo3-python-tracing-subscriber
+[pyo3-python-tracing-subscriber-docs]: https://docs.rs/pyo3-python-tracing-subscriber
+[PythonCallbackLayerBridge]: https://docs.rs/pyo3-python-tracing-subscriber/*/pyo3_python_tracing_subscriber/struct.PythonCallbackLayerBridge.html
+[working examples]: https://github.com/getsentry/pyo3-python-tracing-subscriber/tree/main/demo
+
+[Rust's `tracing` ecosystem]: https://crates.io/crates/tracing
+[tracing-subscriber]: https://docs.rs/tracing-subscriber/*/tracing_subscriber/
+[the `Layer` interface]: https://docs.rs/tracing-subscriber/*/tracing_subscriber/layer/trait.Layer.html
diff --git a/guide/src/exception.md b/guide/src/exception.md
index 225118576f7..bc7be1f65c7 100644
--- a/guide/src/exception.md
+++ b/guide/src/exception.md
@@ -10,8 +10,8 @@ use pyo3::create_exception;
 create_exception!(module, MyError, pyo3::exceptions::PyException);
 ```
 
-* `module` is the name of the containing module.
-* `MyError` is the name of the new exception type.
+- `module` is the name of the containing module.
+- `MyError` is the name of the new exception type.
 
 For example:
 
@@ -23,38 +23,43 @@ use pyo3::exceptions::PyException;
 
 create_exception!(mymodule, CustomError, PyException);
 
-Python::with_gil(|py| {
-    let ctx = [("CustomError", py.get_type::<CustomError>())].into_py_dict_bound(py);
+# fn main() -> PyResult<()> {
+Python::attach(|py| {
+    let ctx = [("CustomError", py.get_type::<CustomError>())].into_py_dict(py)?;
     pyo3::py_run!(
         py,
         *ctx,
         "assert str(CustomError) == \"<class 'mymodule.CustomError'>\""
     );
     pyo3::py_run!(py, *ctx, "assert CustomError('oops').args == ('oops',)");
-});
+#   Ok(())
+})
+# }
 ```
 
 When using PyO3 to create an extension module, you can add the new exception to
 the module like this, so that it is importable from Python:
 
-```rust
+```rust,no_run
+# fn main() {}
 use pyo3::prelude::*;
 use pyo3::exceptions::PyException;
 
 pyo3::create_exception!(mymodule, CustomError, PyException);
 
 #[pymodule]
-fn mymodule(py: Python<'_>, m: &PyModule) -> PyResult<()> {
-    // ... other elements added to module ...
-    m.add("CustomError", py.get_type::<CustomError>())?;
+mod mymodule {
+    #[pymodule_export]
+    use super::CustomError;
 
-    Ok(())
+    // ... other elements added to module ...
 }
 ```
 
 ## Raising an exception
 
-As described in the [function error handling](./function/error_handling.md) chapter, to raise an exception from a `#[pyfunction]` or `#[pymethods]`, return an `Err(PyErr)`. PyO3 will automatically raise this exception for you when returning the result to Python.
+As described in the [function error handling](./function/error-handling.md) chapter, to raise an exception from a `#[pyfunction]` or `#[pymethods]`, return an `Err(PyErr)`.
+PyO3 will automatically raise this exception for you when returning the result to Python.
 
 You can also manually write and fetch errors in the Python interpreter's global state:
 
@@ -62,7 +67,7 @@ You can also manually write and fetch errors in the Python interpreter's global
 use pyo3::{Python, PyErr};
 use pyo3::exceptions::PyTypeError;
 
-Python::with_gil(|py| {
+Python::attach(|py| {
     PyTypeError::new_err("Error").restore(py);
     assert!(PyErr::occurred(py));
     drop(PyErr::fetch(py));
@@ -74,24 +79,27 @@ Python::with_gil(|py| {
 Python has an [`isinstance`](https://docs.python.org/3/library/functions.html#isinstance) method to check an object's type.
 In PyO3 every object has the [`PyAny::is_instance`] and [`PyAny::is_instance_of`] methods which do the same thing.
 
-```rust
+```rust,no_run
 use pyo3::prelude::*;
 use pyo3::types::{PyBool, PyList};
 
-Python::with_gil(|py| {
-    assert!(PyBool::new_bound(py, true).is_instance_of::<PyBool>());
-    let list = PyList::new_bound(py, &[1, 2, 3, 4]);
+# fn main() -> PyResult<()> {
+Python::attach(|py| {
+    assert!(PyBool::new(py, true).is_instance_of::<PyBool>());
+    let list = PyList::new(py, &[1, 2, 3, 4])?;
     assert!(!list.is_instance_of::<PyBool>());
     assert!(list.is_instance_of::<PyList>());
-});
+# Ok(())
+})
+# }
 ```
 
 To check the type of an exception, you can similarly do:
 
-```rust
+```rust,no_run
 # use pyo3::exceptions::PyTypeError;
 # use pyo3::prelude::*;
-# Python::with_gil(|py| {
+# Python::attach(|py| {
 # let err = PyTypeError::new_err(());
 err.is_instance_of::<PyTypeError>(py);
 # });
@@ -100,10 +108,10 @@ err.is_instance_of::<PyTypeError>(py);
 ## Using exceptions defined in Python code
 
 It is possible to use an exception defined in Python code as a native Rust type.
-The `import_exception!` macro allows importing a specific exception class and defines a Rust type
+The [`import_exception!`] macro allows importing a specific exception class and defines a Rust type
 for that exception.
 
-```rust
+```rust,no_run
 #![allow(dead_code)]
 use pyo3::prelude::*;
 
@@ -111,7 +119,7 @@ mod io {
     pyo3::import_exception!(io, UnsupportedOperation);
 }
 
-fn tell(file: &PyAny) -> PyResult<u64> {
+fn tell(file: &Bound<'_, PyAny>) -> PyResult<u64> {
     match file.call_method0("tell") {
         Err(_) => Err(io::UnsupportedOperation::new_err("not supported: tell")),
         Ok(x) => x.extract::<u64>(),
@@ -122,11 +130,54 @@ fn tell(file: &PyAny) -> PyResult<u64> {
 [`pyo3::exceptions`]({{#PYO3_DOCS_URL}}/pyo3/exceptions/index.html)
 defines exceptions for several standard library modules.
 
+## Creating more complex exceptions
+
+If you need to create an exception with more complex behavior, you can also manually create a subclass of `PyException`:
+
+```rust
+#![allow(dead_code)]
+# #[cfg(any(not(feature = "abi3")))] {
+use pyo3::prelude::*;
+use pyo3::types::IntoPyDict;
+use pyo3::exceptions::PyException;
+
+#[pyclass(extends=PyException)]
+struct CustomError {
+    #[pyo3(get)]
+    url: String,
+
+    #[pyo3(get)]
+    message: String,
+}
+
+#[pymethods]
+impl CustomError {
+    #[new]
+    fn new(url: String, message: String) -> Self {
+        Self { url, message }
+    }
+}
+
+# fn main() -> PyResult<()> {
+Python::attach(|py| {
+    let ctx = [("CustomError", py.get_type::<CustomError>())].into_py_dict(py)?;
+    pyo3::py_run!(
+        py,
+        *ctx,
+        "assert str(CustomError) == \"<class 'builtins.CustomError'>\", repr(CustomError)"
+    );
+    pyo3::py_run!(py, *ctx, "assert CustomError('https://example.com/', 'something went bad').args == ('https://example.com/', 'something went bad')");
+    pyo3::py_run!(py, *ctx, "assert CustomError('https://example.com/', 'something went bad').url == 'https://example.com/'");
+#   Ok(())
+})
+# }
+# }
+
+```
+
+Note that this is not possible when the ``abi3`` feature is enabled, as that prevents subclassing ``PyException``.
+
 [`create_exception!`]: {{#PYO3_DOCS_URL}}/pyo3/macro.create_exception.html
 [`import_exception!`]: {{#PYO3_DOCS_URL}}/pyo3/macro.import_exception.html
-
-[`PyErr`]: {{#PYO3_DOCS_URL}}/pyo3/struct.PyErr.html
-[`PyResult`]: {{#PYO3_DOCS_URL}}/pyo3/type.PyResult.html
-[`PyErr::from_value`]: {{#PYO3_DOCS_URL}}/pyo3/struct.PyErr.html#method.from_value
-[`PyAny::is_instance`]: {{#PYO3_DOCS_URL}}/pyo3/struct.PyAny.html#method.is_instance
-[`PyAny::is_instance_of`]: {{#PYO3_DOCS_URL}}/pyo3/struct.PyAny.html#method.is_instance_of
+[`PyAny::is_instance`]: {{#PYO3_DOCS_URL}}/pyo3/types/trait.PyAnyMethods.html#tymethod.is_instance
+[`PyAny::is_instance_of`]: {{#PYO3_DOCS_URL}}/pyo3/types/trait.PyAnyMethods.html#tymethod.is_instance_of
diff --git a/guide/src/faq.md b/guide/src/faq.md
index 8308acc64de..4fdb7f2b78c 100644
--- a/guide/src/faq.md
+++ b/guide/src/faq.md
@@ -1,55 +1,68 @@
 # Frequently Asked Questions and troubleshooting
 
-## I'm experiencing deadlocks using PyO3 with lazy_static or once_cell!
+Sorry that you're having trouble using PyO3.
+If you can't find the answer to your problem in the list below, you can also reach out for help on [GitHub Discussions](https://github.com/PyO3/pyo3/discussions) and on [Discord](https://discord.gg/33kcChzH7f).
 
-`lazy_static` and `once_cell::sync` both use locks to ensure that initialization is performed only by a single thread. Because the Python GIL is an additional lock this can lead to deadlocks in the following way:
+## I'm experiencing deadlocks using PyO3 with `std::sync::OnceLock`, `std::sync::LazyLock`, `lazy_static`, and `once_cell`
 
-1. A thread (thread A) which has acquired the Python GIL starts initialization of a `lazy_static` value.
-2. The initialization code calls some Python API which temporarily releases the GIL e.g. `Python::import`.
-3. Another thread (thread B) acquires the Python GIL and attempts to access the same `lazy_static` value.
-4. Thread B is blocked, because it waits for `lazy_static`'s initialization to lock to release.
-5. Thread A is blocked, because it waits to re-acquire the GIL which thread B still holds.
+`OnceLock`, `LazyLock`, and their thirdparty predecessors use blocking to ensure only one thread ever initializes them.
+Because the Python interpreter can introduce additional locks (the Python GIL and GC can both require all other threads to pause) this can lead to deadlocks in the following way:
+
+1. A thread (thread A) which is attached to the Python interpreter starts initialization of a `OnceLock` value.
+2. The initialization code calls some Python API which temporarily detaches from the interpreter e.g. `Python::import`.
+3. Another thread (thread B) attaches to the Python interpreter and attempts to access the same `OnceLock` value.
+4. Thread B is blocked, because it waits for `OnceLock`'s initialization to lock to release.
+5. On non-free-threaded Python, thread A is now also blocked, because it waits to re-attach to the interpreter (by taking the GIL which thread B still holds).
 6. Deadlock.
 
-PyO3 provides a struct [`GILOnceCell`] which works equivalently to `OnceCell` but relies solely on the Python GIL for thread safety. This means it can be used in place of `lazy_static` or `once_cell` where you are experiencing the deadlock described above. See the documentation for [`GILOnceCell`] for an example how to use it.
+PyO3 provides a struct [`PyOnceLock`] which implements a single-initialization API based on these types that avoids deadlocks.
+You can also make use of the [`OnceExt`] and [`OnceLockExt`] extension traits that enable using the standard library types for this purpose by providing new methods for these types that avoid the risk of deadlocking with the Python interpreter.
+This means they can be used in place of other choices when you are experiencing the deadlock described above.
+See the documentation for [`PyOnceLock`] and [`OnceExt`] for further details and an example how to use them.
 
-[`GILOnceCell`]: {{#PYO3_DOCS_URL}}/pyo3/sync/struct.GILOnceCell.html
+[`PyOnceLock`]: {{#PYO3_DOCS_URL}}/pyo3/sync/struct.PyOnceLock.html
+[`OnceExt`]: {{#PYO3_DOCS_URL}}/pyo3/sync/trait.OnceExt.html
+[`OnceLockExt`]: {{#PYO3_DOCS_URL}}/pyo3/sync/trait.OnceLockExt.html
 
-## I can't run `cargo test`; or I can't build in a Cargo workspace: I'm having linker issues like "Symbol not found" or "Undefined reference to _PyExc_SystemError"!
+## I can't run `cargo test`; or I can't build in a Cargo workspace: I'm having linker issues like "Symbol not found" or "Undefined reference to _PyExc_SystemError"
 
-Currently, [#340](https://github.com/PyO3/pyo3/issues/340) causes `cargo test` to fail with linking errors when the `extension-module` feature is activated. Linking errors can also happen when building in a cargo workspace where a different crate also uses PyO3 (see [#2521](https://github.com/PyO3/pyo3/issues/2521)). For now, there are three ways we can work around these issues.
+Currently, [#340](https://github.com/PyO3/pyo3/issues/340) causes `cargo test` to fail with linking errors when the `extension-module` feature is activated.
+Linking errors can also happen when building in a cargo workspace where a different crate also uses PyO3 (see [#2521](https://github.com/PyO3/pyo3/issues/2521)).
+For now, there are three ways we can work around these issues.
 
-1. Make the `extension-module` feature optional. Build with `maturin develop --features "extension-module"`
+1. Make the `extension-module` feature optional.
+   Build with `maturin develop --features "extension-module"`
 
-```toml
-[dependencies.pyo3]
-{{#PYO3_CRATE_VERSION}}
+   ```toml
+   [dependencies.pyo3]
+   {{#PYO3_CRATE_VERSION}}
 
-[features]
-extension-module = ["pyo3/extension-module"]
-```
+   [features]
+   extension-module = ["pyo3/extension-module"]
+   ```
 
-2. Make the `extension-module` feature optional and default. Run tests with `cargo test --no-default-features`:
+2. Make the `extension-module` feature optional and default.
+   Run tests with `cargo test --no-default-features`:
 
-```toml
-[dependencies.pyo3]
-{{#PYO3_CRATE_VERSION}}
+   ```toml
+   [dependencies.pyo3]
+   {{#PYO3_CRATE_VERSION}}
 
-[features]
-extension-module = ["pyo3/extension-module"]
-default = ["extension-module"]
-```
+   [features]
+   extension-module = ["pyo3/extension-module"]
+   default = ["extension-module"]
+   ```
 
 3. If you are using a [`pyproject.toml`](https://maturin.rs/metadata.html) file to control maturin settings, add the following section:
 
-```toml
-[tool.maturin]
-features = ["pyo3/extension-module"]
-# Or for maturin 0.12:
-# cargo-extra-args = ["--features", "pyo3/extension-module"]
-```
+   ```toml
+   [tool.maturin]
+   features = ["pyo3/extension-module"]
+   # Or for maturin 0.12:
+   # cargo-extra-args = ["--features", "pyo3/extension-module"]
+   ```
 
-## I can't run `cargo test`: my crate cannot be found for tests in `tests/` directory!
+## I can't run `cargo test`: my crate cannot be found for tests in `tests/` directory
 
 The Rust book suggests to [put integration tests inside a `tests/` directory](https://doc.rust-lang.org/book/ch11-03-test-organization.html#integration-tests).
 
@@ -72,17 +85,19 @@ The best solution is to make your crate types include both `rlib` and `cdylib`:
 crate-type = ["cdylib", "rlib"]
 ```
 
-## Ctrl-C doesn't do anything while my Rust code is executing!
+## Ctrl-C doesn't do anything while my Rust code is executing
 
-This is because Ctrl-C raises a SIGINT signal, which is handled by the calling Python process by simply setting a flag to action upon later. This flag isn't checked while Rust code called from Python is executing, only once control returns to the Python interpreter.
+This is because Ctrl-C raises a SIGINT signal, which is handled by the calling Python process by simply setting a flag to action upon later.
+This flag isn't checked while Rust code called from Python is executing, only once control returns to the Python interpreter.
 
-You can give the Python interpreter a chance to process the signal properly by calling `Python::check_signals`. It's good practice to call this function regularly if you have a long-running Rust function so that your users can cancel it.
+You can give the Python interpreter a chance to process the signal properly by calling `Python::check_signals`.
+It's good practice to call this function regularly if you have a long-running Rust function so that your users can cancel it.
 
-## `#[pyo3(get)]` clones my field!
+## `#[pyo3(get)]` clones my field
 
 You may have a nested struct similar to this:
 
-```rust
+```rust,no_run
 # use pyo3::prelude::*;
 #[pyclass]
 #[derive(Clone)]
@@ -119,18 +134,19 @@ AssertionError: a: <builtins.Inner object at 0x00000238FFB9C7B0>
 b: <builtins.Inner object at 0x00000238FFB9C830>
 ```
 
-This can be especially confusing if the field is mutable, as getting the field and then mutating it won't persist - you'll just get a fresh clone of the original on the next access. Unfortunately Python and Rust don't agree about ownership - if PyO3 gave out references to (possibly) temporary Rust objects to Python code, Python code could then keep that reference alive indefinitely. Therefore returning Rust objects requires cloning.
+This can be especially confusing if the field is mutable, as getting the field and then mutating it won't persist - you'll just get a fresh clone of the original on the next access.
+Unfortunately Python and Rust don't agree about ownership - if PyO3 gave out references to (possibly) temporary Rust objects to Python code, Python code could then keep that reference alive indefinitely.
+Therefore returning Rust objects requires cloning.
 
 If you don't want that cloning to happen, a workaround is to allocate the field on the Python heap and store a reference to that, by using [`Py<...>`]({{#PYO3_DOCS_URL}}/pyo3/struct.Py.html):
-```rust
+
+```rust,no_run
 # use pyo3::prelude::*;
 #[pyclass]
-#[derive(Clone)]
 struct Inner {/* fields omitted */}
 
 #[pyclass]
 struct Outer {
-    #[pyo3(get)]
     inner: Py<Inner>,
 }
 
@@ -142,9 +158,16 @@ impl Outer {
             inner: Py::new(py, Inner {})?,
         })
     }
+
+    #[getter]
+    fn inner(&self, py: Python<'_>) -> Py<Inner> {
+        self.inner.clone_ref(py)
+    }
 }
 ```
+
 This time `a` and `b` *are* the same object:
+
 ```python
 outer = Outer()
 
@@ -159,9 +182,11 @@ print(f"a: {a}\nb: {b}")
 a: <builtins.Inner object at 0x0000020044FCC670>
 b: <builtins.Inner object at 0x0000020044FCC670>
 ```
-The downside to this approach is that any Rust code working on the `Outer` struct now has to acquire the GIL to do anything with its field.
 
-## I want to use the `pyo3` crate re-exported from from dependency but the proc-macros fail!
+The downside to this approach is that any Rust code working on the `Outer` struct potentially has to attach to the Python interpreter to do anything with the `inner` field. (If `Inner` is `#[pyclass(frozen)]` and implements `Sync`, then `Py::get`
+may be used to access the `Inner` contents from `Py<Inner>` without needing to attach to the interpreter.)
+
+## I want to use the `pyo3` crate re-exported from dependency but the proc-macros fail
 
 All PyO3 proc-macros (`#[pyclass]`, `#[pyfunction]`, `#[derive(FromPyObject)]`
 and so on) expect the `pyo3` crate to be available under that name in your crate
@@ -172,27 +197,33 @@ However, when the dependency is renamed, or your crate only indirectly depends
 on `pyo3`, you need to let the macro code know where to find the crate.  This is
 done with the `crate` attribute:
 
-```rust
+```rust,no_run
 # use pyo3::prelude::*;
 # pub extern crate pyo3;
 # mod reexported { pub use ::pyo3; }
+# #[allow(dead_code)]
 #[pyclass]
 #[pyo3(crate = "reexported::pyo3")]
 struct MyClass;
 ```
 
-## I'm trying to call Python from Rust but I get `STATUS_DLL_NOT_FOUND` or `STATUS_ENTRYPOINT_NOT_FOUND`!
+## I'm trying to call Python from Rust but I get `STATUS_DLL_NOT_FOUND` or `STATUS_ENTRYPOINT_NOT_FOUND`
+
+This happens on Windows when linking to the python DLL fails or the wrong one is linked.
+The Python DLL on Windows will usually be called something like:
 
-This happens on Windows when linking to the python DLL fails or the wrong one is linked. The Python DLL on Windows will usually be called something like: 
 - `python3X.dll` for Python 3.X, e.g. `python310.dll` for Python 3.10
 - `python3.dll` when using PyO3's `abi3` feature
 
-The DLL needs to be locatable using the [Windows DLL search order](https://learn.microsoft.com/en-us/windows/win32/dlls/dynamic-link-library-search-order#standard-search-order-for-unpackaged-apps). Some ways to achieve this are:
+The DLL needs to be locatable using the [Windows DLL search order](https://learn.microsoft.com/en-us/windows/win32/dlls/dynamic-link-library-search-order#standard-search-order-for-unpackaged-apps).
+Some ways to achieve this are:
+
 - Put the Python DLL in the same folder as your build artifacts
 - Add the directory containing the Python DLL to your `PATH` environment variable, for example `C:\Users\<You>\AppData\Local\Programs\Python\Python310`
 - If this happens when you are *distributing* your program, consider using [PyOxidizer](https://github.com/indygreg/PyOxidizer) to package it with your binary.
 
-If the wrong DLL is linked it is possible that this happened because another program added itself and its own Python DLLs to `PATH`. Rearrange your `PATH` variables to give the correct DLL priority.
+If the wrong DLL is linked it is possible that this happened because another program added itself and its own Python DLLs to `PATH`.
+Rearrange your `PATH` variables to give the correct DLL priority.
 
 > **Note**: Changes to `PATH` (or any other environment variable) are not visible to existing shells. Restart it for changes to take effect.
 
diff --git a/guide/src/features.md b/guide/src/features.md
index 43124e0076e..44172b258aa 100644
--- a/guide/src/features.md
+++ b/guide/src/features.md
@@ -1,6 +1,7 @@
 # Features reference
 
-PyO3 provides a number of Cargo features to customize functionality. This chapter of the guide provides detail on each of them.
+PyO3 provides a number of Cargo features to customize functionality.
+This chapter of the guide provides detail on each of them.
 
 By default, only the `macros` feature is enabled.
 
@@ -12,7 +13,7 @@ This feature is required when building a Python extension module using PyO3.
 
 It tells PyO3's build script to skip linking against `libpython.so` on Unix platforms, where this must not be done.
 
-See the [building and distribution](building_and_distribution.md#linking) section for further detail.
+See the [building and distribution](building-and-distribution.md#the-extension-module-feature) section for further detail.
 
 ### `abi3`
 
@@ -20,7 +21,7 @@ This feature is used when building Python extension modules to create wheels whi
 
 It restricts PyO3's API to a subset of the full Python API which is guaranteed by [PEP 384](https://www.python.org/dev/peps/pep-0384/) to be forwards-compatible with future Python versions.
 
-See the [building and distribution](building_and_distribution.md#py_limited_apiabi3) section for further detail.
+See the [building and distribution](building-and-distribution.md#py_limited_apiabi3) section for further detail.
 
 ### The `abi3-pyXY` features
 
@@ -28,7 +29,7 @@ See the [building and distribution](building_and_distribution.md#py_limited_apia
 
 These features are extensions of the `abi3` feature to specify the exact minimum Python version which the multiple-version-wheel will support.
 
-See the [building and distribution](building_and_distribution.md#minimum-python-version-for-abi3) section for further detail.
+See the [building and distribution](building-and-distribution.md#minimum-python-version-for-abi3) section for further detail.
 
 ### `generate-import-lib`
 
@@ -38,30 +39,45 @@ for MinGW-w64 and MSVC (cross-)compile targets.
 Enabling it allows to (cross-)compile extension modules to any Windows targets
 without having to install the Windows Python distribution files for the target.
 
-See the [building and distribution](building_and_distribution.md#building-abi3-extensions-without-a-python-interpreter)
+See the [building and distribution](building-and-distribution.md#building-abi3-extensions-without-a-python-interpreter)
 section for further detail.
 
 ## Features for embedding Python in Rust
 
 ### `auto-initialize`
 
-This feature changes [`Python::with_gil`]({{#PYO3_DOCS_URL}}/pyo3/struct.Python.html#method.with_gil) to automatically initialize a Python interpreter (by calling [`prepare_freethreaded_python`]({{#PYO3_DOCS_URL}}/pyo3/fn.prepare_freethreaded_python.html)) if needed.
+This feature changes [`Python::attach`]({{#PYO3_DOCS_URL}}/pyo3/marker/struct.Python.html#method.attach) to automatically initialize a Python interpreter (by calling [`Python::initialize`]({{#PYO3_DOCS_URL}}/pyo3/marker/struct.Python.html#method.initialize)) if needed.
 
-If you do not enable this feature, you should call `pyo3::prepare_freethreaded_python()` before attempting to call any other Python APIs.
+If you do not enable this feature, you should call `Python::initialize()` before attempting to call any other Python APIs.
 
 ## Advanced Features
 
+### `experimental-async`
+
+This feature adds support for `async fn` in `#[pyfunction]` and `#[pymethods]`.
+
+The feature has some unfinished refinements and performance improvements.
+To help finish this off, see [issue #1632](https://github.com/PyO3/pyo3/issues/1632) and its associated draft PRs.
+
 ### `experimental-inspect`
 
-This feature adds the `pyo3::inspect` module, as well as `IntoPy::type_output` and `FromPyObject::type_input` APIs to produce Python type "annotations" for Rust types.
+This feature adds to the built binaries introspection data that can be then retrieved using the `pyo3-introspection` crate to generate [type stubs](https://typing.readthedocs.io/en/latest/source/stubs.html).
+
+Also, this feature adds the `pyo3::inspect` module, as well as `IntoPy::type_output` and `FromPyObject::type_input` APIs to produce Python type "annotations" for Rust types.
+
+This is a first step towards adding first-class support for generating type annotations automatically in PyO3, however work is needed to finish this off.
+All feedback and offers of help welcome on [issue #2454](https://github.com/PyO3/pyo3/issues/2454).
 
-This is a first step towards adding first-class support for generating type annotations automatically in PyO3, however work is needed to finish this off. All feedback and offers of help welcome on [issue #2454](https://github.com/PyO3/pyo3/issues/2454).
+### `py-clone`
 
-### `gil-refs`
+This feature was introduced to ease migration.
+It was found that delayed reference counting (which PyO3 used historically) could not be made sound and hence `Clone`-ing an instance of `Py<T>` is impossible when not attached to Python interpreter (it will panic).
+To avoid migrations introducing new panics without warning, the `Clone` implementation itself is now gated behind this feature.
 
-This feature is a backwards-compatibility feature to allow continued use of the "GIL Refs" APIs deprecated in PyO3 0.21. These APIs have performance drawbacks and soundness edge cases which the newer `Bound<T>` smart pointer and accompanying APIs resolve.
+### `pyo3_disable_reference_pool`
 
-This feature and the APIs it enables is expected to be removed in a future PyO3 version.
+This is a performance-oriented conditional compilation flag, e.g. [set via `$RUSTFLAGS`][set-configuration-options], which disabled the global reference pool and the associated overhead for the crossing the Python-Rust boundary.
+However, if enabled, `Drop`ping an instance of `Py<T>` when not attached to the Python interpreter will abort the process.
 
 ### `macros`
 
@@ -75,27 +91,31 @@ This feature enables a dependency on the `pyo3-macros` crate, which provides the
 
 It also provides the `py_run!` macro.
 
-These macros require a number of dependencies which may not be needed by users who just need PyO3 for Python FFI. Disabling this feature enables faster builds for those users, as these dependencies will not be built if this feature is disabled.
+These macros require a number of dependencies which may not be needed by users who just need PyO3 for Python FFI.
+Disabling this feature enables faster builds for those users, as these dependencies will not be built if this feature is disabled.
 
 > This feature is enabled by default. To disable it, set `default-features = false` for the `pyo3` entry in your Cargo.toml.
 
 ### `multiple-pymethods`
 
-This feature enables a dependency on `inventory`, which enables each `#[pyclass]` to have more than one `#[pymethods]` block. This feature also requires a minimum Rust version of 1.62 due to limitations in the `inventory` crate.
+This feature enables each `#[pyclass]` to have more than one `#[pymethods]` block.
 
-Most users should only need a single `#[pymethods]` per `#[pyclass]`. In addition, not all platforms (e.g. Wasm) are supported by `inventory`. For this reason this feature is not enabled by default, meaning fewer dependencies and faster compilation for the majority of users.
+Most users should only need a single `#[pymethods]` per `#[pyclass]`.
+In addition, not all platforms (e.g. Wasm) are supported by `inventory`, which is used in the implementation of the feature.
+For this reason this feature is not enabled by default, meaning fewer dependencies and faster compilation for the majority of users.
 
 See [the `#[pyclass]` implementation details](class.md#implementation-details) for more information.
 
 ### `nightly`
 
-The `nightly` feature needs the nightly Rust compiler. This allows PyO3 to use the `auto_traits` and `negative_impls` features to fix the `Python::allow_threads` function.
+The `nightly` feature needs the nightly Rust compiler.
+This allows PyO3 to use the `auto_traits` and `negative_impls` features to fix the `Python::detach` function.
 
 ### `resolve-config`
 
-The `resolve-config` feature of the `pyo3-build-config` crate controls whether that crate's
-build script automatically resolves a Python interpreter / build configuration. This feature is primarily useful when building PyO3
-itself. By default this feature is not enabled, meaning you can freely use `pyo3-build-config` as a standalone library to read or write PyO3 build configuration files or resolve metadata about a Python interpreter.
+The `resolve-config` feature of the `pyo3-build-config` crate controls whether that crate's build script automatically resolves a Python interpreter / build configuration.
+This feature is primarily useful when building PyO3 itself.
+By default this feature is not enabled, meaning you can freely use `pyo3-build-config` as a standalone library to read or write PyO3 build configuration files or resolve metadata about a Python interpreter.
 
 ## Optional Dependencies
 
@@ -103,31 +123,60 @@ These features enable conversions between Python types and types from other Rust
 
 ### `anyhow`
 
-Adds a dependency on [anyhow](https://docs.rs/anyhow). Enables a conversion from [anyhow](https://docs.rs/anyhow)’s [`Error`](https://docs.rs/anyhow/latest/anyhow/struct.Error.html) type to [`PyErr`]({{#PYO3_DOCS_URL}}/pyo3/struct.PyErr.html), for easy error handling.
+Adds a dependency on [anyhow](https://docs.rs/anyhow).
+Enables a conversion from [anyhow](https://docs.rs/anyhow)’s [`Error`](https://docs.rs/anyhow/latest/anyhow/struct.Error.html) type to [`PyErr`]({{#PYO3_DOCS_URL}}/pyo3/struct.PyErr.html), for easy error handling.
+
+### `arc_lock`
+
+Enables Pyo3's `MutexExt` trait for all Mutexes that extend on [`lock_api::Mutex`](https://docs.rs/lock_api/latest/lock_api/struct.Mutex.html) or [`parking_lot::ReentrantMutex`](https://docs.rs/lock_api/latest/lock_api/struct.ReentrantMutex.html) and are wrapped in an [`Arc`](https://doc.rust-lang.org/std/sync/struct.Arc.html) type.
+Like [`Arc<parking_lot::Mutex>`](https://docs.rs/parking_lot/latest/parking_lot/type.Mutex.html#method.lock_arc)
+
+### `bigdecimal`
+
+Adds a dependency on [bigdecimal](https://docs.rs/bigdecimal) and enables conversions into its [`BigDecimal`](https://docs.rs/bigdecimal/latest/bigdecimal/struct.BigDecimal.html) type.
+
+### `bytes`
+
+Adds a dependency on [bytes](https://docs.rs/bytes/latest/bytes) and enables conversions into its [`Bytes`](https://docs.rs/bytes/latest/bytes/struct.Bytes.html) type.
 
 ### `chrono`
 
-Adds a dependency on [chrono](https://docs.rs/chrono). Enables a conversion from [chrono](https://docs.rs/chrono)'s types to python:
-- [Duration](https://docs.rs/chrono/latest/chrono/struct.Duration.html) -> [`PyDelta`]({{#PYO3_DOCS_URL}}/pyo3/types/struct.PyDelta.html)
+Adds a dependency on [chrono](https://docs.rs/chrono).
+Enables a conversion from [chrono](https://docs.rs/chrono)'s types to python:
+
+- [TimeDelta](https://docs.rs/chrono/latest/chrono/struct.TimeDelta.html) -> [`PyDelta`]({{#PYO3_DOCS_URL}}/pyo3/types/struct.PyDelta.html)
 - [FixedOffset](https://docs.rs/chrono/latest/chrono/offset/struct.FixedOffset.html) -> [`PyDelta`]({{#PYO3_DOCS_URL}}/pyo3/types/struct.PyDelta.html)
 - [Utc](https://docs.rs/chrono/latest/chrono/offset/struct.Utc.html) -> [`PyTzInfo`]({{#PYO3_DOCS_URL}}/pyo3/types/struct.PyTzInfo.html)
 - [NaiveDate](https://docs.rs/chrono/latest/chrono/naive/struct.NaiveDate.html) -> [`PyDate`]({{#PYO3_DOCS_URL}}/pyo3/types/struct.PyDate.html)
 - [NaiveTime](https://docs.rs/chrono/latest/chrono/naive/struct.NaiveTime.html) -> [`PyTime`]({{#PYO3_DOCS_URL}}/pyo3/types/struct.PyTime.html)
 - [DateTime](https://docs.rs/chrono/latest/chrono/struct.DateTime.html) -> [`PyDateTime`]({{#PYO3_DOCS_URL}}/pyo3/types/struct.PyDateTime.html)
 
+### `chrono-local`
+
+Enables conversion from and to [Local](https://docs.rs/chrono/latest/chrono/struct.Local.html) timezones.
+The current system timezone as determined by [`iana_time_zone::get_timezone()`](https://docs.rs/iana-time-zone/latest/iana_time_zone/fn.get_timezone.html) will be used for conversions.
+
+`chrono::DateTime<Local>` will convert from either of:
+
+- `datetime` objects with `tzinfo` equivalent to the current system timezone.
+- "naive" `datetime` objects (those without a `tzinfo`), as it is a convention that naive datetime objects should be treated as using the system timezone.
+
+When converting to Python, `Local` tzinfo is converted to a `zoneinfo.ZoneInfo` matching the current system timezone.
+
 ### `chrono-tz`
 
 Adds a dependency on [chrono-tz](https://docs.rs/chrono-tz).
 Enables conversion from and to [`Tz`](https://docs.rs/chrono-tz/latest/chrono_tz/enum.Tz.html).
-It requires at least Python 3.9.
 
 ### `either`
 
-Adds a dependency on [either](https://docs.rs/either). Enables a conversions into [either](https://docs.rs/either)’s [`Either`](https://docs.rs/either/latest/either/struct.Report.html) type.
+Adds a dependency on [either](https://docs.rs/either).
+Enables a conversions into [either](https://docs.rs/either)’s [`Either`](https://docs.rs/either/latest/either/enum.Either.html) type.
 
 ### `eyre`
 
-Adds a dependency on [eyre](https://docs.rs/eyre). Enables a conversion from [eyre](https://docs.rs/eyre)’s [`Report`](https://docs.rs/eyre/latest/eyre/struct.Report.html) type to [`PyErr`]({{#PYO3_DOCS_URL}}/pyo3/struct.PyErr.html), for easy error handling.
+Adds a dependency on [eyre](https://docs.rs/eyre).
+Enables a conversion from [eyre](https://docs.rs/eyre)’s [`Report`](https://docs.rs/eyre/latest/eyre/struct.Report.html) type to [`PyErr`]({{#PYO3_DOCS_URL}}/pyo3/struct.PyErr.html), for easy error handling.
 
 ### `hashbrown`
 
@@ -137,24 +186,71 @@ Adds a dependency on [hashbrown](https://docs.rs/hashbrown) and enables conversi
 
 Adds a dependency on [indexmap](https://docs.rs/indexmap) and enables conversions into its [`IndexMap`](https://docs.rs/indexmap/latest/indexmap/map/struct.IndexMap.html) type.
 
+### `jiff-02`
+
+Adds a dependency on [jiff@0.2](https://docs.rs/jiff/0.2).
+Enables a conversion from [jiff](https://docs.rs/jiff)'s types to python:
+
+- [SignedDuration](https://docs.rs/jiff/0.2/jiff/struct.SignedDuration.html) -> [`PyDelta`]({{#PYO3_DOCS_URL}}/pyo3/types/struct.PyDelta.html)
+- [TimeZone](https://docs.rs/jiff/0.2/jiff/tz/struct.TimeZone.html) -> [`PyTzInfo`]({{#PYO3_DOCS_URL}}/pyo3/types/struct.PyTzInfo.html)
+- [Offset](https://docs.rs/jiff/0.2/jiff/tz/struct.Offset.html) -> [`PyTzInfo`]({{#PYO3_DOCS_URL}}/pyo3/types/struct.PyTzInfo.html)
+- [Date](https://docs.rs/jiff/0.2/jiff/civil/struct.Date.html) -> [`PyDate`]({{#PYO3_DOCS_URL}}/pyo3/types/struct.PyDate.html)
+- [Time](https://docs.rs/jiff/0.2/jiff/civil/struct.Time.html) -> [`PyTime`]({{#PYO3_DOCS_URL}}/pyo3/types/struct.PyTime.html)
+- [DateTime](https://docs.rs/jiff/0.2/jiff/civil/struct.DateTime.html) -> [`PyDateTime`]({{#PYO3_DOCS_URL}}/pyo3/types/struct.PyDateTime.html)
+- [Zoned](https://docs.rs/jiff/0.2/jiff/struct.Zoned.html) -> [`PyDateTime`]({{#PYO3_DOCS_URL}}/pyo3/types/struct.PyDateTime.html)
+- [Timestamp](https://docs.rs/jiff/0.2/jiff/struct.Timestamp.html) -> [`PyDateTime`]({{#PYO3_DOCS_URL}}/pyo3/types/struct.PyDateTime.html)
+- [ISOWeekDate](https://docs.rs/jiff/0.2/jiff/civil/struct.ISOWeekDate.html) -> [`PyDate`]({{#PYO3_DOCS_URL}}/pyo3/types/struct.PyDate.html)
+
+### `lock_api`
+
+Adds a dependency on [lock_api](https://docs.rs/lock_api) and enables Pyo3's `MutexExt` trait for all mutexes that extend on [`lock_api::Mutex`](https://docs.rs/lock_api/latest/lock_api/struct.Mutex.html) and [`parking_lot::ReentrantMutex`](https://docs.rs/lock_api/latest/lock_api/struct.ReentrantMutex.html) (like `parking_lot` or `spin`).
+
 ### `num-bigint`
 
-Adds a dependency on [num-bigint](https://docs.rs/num-bigint) and enables conversions into its [`BigInt`](https://docs.rs/num-bigint/latest/num_bigint/struct.BigInt.html) and [`BigUint`](https://docs.rs/num-bigint/latest/num_bigint/struct.BigUInt.html) types.
+Adds a dependency on [num-bigint](https://docs.rs/num-bigint) and enables conversions into its [`BigInt`](https://docs.rs/num-bigint/latest/num_bigint/struct.BigInt.html) and [`BigUint`](https://docs.rs/num-bigint/latest/num_bigint/struct.BigUint.html) types.
 
 ### `num-complex`
 
 Adds a dependency on [num-complex](https://docs.rs/num-complex) and enables conversions into its [`Complex`](https://docs.rs/num-complex/latest/num_complex/struct.Complex.html) type.
 
+### `num-rational`
+
+Adds a dependency on [num-rational](https://docs.rs/num-rational) and enables conversions into its [`Ratio`](https://docs.rs/num-rational/latest/num_rational/struct.Ratio.html) type.
+
+### `ordered-float`
+
+Adds a dependency on [ordered-float](https://docs.rs/ordered-float) and enables conversions between [ordered-float](https://docs.rs/ordered-float)'s types and Python:
+
+- [NotNan](https://docs.rs/ordered-float/latest/ordered_float/struct.NotNan.html) -> [`PyFloat`]({{#PYO3_DOCS_URL}}/pyo3/types/struct.PyFloat.html)
+- [OrderedFloat](https://docs.rs/ordered-float/latest/ordered_float/struct.OrderedFloat.html) -> [`PyFloat`]({{#PYO3_DOCS_URL}}/pyo3/types/struct.PyFloat.html)
+
+### `parking-lot`
+
+Adds a dependency on [parking_lot](https://docs.rs/parking_lot) and enables Pyo3's `OnceExt` & `MutexExt` traits for [`parking_lot::Once`](https://docs.rs/parking_lot/latest/parking_lot/struct.Once.html) [`parking_lot::Mutex`](https://docs.rs/parking_lot/latest/parking_lot/type.Mutex.html) and [`parking_lot::ReentrantMutex`](https://docs.rs/parking_lot/latest/parking_lot/type.ReentrantMutex.html) types.
+
 ### `rust_decimal`
 
 Adds a dependency on [rust_decimal](https://docs.rs/rust_decimal) and enables conversions into its [`Decimal`](https://docs.rs/rust_decimal/latest/rust_decimal/struct.Decimal.html) type.
 
+### `time`
+
+Adds a dependency on [time](https://docs.rs/time).
+Enables conversions between [time](https://docs.rs/time)'s types and Python:
+
+- [Date](https://docs.rs/time/0.3.38/time/struct.Date.html) -> [`PyDate`]({{#PYO3_DOCS_URL}}/pyo3/types/struct.PyDate.html)
+- [Time](https://docs.rs/time/0.3.38/time/struct.Time.html) -> [`PyTime`]({{#PYO3_DOCS_URL}}/pyo3/types/struct.PyTime.html)
+- [OffsetDateTime](https://docs.rs/time/0.3.38/time/struct.OffsetDateTime.html) -> [`PyDateTime`]({{#PYO3_DOCS_URL}}/pyo3/types/struct.PyDateTime.html)
+- [PrimitiveDateTime](https://docs.rs/time/0.3.38/time/struct.PrimitiveDateTime.html) -> [`PyDateTime`]({{#PYO3_DOCS_URL}}/pyo3/types/struct.PyDateTime.html)
+- [Duration](https://docs.rs/time/0.3.38/time/struct.Duration.html) -> [`PyDelta`]({{#PYO3_DOCS_URL}}/pyo3/types/struct.PyDelta.html)
+- [UtcOffset](https://docs.rs/time/0.3.38/time/struct.UtcOffset.html) -> [`PyTzInfo`]({{#PYO3_DOCS_URL}}/pyo3/types/struct.PyTzInfo.html)
+- [UtcDateTime](https://docs.rs/time/0.3.38/time/struct.UtcDateTime.html) -> [`PyDateTime`]({{#PYO3_DOCS_URL}}/pyo3/types/struct.PyDateTime.html)
+
 ### `serde`
 
 Enables (de)serialization of `Py<T>` objects via [serde](https://serde.rs/).
 This allows to use [`#[derive(Serialize, Deserialize)`](https://serde.rs/derive.html) on structs that hold references to `#[pyclass]` instances
 
-```rust
+```rust,no_run
 # #[cfg(feature = "serde")]
 # #[allow(dead_code)]
 # mod serde_only {
@@ -179,3 +275,9 @@ struct User {
 ### `smallvec`
 
 Adds a dependency on [smallvec](https://docs.rs/smallvec) and enables conversions into its [`SmallVec`](https://docs.rs/smallvec/latest/smallvec/struct.SmallVec.html) type.
+
+[set-configuration-options]: https://doc.rust-lang.org/reference/conditional-compilation.html#set-configuration-options
+
+### `uuid`
+
+Adds a dependency on [uuid](https://docs.rs/uuid) and enables conversions into its [`Uuid`](https://docs.rs/uuid/latest/uuid/struct.Uuid.html) type.
diff --git a/guide/src/free-threading.md b/guide/src/free-threading.md
new file mode 100644
index 00000000000..5222ff2202b
--- /dev/null
+++ b/guide/src/free-threading.md
@@ -0,0 +1,316 @@
+# Supporting Free-Threaded CPython
+
+CPython 3.14 declared support for the "free-threaded" build of CPython that does not rely on the [global interpreter lock](https://docs.python.org/3/glossary.html#term-global-interpreter-lock) (often referred to as the GIL) for thread safety.
+Since version 0.23, PyO3 supports building Rust extensions for the free-threaded Python build and calling into free-threaded Python from Rust.
+
+If you want more background on free-threaded Python in general, see the
+[what's new](https://docs.python.org/3/whatsnew/3.13.html#whatsnew313-free-threaded-cpython)
+entry in the 3.13 release notes (when the "free-threaded" build was first added as an experimental
+mode), the
+[free-threading HOWTO guide](https://docs.python.org/3/howto/free-threading-extensions.html#freethreading-extensions-howto)
+in the CPython docs, the
+[extension porting guide](https://py-free-threading.github.io/porting-extensions/)
+in the community-maintained Python free-threading guide, and
+[PEP 703](https://peps.python.org/pep-0703/), which provides the technical background
+for the free-threading implementation in CPython.
+
+In the GIL-enabled build (the only choice before the "free-threaded" build was introduced), the global interpreter lock serializes access to the Python runtime.
+The GIL is therefore a fundamental limitation to parallel scaling of multithreaded Python workflows, due to [Amdahl's law](https://en.wikipedia.org/wiki/Amdahl%27s_law), because any time spent executing a parallel processing task on only one execution context fundamentally cannot be sped up using parallelism.
+
+The free-threaded build removes this limit on multithreaded Python scaling.
+This means it's much more straightforward to achieve parallelism using the Python [`threading`] module.
+If you have ever needed to use [`multiprocessing`](https://docs.python.org/3/library/multiprocessing.html) to achieve a parallel speedup for some Python code, free-threading will likely allow the use of Python threads instead for the same workflow.
+
+PyO3's support for free-threaded Python will enable authoring native Python extensions that are thread-safe by construction, with much stronger safety guarantees than C extensions.
+Our goal is to enable ["fearless concurrency"](https://doc.rust-lang.org/book/ch16-00-concurrency.html) in the native Python runtime by building on the Rust [`Send` and `Sync`](https://doc.rust-lang.org/nomicon/send-and-sync.html) traits.
+
+This document provides advice for porting Rust code using PyO3 to run under
+free-threaded Python.
+
+## Supporting free-threaded Python with PyO3
+
+Many simple uses of PyO3, like exposing bindings for a "pure" Rust function with no side-effects or defining an immutable Python class, will likely work "out of the box" on the free-threaded build.
+All that will be necessary is to annotate Python modules declared by rust code in your project to declare that they support free-threaded Python, for example by declaring the module with `#[pymodule(gil_used = false)]`.
+
+More complicated `#[pyclass]` types may need to deal with thread-safety directly; there is [a dedicated section of the guide](./class/thread-safety.md) to discuss this.
+
+At a low-level, annotating a module sets the `Py_MOD_GIL` slot on modules defined by an extension to `Py_MOD_GIL_NOT_USED`, which allows the interpreter to see at runtime that the author of the extension thinks the extension is thread-safe.
+You should only do this if you know that your extension is thread-safe.
+Because of Rust's guarantees, this is already true for many extensions, however see below for more discussion about how to evaluate the thread safety of existing Rust extensions and how to think about the PyO3 API using a Python runtime with no GIL.
+
+If you do not explicitly mark that modules are thread-safe, the Python interpreter will re-enable the GIL at runtime while importing your module and print a `RuntimeWarning` with a message containing the name of the module causing it to re-enable the GIL.
+You can force the GIL to remain disabled by setting the `PYTHON_GIL=0` as an environment variable or passing `-Xgil=0` when starting Python (`0` means the GIL is turned off).
+
+If you are sure that all data structures exposed in a `PyModule` are
+thread-safe, then pass `gil_used = false` as a parameter to the
+`pymodule` procedural macro declaring the module or call
+`PyModule::gil_used` on a `PyModule` instance.  For example:
+
+```rust,no_run
+use pyo3::prelude::*;
+
+/// This module supports free-threaded Python
+#[pymodule(gil_used = false)]
+fn my_extension(m: &Bound<'_, PyModule>) -> PyResult<()> {
+    // add members to the module that you know are thread-safe
+    Ok(())
+}
+```
+
+Or for a module that is set up without using the `pymodule` macro:
+
+```rust,no_run
+use pyo3::prelude::*;
+
+# #[allow(dead_code)]
+fn register_child_module(parent_module: &Bound<'_, PyModule>) -> PyResult<()> {
+    let child_module = PyModule::new(parent_module.py(), "child_module")?;
+    child_module.gil_used(false)?;
+    parent_module.add_submodule(&child_module)
+}
+
+```
+
+For now you must explicitly opt in to free-threading support by annotating modules defined in your extension.
+In a future version of `PyO3`, we plan to make `gil_used = false` the default.
+
+See the
+[`string-sum`](https://github.com/PyO3/pyo3/tree/main/pyo3-ffi/examples/string-sum)
+example for how to declare free-threaded support using raw FFI calls for modules
+using single-phase initialization and the
+[`sequential`](https://github.com/PyO3/pyo3/tree/main/pyo3-ffi/examples/sequential)
+example for modules using multi-phase initialization.
+
+If you would like to use conditional compilation to trigger different code paths under the free-threaded build, you can use the `Py_GIL_DISABLED` attribute once you have configured your crate to generate the necessary build configuration data.
+See [the guide section](./building-and-distribution/multiple-python-versions.md) for more details about supporting multiple different Python versions, including the free-threaded build.
+
+## Special considerations for the free-threaded build
+
+The free-threaded interpreter does not have a GIL.
+Many existing extensions providing mutable data structures relied on the GIL to lock Python objects and make interior mutability thread-safe.
+
+Calling into the CPython C API is only legal when an OS thread is explicitly attached to the interpreter runtime.
+In the GIL-enabled build, this happens when the GIL is acquired.
+In the free-threaded build there is no GIL, but the same C macros that release or acquire the GIL in the GIL-enabled build instead ask the interpreter to attach the thread to the Python runtime, and there can be many threads simultaneously attached.
+See [PEP 703](https://peps.python.org/pep-0703/#thread-states) for more background about how threads can be attached and detached from the interpreter runtime, in a manner analogous to releasing and acquiring the GIL in the GIL-enabled build.
+
+In the GIL-enabled build, PyO3 uses the [`Python<'py>`] type and the `'py` lifetime to signify that the global interpreter lock is held.
+In the freethreaded build, holding a `'py` lifetime means only that the thread is currently attached to the Python interpreter -- other threads can be simultaneously interacting with the interpreter.
+
+### Attaching to the runtime
+
+You still need to obtain a `'py` lifetime to interact with Python objects or call into the CPython C API.
+If you are not yet attached to the Python runtime, you can register a thread using the [`Python::attach`] function.
+Threads created via the Python [`threading`] module do not need to do this, and pyo3 will handle setting up the [`Python<'py>`] token when CPython calls into your extension.
+
+### Detaching to avoid hangs and deadlocks
+
+The free-threaded build triggers global synchronization events in the following
+situations:
+
+- During garbage collection in order to get a globally consistent view of
+  reference counts and references between objects
+- In Python 3.13, when the first background thread is started in
+  order to mark certain objects as immortal
+- When either `sys.settrace` or `sys.setprofile` are called in order to
+  instrument running code objects and threads
+- During a call to `os.fork()`, to ensure a process-wide consistent state.
+
+This is a non-exhaustive list and there may be other situations in future Python
+versions that can trigger global synchronization events.
+
+This means that you should detach from the interpreter runtime using [`Python::detach`] in exactly the same situations as you should detach from the runtime in the GIL-enabled build: when doing long-running tasks that do not require the CPython runtime or when doing any task that needs to re-attach to the runtime (see the [guide section](parallelism.md#sharing-python-objects-between-rust-threads) that covers this).
+In the former case, you would observe a hang on threads that are waiting on the long-running task to complete, and in the latter case you would see a deadlock while a thread tries to attach after the runtime triggers a global synchronization event, but the spawning thread prevents the synchronization event from completing.
+
+### Exceptions and panics for multithreaded access of mutable `pyclass` instances
+
+Data attached to `pyclass` instances is protected from concurrent access by a `RefCell`-like pattern of runtime borrow checking.
+Like a `RefCell`, PyO3 will raise exceptions (or in some cases panic) to enforce exclusive access for mutable borrows.
+It was always possible to generate panics like this in PyO3 in code that releases the GIL with [`Python::detach`] or calling a python method accepting `&self` from a `&mut self` (see [the docs on interior mutability](./class.md#bound-and-interior-mutability),) but now in free-threaded Python there are more opportunities to trigger these panics from Python because there is no GIL to lock concurrent access to mutably borrowed data from Python.
+
+The most straightforward way to trigger this problem is to use the Python [`threading`] module to simultaneously call a rust function that mutably borrows a [`pyclass`]({{#PYO3_DOCS_URL}}/pyo3/attr.pyclass.html) in multiple threads.
+For example, consider the following implementation:
+
+```rust,no_run
+# use pyo3::prelude::*;
+#[pyclass]
+#[derive(Default)]
+struct ThreadIter {
+    count: usize,
+}
+
+#[pymethods]
+impl ThreadIter {
+    #[new]
+    pub fn new() -> Self {
+        Default::default()
+    }
+
+    fn __next__(&mut self, py: Python<'_>) -> usize {
+        self.count += 1;
+        self.count
+    }
+}
+```
+
+And then if we do something like this in Python:
+
+```python
+import concurrent.futures
+from my_module import ThreadIter
+
+i = ThreadIter()
+
+def increment():
+    next(i)
+
+with concurrent.futures.ThreadPoolExecutor(max_workers=16) as tpe:
+    futures = [tpe.submit(increment) for _ in range(100)]
+    [f.result() for f in futures]
+```
+
+We will see an exception:
+
+```text
+Traceback (most recent call last)
+  File "example.py", line 5, in <module>
+    next(i)
+RuntimeError: Already borrowed
+```
+
+We may allow user-selectable semantics for mutable pyclass definitions in a future version of PyO3, allowing some form of opt-in locking to emulate the GIL if that is needed.
+For now you should explicitly add locking, possibly using conditional compilation or using the critical section API, to avoid creating deadlocks with the GIL.
+
+### Cannot build extensions using the limited API
+
+The free-threaded build uses a completely new ABI and there is not yet an equivalent to the limited API for the free-threaded ABI.
+That means if your crate depends on PyO3 using the `abi3` feature or an an `abi3-pyxx` feature, PyO3 will print a warning and ignore that setting when building extensions using the free-threaded interpreter.
+
+This means that if your package makes use of the ABI forward compatibility
+provided by the limited API to upload only one wheel for each release of your
+package, you will need to update your release procedure to also upload a
+version-specific free-threaded wheel.
+
+See [the guide section](./building-and-distribution/multiple-python-versions.md)
+for more details about supporting multiple different Python versions, including
+the free-threaded build.
+
+### Thread-safe single initialization
+
+To initialize data exactly once, use the [`PyOnceLock`] type, which is a close equivalent to [`std::sync::OnceLock`][`OnceLock`] that also helps avoid deadlocks by detaching from the Python interpreter when threads are blocking waiting for another thread to complete initialization.
+If already using [`OnceLock`] and it is impractical to replace with a [`PyOnceLock`], there is the [`OnceLockExt`] extension trait which adds [`OnceLockExt::get_or_init_py_attached`] to detach from the interpreter when blocking in the same fashion as [`PyOnceLock`].
+Here is an example using [`PyOnceLock`] to single-initialize a runtime cache holding a `Py<PyDict>`:
+
+```rust
+# use pyo3::prelude::*;
+use pyo3::sync::PyOnceLock;
+use pyo3::types::PyDict;
+
+let cache: PyOnceLock<Py<PyDict>> = PyOnceLock::new();
+
+Python::attach(|py| {
+    // guaranteed to be called once and only once
+    cache.get_or_init(py, || PyDict::new(py).unbind())
+});
+```
+
+In cases where a function must run exactly once, you can bring the [`OnceExt`] trait into scope.
+The [`OnceExt`] trait adds [`OnceExt::call_once_py_attached`] and [`OnceExt::call_once_force_py_attached`] functions to the api of `std::sync::Once`, enabling use of [`Once`] in contexts where the thread is attached to the Python interpreter.
+These functions are analogous to [`Once::call_once`], [`Once::call_once_force`] except they accept a [`Python<'py>`] token in addition to an `FnOnce`.
+All of these functions detach from the interpreter before blocking and re-attach before executing the function, avoiding deadlocks that are possible without using the PyO3 extension traits.
+Here the same example as above built using a [`Once`] instead of a
+[`PyOnceLock`]:
+
+```rust
+# use pyo3::prelude::*;
+use std::sync::Once;
+use pyo3::sync::OnceExt;
+use pyo3::types::PyDict;
+
+struct RuntimeCache {
+    once: Once,
+    cache: Option<Py<PyDict>>
+}
+
+let mut cache = RuntimeCache {
+    once: Once::new(),
+    cache: None
+};
+
+Python::attach(|py| {
+    // guaranteed to be called once and only once
+    cache.once.call_once_py_attached(py, || {
+        cache.cache = Some(PyDict::new(py).unbind());
+    });
+});
+```
+
+### `GILProtected` is not exposed
+
+[`GILProtected`] is a (deprecated) PyO3 type that allows mutable access to static data by leveraging the GIL to lock concurrent access from other threads.
+In free-threaded Python there is no GIL, so you will need to replace this type with some other form of locking.
+In many cases, a type from [`std::sync::atomic`](https://doc.rust-lang.org/std/sync/atomic/) or a [`std::sync::Mutex`](https://doc.rust-lang.org/std/sync/struct.Mutex.html) will be sufficient.
+
+Before:
+
+```rust
+# #![allow(deprecated)]
+# fn main() {
+# #[cfg(not(Py_GIL_DISABLED))] {
+# use pyo3::prelude::*;
+use pyo3::sync::GILProtected;
+use pyo3::types::{PyDict, PyNone};
+use std::cell::RefCell;
+
+static OBJECTS: GILProtected<RefCell<Vec<Py<PyDict>>>> =
+    GILProtected::new(RefCell::new(Vec::new()));
+
+Python::attach(|py| {
+    // stand-in for something that executes arbitrary Python code
+    let d = PyDict::new(py);
+    d.set_item(PyNone::get(py), PyNone::get(py)).unwrap();
+    OBJECTS.get(py).borrow_mut().push(d.unbind());
+});
+# }}
+```
+
+After:
+
+```rust
+# use pyo3::prelude::*;
+# fn main() {
+use pyo3::types::{PyDict, PyNone};
+use std::sync::Mutex;
+
+static OBJECTS: Mutex<Vec<Py<PyDict>>> = Mutex::new(Vec::new());
+
+Python::attach(|py| {
+    // stand-in for something that executes arbitrary Python code
+    let d = PyDict::new(py);
+    d.set_item(PyNone::get(py), PyNone::get(py)).unwrap();
+    // as with any `Mutex` usage, lock the mutex for as little time as possible
+    // in this case, we do it just while pushing into the `Vec`
+    OBJECTS.lock().unwrap().push(d.unbind());
+});
+# }
+```
+
+If you are executing arbitrary Python code while holding the lock, then you should import the [`MutexExt`] trait and use the `lock_py_attached` method instead of `lock`.
+This ensures that global synchronization events started by the Python runtime can proceed, avoiding possible deadlocks with the interpreter.
+
+[`GILProtected`]: https://docs.rs/pyo3/0.22/pyo3/sync/struct.GILProtected.html
+[`MutexExt`]: {{#PYO3_DOCS_URL}}/pyo3/sync/trait.MutexExt.html
+[`Once`]: https://doc.rust-lang.org/stable/std/sync/struct.Once.html
+[`Once::call_once`]: https://doc.rust-lang.org/stable/std/sync/struct.Once.html#method.call_once
+[`Once::call_once_force`]: https://doc.rust-lang.org/stable/std/sync/struct.Once.html#method.call_once_force
+[`OnceExt`]: {{#PYO3_DOCS_URL}}/pyo3/sync/trait.OnceExt.html
+[`OnceExt::call_once_py_attached`]: {{#PYO3_DOCS_URL}}/pyo3/sync/trait.OnceExt.html#tymethod.call_once_py_attached
+[`OnceExt::call_once_force_py_attached`]: {{#PYO3_DOCS_URL}}/pyo3/sync/trait.OnceExt.html#tymethod.call_once_force_py_attached
+[`OnceLockExt`]: {{#PYO3_DOCS_URL}}/pyo3/sync/trait.OnceLockExt.html
+[`OnceLockExt::get_or_init_py_attached`]: {{#PYO3_DOCS_URL}}/pyo3/sync/trait.OnceLockExt.html#tymethod.get_or_init_py_attached
+[`OnceLock`]: https://doc.rust-lang.org/stable/std/sync/struct.OnceLock.html
+[`Python::detach`]: {{#PYO3_DOCS_URL}}/pyo3/marker/struct.Python.html#method.detach
+[`Python::attach`]: {{#PYO3_DOCS_URL}}/pyo3/marker/struct.Python.html#method.attach
+[`Python<'py>`]: {{#PYO3_DOCS_URL}}/pyo3/marker/struct.Python.html
+[`PyOnceLock`]: {{#PYO3_DOCS_URL}}/pyo3/sync/struct.PyOnceLock.html
+[`threading`]: https://docs.python.org/3/library/threading.html
diff --git a/guide/src/function-calls.md b/guide/src/function-calls.md
new file mode 100644
index 00000000000..e5c9c1ed9b3
--- /dev/null
+++ b/guide/src/function-calls.md
@@ -0,0 +1 @@
+# Calling Python functions
diff --git a/guide/src/function.md b/guide/src/function.md
index f3955ba554b..3eb13058c57 100644
--- a/guide/src/function.md
+++ b/guide/src/function.md
@@ -1,44 +1,45 @@
 # Python functions
 
-The `#[pyfunction]` attribute is used to define a Python function from a Rust function. Once defined, the function needs to be added to a [module](./module.md) using the `wrap_pyfunction!` macro.
+The `#[pyfunction]` attribute is used to define a Python function from a Rust function.
+Once defined, the function needs to be added to a [module](./module.md).
 
 The following example defines a function called `double` in a Python module called `my_extension`:
 
-```rust
-use pyo3::prelude::*;
-
-#[pyfunction]
-fn double(x: usize) -> usize {
-    x * 2
-}
+```rust,no_run
+#[pyo3::pymodule]
+mod my_extension {
+    use pyo3::prelude::*;
 
-#[pymodule]
-fn my_extension(py: Python<'_>, m: &PyModule) -> PyResult<()> {
-    m.add_function(wrap_pyfunction!(double, m)?)?;
-    Ok(())
+    #[pyfunction]
+    fn double(x: usize) -> usize {
+        x * 2
+    }
 }
 ```
 
-This chapter of the guide explains full usage of the `#[pyfunction]` attribute. In this first section, the following topics are covered:
+This chapter of the guide explains full usage of the `#[pyfunction]` attribute.
+In this first section, the following topics are covered:
 
 - [Function options](#function-options)
   - [`#[pyo3(name = "...")]`](#name)
   - [`#[pyo3(signature = (...))]`](#signature)
   - [`#[pyo3(text_signature = "...")]`](#text_signature)
   - [`#[pyo3(pass_module)]`](#pass_module)
+  - [`#[pyo3(warn(message = "...", category = ...))]`](#warn)
 - [Per-argument options](#per-argument-options)
 - [Advanced function patterns](#advanced-function-patterns)
-- [`#[pyfn]` shorthand](#pyfn-shorthand)
 
 There are also additional sections on the following topics:
 
 - [Function Signatures](./function/signature.md)
+- [Error Handling](./function/error-handling.md)
 
 ## Function options
 
-The `#[pyo3]` attribute can be used to modify properties of the generated Python function. It can take any combination of the following options:
+The `#[pyo3]` attribute can be used to modify properties of the generated Python function.
+It can take any combination of the following options:
 
-  - <a name="name"></a> `#[pyo3(name = "...")]`
+- <a id="name"></a> `#[pyo3(name = "...")]`
 
     Overrides the name exposed to Python.
 
@@ -46,81 +47,184 @@ The `#[pyo3]` attribute can be used to modify properties of the generated Python
     `module_with_functions` as the Python function `no_args`:
 
     ```rust
-    use pyo3::prelude::*;
-
-    #[pyfunction]
-    #[pyo3(name = "no_args")]
-    fn no_args_py() -> usize {
-        42
+    # use pyo3::prelude::*;
+    #[pyo3::pymodule]
+    mod module_with_functions {
+        use pyo3::prelude::*;
+
+        #[pyfunction]
+        #[pyo3(name = "no_args")]
+        fn no_args_py() -> usize {
+            42
+        }
     }
 
-    #[pymodule]
-    fn module_with_functions(py: Python<'_>, m: &PyModule) -> PyResult<()> {
-        m.add_function(wrap_pyfunction!(no_args_py, m)?)?;
-        Ok(())
-    }
-
-    # Python::with_gil(|py| {
+    # Python::attach(|py| {
     #     let m = pyo3::wrap_pymodule!(module_with_functions)(py);
     #     assert!(m.getattr(py, "no_args").is_ok());
     #     assert!(m.getattr(py, "no_args_py").is_err());
     # });
     ```
 
-  - <a name="signature"></a> `#[pyo3(signature = (...))]`
+- <a id="signature"></a> `#[pyo3(signature = (...))]`
 
     Defines the function signature in Python. See [Function Signatures](./function/signature.md).
 
-  - <a name="text_signature"></a> `#[pyo3(text_signature = "...")]`
+- <a id="text_signature"></a> `#[pyo3(text_signature = "...")]`
 
     Overrides the PyO3-generated function signature visible in Python tooling (such as via [`inspect.signature`]). See the [corresponding topic in the Function Signatures subchapter](./function/signature.md#making-the-function-signature-available-to-python).
 
-  - <a name="pass_module" ></a> `#[pyo3(pass_module)]`
+- <a id="pass_module" ></a> `#[pyo3(pass_module)]`
 
-    Set this option to make PyO3 pass the containing module as the first argument to the function. It is then possible to use the module in the function body. The first argument **must** be of type `&PyModule`.
+    Set this option to make PyO3 pass the containing module as the first argument to the function. It is then possible to use the module in the function body. The first argument **must** be of type `&Bound<'_, PyModule>`, `Bound<'_, PyModule>`, or `Py<PyModule>`.
 
     The following example creates a function `pyfunction_with_module` which returns the containing module's name (i.e. `module_with_fn`):
 
+    ```rust,no_run
+    #[pyo3::pymodule]
+    mod module_with_fn {
+        use pyo3::prelude::*;
+        use pyo3::types::PyString;
+
+        #[pyfunction]
+        #[pyo3(pass_module)]
+        fn pyfunction_with_module<'py>(
+            module: &Bound<'py, PyModule>,
+        ) -> PyResult<Bound<'py, PyString>> {
+            module.name()
+        }
+    }
+    ```
+
+- <a id="warn"></a> `#[pyo3(warn(message = "...", category = ...))]`
+
+    This option is used to display a warning when the function is used in Python. It is equivalent to [`warnings.warn(message, category)`](https://docs.python.org/3/library/warnings.html#warnings.warn).
+    The `message` parameter is a string that will be displayed when the function is called, and the `category` parameter is optional and has to be a subclass of [`Warning`](https://docs.python.org/3/library/exceptions.html#Warning).
+    When the `category` parameter is not provided, the warning will be defaulted to [`UserWarning`](https://docs.python.org/3/library/exceptions.html#UserWarning).
+
+    > Note: when used with `#[pymethods]`, this attribute does not work with `#[classattr]` nor `__traverse__` magic method.
+
+    The following are examples of using the `#[pyo3(warn)]` attribute:
+
     ```rust
     use pyo3::prelude::*;
-    use pyo3::types::PyString;
-
-    #[pyfunction]
-    #[pyo3(pass_module)]
-    fn pyfunction_with_module<'py>(module: &Bound<'py, PyModule>) -> PyResult<Bound<'py, PyString>> {
-        module.name()
-    }
 
     #[pymodule]
-    fn module_with_fn(py: Python<'_>, m: &PyModule) -> PyResult<()> {
-        m.add_function(wrap_pyfunction!(pyfunction_with_module, m)?)
+    mod raising_warning_fn {
+        use pyo3::prelude::pyfunction;
+        use pyo3::exceptions::PyFutureWarning;
+
+        #[pyfunction]
+        #[pyo3(warn(message = "This is a warning message"))]
+        fn function_with_warning() -> usize {
+            42
+        }
+
+        #[pyfunction]
+        #[pyo3(warn(message = "This function is warning with FutureWarning", category = PyFutureWarning))]
+        fn function_with_warning_and_custom_category() -> usize {
+            42
+        }
     }
+
+    # use pyo3::exceptions::{PyFutureWarning, PyUserWarning};
+    # use pyo3::types::{IntoPyDict, PyList};
+    # use pyo3::PyTypeInfo;
+    #
+    # fn catch_warning(py: Python<'_>, f: impl FnOnce(&Bound<'_, PyList>) -> ()) -> PyResult<()> {
+    #     let warnings = py.import("warnings")?;
+    #     let kwargs = [("record", true)].into_py_dict(py)?;
+    #     let catch_warnings = warnings
+    #         .getattr("catch_warnings")?
+    #         .call((), Some(&kwargs))?;
+    #     let list = catch_warnings.call_method0("__enter__")?.cast_into()?;
+    #     warnings.getattr("simplefilter")?.call1(("always",))?;  // show all warnings
+    #     f(&list);
+    #     catch_warnings
+    #         .call_method1("__exit__", (py.None(), py.None(), py.None()))
+    #         .unwrap();
+    #     Ok(())
+    # }
+    #
+    # macro_rules! assert_warnings {
+    #     ($py:expr, $body:expr, [$(($category:ty, $message:literal)),+] $(,)? ) => {
+    #         catch_warning($py, |list| {
+    #             $body;
+    #             let expected_warnings = [$((<$category as PyTypeInfo>::type_object($py), $message)),+];
+    #             assert_eq!(list.len(), expected_warnings.len());
+    #             for (warning, (category, message)) in list.iter().zip(expected_warnings) {
+    #                 assert!(warning.getattr("category").unwrap().is(&category));
+    #                 assert_eq!(
+    #                     warning.getattr("message").unwrap().str().unwrap().to_string_lossy(),
+    #                     message
+    #                 );
+    #             }
+    #         }).unwrap();
+    #     };
+    # }
+    #
+    # Python::attach(|py| {
+    #     assert_warnings!(
+    #         py,
+    #         {
+    #             let m = pyo3::wrap_pymodule!(raising_warning_fn)(py);
+    #             let f1 = m.getattr(py, "function_with_warning").unwrap();
+    #             let f2 = m.getattr(py, "function_with_warning_and_custom_category").unwrap();
+    #             f1.call0(py).unwrap();
+    #             f2.call0(py).unwrap();
+    #         },
+    #         [
+    #             (PyUserWarning, "This is a warning message"),
+    #             (
+    #                 PyFutureWarning,
+    #                 "This function is warning with FutureWarning"
+    #             )
+    #         ]
+    #     );
+    # });
+    ```
+
+    When the functions are called as the following, warnings will be displayed.
+
+    ```python
+    import warnings
+    from raising_warning_fn import function_with_warning, function_with_warning_and_custom_category
+
+    function_with_warning()
+    function_with_warning_and_custom_category()
+    ```
+
+    The warning output will be:
+
+    ```plaintext
+    UserWarning: This is a warning message
+    FutureWarning: This function is warning with FutureWarning
     ```
 
 ## Per-argument options
 
-The `#[pyo3]` attribute can be used on individual arguments to modify properties of them in the generated function. It can take any combination of the following options:
+The `#[pyo3]` attribute can be used on individual arguments to modify properties of them in the generated function.
+It can take any combination of the following options:
 
-  - <a name="from_py_with"></a> `#[pyo3(from_py_with = "...")]`
+- <a id="from_py_with"></a> `#[pyo3(from_py_with = ...)]`
 
-    Set this on an option to specify a custom function to convert the function argument from Python to the desired Rust type, instead of using the default `FromPyObject` extraction. The function signature must be `fn(&PyAny) -> PyResult<T>` where `T` is the Rust type of the argument.
+    Set this on an option to specify a custom function to convert the function argument from Python to the desired Rust type, instead of using the default `FromPyObject` extraction. The function signature must be `fn(&Bound<'_, PyAny>) -> PyResult<T>` where `T` is the Rust type of the argument.
 
     The following example uses `from_py_with` to convert the input Python object to its length:
 
     ```rust
     use pyo3::prelude::*;
 
-    fn get_length(obj: &PyAny) -> PyResult<usize> {
-        let length = obj.len()?;
-        Ok(length)
+    fn get_length(obj: &Bound<'_, PyAny>) -> PyResult<usize> {
+        obj.len()
     }
 
     #[pyfunction]
-    fn object_length(#[pyo3(from_py_with = "get_length")] argument: usize) -> usize {
+    fn object_length(#[pyo3(from_py_with = get_length)] argument: usize) -> usize {
         argument
     }
 
-    # Python::with_gil(|py| {
+    # Python::attach(|py| {
     #     let f = pyo3::wrap_pyfunction!(object_length)(py).unwrap();
     #     assert_eq!(f.call1((vec![1, 2, 3],)).unwrap().extract::<usize>().unwrap(), 3);
     # });
@@ -134,11 +238,9 @@ You can pass Python `def`'d functions and built-in functions to Rust functions [
 corresponds to regular Python functions while [`PyCFunction`] describes built-ins such as
 `repr()`.
 
-You can also use [`PyAny::is_callable`] to check if you have a callable object. `is_callable` will
-return `true` for functions (including lambdas), methods and objects with a `__call__` method.
-You can call the object with [`PyAny::call`] with the args as first parameter and the kwargs
-(or `None`) as second parameter. There are also [`PyAny::call0`] with no args and [`PyAny::call1`]
-with only positional args.
+You can also use [`Bound<'_, PyAny>::is_callable`] to check if you have a callable object. `is_callable` will return `true` for functions (including lambdas), methods and objects with a `__call__` method.
+You can call the object with [`Bound<'_, PyAny>::call`] with the args as first parameter and the kwargs (or `None`) as second parameter.
+There are also [`Bound<'_, PyAny>::call0`] with no args and [`Bound<'_, PyAny>::call1`] with only positional args.
 
 ### Calling Rust functions in Python
 
@@ -149,63 +251,24 @@ The ways to convert a Rust function into a Python object vary depending on the f
   - use a `#[pyclass]` struct which stores the function as a field and implement `__call__` to call the stored function.
   - use `PyCFunction::new_closure` to create an object directly from the function.
 
-[`PyAny::is_callable`]: {{#PYO3_DOCS_URL}}/pyo3/struct.PyAny.html#tymethod.is_callable
-[`PyAny::call`]: {{#PYO3_DOCS_URL}}/pyo3/struct.PyAny.html#tymethod.call
-[`PyAny::call0`]: {{#PYO3_DOCS_URL}}/pyo3/struct.PyAny.html#tymethod.call0
-[`PyAny::call1`]: {{#PYO3_DOCS_URL}}/pyo3/struct.PyAny.html#tymethod.call1
-[`PyObject`]: {{#PYO3_DOCS_URL}}/pyo3/type.PyObject.html
-[`wrap_pyfunction!`]: {{#PYO3_DOCS_URL}}/pyo3/macro.wrap_pyfunction.html
-[`PyFunction`]: {{#PYO3_DOCS_URL}}/pyo3/types/struct.PyFunction.html
-[`PyCFunction`]: {{#PYO3_DOCS_URL}}/pyo3/types/struct.PyCFunction.html
-
 ### Accessing the FFI functions
 
-In order to make Rust functions callable from Python, PyO3 generates an `extern "C"`
-function whose exact signature depends on the Rust signature.  (PyO3 chooses the optimal
-Python argument passing convention.) It then embeds the call to the Rust function inside this
-FFI-wrapper function. This wrapper handles extraction of the regular arguments and the keyword
-arguments from the input `PyObject`s.
-
-The `wrap_pyfunction` macro can be used to directly get a `PyCFunction` given a
-`#[pyfunction]` and a `PyModule`: `wrap_pyfunction!(rust_fun, module)`.
-
-## `#[pyfn]` shorthand
-
-There is a shorthand to `#[pyfunction]` and `wrap_pymodule!`: the function can be placed inside the module definition and
-annotated with `#[pyfn]`. To simplify PyO3, it is expected that `#[pyfn]` may be removed in a future release (See [#694](https://github.com/PyO3/pyo3/issues/694)).
-
-An example of `#[pyfn]` is below:
-
-```rust
-use pyo3::prelude::*;
-
-#[pymodule]
-fn my_extension(py: Python<'_>, m: &PyModule) -> PyResult<()> {
-    #[pyfn(m)]
-    fn double(x: usize) -> usize {
-        x * 2
-    }
-
-    Ok(())
-}
-```
-
-`#[pyfn(m)]` is just syntactic sugar for `#[pyfunction]`, and takes all the same options
-documented in the rest of this chapter. The code above is expanded to the following:
+In order to make Rust functions callable from Python, PyO3 generates an `extern "C"` function whose exact signature depends on the Rust signature.  (PyO3 chooses the optimal Python argument passing convention.) It then embeds the call to the Rust function inside this FFI-wrapper function.
+This wrapper handles extraction of the regular arguments and the keyword arguments from the input `PyObject`s.
 
-```rust
-use pyo3::prelude::*;
-
-#[pymodule]
-fn my_extension(py: Python<'_>, m: &PyModule) -> PyResult<()> {
-    #[pyfunction]
-    fn double(x: usize) -> usize {
-        x * 2
-    }
-
-    m.add_function(wrap_pyfunction!(double, m)?)?;
-    Ok(())
-}
-```
+The `wrap_pyfunction` macro can be used to directly get a `Bound<PyCFunction>` given a
+`#[pyfunction]` and a `Bound<PyModule>`: `wrap_pyfunction!(rust_fun, module)`.
 
+<!-- rumdl-disable-next-line MD053 - false positive -->
+[`Bound<'_, PyAny>::is_callable`]: {{#PYO3_DOCS_URL}}/pyo3/prelude/trait.PyAnyMethods.html#tymethod.is_callable
+<!-- rumdl-disable-next-line MD053 - false positive -->
+[`Bound<'_, PyAny>::call`]: {{#PYO3_DOCS_URL}}/pyo3/prelude/trait.PyAnyMethods.html#tymethod.call
+<!-- rumdl-disable-next-line MD053 - false positive -->
+[`Bound<'_, PyAny>::call0`]: {{#PYO3_DOCS_URL}}/pyo3/prelude/trait.PyAnyMethods.html#tymethod.call0
+<!-- rumdl-disable-next-line MD053 - false positive -->
+[`Bound<'_, PyAny>::call1`]: {{#PYO3_DOCS_URL}}/pyo3/prelude/trait.PyAnyMethods.html#tymethod.call1
+[`wrap_pyfunction!`]: {{#PYO3_DOCS_URL}}/pyo3/macro.wrap_pyfunction.html
+[`PyFunction`]: {{#PYO3_DOCS_URL}}/pyo3/types/struct.PyFunction.html
+[`PyCFunction`]: {{#PYO3_DOCS_URL}}/pyo3/types/struct.PyCFunction.html
+<!-- rumdl-disable-next-line MD053 - false positive -->
 [`inspect.signature`]: https://docs.python.org/3/library/inspect.html#inspect.signature
diff --git a/guide/src/function/error_handling.md b/guide/src/function/error-handling.md
similarity index 78%
rename from guide/src/function/error_handling.md
rename to guide/src/function/error-handling.md
index b0f63885cdf..5db344bb6c1 100644
--- a/guide/src/function/error_handling.md
+++ b/guide/src/function/error-handling.md
@@ -8,11 +8,14 @@ There is a later section of the guide on [Python exceptions](../exception.md) wh
 
 ## Representing Python exceptions
 
-Rust code uses the generic [`Result<T, E>`] enum to propagate errors. The error type `E` is chosen by the code author to describe the possible errors which can happen.
+Rust code uses the generic [`Result<T, E>`] enum to propagate errors.
+The error type `E` is chosen by the code author to describe the possible errors which can happen.
 
-PyO3 has the [`PyErr`] type which represents a Python exception. If a PyO3 API could result in a Python exception being raised, the return type of that `API` will be [`PyResult<T>`], which is an alias for the type `Result<T, PyErr>`.
+PyO3 has the [`PyErr`] type which represents a Python exception.
+If a PyO3 API could result in a Python exception being raised, the return type of that `API` will be [`PyResult<T>`], which is an alias for the type `Result<T, PyErr>`.
 
 In summary:
+
 - When Python exceptions are raised and caught by PyO3, the exception will be stored in the `Err` variant of the `PyResult`.
 - Passing Python exceptions through Rust code then uses all the "normal" techniques such as the `?` operator, with `PyErr` as the error type.
 - Finally, when a `PyResult` crosses from Rust back to Python via PyO3, if the result is an `Err` variant the contained exception will be raised.
@@ -23,7 +26,8 @@ In summary:
 
 As indicated in the previous section, when a `PyResult` containing an `Err` crosses from Rust to Python, PyO3 will raise the exception contained within.
 
-Accordingly, to raise an exception from a `#[pyfunction]`, change the return type `T` to `PyResult<T>`. When the function returns an `Err` it will raise a Python exception. (Other `Result<T, E>` types can be used as long as the error `E` has a `From` conversion for `PyErr`, see [implementing a conversion](#implementing-an-error-conversion) below.)
+Accordingly, to raise an exception from a `#[pyfunction]`, change the return type `T` to `PyResult<T>`.
+When the function returns an `Err` it will raise a Python exception. (Other `Result<T, E>` types can be used as long as the error `E` has a `From` conversion for `PyErr`, see [custom Rust error types](#custom-rust-error-types) below.)
 
 This also works for functions in `#[pymethods]`.
 
@@ -43,7 +47,7 @@ fn check_positive(x: i32) -> PyResult<()> {
 }
 #
 # fn main(){
-# 	Python::with_gil(|py|{
+# 	Python::attach(|py|{
 # 		let fun = pyo3::wrap_pyfunction!(check_positive, py).unwrap();
 # 		fun.call1((-1,)).unwrap_err();
 # 		fun.call1((1,)).unwrap();
@@ -51,11 +55,13 @@ fn check_positive(x: i32) -> PyResult<()> {
 # }
 ```
 
-All built-in Python exception types are defined in the [`pyo3::exceptions`] module. They have a `new_err` constructor to directly build a `PyErr`, as seen in the example above.
+All built-in Python exception types are defined in the [`pyo3::exceptions`] module.
+They have a `new_err` constructor to directly build a `PyErr`, as seen in the example above.
 
 ## Custom Rust error types
 
-PyO3 will automatically convert a `Result<T, E>` returned by a `#[pyfunction]` into a `PyResult<T>` as long as there is an implementation of `std::from::From<E> for PyErr`. Many error types in the Rust standard library have a [`From`] conversion defined in this way.
+PyO3 will automatically convert a `Result<T, E>` returned by a `#[pyfunction]` into a `PyResult<T>` as long as there is an implementation of `std::from::From<E> for PyErr`.
+Many error types in the Rust standard library have a [`From`] conversion defined in this way.
 
 If the type `E` you are handling is defined in a third-party crate, see the section on [foreign rust error types](#foreign-rust-error-types) below for ways to work with this error.
 
@@ -71,7 +77,7 @@ fn parse_int(x: &str) -> Result<usize, ParseIntError> {
 }
 
 # fn main() {
-#     Python::with_gil(|py| {
+#     Python::attach(|py| {
 #         let fun = pyo3::wrap_pyfunction!(parse_int, py).unwrap();
 #         let value: usize = fun.call1(("5",)).unwrap().extract().unwrap();
 #         assert_eq!(value, 5);
@@ -88,7 +94,8 @@ Traceback (most recent call last):
 ValueError: invalid digit found in string
 ```
 
-As a more complete example, the following snippet defines a Rust error named `CustomIOError`. It then defines a `From<CustomIOError> for PyErr`, which returns a `PyErr` representing Python's `OSError`.
+As a more complete example, the following snippet defines a Rust error named `CustomIOError`.
+It then defines a `From<CustomIOError> for PyErr`, which returns a `PyErr` representing Python's `OSError`.
 Therefore, it can use this error in the result of a `#[pyfunction]` directly, relying on the conversion if it has to be propagated into a Python exception.
 
 ```rust
@@ -131,7 +138,7 @@ fn connect(s: String) -> Result<(), CustomIOError> {
 }
 
 fn main() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let fun = pyo3::wrap_pyfunction!(connect, py).unwrap();
         let err = fun.call1(("0.0.0.0",)).unwrap_err();
         assert!(err.is_instance_of::<PyOSError>(py));
@@ -139,13 +146,11 @@ fn main() {
 }
 ```
 
-If lazy construction of the Python exception instance is desired, the
-[`PyErrArguments`]({{#PYO3_DOCS_URL}}/pyo3/trait.PyErrArguments.html)
-trait can be implemented instead of `From`. In that case, actual exception argument creation is delayed
-until the `PyErr` is needed.
+If lazy construction of the Python exception instance is desired, the [`PyErrArguments`]({{#PYO3_DOCS_URL}}/pyo3/trait.PyErrArguments.html) trait can be implemented instead of `From`.
+In that case, actual exception argument creation is delayed until the `PyErr` is needed.
 
-A final note is that any errors `E` which have a `From` conversion can be used with the `?`
-("try") operator with them. An alternative implementation of the above `parse_int` which instead returns `PyResult` is below:
+A final note is that any errors `E` which have a `From` conversion can be used with the `?` ("try") operator with them.
+An alternative implementation of the above `parse_int` which instead returns `PyResult` is below:
 
 ```rust
 use pyo3::prelude::*;
@@ -158,7 +163,7 @@ fn parse_int(s: String) -> PyResult<usize> {
 # use pyo3::exceptions::PyValueError;
 #
 # fn main() {
-#     Python::with_gil(|py| {
+#     Python::attach(|py| {
 #         assert_eq!(parse_int(String::from("1")).unwrap(), 1);
 #         assert_eq!(parse_int(String::from("1337")).unwrap(), 1337);
 #
@@ -181,10 +186,13 @@ The Rust compiler will not permit implementation of traits for types outside of
 
 Given a type `OtherError` which is defined in third-party code, there are two main strategies available to integrate it with PyO3:
 
-- Create a newtype wrapper, e.g. `MyOtherError`. Then implement `From<MyOtherError> for PyErr` (or `PyErrArguments`), as well as `From<OtherError>` for `MyOtherError`.
-- Use Rust's Result combinators such as `map_err` to write code freely to convert `OtherError` into whatever is needed. This requires boilerplate at every usage however gives unlimited flexibility.
+- Create a newtype wrapper, e.g. `MyOtherError`.
+  Then implement `From<MyOtherError> for PyErr` (or `PyErrArguments`), as well as `From<OtherError>` for `MyOtherError`.
+- Use Rust's Result combinators such as `map_err` to write code freely to convert `OtherError` into whatever is needed.
+  This requires boilerplate at every usage however gives unlimited flexibility.
 
-To detail the newtype strategy a little further, the key trick is to return `Result<T, MyOtherError>` from the `#[pyfunction]`. This means that PyO3 will make use of `From<MyOtherError> for PyErr` to create Python exceptions while the `#[pyfunction]` implementation can use `?` to convert `OtherError` to `MyOtherError` automatically.
+To detail the newtype strategy a little further, the key trick is to return `Result<T, MyOtherError>` from the `#[pyfunction]`.
+This means that PyO3 will make use of `From<MyOtherError> for PyErr` to create Python exceptions while the `#[pyfunction]` implementation can use `?` to convert `OtherError` to `MyOtherError` automatically.
 
 The following example demonstrates this for some imaginary third-party crate `some_crate` with a function `get_x` returning `Result<i32, OtherError>`:
 
@@ -223,7 +231,7 @@ fn wrapped_get_x() -> Result<i32, MyOtherError> {
 }
 
 # fn main() {
-#     Python::with_gil(|py| {
+#     Python::attach(|py| {
 #         let fun = pyo3::wrap_pyfunction!(wrapped_get_x, py).unwrap();
 #         let value: usize = fun.call0().unwrap().extract().unwrap();
 #         assert_eq!(value, 5);
@@ -231,11 +239,13 @@ fn wrapped_get_x() -> Result<i32, MyOtherError> {
 # }
 ```
 
+## Notes
+
+In Python 3.11 and up, notes can be added to Python exceptions to provide additional debugging information when printing the exception.
+In PyO3, you can use the `add_note` method on `PyErr` to accomplish this functionality.
 
 [`From`]: https://doc.rust-lang.org/stable/std/convert/trait.From.html
 [`Result<T, E>`]: https://doc.rust-lang.org/stable/std/result/enum.Result.html
-
-[`PyResult<T>`]: {{#PYO3_DOCS_URL}}/pyo3/prelude/type.PyResult.html
 [`PyResult<T>`]: {{#PYO3_DOCS_URL}}/pyo3/prelude/type.PyResult.html
 [`PyErr`]: {{#PYO3_DOCS_URL}}/pyo3/struct.PyErr.html
 [`pyo3::exceptions`]: {{#PYO3_DOCS_URL}}/pyo3/exceptions/index.html
diff --git a/guide/src/function/signature.md b/guide/src/function/signature.md
index 8341f51c38c..a185bb541c0 100644
--- a/guide/src/function/signature.md
+++ b/guide/src/function/signature.md
@@ -1,8 +1,12 @@
 # Function signatures
 
-The `#[pyfunction]` attribute also accepts parameters to control how the generated Python function accepts arguments. Just like in Python, arguments can be positional-only, keyword-only, or accept either. `*args` lists and `**kwargs` dicts can also be accepted. These parameters also work for `#[pymethods]` which will be introduced in the [Python Classes](../class.md) section of the guide.
+The `#[pyfunction]` attribute also accepts parameters to control how the generated Python function accepts arguments.
+Just like in Python, arguments can be positional-only, keyword-only, or accept either. `*args` lists and `**kwargs` dicts can also be accepted.
+These parameters also work for `#[pymethods]` which will be introduced in the [Python Classes](../class.md) section of the guide.
 
-Like Python, by default PyO3 accepts all arguments as either positional or keyword arguments. Most arguments are required by default, except for trailing `Option<_>` arguments, which are [implicitly given a default of `None`](#trailing-optional-arguments). This behaviour can be configured by the `#[pyo3(signature = (...))]` option which allows writing a signature in Python syntax.
+Like Python, by default PyO3 accepts all arguments as either positional or keyword arguments.
+All arguments are required by default.
+This behaviour can be configured by the `#[pyo3(signature = (...))]` option which allows writing a signature in Python syntax.
 
 This section of the guide goes into detail about use of the `#[pyo3(signature = (...))]` option and its related option `#[pyo3(text_signature = "...")]`
 
@@ -10,36 +14,35 @@ This section of the guide goes into detail about use of the `#[pyo3(signature =
 
 For example, below is a function that accepts arbitrary keyword arguments (`**kwargs` in Python syntax) and returns the number that was passed:
 
-```rust
-use pyo3::prelude::*;
-use pyo3::types::PyDict;
-
-#[pyfunction]
-#[pyo3(signature = (**kwds))]
-fn num_kwds(kwds: Option<&PyDict>) -> usize {
-    kwds.map_or(0, |dict| dict.len())
-}
+```rust,no_run
+#[pyo3::pymodule]
+mod module_with_functions {
+    use pyo3::prelude::*;
+    use pyo3::types::PyDict;
 
-#[pymodule]
-fn module_with_functions(py: Python<'_>, m: &PyModule) -> PyResult<()> {
-    m.add_function(wrap_pyfunction!(num_kwds, m)?).unwrap();
-    Ok(())
+    #[pyfunction]
+    #[pyo3(signature = (**kwds))]
+    fn num_kwds(kwds: Option<&Bound<'_, PyDict>>) -> usize {
+        kwds.map_or(0, |dict| dict.len())
+    }
 }
 ```
 
 Just like in Python, the following constructs can be part of the signature::
 
- * `/`: positional-only arguments separator, each parameter defined before `/` is a positional-only parameter.
- * `*`: var arguments separator, each parameter defined after `*` is a keyword-only parameter.
- * `*args`: "args" is var args. Type of the `args` parameter has to be `&PyTuple`.
- * `**kwargs`: "kwargs" receives keyword arguments. The type of the `kwargs` parameter has to be `Option<&PyDict>`.
- * `arg=Value`: arguments with default value.
+- `/`: positional-only arguments separator, each parameter defined before `/` is a positional-only parameter.
+- `*`: var arguments separator, each parameter defined after `*` is a keyword-only parameter.
+- `*args`: "args" is var args.
+  Type of the `args` parameter has to be `&Bound<'_, PyTuple>`.
+- `**kwargs`: "kwargs" receives keyword arguments.
+  The type of the `kwargs` parameter has to be `Option<&Bound<'_, PyDict>>`.
+- `arg=Value`: arguments with default value.
    If the `arg` argument is defined after var arguments, it is treated as a keyword-only argument.
-   Note that `Value` has to be valid rust code, PyO3 just inserts it into the generated
-   code unmodified.
+   Note that `Value` has to be valid rust code, PyO3 just inserts it into the generated code unmodified.
 
 Example:
-```rust
+
+```rust,no_run
 # use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyTuple};
 #
@@ -59,9 +62,9 @@ impl MyClass {
     fn method(
         &mut self,
         num: i32,
-        py_args: &PyTuple,
+        py_args: &Bound<'_, PyTuple>,
         name: &str,
-        py_kwargs: Option<&PyDict>,
+        py_kwargs: Option<&Bound<'_, PyDict>>,
     ) -> String {
         let num_before = self.num;
         self.num = num;
@@ -80,36 +83,41 @@ impl MyClass {
 
 Arguments of type `Python` must not be part of the signature:
 
-```rust
+```rust,no_run
 # #![allow(dead_code)]
 # use pyo3::prelude::*;
 #[pyfunction]
 #[pyo3(signature = (lambda))]
-pub fn simple_python_bound_function(py: Python<'_>, lambda: PyObject) -> PyResult<()> {
+pub fn simple_python_bound_function(py: Python<'_>, lambda: Py<PyAny>) -> PyResult<()> {
     Ok(())
 }
 ```
 
-N.B. the position of the `/` and `*` arguments (if included) control the system of handling positional and keyword arguments. In Python:
+N.B. the position of the `/` and `*` arguments (if included) control the system of handling positional and keyword arguments.
+In Python:
+
 ```python
 import mymodule
 
 mc = mymodule.MyClass()
 print(mc.method(44, False, "World", 666, x=44, y=55))
 print(mc.method(num=-1, name="World"))
-print(mc.make_change(44, False))
+print(mc.make_change(44))
 ```
+
 Produces output:
+
 ```text
-py_args=('World', 666), py_kwargs=Some({'x': 44, 'y': 55}), name=Hello, num=44
-py_args=(), py_kwargs=None, name=World, num=-1
+num=44 (was previously=-1), py_args=(False, 'World', 666), name=Hello, py_kwargs=Some({'x': 44, 'y': 55})
+num=-1 (was previously=44), py_args=(), name=World, py_kwargs=None
 num=44
-num=-1
 ```
 
+<!-- rumdl-disable MD052 - code block in quote confuses linter -->
+
 > Note: to use keywords like `struct` as a function argument, use "raw identifier" syntax `r#struct` in both the signature and the function definition:
 >
-> ```rust
+> ```rust,no_run
 > # #![allow(dead_code)]
 > # use pyo3::prelude::*;
 > #[pyfunction(signature = (r#struct = "foo"))]
@@ -119,74 +127,15 @@ num=-1
 > }
 > ```
 
-## Trailing optional arguments
-
-As a convenience, functions without a `#[pyo3(signature = (...))]` option will treat trailing `Option<T>` arguments as having a default of `None`. In the example below, PyO3 will create `increment` with a signature of `increment(x, amount=None)`.
-
-```rust
-use pyo3::prelude::*;
-
-/// Returns a copy of `x` increased by `amount`.
-///
-/// If `amount` is unspecified or `None`, equivalent to `x + 1`.
-#[pyfunction]
-fn increment(x: u64, amount: Option<u64>) -> u64 {
-    x + amount.unwrap_or(1)
-}
-#
-# fn main() -> PyResult<()> {
-#     Python::with_gil(|py| {
-#         let fun = pyo3::wrap_pyfunction!(increment, py)?;
-#
-#         let inspect = PyModule::import(py, "inspect")?.getattr("signature")?;
-#         let sig: String = inspect
-#             .call1((fun,))?
-#             .call_method0("__str__")?
-#             .extract()?;
-#
-#         #[cfg(Py_3_8)]  // on 3.7 the signature doesn't render b, upstream bug?
-#         assert_eq!(sig, "(x, amount=None)");
-#
-#         Ok(())
-#     })
-# }
-```
-
-To make trailing `Option<T>` arguments required, but still accept `None`, add a `#[pyo3(signature = (...))]` annotation. For the example above, this would be `#[pyo3(signature = (x, amount))]`:
-
-```rust
-# use pyo3::prelude::*;
-#[pyfunction]
-#[pyo3(signature = (x, amount))]
-fn increment(x: u64, amount: Option<u64>) -> u64 {
-    x + amount.unwrap_or(1)
-}
-#
-# fn main() -> PyResult<()> {
-#     Python::with_gil(|py| {
-#         let fun = pyo3::wrap_pyfunction!(increment, py)?;
-#
-#         let inspect = PyModule::import(py, "inspect")?.getattr("signature")?;
-#         let sig: String = inspect
-#             .call1((fun,))?
-#             .call_method0("__str__")?
-#             .extract()?;
-#
-#         #[cfg(Py_3_8)]  // on 3.7 the signature doesn't render b, upstream bug?
-#         assert_eq!(sig, "(x, amount)");
-#
-#         Ok(())
-#     })
-# }
-```
-
-To help avoid confusion, PyO3 requires `#[pyo3(signature = (...))]` when an `Option<T>` argument is surrounded by arguments which aren't `Option<T>`.
+<!-- rumdl-enable MD052 -->
 
 ## Making the function signature available to Python
 
-The function signature is exposed to Python via the `__text_signature__` attribute. PyO3 automatically generates this for every `#[pyfunction]` and all `#[pymethods]` directly from the Rust function, taking into account any override done with the `#[pyo3(signature = (...))]` option.
+The function signature is exposed to Python via the `__text_signature__` attribute.
+PyO3 automatically generates this for every `#[pyfunction]` and all `#[pymethods]` directly from the Rust function, taking into account any override done with the `#[pyo3(signature = (...))]` option.
 
-This automatic generation can only display the value of default arguments for strings, integers, boolean types, and `None`. Any other default arguments will be displayed as `...`. (`.pyi` type stub files commonly also use `...` for default arguments in the same way.)
+This automatic generation can only display the value of default arguments for strings, integers, boolean types, and `None`.
+Any other default arguments will be displayed as `...`. (`.pyi` type stub files commonly also use `...` for default arguments in the same way.)
 
 In cases where the automatically-generated signature needs adjusting, it can [be overridden](#overriding-the-generated-signature) using the `#[pyo3(text_signature)]` option.)
 
@@ -203,7 +152,7 @@ fn add(a: u64, b: u64) -> u64 {
 }
 #
 # fn main() -> PyResult<()> {
-#     Python::with_gil(|py| {
+#     Python::attach(|py| {
 #         let fun = pyo3::wrap_pyfunction!(add, py)?;
 #
 #         let doc: String = fun.getattr("__doc__")?.extract()?;
@@ -251,7 +200,7 @@ fn add(a: u64, b: u64) -> u64 {
 }
 #
 # fn main() -> PyResult<()> {
-#     Python::with_gil(|py| {
+#     Python::attach(|py| {
 #         let fun = pyo3::wrap_pyfunction!(add, py)?;
 #
 #         let doc: String = fun.getattr("__doc__")?.extract()?;
@@ -269,7 +218,8 @@ fn add(a: u64, b: u64) -> u64 {
 # }
 ```
 
-PyO3 will include the contents of the annotation unmodified as the `__text_signature`. Below shows how IPython will now present this (see the default value of 0 for b):
+PyO3 will include the contents of the annotation unmodified as the `__text_signature__`.
+Below shows how IPython will now present this (see the default value of 0 for b):
 
 ```text
 >>> pyo3_test.add.__text_signature__
@@ -280,7 +230,8 @@ Docstring: This function adds two unsigned 64-bit integers.
 Type:      builtin_function_or_method
 ```
 
-If no signature is wanted at all, `#[pyo3(text_signature = None)]` will disable the built-in signature. The snippet below demonstrates use of this:
+If no signature is wanted at all, `#[pyo3(text_signature = None)]` will disable the built-in signature.
+The snippet below demonstrates use of this:
 
 ```rust
 use pyo3::prelude::*;
@@ -293,7 +244,7 @@ fn add(a: u64, b: u64) -> u64 {
 }
 #
 # fn main() -> PyResult<()> {
-#     Python::with_gil(|py| {
+#     Python::attach(|py| {
 #         let fun = pyo3::wrap_pyfunction!(add, py)?;
 #
 #         let doc: String = fun.getattr("__doc__")?.extract()?;
@@ -314,3 +265,40 @@ True
 Docstring: This function adds two unsigned 64-bit integers.
 Type:      builtin_function_or_method
 ```
+
+### Type annotations in the signature
+
+When the `experimental-inspect` Cargo feature is enabled, the `signature` attribute can also contain type hints:
+
+```rust
+# #[cfg(feature = "experimental-inspect")] {
+use pyo3::prelude::*;
+
+#[pymodule]
+pub mod example {
+   use pyo3::prelude::*;
+
+   #[pyfunction]
+   #[pyo3(signature = (arg: "list[int]") -> "list[int]")]
+   fn list_of_int_identity(arg: Bound<'_, PyAny>) -> Bound<'_, PyAny> {
+      arg
+   }
+}
+# }
+```
+
+It enables the [work-in-progress capacity of PyO3 to autogenerate type stubs](../type-stub.md) to generate a file with the correct type hints:
+
+```python
+def list_of_int_identity(arg: list[int]) -> list[int]: ...
+```
+
+instead of the generic:
+
+```python
+import typing
+
+def list_of_int_identity(arg: typing.Any) -> typing.Any: ...
+```
+
+Note that currently type annotations must be written as Rust strings.
diff --git a/guide/src/getting_started.md b/guide/src/getting-started.md
similarity index 53%
rename from guide/src/getting_started.md
rename to guide/src/getting-started.md
index 22bce336d80..a621b97ca1a 100644
--- a/guide/src/getting_started.md
+++ b/guide/src/getting-started.md
@@ -1,64 +1,76 @@
 # Installation
 
-To get started using PyO3 you will need three things: a Rust toolchain, a Python environment, and a way to build. We'll cover each of these below.
+To get started using PyO3 you will need three things: a Rust toolchain, a Python environment, and a way to build.
+We'll cover each of these below.
+
+> If you'd like to chat to the PyO3 maintainers and other PyO3 users, consider joining the [PyO3 Discord server](https://discord.gg/33kcChzH7f). We're keen to hear about your experience getting started, so we can make PyO3 as accessible as possible for everyone!
 
 ## Rust
 
-First, make sure you have Rust installed on your system. If you haven't already done so, try following the instructions [here](https://www.rust-lang.org/tools/install). PyO3 runs on both the `stable` and `nightly` versions so you can choose whichever one fits you best. The minimum required Rust version is 1.56.
+First, make sure you have Rust installed on your system.
+If you haven't already done so, try following the instructions [here](https://www.rust-lang.org/tools/install).
+PyO3 runs on both the `stable` and `nightly` versions so you can choose whichever one fits you best.
+The minimum required Rust version is 1.83.
 
 If you can run `rustc --version` and the version is new enough you're good to go!
 
 ## Python
 
-To use PyO3, you need at least Python 3.7. While you can simply use the default Python interpreter on your system, it is recommended to use a virtual environment.
+To use PyO3, you need at least Python 3.7.
+While you can simply use the default Python interpreter on your system, it is recommended to use a virtual environment.
 
 ## Virtualenvs
 
-While you can use any virtualenv manager you like, we recommend the use of `pyenv` in particular if you want to develop or test for multiple different Python versions, so that is what the examples in this book will use. The installation instructions for `pyenv` can be found [here](https://github.com/pyenv/pyenv#getting-pyenv). (Note: To get the `pyenv activate` and `pyenv virtualenv` commands, you will also need to install the [`pyenv-virtualenv`](https://github.com/pyenv/pyenv-virtualenv) plugin. The [pyenv installer](https://github.com/pyenv/pyenv-installer#installation--update--uninstallation) will install both together.)
+While you can use any virtualenv manager you like, we recommend the use of `pyenv` in particular if you want to develop or test for multiple different Python versions, so that is what the examples in this book will use.
+The installation instructions for `pyenv` can be found [here](https://github.com/pyenv/pyenv#a-getting-pyenv). (Note: To get the `pyenv activate` and `pyenv virtualenv` commands, you will also need to install the [`pyenv-virtualenv`](https://github.com/pyenv/pyenv-virtualenv) plugin.
+The [pyenv installer](https://github.com/pyenv/pyenv-installer#installation--update--uninstallation) will install both together.)
 
-If you intend to run Python from Rust (for example in unit tests) you should set the following environment variable when installing a new Python version using `pyenv`:
-```bash
-PYTHON_CONFIGURE_OPTS="--enable-shared"
-```
+It can be useful to keep the sources used when installing using `pyenv` so that future debugging can see the original source files.
+This can be done by passing the `--keep` flag as part of the `pyenv install` command.
 
 For example:
 
 ```bash
-env PYTHON_CONFIGURE_OPTS="--enable-shared" pyenv install 3.12
+pyenv install 3.12 --keep
 ```
 
-You can read more about `pyenv`'s configuration options [here](https://github.com/pyenv/pyenv/blob/master/plugins/python-build/README.md#building-with---enable-shared).
-
 ### Building
 
-There are a number of build and Python package management systems such as [`setuptools-rust`](https://github.com/PyO3/setuptools-rust) or [manually](https://pyo3.rs/latest/building_and_distribution.html#manual-builds). We recommend the use of `maturin`, which you can install [here](https://maturin.rs/installation.html). It is developed to work with PyO3 and provides the most "batteries included" experience, especially if you are aiming to publish to PyPI. `maturin` is just a Python package, so you can add it in the same you already install Python packages.
+There are a number of build and Python package management systems such as [`setuptools-rust`](https://github.com/PyO3/setuptools-rust) or [manually](./building-and-distribution.md#manual-builds).
+We recommend the use of `maturin`, which you can install [here](https://maturin.rs/installation.html).
+It is developed to work with PyO3 and provides the most "batteries included" experience, especially if you are aiming to publish to PyPI. `maturin` is just a Python package, so you can add it in the same way you already install Python packages.
 
 System Python:
+
 ```bash
 pip install maturin --user
 ```
 
 pipx:
+
 ```bash
 pipx install maturin
 ```
 
 pyenv:
+
 ```bash
 pyenv activate pyo3
 pip install maturin
 ```
 
 poetry:
+
 ```bash
 poetry add -G dev maturin
 ```
 
 After installation, you can run `maturin --version` to check that you have correctly installed it.
 
-# Starting a new project
+## Starting a new project
 
-First you should create the folder and virtual environment that are going to contain your new project. Here we will use the recommended `pyenv`:
+First you should create the folder and virtual environment that are going to contain your new project.
+Here we will use the recommended `pyenv`:
 
 ```bash
 mkdir pyo3-example
@@ -67,7 +79,9 @@ pyenv virtualenv pyo3
 pyenv local pyo3
 ```
 
-After this, you should install your build manager. In this example, we will use `maturin`. After you've activated your virtualenv, add `maturin` to it:
+After this, you should install your build manager.
+In this example, we will use `maturin`.
+After you've activated your virtualenv, add `maturin` to it:
 
 ```bash
 pip install maturin
@@ -88,7 +102,7 @@ pyenv virtualenv pyo3
 pyenv local pyo3
 ```
 
-# Adding to an existing project
+## Adding to an existing project
 
 Sadly, `maturin` cannot currently be run in existing projects, so if you want to use Python in an existing project you basically have two options:
 
@@ -99,8 +113,9 @@ If you opt for the second option, here are the things you need to pay attention
 
 ## Cargo.toml
 
-Make sure that the Rust crate you want to be able to access from Python is compiled into a library. You can have a binary output as well, but the code you want to access from Python has to be in the library part. Also, make sure that the crate type is `cdylib` and add PyO3 as a dependency as so:
-
+Make sure that the Rust crate you want to be able to access from Python is compiled into a library.
+You can have a binary output as well, but the code you want to access from Python has to be in the library part.
+Also, make sure that the crate type is `cdylib` and add PyO3 as a dependency as so:
 
 ```toml
 # If you already have [package] information in `Cargo.toml`, you can ignore
@@ -148,22 +163,19 @@ classifiers = [
 
 After this you can setup Rust code to be available in Python as below; for example, you can place this code in `src/lib.rs`:
 
-```rust
-use pyo3::prelude::*;
-
-/// Formats the sum of two numbers as string.
-#[pyfunction]
-fn sum_as_string(a: usize, b: usize) -> PyResult<String> {
-    Ok((a + b).to_string())
-}
-
+```rust,no_run
 /// A Python module implemented in Rust. The name of this function must match
 /// the `lib.name` setting in the `Cargo.toml`, else Python will not be able to
 /// import the module.
-#[pymodule]
-fn pyo3_example(_py: Python<'_>, m: &PyModule) -> PyResult<()> {
-    m.add_function(wrap_pyfunction!(sum_as_string, m)?)?;
-    Ok(())
+#[pyo3::pymodule]
+mod pyo3_example {
+    use pyo3::prelude::*;
+
+    /// Formats the sum of two numbers as string.
+    #[pyfunction]
+    fn sum_as_string(a: usize, b: usize) -> PyResult<String> {
+        Ok((a + b).to_string())
+    }
 }
 ```
 
@@ -178,4 +190,9 @@ $ python
 '25'
 ```
 
-For more instructions on how to use Python code from Rust, see the [Python from Rust](python_from_rust.md) page.
+For more instructions on how to use Python code from Rust, see the [Python from Rust](python-from-rust.md) page.
+
+## Maturin Import Hook
+
+In development, any changes in the code would require running `maturin develop` before testing.
+To streamline the development process, you may want to install [Maturin Import Hook](https://github.com/PyO3/maturin-import-hook) which will run `maturin develop` automatically when the library with code changes is being imported.
diff --git a/guide/src/index.md b/guide/src/index.md
index 80534caea5f..309809ad9cb 100644
--- a/guide/src/index.md
+++ b/guide/src/index.md
@@ -1,7 +1,17 @@
 # The PyO3 user guide
 
-Welcome to the PyO3 user guide! This book is a companion to [PyO3's API docs](https://docs.rs/pyo3). It contains examples and documentation to explain all of PyO3's use cases in detail.
+Welcome to the PyO3 user guide!
+This book is a companion to [PyO3's API docs](https://docs.rs/pyo3).
+It contains examples and documentation to explain all of PyO3's use cases in detail.
+
+The rough order of material in this user guide is as follows:
+  1. Getting started
+  2. Wrapping Rust code for use from Python
+  3. How to use Python code from Rust
+  4. Remaining topics which go into advanced concepts in detail
 
 Please choose from the chapters on the left to jump to individual topics, or continue below to start with PyO3's README.
 
+<hr style="opacity:0.2">
+
 {{#include ../../README.md}}
diff --git a/guide/src/memory.md b/guide/src/memory.md
deleted file mode 100644
index 2f5e5d9b0bd..00000000000
--- a/guide/src/memory.md
+++ /dev/null
@@ -1,233 +0,0 @@
-# Memory management
-
-Rust and Python have very different notions of memory management.  Rust has
-a strict memory model with concepts of ownership, borrowing, and lifetimes,
-where memory is freed at predictable points in program execution.  Python has
-a looser memory model in which variables are reference-counted with shared,
-mutable state by default. A global interpreter lock (GIL) is needed to prevent
-race conditions, and a garbage collector is needed to break reference cycles.
-Memory in Python is freed eventually by the garbage collector, but not usually
-in a predictable way.
-
-PyO3 bridges the Rust and Python memory models with two different strategies for
-accessing memory allocated on Python's heap from inside Rust.  These are
-GIL-bound, or "owned" references, and GIL-independent `Py<Any>` smart pointers.
-
-## GIL-bound memory
-
-PyO3's GIL-bound, "owned references" (`&PyAny` etc.) make PyO3 more ergonomic to
-use by ensuring that their lifetime can never be longer than the duration the
-Python GIL is held.  This means that most of PyO3's API can assume the GIL is
-held. (If PyO3 could not assume this, every PyO3 API would need to take a
-`Python` GIL token to prove that the GIL is held.)  This allows us to write
-very simple and easy-to-understand programs like this:
-
-```rust
-# use pyo3::prelude::*;
-# use pyo3::types::PyString;
-# fn main() -> PyResult<()> {
-Python::with_gil(|py| -> PyResult<()> {
-    let hello = py.eval_bound("\"Hello World!\"", None, None)?.downcast_into::<PyString>()?;
-    println!("Python says: {}", hello);
-    Ok(())
-})?;
-# Ok(())
-# }
-```
-
-Internally, calling `Python::with_gil()` creates a `GILPool` which owns the
-memory pointed to by the reference.  In the example above, the lifetime of the
-reference `hello` is bound to the `GILPool`.  When the `with_gil()` closure ends
-the `GILPool` is also dropped and the Python reference counts of the variables
-it owns are decreased, releasing them to the Python garbage collector.  Most
-of the time we don't have to think about this, but consider the following:
-
-```rust
-# use pyo3::prelude::*;
-# use pyo3::types::PyString;
-# fn main() -> PyResult<()> {
-Python::with_gil(|py| -> PyResult<()> {
-    for _ in 0..10 {
-        let hello = py.eval_bound("\"Hello World!\"", None, None)?.downcast_into::<PyString>()?;
-        println!("Python says: {}", hello);
-    }
-    // There are 10 copies of `hello` on Python's heap here.
-    Ok(())
-})?;
-# Ok(())
-# }
-```
-
-We might assume that the `hello` variable's memory is freed at the end of each
-loop iteration, but in fact we create 10 copies of `hello` on Python's heap.
-This may seem surprising at first, but it is completely consistent with Rust's
-memory model.  The `hello` variable is dropped at the end of each loop, but it
-is only a reference to the memory owned by the `GILPool`, and its lifetime is
-bound to the `GILPool`, not the for loop.  The `GILPool` isn't dropped until
-the end of the `with_gil()` closure, at which point the 10 copies of `hello`
-are finally released to the Python garbage collector.
-
-In general we don't want unbounded memory growth during loops!  One workaround
-is to acquire and release the GIL with each iteration of the loop.
-
-```rust
-# use pyo3::prelude::*;
-# use pyo3::types::PyString;
-# fn main() -> PyResult<()> {
-for _ in 0..10 {
-    Python::with_gil(|py| -> PyResult<()> {
-        let hello = py.eval_bound("\"Hello World!\"", None, None)?.downcast_into::<PyString>()?;
-        println!("Python says: {}", hello);
-        Ok(())
-    })?; // only one copy of `hello` at a time
-}
-# Ok(())
-# }
-```
-
-It might not be practical or performant to acquire and release the GIL so many
-times.  Another workaround is to work with the `GILPool` object directly, but
-this is unsafe.
-
-```rust
-# use pyo3::prelude::*;
-# use pyo3::types::PyString;
-# fn main() -> PyResult<()> {
-Python::with_gil(|py| -> PyResult<()> {
-    for _ in 0..10 {
-        let pool = unsafe { py.new_pool() };
-        let py = pool.python();
-        let hello = py.eval_bound("\"Hello World!\"", None, None)?.downcast_into::<PyString>()?;
-        println!("Python says: {}", hello);
-    }
-    Ok(())
-})?;
-# Ok(())
-# }
-```
-
-The unsafe method `Python::new_pool` allows you to create a nested `GILPool`
-from which you can retrieve a new `py: Python` GIL token.  Variables created
-with this new GIL token are bound to the nested `GILPool` and will be released
-when the nested `GILPool` is dropped.  Here, the nested `GILPool` is dropped
-at the end of each loop iteration, before the `with_gil()` closure ends.
-
-When doing this, you must be very careful to ensure that once the `GILPool` is
-dropped you do not retain access to any owned references created after the
-`GILPool` was created.  Read the
-[documentation for `Python::new_pool()`]({{#PYO3_DOCS_URL}}/pyo3/prelude/struct.Python.html#method.new_pool)
-for more information on safety.
-
-This memory management can also be applicable when writing extension modules.
-`#[pyfunction]` and `#[pymethods]` will create a `GILPool` which lasts the entire
-function call, releasing objects when the function returns. Most functions only create
-a few objects, meaning this doesn't have a significant impact. Occasionally functions
-with long complex loops may need to use `Python::new_pool` as shown above.
-
-This behavior may change in future, see [issue #1056](https://github.com/PyO3/pyo3/issues/1056).
-
-## GIL-independent memory
-
-Sometimes we need a reference to memory on Python's heap that can outlive the
-GIL.  Python's `Py<PyAny>` is analogous to `Arc<T>`, but for variables whose
-memory is allocated on Python's heap.  Cloning a `Py<PyAny>` increases its
-internal reference count just like cloning `Arc<T>`.  The smart pointer can
-outlive the "GIL is held" period in which it was created.  It isn't magic,
-though.  We need to reacquire the GIL to access the memory pointed to by the
-`Py<PyAny>`.
-
-What happens to the memory when the last `Py<PyAny>` is dropped and its
-reference count reaches zero?  It depends whether or not we are holding the GIL.
-
-```rust
-# use pyo3::prelude::*;
-# use pyo3::types::PyString;
-# fn main() -> PyResult<()> {
-Python::with_gil(|py| -> PyResult<()> {
-    let hello: Py<PyString> = py.eval_bound("\"Hello World!\"", None, None)?.extract()?;
-    println!("Python says: {}", hello.bind(py));
-    Ok(())
-})?;
-# Ok(())
-# }
-```
-
-At the end of the `Python::with_gil()` closure `hello` is dropped, and then the
-GIL is dropped.  Since `hello` is dropped while the GIL is still held by the
-current thread, its memory is released to the Python garbage collector
-immediately.
-
-This example wasn't very interesting.  We could have just used a GIL-bound
-`&PyString` reference.  What happens when the last `Py<Any>` is dropped while
-we are *not* holding the GIL?
-
-```rust
-# use pyo3::prelude::*;
-# use pyo3::types::PyString;
-# fn main() -> PyResult<()> {
-let hello: Py<PyString> = Python::with_gil(|py| {
-    py.eval_bound("\"Hello World!\"", None, None)?.extract()
-})?;
-// Do some stuff...
-// Now sometime later in the program we want to access `hello`.
-Python::with_gil(|py| {
-    println!("Python says: {}", hello.as_ref(py));
-});
-// Now we're done with `hello`.
-drop(hello); // Memory *not* released here.
-// Sometime later we need the GIL again for something...
-Python::with_gil(|py|
-    // Memory for `hello` is released here.
-# ()
-);
-# Ok(())
-# }
-```
-
-When `hello` is dropped *nothing* happens to the pointed-to memory on Python's
-heap because nothing _can_ happen if we're not holding the GIL.  Fortunately,
-the memory isn't leaked.  PyO3 keeps track of the memory internally and will
-release it the next time we acquire the GIL.
-
-We can avoid the delay in releasing memory if we are careful to drop the
-`Py<Any>` while the GIL is held.
-
-```rust
-# use pyo3::prelude::*;
-# use pyo3::types::PyString;
-# fn main() -> PyResult<()> {
-let hello: Py<PyString> =
-    Python::with_gil(|py| py.eval_bound("\"Hello World!\"", None, None)?.extract())?;
-// Do some stuff...
-// Now sometime later in the program:
-Python::with_gil(|py| {
-    println!("Python says: {}", hello.bind(py));
-    drop(hello); // Memory released here.
-});
-# Ok(())
-# }
-```
-
-We could also have used `Py::into_ref()`, which consumes `self`, instead of
-`Py::as_ref()`.  But note that in addition to being slower than `as_ref()`,
-`into_ref()` binds the memory to the lifetime of the `GILPool`, which means
-that rather than being released immediately, the memory will not be released
-until the GIL is dropped.
-
-```rust
-# use pyo3::prelude::*;
-# use pyo3::types::PyString;
-# fn main() -> PyResult<()> {
-let hello: Py<PyString> =
-    Python::with_gil(|py| py.eval_bound("\"Hello World!\"", None, None)?.extract())?;
-// Do some stuff...
-// Now sometime later in the program:
-Python::with_gil(|py| {
-    println!("Python says: {}", hello.into_bound(py));
-    // Memory not released yet.
-    // Do more stuff...
-    // Memory released here at end of `with_gil()` closure.
-});
-# Ok(())
-# }
-```
diff --git a/guide/src/migration.md b/guide/src/migration.md
index 936784897bd..c92fed5126d 100644
--- a/guide/src/migration.md
+++ b/guide/src/migration.md
@@ -3,24 +3,800 @@
 This guide can help you upgrade code through breaking changes from one PyO3 version to the next.
 For a detailed list of all changes, see the [CHANGELOG](changelog.md).
 
+## from 0.26.* to 0.27
+
+### `FromPyObject` reworked for flexibility and efficiency
+
+<details open>
+<summary><small>Click to expand</small></summary>
+
+With the removal of the `gil-ref` API in PyO3 0.23 it is now possible to fully split the Python lifetime `'py` and the input lifetime `'a`.
+This allows borrowing from the input data without extending the lifetime of being attached to the interpreter.
+
+`FromPyObject` now takes an additional lifetime `'a` describing the input lifetime.
+The argument type of the `extract` method changed from `&Bound<'py, PyAny>` to `Borrowed<'a, 'py, PyAny>`.
+This was done because `&'a Bound<'py, PyAny>` would have an implicit restriction `'py: 'a` due to the reference type.
+
+This new form was partly implemented already in 0.22 using the internal `FromPyObjectBound` trait and
+is now extended to all types.
+
+Most implementations can just add an elided lifetime to migrate.
+
+Additionally `FromPyObject` gained an associated type `Error`.
+This is the error type that can be used in case of a conversion error.
+During migration using `PyErr` is a good default, later a custom error type can be introduced to prevent unneccessary creation of Python exception objects and improved type safety.
+
+Before:
+
+```rust,ignore
+impl<'py> FromPyObject<'py> for IpAddr {
+    fn extract_bound(obj: &Bound<'py, PyAny>) -> PyResult<Self> {
+        ...
+    }
+}
+```
+
+After
+
+```rust,ignore
+impl<'py> FromPyObject<'_, 'py> for IpAddr {
+    type Error = PyErr;
+
+    fn extract(obj: Borrowed<'_, 'py, PyAny>) -> Result<Self, Self::Error> {
+        ...
+        // since `Borrowed` derefs to `&Bound`, the body often
+        // needs no changes, or adding an occasional `&`
+    }
+}
+```
+
+Occasionally, more steps are necessary.
+For generic types, the bounds need to be adjusted.
+The correct bound depends on how the type is used.
+
+For simple wrapper types usually it's possible to just forward the bound.
+
+Before:
+
+```rust,ignore
+struct MyWrapper<T>(T);
+
+impl<'py, T> FromPyObject<'py> for MyWrapper<T>
+where
+    T: FromPyObject<'py>
+{
+    fn extract_bound(obj: &Bound<'py, PyAny>) -> PyResult<Self> {
+        ob.extract().map(MyWrapper)
+    }
+}
+```
+
+After:
+
+```rust
+# use pyo3::prelude::*;
+# #[allow(dead_code)]
+# pub struct MyWrapper<T>(T);
+impl<'a, 'py, T> FromPyObject<'a, 'py> for MyWrapper<T>
+where
+    T: FromPyObject<'a, 'py>
+{
+    type Error = T::Error;
+
+    fn extract(obj: Borrowed<'a, 'py, PyAny>) -> Result<Self, Self::Error> {
+        obj.extract().map(MyWrapper)
+    }
+}
+```
+
+Container types that need to create temporary Python references during extraction, for example extracing from a `PyList`, requires a stronger bound.
+For these the `FromPyObjectOwned` trait was introduced.
+It is automatically implemented for any type that implements `FromPyObject` and does not borrow from the input.
+It is intended to be used as a trait bound in these situations.
+
+Before:
+
+```rust,ignore
+struct MyVec<T>(Vec<T>);
+impl<'py, T> FromPyObject<'py> for Vec<T>
+where
+    T: FromPyObject<'py>,
+{
+    fn extract_bound(obj: &Bound<'py, PyAny>) -> PyResult<Self> {
+        let mut v = MyVec(Vec::new());
+        for item in obj.try_iter()? {
+            v.0.push(item?.extract::<T>()?);
+        }
+        Ok(v)
+    }
+}
+```
+
+After:
+
+```rust
+# use pyo3::prelude::*;
+# #[allow(dead_code)]
+# pub struct MyVec<T>(Vec<T>);
+impl<'py, T> FromPyObject<'_, 'py> for MyVec<T>
+where
+    T: FromPyObjectOwned<'py> // 👈 can only extract owned values, because each `item` below
+                              //    is a temporary short lived owned reference
+{
+    type Error = PyErr;
+
+    fn extract(obj: Borrowed<'_, 'py, PyAny>) -> Result<Self, Self::Error> {
+        let mut v = MyVec(Vec::new());
+        for item in obj.try_iter()? {
+            v.0.push(item?.extract::<T>().map_err(Into::into)?); // `map_err` is needed because `?` uses `From`, not `Into` 🙁
+        }
+        Ok(v)
+    }
+}
+```
+
+This is very similar to `serde`s [`Deserialize`] and [`DeserializeOwned`] traits, see [here](https://serde.rs/lifetimes.html).
+
+[`Deserialize`]: https://docs.rs/serde/latest/serde/trait.Deserialize.html
+[`DeserializeOwned`]: https://docs.rs/serde/latest/serde/de/trait.DeserializeOwned.html
+</details>
+
+## `.downcast()` and `DowncastError` replaced with `.cast()` and `CastError`
+
+The `.downcast()` family of functions were only available on `Bound<PyAny>`.
+In corner cases (particularly related to `.downcast_into()`) this would require use of `.as_any().downcast()` or `.into_any().downcast_into()` chains.
+Additionally, `DowncastError` produced Python exception messages which are not very Pythonic due to use of Rust type names in the error messages.
+
+The `.cast()` family of functions are available on all `Bound` and `Borrowed` smart pointers, whatever the type, and have error messages derived from the actual type at runtime.
+This produces a nicer experience for both PyO3 module authors and consumers.
+
+To migrate, replace `.downcast()` with `.cast()` and `DowncastError` with `CastError` (and similar with `.downcast_into()` / `DowncastIntoError` etc).
+
+`CastError` requires a Python `type` object (or other "classinfo" object compatible with `isinstance()`) as the second object, so in the rare case where `DowncastError` was manually constructed, small adjustments to code may apply.
+
+## `PyTypeCheck` is now an `unsafe trait`
+
+Because `PyTypeCheck` is the trait used to guard the `.cast()` functions to treat Python objects as specific concrete types, the trait is `unsafe` to implement.
+
+This should always have been the case, it was an unfortunate omission from its original implementation which is being corrected in this release.
+
+## from 0.25.* to 0.26
+
+### Rename of `Python::with_gil`, `Python::allow_threads`, and `pyo3::prepare_freethreaded_python`
+
+<details open>
+<summary><small>Click to expand</small></summary>
+
+The names for these APIs were created when the global interpreter lock (GIL) was mandatory.
+With the introduction of free-threading in Python 3.13 this is no longer the case, and the naming has no universal meaning anymore.
+For this reason, we chose to rename these to more modern terminology introduced in free-threading:
+
+- `Python::with_gil` is now called `Python::attach`, it attaches a Python thread-state to the current thread.
+  In GIL enabled builds there can only be 1 thread attached to the interpreter, in free-threading there can be more.
+- `Python::allow_threads` is now called `Python::detach`, it detaches a previously attached thread-state.
+- `pyo3::prepare_freethreaded_python` is now called `Python::initialize`.
+</details>
+
+### Deprecation of `PyObject` type alias
+
+<details open>
+<summary><small>Click to expand</small></summary>
+
+The type alias `PyObject` (aka `Py<PyAny>`) is often confused with the identically named FFI definition `pyo3::ffi::PyObject`.
+For this reason we are deprecating its usage.
+To migrate simply replace its usage by the target type `Py<PyAny>`.
+</details>
+
+### Replacement of `GILOnceCell` with `PyOnceLock`
+
+<details open>
+<summary><small>Click to expand</small></summary>
+
+Similar to the above renaming of `Python::with_gil` and related APIs, the `GILOnceCell` type was designed for a Python interpreter which was limited by the GIL.
+Aside from its name, it allowed for the "once" initialization to race because the racing was mediated by the GIL and was extremely unlikely to manifest in practice.
+
+With the introduction of free-threaded Python the racy initialization behavior is more likely to be problematic and so a new type `PyOnceLock` has been introduced which performs true single-initialization correctly while attached to the Python interpreter.
+It exposes the same API as `GILOnceCell`, so should be a drop-in replacement with the notable exception that if the racy initialization of `GILOnceCell` was inadvertently relied on (e.g. due to circular references) then the stronger once-ever guarantee of `PyOnceLock` may lead to deadlocking which requires refactoring.
+
+Before:
+
+```rust
+# #![allow(deprecated)]
+# use pyo3::prelude::*;
+# use pyo3::sync::GILOnceCell;
+# use pyo3::types::PyType;
+# fn main() -> PyResult<()> {
+# Python::attach(|py| {
+static DECIMAL_TYPE: GILOnceCell<Py<PyType>> = GILOnceCell::new();
+DECIMAL_TYPE.import(py, "decimal", "Decimal")?;
+# Ok(())
+# })
+# }
+```
+
+After:
+
+```rust
+# use pyo3::prelude::*;
+# use pyo3::sync::PyOnceLock;
+# use pyo3::types::PyType;
+# fn main() -> PyResult<()> {
+# Python::attach(|py| {
+static DECIMAL_TYPE: PyOnceLock<Py<PyType>> = PyOnceLock::new();
+DECIMAL_TYPE.import(py, "decimal", "Decimal")?;
+# Ok(())
+# })
+# }
+```
+
+</details>
+
+### Deprecation of `GILProtected`
+
+<details open>
+<summary><small>Click to expand</small></summary>
+
+As another cleanup related to concurrency primitives designed for a Python constrained by the GIL, the `GILProtected` type is now deprecated.
+Prefer to use concurrency primitives which are compatible with free-threaded Python, such as [`std::sync::Mutex`](https://doc.rust-lang.org/std/sync/struct.Mutex.html) (in combination with PyO3's [`MutexExt`]({{#PYO3_DOCS_URL}}/pyo3/sync/trait.MutexExt.html) trait).
+
+Before:
+
+```rust
+# #![allow(deprecated)]
+# use pyo3::prelude::*;
+# fn main() {
+# #[cfg(not(Py_GIL_DISABLED))] {
+use pyo3::sync::GILProtected;
+use std::cell::RefCell;
+# Python::attach(|py| {
+static NUMBERS: GILProtected<RefCell<Vec<i32>>> = GILProtected::new(RefCell::new(Vec::new()));
+Python::attach(|py| {
+    NUMBERS.get(py).borrow_mut().push(42);
+});
+# })
+# }
+# }
+```
+
+After:
+
+```rust
+# use pyo3::prelude::*;
+use pyo3::sync::MutexExt;
+use std::sync::Mutex;
+# fn main() {
+# Python::attach(|py| {
+static NUMBERS: Mutex<Vec<i32>> = Mutex::new(Vec::new());
+Python::attach(|py| {
+    NUMBERS.lock_py_attached(py).expect("no poisoning").push(42);
+});
+# })
+# }
+```
+
+</details>
+
+### `PyMemoryError` now maps to `io::ErrorKind::OutOfMemory` when converted to `io::Error`
+
+<details>
+<summary><small>Click to expand</small></summary>
+
+Previously, converting a `PyMemoryError` into a Rust `io::Error` would result in an error with kind `Other`.
+Now, it produces an error with kind `OutOfMemory`.
+Similarly, converting an `io::Error` with kind `OutOfMemory` back into a Python error would previously yield a generic `PyOSError`.
+Now, it yields a `PyMemoryError`.
+
+This change makes error conversions more precise and matches the semantics of out-of-memory errors between Python and Rust.
+</details>
+
+## from 0.24.* to 0.25
+
+### `AsPyPointer` removal
+
+<details>
+<summary><small>Click to expand</small></summary>
+The `AsPyPointer` trait is mostly a leftover from the now removed gil-refs API. The last remaining uses were the GC API, namely `PyVisit::call`, and identity comparison (`PyAnyMethods::is` and `Py::is`).
+
+`PyVisit::call` has been updated to take `T: Into<Option<&Py<T>>>`, which allows for arguments of type `&Py<T>`, `&Option<Py<T>>` and `Option<&Py<T>>`.
+It is unlikely any changes are needed here to migrate.
+
+`PyAnyMethods::is`/ `Py::is` has been updated to take `T: AsRef<Py<PyAny>>>`.
+Additionally `AsRef<Py<PyAny>>>` implementations were added for `Py`, `Bound` and `Borrowed`.
+Because of the existing `AsRef<Bound<PyAny>> for Bound<T>` implementation this may cause inference issues in non-generic code.
+This can be easily migrated by switching to `as_any` instead of `as_ref` for these calls.
+</details>
+
+## from 0.23.* to 0.24
+
+<details>
+<summary><small>Click to expand</small></summary>
+There were no significant changes from 0.23 to 0.24 which required documenting in this guide.
+</details>
+
+## from 0.22.* to 0.23
+
+<details>
+<summary><small>Click to expand</small></summary>
+
+PyO3 0.23 is a significant rework of PyO3's internals for two major improvements:
+
+- Support of Python 3.13's new freethreaded build (aka "3.13t")
+- Rework of to-Python conversions with a new `IntoPyObject` trait.
+
+These changes are both substantial and reasonable efforts have been made to allow as much code as possible to continue to work as-is despite the changes.
+The impacts are likely to be seen in three places when upgrading:
+
+- PyO3's data structures [are now thread-safe](#free-threaded-python-support) instead of reliant on the GIL for synchronization.
+  In particular, `#[pyclass]` types are [now required to be `Sync`](./class/thread-safety.md).
+- The [`IntoPyObject` trait](#new-intopyobject-trait-unifies-to-python-conversions) may need to be implemented for types in your codebase.
+  In most cases this can simply be done with [`#[derive(IntoPyObject)]`](#intopyobject-and-intopyobjectref-derive-macros).
+  There will be many deprecation warnings from the replacement of `IntoPy` and `ToPyObject` traits.
+- There will be many deprecation warnings from the [final removal of the `gil-refs` feature](#gil-refs-feature-removed), which opened up API space for a cleanup and simplification to PyO3's "Bound" API.
+
+The sections below discuss the rationale and details of each change in more depth.
+</details>
+
+### Free-threaded Python Support
+
+<details>
+<summary><small>Click to expand</small></summary>
+
+PyO3 0.23 introduces initial support for the new free-threaded build of
+CPython 3.13, aka "3.13t".
+
+Because this build allows multiple Python threads to operate simultaneously on underlying Rust data, the `#[pyclass]` macro now requires that types it operates on implement `Sync`.
+
+Aside from the change to `#[pyclass]`, most features of PyO3 work unchanged, as the changes have been to the internal data structures to make them thread-safe.
+An example of this is the `GILOnceCell` type, which used the GIL to synchronize single-initialization.
+It now uses internal locks to guarantee that only one write ever succeeds, however it allows for multiple racing runs of the initialization closure.
+It may be preferable to instead use `std::sync::OnceLock` in combination with the `pyo3::sync::OnceLockExt` trait which adds `OnceLock::get_or_init_py_attached` for single-initialization where the initialization closure is guaranteed only ever to run once and without deadlocking with the GIL.
+
+Future PyO3 versions will likely add more traits and data structures to make working with free-threaded Python easier.
+
+Some features are unaccessible on the free-threaded build:
+
+- The `GILProtected` type, which relied on the GIL to expose synchronized access to inner contents
+- `PyList::get_item_unchecked`, which cannot soundly be used due to races between time-of-check and time-of-use
+
+If you make use of these features then you will need to account for the unavailability of the API in the free-threaded build.
+One way to handle it is via conditional compilation -- extensions can use `pyo3-build-config` to get access to a `#[cfg(Py_GIL_DISABLED)]` guard.
+
+See [the guide section on free-threaded Python](free-threading.md) for more details about supporting free-threaded Python in your PyO3 extensions.
+</details>
+
+### New `IntoPyObject` trait unifies to-Python conversions
+
+<details>
+<summary><small>Click to expand</small></summary>
+
+PyO3 0.23 introduces a new `IntoPyObject` trait to convert Rust types into Python objects which replaces both `IntoPy` and `ToPyObject`.
+Notable features of this new trait include:
+
+- conversions can now return an error
+- it is designed to work efficiently for both `T` owned types and `&T` references
+- compared to `IntoPy<T>` the generic `T` moved into an associated type, so
+  - there is now only one way to convert a given type
+  - the output type is stronger typed and may return any Python type instead of just `PyAny`
+- byte collections are specialized to convert into `PyBytes` now, see [below](#to-python-conversions-changed-for-byte-collections-vecu8-u8-n-and-smallvecu8-n)
+- `()` (unit) is now only specialized in return position of `#[pyfunction]` and `#[pymethods]` to return `None`, in normal usage it converts into an empty `PyTuple`
+
+All PyO3 provided types as well as `#[pyclass]`es already implement `IntoPyObject`.
+Other types will need to adapt an implementation of `IntoPyObject` to stay compatible with the Python APIs.
+In many cases the new [`#[derive(IntoPyObject)]`](#intopyobject-and-intopyobjectref-derive-macros) macro can be used instead of [manual implementations](#intopyobject-manual-implementation).
+
+Since `IntoPyObject::into_pyobject` may return either a `Bound` or `Borrowed`, you may find the [`BoundObject`](conversions/traits.md#boundobject-for-conversions-that-may-be-bound-or-borrowed) trait to be useful to write code that generically handles either type of smart pointer.
+
+Together with the introduction of `IntoPyObject` the old conversion traits `ToPyObject` and `IntoPy`
+are deprecated and will be removed in a future PyO3 version.
+
+#### `IntoPyObject` and `IntoPyObjectRef` derive macros
+
+To implement the new trait you may use the new `IntoPyObject` and `IntoPyObjectRef` derive macros as below.
+
+```rust,no_run
+# use pyo3::prelude::*;
+#[derive(IntoPyObject, IntoPyObjectRef)]
+struct Struct {
+    count: usize,
+    obj: Py<PyAny>,
+}
+```
+
+The `IntoPyObjectRef` derive macro derives implementations for references (e.g. for `&Struct` in the example above), which is a replacement for the `ToPyObject` trait.
+
+#### `IntoPyObject` manual implementation
+
+Before:
+
+```rust,ignore
+# use pyo3::prelude::*;
+# #[allow(dead_code)]
+struct MyPyObjectWrapper(PyObject);
+
+impl IntoPy<PyObject> for MyPyObjectWrapper {
+    fn into_py(self, py: Python<'_>) -> PyObject {
+        self.0
+    }
+}
+
+impl ToPyObject for MyPyObjectWrapper {
+    fn to_object(&self, py: Python<'_>) -> PyObject {
+        self.0.clone_ref(py)
+    }
+}
+```
+
+After:
+
+```rust,no_run
+# #![allow(deprecated)]
+# use pyo3::prelude::*;
+# #[allow(dead_code)]
+# struct MyPyObjectWrapper(PyObject);
+
+impl<'py> IntoPyObject<'py> for MyPyObjectWrapper {
+    type Target = PyAny; // the Python type
+    type Output = Bound<'py, Self::Target>; // in most cases this will be `Bound`
+    type Error = std::convert::Infallible;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        Ok(self.0.into_bound(py))
+    }
+}
+
+// `ToPyObject` implementations should be converted to implementations on reference types
+impl<'a, 'py> IntoPyObject<'py> for &'a MyPyObjectWrapper {
+    type Target = PyAny;
+    type Output = Borrowed<'a, 'py, Self::Target>; // `Borrowed` can be used to optimized reference counting
+    type Error = std::convert::Infallible;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        Ok(self.0.bind_borrowed(py))
+    }
+}
+```
+
+</details>
+
+### To-Python conversions changed for byte collections (`Vec<u8>`, `[u8; N]` and `SmallVec<[u8; N]>`)
+
+<details>
+<summary><small>Click to expand</small></summary>
+
+With the introduction of the `IntoPyObject` trait, PyO3's macros now prefer `IntoPyObject` implementations over `IntoPy<PyObject>` when producing Python values.
+This applies to `#[pyfunction]` and `#[pymethods]` return values and also fields accessed via `#[pyo3(get)]`.
+
+This change has an effect on functions and methods returning _byte_ collections like
+
+- `Vec<u8>`
+- `[u8; N]`
+- `SmallVec<[u8; N]>`
+
+In their new `IntoPyObject` implementation these will now turn into `PyBytes` rather than a `PyList`.
+All other `T`s are unaffected and still convert into a `PyList`.
+
+```rust,no_run
+# #![allow(dead_code)]
+# use pyo3::prelude::*;
+#[pyfunction]
+fn foo() -> Vec<u8> { // would previously turn into a `PyList`, now `PyBytes`
+    vec![0, 1, 2, 3]
+}
+
+#[pyfunction]
+fn bar() -> Vec<u16> { // unaffected, returns `PyList`
+    vec![0, 1, 2, 3]
+}
+```
+
+If this conversion is _not_ desired, consider building a list manually using `PyList::new`.
+
+The following types were previously _only_ implemented for `u8` and now allow other `T`s turn into `PyList`:
+
+- `&[T]`
+- `Cow<[T]>`
+
+This is purely additional and should just extend the possible return types.
+
+</details>
+
+### `gil-refs` feature removed
+
+<details>
+<summary><small>Click to expand</small></summary>
+
+PyO3 0.23 completes the removal of the "GIL Refs" API in favour of the new "Bound" API introduced in PyO3 0.21.
+
+With the removal of the old API, many "Bound" API functions which had been introduced with `_bound` suffixes no longer need the suffixes as these names have been freed up.
+For example, `PyTuple::new_bound` is now just `PyTuple::new` (the existing name remains but is deprecated).
+
+Before:
+
+```rust,ignore
+# #![allow(deprecated)]
+# use pyo3::prelude::*;
+# use pyo3::types::PyTuple;
+# fn main() {
+# Python::attach(|py| {
+// For example, for PyTuple. Many such APIs have been changed.
+let tup = PyTuple::new_bound(py, [1, 2, 3]);
+# })
+# }
+```
+
+After:
+
+```rust
+# use pyo3::prelude::*;
+# use pyo3::types::PyTuple;
+# fn main() {
+# Python::attach(|py| {
+// For example, for PyTuple. Many such APIs have been changed.
+let tup = PyTuple::new(py, [1, 2, 3]);
+# })
+# }
+```
+
+#### `IntoPyDict` trait adjusted for removal of `gil-refs`
+
+As part of this API simplification, the `IntoPyDict` trait has had a small breaking change: `IntoPyDict::into_py_dict_bound` method has been renamed to `IntoPyDict::into_py_dict`.
+It is also now fallible as part of the `IntoPyObject` trait addition.
+
+If you implemented `IntoPyDict` for your type, you should implement `into_py_dict` instead of `into_py_dict_bound`.
+The old name is still available for calling but deprecated.
+
+Before:
+
+```rust,ignore
+# use pyo3::prelude::*;
+# use pyo3::types::{PyDict, IntoPyDict};
+# use std::collections::HashMap;
+
+struct MyMap<K, V>(HashMap<K, V>);
+
+impl<K, V> IntoPyDict for MyMap<K, V>
+where
+    K: ToPyObject,
+    V: ToPyObject,
+{
+    fn into_py_dict_bound(self, py: Python<'_>) -> Bound<'_, PyDict> {
+        let dict = PyDict::new_bound(py);
+        for (key, value) in self.0 {
+            dict.set_item(key, value)
+                .expect("Failed to set_item on dict");
+        }
+        dict
+    }
+}
+```
+
+After:
+
+```rust,no_run
+# use pyo3::prelude::*;
+# use pyo3::types::{PyDict, IntoPyDict};
+# use std::collections::HashMap;
+
+# #[allow(dead_code)]
+struct MyMap<K, V>(HashMap<K, V>);
+
+impl<'py, K, V> IntoPyDict<'py> for MyMap<K, V>
+where
+    K: IntoPyObject<'py>,
+    V: IntoPyObject<'py>,
+{
+    fn into_py_dict(self, py: Python<'py>) -> PyResult<Bound<'py, PyDict>> {
+        let dict = PyDict::new(py);
+        for (key, value) in self.0 {
+            dict.set_item(key, value)?;
+        }
+        Ok(dict)
+    }
+}
+```
+
+</details>
+
+## from 0.21.* to 0.22
+
+### Deprecation of `gil-refs` feature continues
+
+<details>
+<summary><small>Click to expand</small></summary>
+
+Following the introduction of the "Bound" API in PyO3 0.21 and the planned removal of the "GIL Refs" API, all functionality related to GIL Refs is now gated behind the `gil-refs` feature and emits a deprecation warning on use.
+
+See <a href="#from-021-to-022">the 0.21 migration entry</a> for help upgrading.
+</details>
+
+### Deprecation of implicit default for trailing optional arguments
+
+<details>
+<summary><small>Click to expand</small></summary>
+
+With `pyo3` 0.22 the implicit `None` default for trailing `Option<T>` type argument is deprecated.
+To migrate, place a `#[pyo3(signature = (...))]` attribute on affected functions or methods and specify the desired behavior.
+The migration warning specifies the corresponding signature to keep the current behavior.
+With 0.23 the signature will be required for any function containing `Option<T>` type parameters to prevent accidental and unnoticed changes in behavior.
+With 0.24 this restriction will be lifted again and `Option<T>` type arguments will be treated as any other argument _without_ special handling.
+
+Before:
+
+```rust,no_run
+# #![allow(deprecated, dead_code)]
+# use pyo3::prelude::*;
+#[pyfunction]
+fn increment(x: u64, amount: Option<u64>) -> u64 {
+    x + amount.unwrap_or(1)
+}
+```
+
+After:
+
+```rust,no_run
+# #![allow(dead_code)]
+# use pyo3::prelude::*;
+#[pyfunction]
+#[pyo3(signature = (x, amount=None))]
+fn increment(x: u64, amount: Option<u64>) -> u64 {
+    x + amount.unwrap_or(1)
+}
+```
+
+</details>
+
+### `Py::clone` is now gated behind the `py-clone` feature
+
+<details>
+<summary><small>Click to expand</small></summary>
+If you rely on `impl<T> Clone for Py<T>` to fulfil trait requirements imposed by existing Rust code written without PyO3-based code in mind, the newly introduced feature `py-clone` must be enabled.
+
+However, take care to note that the behaviour is different from previous versions.
+If `Clone` was called without the GIL being held, we tried to delay the application of these reference count increments until PyO3-based code would re-acquire it.
+This turned out to be impossible to implement in a sound manner and hence was removed.
+Now, if `Clone` is called without the GIL being held, we panic instead for which calling code might not be prepared.
+
+It is advised to migrate off the `py-clone` feature.
+The simplest way to remove dependency on `impl<T> Clone for Py<T>` is to wrap `Py<T>` as `Arc<Py<T>>` and use cloning of the arc.
+
+Related to this, we also added a `pyo3_disable_reference_pool` conditional compilation flag which removes the infrastructure necessary to apply delayed reference count decrements implied by `impl<T> Drop for Py<T>`.
+They do not appear to be a soundness hazard as they should lead to memory leaks in the worst case.
+However, the global synchronization adds significant overhead to cross the Python-Rust boundary.
+Enabling this feature will remove these costs and make the `Drop` implementation abort the process if called without the GIL being held instead.
+</details>
+
+### Require explicit opt-in for comparison for simple enums
+
+<details>
+<summary><small>Click to expand</small></summary>
+
+With `pyo3` 0.22 the new `#[pyo3(eq)]` options allows automatic implementation of Python equality using Rust's `PartialEq`.
+Previously simple enums automatically implemented equality in terms of their discriminants.
+To make PyO3 more consistent, this automatic equality implementation is deprecated in favour of having opt-ins for all `#[pyclass]` types.
+Similarly, simple enums supported comparison with integers, which is not covered by Rust's `PartialEq` derive, so has been split out into the `#[pyo3(eq_int)]` attribute.
+
+To migrate, place a `#[pyo3(eq, eq_int)]` attribute on simple enum classes.
+
+Before:
+
+```rust,no_run
+# #![allow(deprecated, dead_code)]
+# use pyo3::prelude::*;
+#[pyclass]
+enum SimpleEnum {
+    VariantA,
+    VariantB = 42,
+}
+```
+
+After:
+
+```rust,no_run
+# #![allow(dead_code)]
+# use pyo3::prelude::*;
+#[pyclass(eq, eq_int)]
+#[derive(PartialEq)]
+enum SimpleEnum {
+    VariantA,
+    VariantB = 42,
+}
+```
+
+</details>
+
+### `PyType::name` reworked to better match Python `__name__`
+
+<details>
+<summary><small>Click to expand</small></summary>
+
+This function previously would try to read directly from Python type objects' C API field (`tp_name`), in which case it would return a `Cow::Borrowed`.
+However the contents of `tp_name` don't have well-defined semantics.
+
+Instead `PyType::name()` now returns the equivalent of Python `__name__` and returns `PyResult<Bound<'py, PyString>>`.
+
+The closest equivalent to PyO3 0.21's version of `PyType::name()` has been introduced as a new function `PyType::fully_qualified_name()`,
+which is equivalent to `__module__` and `__qualname__` joined as `module.qualname`.
+
+Before:
+
+```rust,ignore
+# #![allow(deprecated, dead_code)]
+# use pyo3::prelude::*;
+# use pyo3::types::{PyBool};
+# fn main() -> PyResult<()> {
+Python::with_gil(|py| {
+    let bool_type = py.get_type_bound::<PyBool>();
+    let name = bool_type.name()?.into_owned();
+    println!("Hello, {}", name);
+
+    let mut name_upper = bool_type.name()?;
+    name_upper.to_mut().make_ascii_uppercase();
+    println!("Hello, {}", name_upper);
+
+    Ok(())
+})
+# }
+```
+
+After:
+
+```rust,ignore
+# #![allow(dead_code)]
+# use pyo3::prelude::*;
+# use pyo3::types::{PyBool};
+# fn main() -> PyResult<()> {
+Python::with_gil(|py| {
+    let bool_type = py.get_type_bound::<PyBool>();
+    let name = bool_type.name()?;
+    println!("Hello, {}", name);
+
+    // (if the full dotted path was desired, switch from `name()` to `fully_qualified_name()`)
+    let mut name_upper = bool_type.fully_qualified_name()?.to_string();
+    name_upper.make_ascii_uppercase();
+    println!("Hello, {}", name_upper);
+
+    Ok(())
+})
+# }
+```
+
+</details>
+
 ## from 0.20.* to 0.21
 
-PyO3 0.21 introduces a new `Bound<'py, T>` smart pointer which replaces the existing "GIL Refs" API to interact with Python objects. For example, in PyO3 0.20 the reference `&'py PyAny` would be used to interact with Python objects. In PyO3 0.21 the updated type is `Bound<'py, PyAny>`. Making this change moves Rust ownership semantics out of PyO3's internals and into user code. This change fixes [a known soundness edge case of interaction with gevent](https://github.com/PyO3/pyo3/issues/3668) as well as improves CPU and [memory performance](https://github.com/PyO3/pyo3/issues/1056). For a full history of discussion see https://github.com/PyO3/pyo3/issues/3382.
+<details>
+<summary><small>Click to expand</small></summary>
+
+PyO3 0.21 introduces a new `Bound<'py, T>` smart pointer which replaces the existing "GIL Refs" API to interact with Python objects.
+For example, in PyO3 0.20 the reference `&'py PyAny` would be used to interact with Python objects.
+In PyO3 0.21 the updated type is `Bound<'py, PyAny>`.
+Making this change moves Rust ownership semantics out of PyO3's internals and into user code.
+This change fixes [a known soundness edge case of interaction with gevent](https://github.com/PyO3/pyo3/issues/3668) as well as improves CPU and [memory performance](https://github.com/PyO3/pyo3/issues/1056).
+For a full history of discussion see .
+For a full history of discussion see <https://github.com/PyO3/pyo3/issues/3382>.
 
-The "GIL Ref" `&'py PyAny` and similar types such as `&'py PyDict` continue to be available as a deprecated API. Due to the advantages of the new API it is advised that all users make the effort to upgrade as soon as possible.
+The "GIL Ref" `&'py PyAny` and similar types such as `&'py PyDict` continue to be available as a deprecated API.
+Due to the advantages of the new API it is advised that all users make the effort to upgrade as soon as possible.
 
 In addition to the major API type overhaul, PyO3 has needed to make a few small breaking adjustments to other APIs to close correctness and soundness gaps.
 
 The recommended steps to update to PyO3 0.21 is as follows:
-  1. Enable the `gil-refs` feature to silence deprecations related to the API change
-  2. Fix all other PyO3 0.21 migration steps
-  3. Disable the `gil-refs` feature and migrate off the deprecated APIs
+
+1. Enable the `gil-refs` feature to silence deprecations related to the API change
+2. Fix all other PyO3 0.21 migration steps
+3. Disable the `gil-refs` feature and migrate off the deprecated APIs
 
 The following sections are laid out in this order.
+</details>
 
 ### Enable the `gil-refs` feature
 
-To make the transition for the PyO3 ecosystem away from the GIL Refs API as smooth as possible, in PyO3 0.21 no APIs consuming or producing GIL Refs have been altered. Instead, variants using `Bound<T>` smart pointers have been introduced, for example `PyTuple::new_bound` which returns `Bound<PyTuple>` is the replacement form of `PyTuple::new`. The GIL Ref APIs have been deprecated, but to make migration easier it is possible to disable these deprecation warnings by enabling the `gil-refs` feature.
+<details>
+<summary><small>Click to expand</small></summary>
+
+To make the transition for the PyO3 ecosystem away from the GIL Refs API as smooth as possible, in PyO3 0.21 no APIs consuming or producing GIL Refs have been altered.
+Instead, variants using `Bound<T>` smart pointers have been introduced, for example `PyTuple::new_bound` which returns `Bound<PyTuple>` is the replacement form of `PyTuple::new`.
+The GIL Ref APIs have been deprecated, but to make migration easier it is possible to disable these deprecation warnings by enabling the `gil-refs` feature.
 
 > The one single exception where an existing API was changed in-place is the `pyo3::intern!` macro. Almost all uses of this macro did not need to update code to account it changing to return `&Bound<PyString>` immediately, and adding an `intern_bound!` replacement was perceived as adding more work for users.
 
@@ -42,17 +818,24 @@ After:
 pyo3 = { version = "0.21", features = ["gil-refs"] }
 ```
 
+</details>
+
 ### `PyTypeInfo` and `PyTryFrom` have been adjusted
 
-The `PyTryFrom` trait has aged poorly, its [`try_from`] method now conflicts with `try_from` in the 2021 edition prelude. A lot of its functionality was also duplicated with `PyTypeInfo`.
+<details>
+<summary><small>Click to expand</small></summary>
+
+The `PyTryFrom` trait has aged poorly, its `try_from` method now conflicts with `TryFrom::try_from` in the 2021 edition prelude.
+A lot of its functionality was also duplicated with `PyTypeInfo`.
 
-To tighten up the PyO3 traits as part of the deprecation of the GIL Refs API the `PyTypeInfo` trait has had a simpler companion `PyTypeCheck`. The methods [`PyAny::downcast`]({{#PYO3_DOCS_URL}}/pyo3/types/struct.PyAny.html#method.downcast) and [`PyAny::downcast_exact`]({{#PYO3_DOCS_URL}}/pyo3/types/struct.PyAny.html#method.downcast_exact) no longer use `PyTryFrom` as a bound, instead using `PyTypeCheck` and `PyTypeInfo` respectively.
+To tighten up the PyO3 traits as part of the deprecation of the GIL Refs API the `PyTypeInfo` trait has had a simpler companion `PyTypeCheck`.
+The methods `PyAny::downcast` and `PyAny::downcast_exact` no longer use `PyTryFrom` as a bound, instead using `PyTypeCheck` and `PyTypeInfo` respectively.
 
 To migrate, switch all type casts to use `obj.downcast()` instead of `try_from(obj)` (and similar for `downcast_exact`).
 
 Before:
 
-```rust
+```rust,ignore
 # #![allow(deprecated)]
 # use pyo3::prelude::*;
 # use pyo3::types::{PyInt, PyList};
@@ -67,7 +850,7 @@ Python::with_gil(|py| {
 
 After:
 
-```rust
+```rust,ignore
 # use pyo3::prelude::*;
 # use pyo3::types::{PyInt, PyList};
 # fn main() -> PyResult<()> {
@@ -82,14 +865,21 @@ Python::with_gil(|py| {
 # }
 ```
 
+</details>
+
 ### `Iter(A)NextOutput` are deprecated
 
-The `__next__` and `__anext__` magic methods can now return any type convertible into Python objects directly just like all other `#[pymethods]`. The `IterNextOutput` used by `__next__` and `IterANextOutput` used by `__anext__` are subsequently deprecated. Most importantly, this change allows returning an awaitable from `__anext__` without non-sensically wrapping it into `Yield` or `Some`. Only the return types `Option<T>` and `Result<Option<T>, E>` are still handled in a special manner where `Some(val)` yields `val` and `None` stops iteration.
+<details>
+<summary><small>Click to expand</small></summary>
+
+The `__next__` and `__anext__` magic methods can now return any type convertible into Python objects directly just like all other `#[pymethods]`.
+The `IterNextOutput` used by `__next__` and `IterANextOutput` used by `__anext__` are subsequently deprecated.
+Most importantly, this change allows returning an awaitable from `__anext__` without non-sensically wrapping it into `Yield` or `Some`.
+Only the return types `Option<T>` and `Result<Option<T>, E>` are still handled in a special manner where `Some(val)` yields `val` and `None` stops iteration.
 
 Starting with an implementation of a Python iterator using `IterNextOutput`, e.g.
 
-```rust
-#![allow(deprecated)]
+```rust,ignore
 use pyo3::prelude::*;
 use pyo3::iter::IterNextOutput;
 
@@ -113,7 +903,7 @@ impl PyClassIter {
 
 If returning `"done"` via `StopIteration` is not really required, this should be written as
 
-```rust
+```rust,no_run
 use pyo3::prelude::*;
 
 #[pyclass]
@@ -134,11 +924,12 @@ impl PyClassIter {
 }
 ```
 
-This form also has additional benefits: It has already worked in previous PyO3 versions, it matches the signature of Rust's [`Iterator` trait](https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html) and it allows using a fast path in CPython which completely avoids the cost of raising a `StopIteration` exception. Note that using [`Option::transpose`](https://doc.rust-lang.org/stable/std/option/enum.Option.html#method.transpose) and the `Result<Option<T>, E>` variant, this form can also be used to wrap fallible iterators.
+This form also has additional benefits: It has already worked in previous PyO3 versions, it matches the signature of Rust's [`Iterator` trait](https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html) and it allows using a fast path in CPython which completely avoids the cost of raising a `StopIteration` exception.
+Note that using [`Option::transpose`](https://doc.rust-lang.org/stable/std/option/enum.Option.html#method.transpose) and the `Result<Option<T>, E>` variant, this form can also be used to wrap fallible iterators.
 
 Alternatively, the implementation can also be done as it would in Python itself, i.e. by "raising" a `StopIteration` exception
 
-```rust
+```rust,no_run
 use pyo3::prelude::*;
 use pyo3::exceptions::PyStopIteration;
 
@@ -162,7 +953,7 @@ impl PyClassIter {
 
 Finally, an asynchronous iterator can directly return an awaitable without confusing wrapping
 
-```rust
+```rust,no_run
 use pyo3::prelude::*;
 
 #[pyclass]
@@ -190,7 +981,9 @@ struct PyClassAsyncIter {
 impl PyClassAsyncIter {
     fn __anext__(&mut self) -> PyClassAwaitable {
         self.number += 1;
-        PyClassAwaitable { number: self.number }
+        PyClassAwaitable {
+            number: self.number,
+        }
     }
 
     fn __aiter__(slf: Py<Self>) -> Py<Self> {
@@ -199,34 +992,102 @@ impl PyClassAsyncIter {
 }
 ```
 
+</details>
+
 ### `PyType::name` has been renamed to `PyType::qualname`
 
-`PyType::name` has been renamed to `PyType::qualname` to indicate that it does indeed return the [qualified name](https://docs.python.org/3/glossary.html#term-qualified-name), matching the `__qualname__` attribute. The newly added `PyType::name` yields the full name including the module name now which corresponds to `__module__.__name__` on the level of attributes.
+<details>
+<summary><small>Click to expand</small></summary>
+
+`PyType::name` has been renamed to `PyType::qualname` to indicate that it does indeed return the [qualified name](https://docs.python.org/3/glossary.html#term-qualified-name), matching the `__qualname__` attribute.
+The newly added `PyType::name` yields the full name including the module name now which corresponds to `__module__.__name__` on the level of attributes.
+</details>
+
+### `PyCell` has been deprecated
+
+<details>
+<summary><small>Click to expand</small></summary>
+
+Interactions with Python objects implemented in Rust no longer need to go though `PyCell<T>`.
+Instead interactions with Python object now consistently go through `Bound<T>` or `Py<T>` independently of whether `T` is native Python object or a `#[pyclass]` implemented in Rust.
+Use `Bound::new` or `Py::new` respectively to create and `Bound::borrow(_mut)` / `Py::borrow(_mut)` to borrow the Rust object.
+</details>
+
+### Migrating from the GIL Refs API to `Bound<T>`
+
+<details>
+<summary><small>Click to expand</small></summary>
 
-### Migrating from the GIL-Refs API to `Bound<T>`
+To minimise breakage of code using the GIL Refs API, the `Bound<T>` smart pointer has been introduced by adding complements to all functions which accept or return GIL Refs.
+This allows code to migrate by replacing the deprecated APIs with the new ones.
 
-To minimise breakage of code using the GIL-Refs API, the `Bound<T>` smart pointer has been introduced by adding complements to all functions which accept or return GIL Refs. This allows code to migrate by replacing the deprecated APIs with the new ones.
+To identify what to migrate, temporarily switch off the `gil-refs` feature to see deprecation warnings on [almost](#cases-where-pyo3-cannot-emit-gil-ref-deprecation-warnings) all uses of APIs accepting and producing GIL Refs .
+Over one or more PRs it should be possible to follow the deprecation hints to update code.
+Depending on your development environment, switching off the `gil-refs` feature may introduce [some very targeted breakages](#deactivating-the-gil-refs-feature), so you may need to fixup those first.
 
 For example, the following APIs have gained updated variants:
-- `PyList::new`, `PyTyple::new` and similar constructors have replacements `PyList::new_bound`, `PyTuple::new_bound` etc.
+
+- `PyList::new`, `PyTuple::new` and similar constructors have replacements `PyList::new_bound`, `PyTuple::new_bound` etc.
 - `FromPyObject::extract` has a new `FromPyObject::extract_bound` (see the section below)
 - The `PyTypeInfo` trait has had new `_bound` methods added to accept / return `Bound<T>`.
 
 Because the new `Bound<T>` API brings ownership out of the PyO3 framework and into user code, there are a few places where user code is expected to need to adjust while switching to the new API:
+
 - Code will need to add the occasional `&` to borrow the new smart pointer as `&Bound<T>` to pass these types around (or use `.clone()` at the very small cost of increasing the Python reference count)
 - `Bound<PyList>` and `Bound<PyTuple>` cannot support indexing with `list[0]`, you should use `list.get_item(0)` instead.
-- `Bound<PyTuple>::iter_borrowed` is slightly more efficient than `Bound<PyTuple>::iter`. The default iteration of `Bound<PyTuple>` cannot return borrowed references because Rust does not (yet) have "lending iterators". Similarly `Bound<PyTuple>::get_borrowed_item` is more efficient than `Bound<PyTuple>::get_item` for the same reason.
-- `&Bound<T>` does not implement `FromPyObject` (although it might be possible to do this in the future once the GIL Refs API is completely removed). Use `bound_any.downcast::<T>()` instead of `bound_any.extract::<&Bound<T>>()`.
-- To convert between `&PyAny` and `&Bound<PyAny>` you can use the `as_borrowed()` method:
+- `Bound<PyTuple>::iter_borrowed` is slightly more efficient than `Bound<PyTuple>::iter`.
+  The default iteration of `Bound<PyTuple>` cannot return borrowed references because Rust does not (yet) have "lending iterators".
+  Similarly `Bound<PyTuple>::get_borrowed_item` is more efficient than `Bound<PyTuple>::get_item` for the same reason.
+- `&Bound<T>` does not implement `FromPyObject` (although it might be possible to do this in the future once the GIL Refs API is completely removed).
+  Use `bound_any.downcast::<T>()` instead of `bound_any.extract::<&Bound<T>>()`.
+- `Bound<PyString>::to_str` now borrows from the `Bound<PyString>` rather than from the `'py` lifetime, so code will need to store the smart pointer as a value in some cases where previously `&PyString` was just used as a temporary. (There are some more details relating to this in [the section below](#deactivating-the-gil-refs-feature).)
+- `.extract::<&str>()` now borrows from the source Python object.
+  The simplest way to update is to change to `.extract::<PyBackedStr>()`, which retains ownership of the Python reference.
+  See more information [in the section on deactivating the `gil-refs` feature](#deactivating-the-gil-refs-feature).
+
+To convert between `&PyAny` and `&Bound<PyAny>` use the `as_borrowed()` method:
 
 ```rust,ignore
 let gil_ref: &PyAny = ...;
 let bound: &Bound<PyAny> = &gil_ref.as_borrowed();
 ```
 
+To convert between `Py<T>` and `Bound<T>` use the `bind()` / `into_bound()` methods, and `as_unbound()` / `unbind()` to go back from `Bound<T>` to `Py<T>`.
+
+```rust,ignore
+let obj: Py<PyList> = ...;
+let bound: &Bound<'py, PyList> = obj.bind(py);
+let bound: Bound<'py, PyList> = obj.into_bound(py);
+
+let obj: &Py<PyList> = bound.as_unbound();
+let obj: Py<PyList> = bound.unbind();
+```
+
+<div class="warning">
+
+⚠️ Warning: dangling pointer trap 💣
+
+> Because of the ownership changes, code which uses `.as_ptr()` to convert `&PyAny` and other GIL Refs to a `*mut pyo3_ffi::PyObject` should take care to avoid creating dangling pointers now that `Bound<PyAny>` carries ownership.
+>
+> For example, the following pattern with `Option<&PyAny>` can easily create a dangling pointer when migrating to the `Bound<PyAny>` smart pointer:
+>
+> ```rust,ignore
+> let opt: Option<&PyAny> = ...;
+> let p: *mut ffi::PyObject = opt.map_or(std::ptr::null_mut(), |any| any.as_ptr());
+> ```
+>
+> The correct way to migrate this code is to use `.as_ref()` to avoid dropping the `Bound<PyAny>` in the `map_or` closure:
+>
+> ```rust,ignore
+> let opt: Option<Bound<PyAny>> = ...;
+> let p: *mut ffi::PyObject = opt.as_ref().map_or(std::ptr::null_mut(), Bound::as_ptr);
+> ```
+<div>
+
 #### Migrating `FromPyObject` implementations
 
-`FromPyObject` has had a new method `extract_bound` which takes `&Bound<'py, PyAny>` as an argument instead of `&PyAny`. Both `extract` and `extract_bound` have been given default implementations in terms of the other, to avoid breaking code immediately on update to 0.21.
+`FromPyObject` has had a new method `extract_bound` which takes `&Bound<'py, PyAny>` as an argument instead of `&PyAny`.
+Both `extract` and `extract_bound` have been given default implementations in terms of the other, to avoid breaking code immediately on update to 0.21.
 
 All implementations of `FromPyObject` should be switched from `extract` to `extract_bound`.
 
@@ -252,17 +1113,117 @@ impl<'py> FromPyObject<'py> for MyType {
 
 The expectation is that in 0.22 `extract_bound` will have the default implementation removed and in 0.23 `extract` will be removed.
 
+#### Cases where PyO3 cannot emit GIL Ref deprecation warnings
 
+Despite a large amount of deprecations warnings produced by PyO3 to aid with the transition from GIL Refs to the Bound API, there are a few cases where PyO3 cannot automatically warn on uses of GIL Refs.
+It is worth checking for these cases manually after the deprecation warnings have all been addressed:
+
+- Individual implementations of the `FromPyObject` trait cannot be deprecated, so PyO3 cannot warn about uses of code patterns like `.extract<&PyAny>()` which produce a GIL Ref.
+- GIL Refs in `#[pyfunction]` arguments emit a warning, but if the GIL Ref is wrapped inside another container such as `Vec<&PyAny>` then PyO3 cannot warn against this.
+- The `wrap_pyfunction!(function)(py)` deferred argument form of the `wrap_pyfunction` macro taking `py: Python<'py>` produces a GIL Ref, and due to limitations in type inference PyO3 cannot warn against this specific case.
+
+</details>
+
+### Deactivating the `gil-refs` feature
+
+<details>
+<summary><small>Click to expand</small></summary>
+
+As a final step of migration, deactivating the `gil-refs` feature will set up code for best performance and is intended to set up a forward-compatible API for PyO3 0.22.
+
+At this point code that needed to manage GIL Ref memory can safely remove uses of `GILPool` (which are constructed by calls to `Python::new_pool` and `Python::with_pool`).
+Deprecation warnings will highlight these cases.
+
+There is just one case of code that changes upon disabling these features: `FromPyObject` trait implementations for types that borrow directly from the input data cannot be implemented by PyO3 without GIL Refs (while the GIL Refs API is in the process of being removed).
+The main types affected are `&str`, `Cow<'_, str>`, `&[u8]`, `Cow<'_, u8>`.
+
+To make PyO3's core functionality continue to work while the GIL Refs API is in the process of being removed, disabling the `gil-refs` feature moves the implementations of `FromPyObject` for `&str`, `Cow<'_, str>`, `&[u8]`, `Cow<'_, u8>` to a new temporary trait `FromPyObjectBound`.
+This trait is the expected future form of `FromPyObject` and has an additional lifetime `'a` to enable these types to borrow data from Python objects.
+
+PyO3 0.21 has introduced the [`PyBackedStr`]({{#PYO3_DOCS_URL}}/pyo3/pybacked/struct.PyBackedStr.html) and [`PyBackedBytes`]({{#PYO3_DOCS_URL}}/pyo3/pybacked/struct.PyBackedBytes.html) types to help with this case.
+The easiest way to avoid lifetime challenges from extracting `&str` is to use these.
+For more complex types like `Vec<&str>`, is now impossible to extract directly from a Python object and `Vec<PyBackedStr>` is the recommended upgrade path.
+
+A key thing to note here is because extracting to these types now ties them to the input lifetime, some extremely common patterns may need to be split into multiple Rust lines.
+For example, the following snippet of calling `.extract::<&str>()` directly on the result of `.getattr()` needs to be adjusted when deactivating the `gil-refs` feature.
+
+Before:
+
+```rust,ignore
+# #[cfg(feature = "gil-refs")] {
+# use pyo3::prelude::*;
+# use pyo3::types::{PyList, PyType};
+# fn example<'py>(py: Python<'py>) -> PyResult<()> {
+#[allow(deprecated)] // GIL Ref API
+let obj: &'py PyType = py.get_type::<PyList>();
+let name: &'py str = obj.getattr("__name__")?.extract()?;
+assert_eq!(name, "list");
+# Ok(())
+# }
+# Python::with_gil(example).unwrap();
+# }
+```
+
+After:
+
+```rust,ignore
+# #[cfg(any(not(Py_LIMITED_API), Py_3_10))] {
+# use pyo3::prelude::*;
+# use pyo3::types::{PyList, PyType};
+# fn example<'py>(py: Python<'py>) -> PyResult<()> {
+let obj: Bound<'py, PyType> = py.get_type_bound::<PyList>();
+let name_obj: Bound<'py, PyAny> = obj.getattr("__name__")?;
+// the lifetime of the data is no longer `'py` but the much shorter
+// lifetime of the `name_obj` smart pointer above
+let name: &'_ str = name_obj.extract()?;
+assert_eq!(name, "list");
+# Ok(())
+# }
+# Python::with_gil(example).unwrap();
+# }
+```
+
+To avoid needing to worry about lifetimes at all, it is also possible to use the new `PyBackedStr` type, which stores a reference to the Python `str` without a lifetime attachment.
+In particular, `PyBackedStr` helps for `abi3` builds for Python older than 3.10.
+Due to limitations in the `abi3` CPython API for those older versions, PyO3 cannot offer a `FromPyObjectBound` implementation for `&str` on those versions.
+The easiest way to migrate for older `abi3` builds is to replace any cases of `.extract::<&str>()` with `.extract::<PyBackedStr>()`.
+Alternatively, use `.extract::<Cow<str>>()`, `.extract::<String>()` to copy the data into Rust.
+
+The following example uses the same snippet as those just above, but this time the final extracted type is `PyBackedStr`:
+
+```rust,ignore
+# use pyo3::prelude::*;
+# use pyo3::types::{PyList, PyType};
+# fn example<'py>(py: Python<'py>) -> PyResult<()> {
+use pyo3::pybacked::PyBackedStr;
+let obj: Bound<'py, PyType> = py.get_type_bound::<PyList>();
+let name: PyBackedStr = obj.getattr("__name__")?.extract()?;
+assert_eq!(&*name, "list");
+# Ok(())
+# }
+# Python::with_gil(example).unwrap();
+```
+
+</details>
 
 ## from 0.19.* to 0.20
 
 ### Drop support for older technologies
 
-PyO3 0.20 has increased minimum Rust version to 1.56. This enables use of newer language features and simplifies maintenance of the project.
+<details>
+<summary><small>Click to expand</small></summary>
+
+PyO3 0.20 has increased minimum Rust version to 1.56.
+This enables use of newer language features and simplifies maintenance of the project.
+</details>
 
 ### `PyDict::get_item` now returns a `Result`
 
-`PyDict::get_item` in PyO3 0.19 and older was implemented using a Python API which would suppress all exceptions and return `None` in those cases. This included errors in `__hash__` and `__eq__` implementations of the key being looked up.
+<details>
+<summary><small>Click to expand</small></summary>
+
+`PyDict::get_item` in PyO3 0.19 and older was implemented using a Python API which would suppress all exceptions and return `None` in those cases.
+This included errors in `__hash__` and `__eq__` implementations of the key being looked up.
 
 Newer recommendations by the Python core developers advise against using these APIs which suppress exceptions, instead allowing exceptions to bubble upwards. `PyDict::get_item_with_error` already implemented this recommended behavior, so that API has been renamed to `PyDict::get_item`.
 
@@ -282,7 +1243,10 @@ Python::with_gil(|py| {
     // `b` is not in the dictionary
     assert!(dict.get_item("b").is_none());
     // `dict` is not hashable, so this fails with a `TypeError`
-    assert!(dict.get_item_with_error(dict).unwrap_err().is_instance_of::<PyTypeError>(py));
+    assert!(dict
+        .get_item_with_error(dict)
+        .unwrap_err()
+        .is_instance_of::<PyTypeError>(py));
 });
 # }
 ```
@@ -303,16 +1267,26 @@ Python::with_gil(|py| -> PyResult<()> {
     // `b` is not in the dictionary
     assert!(dict.get_item("b")?.is_none());
     // `dict` is not hashable, so this fails with a `TypeError`
-    assert!(dict.get_item(dict).unwrap_err().is_instance_of::<PyTypeError>(py));
+    assert!(dict
+        .get_item(dict)
+        .unwrap_err()
+        .is_instance_of::<PyTypeError>(py));
 
     Ok(())
 });
 # }
 ```
 
+</details>
+
 ### Required arguments are no longer accepted after optional arguments
 
-[Trailing `Option<T>` arguments](./function/signature.md#trailing-optional-arguments) have an automatic default of `None`. To avoid unwanted changes when modifying function signatures, in PyO3 0.18 it was deprecated to have a required argument after an `Option<T>` argument without using `#[pyo3(signature = (...))]` to specify the intended defaults. In PyO3 0.20, this becomes a hard error.
+<details>
+<summary><small>Click to expand</small></summary>
+
+Trailing `Option<T>` arguments have an automatic default of `None`.
+To avoid unwanted changes when modifying function signatures, in PyO3 0.18 it was deprecated to have a required argument after an `Option<T>` argument without using `#[pyo3(signature = (...))]` to specify the intended defaults.
+In PyO3 0.20, this becomes a hard error.
 
 Before:
 
@@ -325,7 +1299,7 @@ fn x_or_y(x: Option<u64>, y: u64) -> u64 {
 
 After:
 
-```rust
+```rust,no_run
 # #![allow(dead_code)]
 # use pyo3::prelude::*;
 
@@ -336,9 +1310,15 @@ fn x_or_y(x: Option<u64>, y: u64) -> u64 {
 }
 ```
 
+</details>
+
 ### Remove deprecated function forms
 
-In PyO3 0.18 the `#[args]` attribute for `#[pymethods]`, and directly specifying the function signature in `#[pyfunction]`, was deprecated. This functionality has been removed in PyO3 0.20.
+<details>
+<summary><small>Click to expand</small></summary>
+
+In PyO3 0.18 the `#[args]` attribute for `#[pymethods]`, and directly specifying the function signature in `#[pyfunction]`, was deprecated.
+This functionality has been removed in PyO3 0.20.
 
 Before:
 
@@ -352,7 +1332,7 @@ fn add(a: u64, b: u64) -> u64 {
 
 After:
 
-```rust
+```rust,no_run
 # #![allow(dead_code)]
 # use pyo3::prelude::*;
 
@@ -363,23 +1343,38 @@ fn add(a: u64, b: u64) -> u64 {
 }
 ```
 
+</details>
+
 ### `IntoPyPointer` trait removed
 
+<details>
+<summary><small>Click to expand</small></summary>
+
 The trait `IntoPyPointer`, which provided the `into_ptr` method on many types, has been removed. `into_ptr` is now available as an inherent method on all types that previously implemented this trait.
+</details>
 
 ### `AsPyPointer` now `unsafe` trait
 
+<details>
+<summary><small>Click to expand</small></summary>
+
 The trait `AsPyPointer` is now `unsafe trait`, meaning any external implementation of it must be marked as `unsafe impl`, and ensure that they uphold the invariant of returning valid pointers.
+</details>
 
 ## from 0.18.* to 0.19
 
 ### Access to `Python` inside `__traverse__` implementations are now forbidden
 
-During `__traverse__` implementations for Python's Garbage Collection it is forbidden to do anything other than visit the members of the `#[pyclass]` being traversed. This means making Python function calls or other API calls are forbidden.
+<details>
+<summary><small>Click to expand</small></summary>
+
+During `__traverse__` implementations for Python's Garbage Collection it is forbidden to do anything other than visit the members of the `#[pyclass]` being traversed.
+This means making Python function calls or other API calls are forbidden.
 
 Previous versions of PyO3 would allow access to `Python` (e.g. via `Python::with_gil`), which could cause the Python interpreter to crash or otherwise confuse the garbage collection algorithm.
 
-Attempts to acquire the GIL will now panic. See [#3165](https://github.com/PyO3/pyo3/issues/3165) for more detail.
+Attempts to acquire the GIL will now panic.
+See [#3165](https://github.com/PyO3/pyo3/issues/3165) for more detail.
 
 ```rust,ignore
 # use pyo3::prelude::*;
@@ -394,11 +1389,16 @@ impl SomeClass {
 }
 ```
 
+</details>
+
 ### Smarter `anyhow::Error` / `eyre::Report` conversion when inner error is "simple" `PyErr`
 
+<details>
+<summary><small>Click to expand</small></summary>
+
 When converting from `anyhow::Error` or `eyre::Report` to `PyErr`, if the inner error is a "simple" `PyErr` (with no source error), then the inner error will be used directly as the `PyErr` instead of wrapping it in a new `PyRuntimeError` with the original information converted into a string.
 
-```rust
+```rust,ignore
 # #[cfg(feature = "anyhow")]
 # #[allow(dead_code)]
 # mod anyhow_only {
@@ -432,10 +1432,14 @@ Before, the above code would have printed `RuntimeError('ValueError: original er
 After, the same code will print `ValueError: original error message`, which is more straightforward.
 
 However, if the `anyhow::Error` or `eyre::Report` has a source, then the original exception will still be wrapped in a `PyRuntimeError`.
+</details>
 
 ### The deprecated `Python::acquire_gil` was removed and `Python::with_gil` must be used instead
 
-While the API provided by [`Python::acquire_gil`](https://docs.rs/pyo3/0.18.3/pyo3/marker/struct.Python.html#method.acquire_gil) seems convenient, it is somewhat brittle as the design of the GIL token [`Python`](https://docs.rs/pyo3/0.18.3/pyo3/marker/struct.Python.html) relies on proper nesting and panics if not used correctly, e.g.
+<details>
+<summary><small>Click to expand</small></summary>
+
+While the API provided by [`Python::acquire_gil`](https://docs.rs/pyo3/0.18.3/pyo3/marker/struct.Python.html#method.acquire_gil) seems convenient, it is somewhat brittle as the design of the [`Python`](https://docs.rs/pyo3/0.18.3/pyo3/marker/struct.Python.html) token relies on proper nesting and panics if not used correctly, e.g.
 
 ```rust,ignore
 # #![allow(dead_code, deprecated)]
@@ -465,9 +1469,9 @@ drop(first);
 drop(second);
 ```
 
-The replacement is [`Python::with_gil`]() which is more cumbersome but enforces the proper nesting by design, e.g.
+The replacement is [`Python::with_gil`](https://docs.rs/pyo3/0.18.3/pyo3/marker/struct.Python.html#method.with_gil) which is more cumbersome but enforces the proper nesting by design, e.g.
 
-```rust
+```rust,ignore
 # #![allow(dead_code)]
 # use pyo3::prelude::*;
 
@@ -486,13 +1490,13 @@ impl Object {
     }
 }
 
-// It either forces us to release the GIL before aquiring it again.
+// It either forces us to release the GIL before acquiring it again.
 let first = Python::with_gil(|py| Object::new(py));
 let second = Python::with_gil(|py| Object::new(py));
 drop(first);
 drop(second);
 
-// Or it ensure releasing the inner lock before the outer one.
+// Or it ensures releasing the inner lock before the outer one.
 Python::with_gil(|py| {
     let first = Object::new(py);
     let second = Python::with_gil(|py| Object::new(py));
@@ -501,19 +1505,26 @@ Python::with_gil(|py| {
 });
 ```
 
-Furthermore, `Python::acquire_gil` provides ownership of a `GILGuard` which can be freely stored and passed around. This is usually not helpful as it may keep the lock held for a long time thereby blocking progress in other parts of the program. Due to the generative lifetime attached to the GIL token supplied by `Python::with_gil`, the problem is avoided as the GIL token can only be passed down the call chain. Often, this issue can also be avoided entirely as any GIL-bound reference `&'py PyAny` implies access to a GIL token `Python<'py>` via the [`PyAny::py`](https://docs.rs/pyo3/latest/pyo3/types/struct.PyAny.html#method.py) method.
+Furthermore, `Python::acquire_gil` provides ownership of a `GILGuard` which can be freely stored and passed around.
+This is usually not helpful as it may keep the lock held for a long time thereby blocking progress in other parts of the program.
+Due to the generative lifetime attached to the Python token supplied by `Python::with_gil`, the problem is avoided as the Python token can only be passed down the call chain.
+Often, this issue can also be avoided entirely as any GIL-bound reference `&'py PyAny` implies access to a Python token `Python<'py>` via the [`PyAny::py`](https://docs.rs/pyo3/0.22.5/pyo3/types/struct.PyAny.html#method.py) method.
+</details>
 
 ## from 0.17.* to 0.18
 
 ### Required arguments after `Option<_>` arguments will no longer be automatically inferred
 
+<details>
+<summary><small>Click to expand</small></summary>
+
 In `#[pyfunction]` and `#[pymethods]`, if a "required" function input such as `i32` came after an `Option<_>` input, then the `Option<_>` would be implicitly treated as required. (All trailing `Option<_>` arguments were treated as optional with a default value of `None`).
 
 Starting with PyO3 0.18, this is deprecated and a future PyO3 version will require a [`#[pyo3(signature = (...))]` option](./function/signature.md) to explicitly declare the programmer's intention.
 
 Before, x in the below example would be required to be passed from Python code:
 
-```rust,compile_fail
+```rust,compile_fail,ignore
 # #![allow(dead_code)]
 # use pyo3::prelude::*;
 
@@ -523,7 +1534,7 @@ fn required_argument_after_option(x: Option<i32>, y: i32) {}
 
 After, specify the intended Python signature explicitly:
 
-```rust
+```rust,no_run
 # #![allow(dead_code)]
 # use pyo3::prelude::*;
 
@@ -536,11 +1547,18 @@ fn required_argument_after_option_a(x: Option<i32>, y: i32) {}
 fn required_argument_after_option_b(x: Option<i32>, y: i32) {}
 ```
 
+</details>
+
 ### `__text_signature__` is now automatically generated for `#[pyfunction]` and `#[pymethods]`
 
+<details>
+<summary><small>Click to expand</small></summary>
+
 The [`#[pyo3(text_signature = "...")]` option](./function/signature.md#making-the-function-signature-available-to-python) was previously the only supported way to set the `__text_signature__` attribute on generated Python functions.
 
-PyO3 is now able to automatically populate `__text_signature__` for all functions automatically based on their Rust signature (or the [new `#[pyo3(signature = (...))]` option](./function/signature.md)). These automatically-generated `__text_signature__` values will currently only render `...` for all default values. Many `#[pyo3(text_signature = "...")]` options can be removed from functions when updating to PyO3 0.18, however in cases with default values a manual implementation may still be preferred for now.
+PyO3 is now able to automatically populate `__text_signature__` for all functions automatically based on their Rust signature (or the [new `#[pyo3(signature = (...))]` option](./function/signature.md)).
+These automatically-generated `__text_signature__` values will currently only render `...` for all default values.
+Many `#[pyo3(text_signature = "...")]` options can be removed from functions when updating to PyO3 0.18, however in cases with default values a manual implementation may still be preferred for now.
 
 As examples:
 
@@ -558,7 +1576,7 @@ fn simple_function(a: i32, b: i32, c: i32) {}
 fn function_with_defaults(a: i32, b: i32, c: i32) {}
 
 # fn main() {
-#     Python::with_gil(|py| {
+#     Python::attach(|py| {
 #         let simple = wrap_pyfunction!(simple_function, py).unwrap();
 #         assert_eq!(simple.getattr("__text_signature__").unwrap().to_string(), "(a, b, c)");
 #         let defaulted = wrap_pyfunction!(function_with_defaults, py).unwrap();
@@ -567,31 +1585,30 @@ fn function_with_defaults(a: i32, b: i32, c: i32) {}
 # }
 ```
 
+</details>
+
 ## from 0.16.* to 0.17
 
 ### Type checks have been changed for `PyMapping` and `PySequence` types
 
+<details>
+<summary><small>Click to expand</small></summary>
+
 Previously the type checks for `PyMapping` and `PySequence` (implemented in `PyTryFrom`)
 used the Python C-API functions `PyMapping_Check` and `PySequence_Check`.
 Unfortunately these functions are not sufficient for distinguishing such types,
 leading to inconsistent behavior (see
 [pyo3/pyo3#2072](https://github.com/PyO3/pyo3/issues/2072)).
 
-PyO3 0.17 changes these downcast checks to explicitly test if the type is a
-subclass of the corresponding abstract base class `collections.abc.Mapping` or
-`collections.abc.Sequence`. Note this requires calling into Python, which may
-incur a performance penalty over the previous method. If this performance
-penalty is a problem, you may be able to perform your own checks and use
-`try_from_unchecked` (unsafe).
+PyO3 0.17 changes these downcast checks to explicitly test if the type is a subclass of the corresponding abstract base class `collections.abc.Mapping` or `collections.abc.Sequence`.
+Note this requires calling into Python, which may incur a performance penalty over the previous method.
+If this performance penalty is a problem, you may be able to perform your own checks and use `try_from_unchecked` (unsafe).
 
-Another side-effect is that a pyclass defined in Rust with PyO3 will need to
-be _registered_ with the corresponding Python abstract base class for
-downcasting to succeed. `PySequence::register` and `PyMapping:register` have
-been added to make it easy to do this from Rust code. These are equivalent to
-calling `collections.abc.Mapping.register(MappingPyClass)` or
-`collections.abc.Sequence.register(SequencePyClass)` from Python.
+Another side-effect is that a pyclass defined in Rust with PyO3 will need to be _registered_ with the corresponding Python abstract base class for downcasting to succeed. `PySequence::register` and `PyMapping:register` have been added to make it easy to do this from Rust code.
+These are equivalent to calling `collections.abc.Mapping.register(MappingPyClass)` or `collections.abc.Sequence.register(SequencePyClass)` from Python.
 
 For example, for a mapping class defined in Rust:
+
 ```rust,compile_fail
 use pyo3::prelude::*;
 use std::collections::HashMap;
@@ -611,6 +1628,7 @@ impl Mapping {
 ```
 
 You must register the class with `collections.abc.Mapping` before the downcast will work:
+
 ```rust,compile_fail
 let m = Py::new(py, Mapping { index }).unwrap();
 assert!(m.as_ref(py).downcast::<PyMapping>().is_err());
@@ -619,17 +1637,26 @@ assert!(m.as_ref(py).downcast::<PyMapping>().is_ok());
 ```
 
 Note that this requirement may go away in the future when a pyclass is able to inherit from the abstract base class directly (see [pyo3/pyo3#991](https://github.com/PyO3/pyo3/issues/991)).
+</details>
 
 ### The `multiple-pymethods` feature now requires Rust 1.62
 
-Due to limitations in the `inventory` crate which the `multiple-pymethods` feature depends on, this feature now
-requires Rust 1.62. For more information see [dtolnay/inventory#32](https://github.com/dtolnay/inventory/issues/32).
+<details>
+<summary><small>Click to expand</small></summary>
+
+Due to limitations in the `inventory` crate which the `multiple-pymethods` feature depends on, this feature now requires Rust 1.62.
+For more information see [dtolnay/inventory#32](https://github.com/dtolnay/inventory/issues/32).
+</details>
 
 ### Added `impl IntoPy<Py<PyString>> for &str`
 
+<details>
+<summary><small>Click to expand</small></summary>
+
 This may cause inference errors.
 
 Before:
+
 ```rust,compile_fail
 # use pyo3::prelude::*;
 #
@@ -643,7 +1670,8 @@ Python::with_gil(|py| {
 
 After, some type annotations may be necessary:
 
-```rust
+```rust,ignore
+# #![allow(deprecated)]
 # use pyo3::prelude::*;
 #
 # fn main() {
@@ -653,13 +1681,24 @@ Python::with_gil(|py| {
 # }
 ```
 
+</details>
+
 ### The `pyproto` feature is now disabled by default
 
-In preparation for removing the deprecated `#[pyproto]` attribute macro in a future PyO3 version, it is now gated behind an opt-in feature flag. This also gives a slight saving to compile times for code which does not use the deprecated macro.
+<details>
+<summary><small>Click to expand</small></summary>
+
+In preparation for removing the deprecated `#[pyproto]` attribute macro in a future PyO3 version, it is now gated behind an opt-in feature flag.
+This also gives a slight saving to compile times for code which does not use the deprecated macro.
+</details>
 
 ### `PyTypeObject` trait has been deprecated
 
-The `PyTypeObject` trait already was near-useless; almost all functionality was already on the `PyTypeInfo` trait, which `PyTypeObject` had a blanket implementation based upon. In PyO3 0.17 the final method, `PyTypeObject::type_object` was moved to `PyTypeInfo::type_object`.
+<details>
+<summary><small>Click to expand</small></summary>
+
+The `PyTypeObject` trait already was near-useless; almost all functionality was already on the `PyTypeInfo` trait, which `PyTypeObject` had a blanket implementation based upon.
+In PyO3 0.17 the final method, `PyTypeObject::type_object` was moved to `PyTypeInfo::type_object`.
 
 To migrate, update trait bounds and imports from `PyTypeObject` to `PyTypeInfo`.
 
@@ -688,25 +1727,52 @@ fn get_type_object<T: PyTypeInfo>(py: Python<'_>) -> &PyType {
 # Python::with_gil(|py| { get_type_object::<pyo3::types::PyList>(py); });
 ```
 
+</details>
+
 ### `impl<T, const N: usize> IntoPy<PyObject> for [T; N]` now requires `T: IntoPy` rather than `T: ToPyObject`
 
-If this leads to errors, simply implement `IntoPy`. Because pyclasses already implement `IntoPy`, you probably don't need to worry about this.
+<details>
+<summary><small>Click to expand</small></summary>
+
+If this leads to errors, simply implement `IntoPy`.
+Because pyclasses already implement `IntoPy`, you probably don't need to worry about this.
+</details>
 
 ### Each `#[pymodule]` can now only be initialized once per process
 
-To make PyO3 modules sound in the presence of Python sub-interpreters, for now it has been necessary to explicitly disable the ability to initialize a `#[pymodule]` more than once in the same process. Attempting to do this will now raise an `ImportError`.
+<details>
+<summary><small>Click to expand</small></summary>
+
+To make PyO3 modules sound in the presence of Python sub-interpreters, for now it has been necessary to explicitly disable the ability to initialize a `#[pymodule]` more than once in the same process.
+Attempting to do this will now raise an `ImportError`.
+</details>
 
 ## from 0.15.* to 0.16
 
+<!-- rumdl-disable MD024 - same heading used above -->
+
 ### Drop support for older technologies
 
-PyO3 0.16 has increased minimum Rust version to 1.48 and minimum Python version to 3.7. This enables use of newer language features (enabling some of the other additions in 0.16) and simplifies maintenance of the project.
+<!-- rumdl-enable MD024 -->
+
+<details>
+<summary><small>Click to expand</small></summary>
+
+PyO3 0.16 has increased minimum Rust version to 1.48 and minimum Python version to 3.7.
+This enables use of newer language features (enabling some of the other additions in 0.16) and simplifies maintenance of the project.
+</details>
 
 ### `#[pyproto]` has been deprecated
 
-In PyO3 0.15, the `#[pymethods]` attribute macro gained support for implementing "magic methods" such as `__str__` (aka "dunder" methods). This implementation was not quite finalized at the time, with a few edge cases to be decided upon. The existing `#[pyproto]` attribute macro was left untouched, because it covered these edge cases.
+<details>
+<summary><small>Click to expand</small></summary>
+
+In PyO3 0.15, the `#[pymethods]` attribute macro gained support for implementing "magic methods" such as `__str__` (aka "dunder" methods).
+This implementation was not quite finalized at the time, with a few edge cases to be decided upon.
+The existing `#[pyproto]` attribute macro was left untouched, because it covered these edge cases.
 
-In PyO3 0.16, the `#[pymethods]` implementation has been completed and is now the preferred way to implement magic methods. To allow the PyO3 project to move forward, `#[pyproto]` has been deprecated (with expected removal in PyO3 0.18).
+In PyO3 0.16, the `#[pymethods]` implementation has been completed and is now the preferred way to implement magic methods.
+To allow the PyO3 project to move forward, `#[pyproto]` has been deprecated (with expected removal in PyO3 0.18).
 
 Migration from `#[pyproto]` to `#[pymethods]` is straightforward; copying the existing methods directly from the `#[pyproto]` trait implementation is all that is needed in most cases.
 
@@ -756,8 +1822,13 @@ impl MyClass {
 }
 ```
 
+</details>
+
 ### Removed `PartialEq` for object wrappers
 
+<details>
+<summary><small>Click to expand</small></summary>
+
 The Python object wrappers `Py` and `PyAny` had implementations of `PartialEq`
 so that `object_a == object_b` would compare the Python objects for pointer
 equality, which corresponds to the `is` operator, not the `==` operator in
@@ -768,14 +1839,21 @@ wrapper type for `object_a` and `object_b`; you can now directly compare a
 
 To check for Python object equality (the Python `==` operator), use the new
 method `eq()`.
+</details>
 
 ### Container magic methods now match Python behavior
 
-In PyO3 0.15, `__getitem__`, `__setitem__` and `__delitem__` in `#[pymethods]` would generate only the _mapping_ implementation for a `#[pyclass]`. To match the Python behavior, these methods now generate both the _mapping_ **and** _sequence_ implementations.
+<details>
+<summary><small>Click to expand</small></summary>
 
-This means that classes implementing these `#[pymethods]` will now also be treated as sequences, same as a Python `class` would be. Small differences in behavior may result:
- - PyO3 will allow instances of these classes to be cast to `PySequence` as well as `PyMapping`.
- - Python will provide a default implementation of `__iter__` (if the class did not have one) which repeatedly calls `__getitem__` with integers (starting at 0) until an `IndexError` is raised.
+In PyO3 0.15, `__getitem__`, `__setitem__` and `__delitem__` in `#[pymethods]` would generate only the _mapping_ implementation for a `#[pyclass]`.
+To match the Python behavior, these methods now generate both the _mapping_ **and** _sequence_ implementations.
+
+This means that classes implementing these `#[pymethods]` will now also be treated as sequences, same as a Python `class` would be.
+Small differences in behavior may result:
+
+- PyO3 will allow instances of these classes to be cast to `PySequence` as well as `PyMapping`.
+- Python will provide a default implementation of `__iter__` (if the class did not have one) which repeatedly calls `__getitem__` with integers (starting at 0) until an `IndexError` is raised.
 
 To explain this in detail, consider the following Python class:
 
@@ -793,14 +1871,21 @@ class ExampleContainer:
 
 This class implements a Python [sequence](https://docs.python.org/3/glossary.html#term-sequence).
 
-The `__len__` and `__getitem__` methods are also used to implement a Python [mapping](https://docs.python.org/3/glossary.html#term-mapping). In the Python C-API, these methods are not shared: the sequence `__len__` and `__getitem__` are defined by the `sq_length` and `sq_item` slots, and the mapping equivalents are `mp_length` and `mp_subscript`. There are similar distinctions for `__setitem__` and `__delitem__`.
+The `__len__` and `__getitem__` methods are also used to implement a Python [mapping](https://docs.python.org/3/glossary.html#term-mapping).
+In the Python C-API, these methods are not shared: the sequence `__len__` and `__getitem__` are defined by the `sq_length` and `sq_item` slots, and the mapping equivalents are `mp_length` and `mp_subscript`.
+There are similar distinctions for `__setitem__` and `__delitem__`.
 
-Because there is no such distinction from Python, implementing these methods will fill the mapping and sequence slots simultaneously. A Python class with `__len__` implemented, for example, will have both the `sq_length` and `mp_length` slots filled.
+Because there is no such distinction from Python, implementing these methods will fill the mapping and sequence slots simultaneously.
+A Python class with `__len__` implemented, for example, will have both the `sq_length` and `mp_length` slots filled.
 
 The PyO3 behavior in 0.16 has been changed to be closer to this Python behavior by default.
+</details>
 
 ### `wrap_pymodule!` and `wrap_pyfunction!` now respect privacy correctly
 
+<details>
+<summary><small>Click to expand</small></summary>
+
 Prior to PyO3 0.16 the `wrap_pymodule!` and `wrap_pyfunction!` macros could use modules and functions whose defining `fn` was not reachable according Rust privacy rules.
 
 For example, the following code was legal before 0.16, but in 0.16 is rejected because the `wrap_pymodule!` macro cannot access the `private_submodule` function:
@@ -827,7 +1912,7 @@ fn my_module(_py: Python<'_>, m: &PyModule) -> PyResult<()> {
 
 To fix it, make the private submodule visible, e.g. with `pub` or `pub(crate)`.
 
-```rust
+```rust,ignore
 mod foo {
     use pyo3::prelude::*;
 
@@ -848,10 +1933,15 @@ fn my_module(_py: Python<'_>, m: &PyModule) -> PyResult<()> {
 }
 ```
 
+</details>
+
 ## from 0.14.* to 0.15
 
 ### Changes in sequence indexing
 
+<details>
+<summary><small>Click to expand</small></summary>
+
 For all types that take sequence indices (`PyList`, `PyTuple` and `PySequence`),
 the API has been made consistent to only take `usize` indices, for consistency
 with Rust's indexing conventions.  Negative indices, which were only
@@ -862,7 +1952,7 @@ Further, the `get_item` methods now always return a `PyResult` instead of
 panicking on invalid indices.  The `Index` trait has been implemented instead,
 and provides the same panic behavior as on Rust vectors.
 
-Note that *slice* indices (accepted by `PySequence::get_slice` and other) still
+Note that _slice_ indices (accepted by `PySequence::get_slice` and other) still
 inherit the Python behavior of clamping the indices to the actual length, and
 not panicking/returning an error on out of range indices.
 
@@ -870,7 +1960,7 @@ An additional advantage of using Rust's indexing conventions for these types is
 that these types can now also support Rust's indexing operators as part of a
 consistent API:
 
-```rust
+```rust,ignore
 #![allow(deprecated)]
 use pyo3::{Python, types::PyList};
 
@@ -880,21 +1970,37 @@ Python::with_gil(|py| {
 });
 ```
 
+</details>
+
 ## from 0.13.* to 0.14
 
 ### `auto-initialize` feature is now opt-in
 
+<details>
+<summary><small>Click to expand</small></summary>
+
 For projects embedding Python in Rust, PyO3 no longer automatically initializes a Python interpreter on the first call to `Python::with_gil` (or `Python::acquire_gil`) unless the [`auto-initialize` feature](features.md#auto-initialize) is enabled.
+</details>
 
 ### New `multiple-pymethods` feature
 
-`#[pymethods]` have been reworked with a simpler default implementation which removes the dependency on the `inventory` crate. This reduces dependencies and compile times for the majority of users.
+<details>
+<summary><small>Click to expand</small></summary>
+
+`#[pymethods]` have been reworked with a simpler default implementation which removes the dependency on the `inventory` crate.
+This reduces dependencies and compile times for the majority of users.
 
-The limitation of the new default implementation is that it cannot support multiple `#[pymethods]` blocks for the same `#[pyclass]`. If you need this functionality, you must enable the `multiple-pymethods` feature which will switch `#[pymethods]` to the inventory-based implementation.
+The limitation of the new default implementation is that it cannot support multiple `#[pymethods]` blocks for the same `#[pyclass]`.
+If you need this functionality, you must enable the `multiple-pymethods` feature which will switch `#[pymethods]` to the inventory-based implementation.
+</details>
 
 ### Deprecated `#[pyproto]` methods
 
-Some protocol (aka `__dunder__`) methods such as `__bytes__` and `__format__` have been possible to implement two ways in PyO3 for some time: via a `#[pyproto]` (e.g. `PyObjectProtocol` for the methods listed here), or by writing them directly in `#[pymethods]`. This is only true for a handful of the `#[pyproto]` methods (for technical reasons to do with the way PyO3 currently interacts with the Python C-API).
+<details>
+<summary><small>Click to expand</small></summary>
+
+Some protocol (aka `__dunder__`) methods such as `__bytes__` and `__format__` have been possible to implement two ways in PyO3 for some time: via a `#[pyproto]` (e.g. `PyObjectProtocol` for the methods listed here), or by writing them directly in `#[pymethods]`.
+This is only true for a handful of the `#[pyproto]` methods (for technical reasons to do with the way PyO3 currently interacts with the Python C-API).
 
 In the interest of having only one way to do things, the `#[pyproto]` forms of these methods have been deprecated.
 
@@ -919,7 +2025,7 @@ impl PyObjectProtocol for MyClass {
 
 After:
 
-```rust
+```rust,no_run
 use pyo3::prelude::*;
 
 #[pyclass]
@@ -933,76 +2039,113 @@ impl MyClass {
 }
 ```
 
+</details>
+
 ## from 0.12.* to 0.13
 
 ### Minimum Rust version increased to Rust 1.45
 
-PyO3 `0.13` makes use of new Rust language features stabilized between Rust 1.40 and Rust 1.45. If you are using a Rust compiler older than Rust 1.45, you will need to update your toolchain to be able to continue using PyO3.
+<details>
+<summary><small>Click to expand</small></summary>
+
+PyO3 `0.13` makes use of new Rust language features stabilized between Rust 1.40 and Rust 1.45.
+If you are using a Rust compiler older than Rust 1.45, you will need to update your toolchain to be able to continue using PyO3.
+</details>
 
 ### Runtime changes to support the CPython limited API
 
-In PyO3 `0.13` support was added for compiling against the CPython limited API. This had a number of implications for _all_ PyO3 users, described here.
+<details>
+<summary><small>Click to expand</small></summary>
 
-The largest of these is that all types created from PyO3 are what CPython calls "heap" types. The specific implications of this are:
+In PyO3 `0.13` support was added for compiling against the CPython limited API.
+This had a number of implications for _all_ PyO3 users, described here.
+
+The largest of these is that all types created from PyO3 are what CPython calls "heap" types.
+The specific implications of this are:
 
 - If you wish to subclass one of these types _from Rust_ you must mark it `#[pyclass(subclass)]`, as you would if you wished to allow subclassing it from Python code.
 - Type objects are now mutable - Python code can set attributes on them.
 - `__module__` on types without `#[pyclass(module="mymodule")]` no longer returns `builtins`, it now raises `AttributeError`.
+</details>
 
 ## from 0.11.* to 0.12
 
 ### `PyErr` has been reworked
 
-In PyO3 `0.12` the `PyErr` type has been re-implemented to be significantly more compatible with
-the standard Rust error handling ecosystem. Specifically `PyErr` now implements
-`Error + Send + Sync`, which are the standard traits used for error types.
+<details>
+<summary><small>Click to expand</small></summary>
+
+In PyO3 `0.12` the `PyErr` type has been re-implemented to be significantly more compatible with the standard Rust error handling ecosystem.
+Specifically `PyErr` now implements `Error + Send + Sync`, which are the standard traits used for error types.
 
-While this has necessitated the removal of a number of APIs, the resulting `PyErr` type should now
-be much more easier to work with. The following sections list the changes in detail and how to
-migrate to the new APIs.
+While this has necessitated the removal of a number of APIs, the resulting `PyErr` type should now be much more easier to work with.
+The following sections list the changes in detail and how to migrate to the new APIs.
+</details>
 
 #### `PyErr::new` and `PyErr::from_type` now require `Send + Sync` for their argument
 
-For most uses no change will be needed. If you are trying to construct `PyErr` from a value that is
-not `Send + Sync`, you will need to first create the Python object and then use
-`PyErr::from_instance`.
+<details>
+<summary><small>Click to expand</small></summary>
+
+For most uses no change will be needed.
+If you are trying to construct `PyErr` from a value that is not `Send + Sync`, you will need to first create the Python object and then use `PyErr::from_instance`.
 
 Similarly, any types which implemented `PyErrArguments` will now need to be `Send + Sync`.
+</details>
 
 #### `PyErr`'s contents are now private
 
+<details>
+<summary><small>Click to expand</small></summary>
+
 It is no longer possible to access the fields `.ptype`, `.pvalue` and `.ptraceback` of a `PyErr`.
 You should instead now use the new methods `PyErr::ptype`, `PyErr::pvalue` and `PyErr::ptraceback`.
+</details>
 
 #### `PyErrValue` and `PyErr::from_value` have been removed
 
+<details>
+<summary><small>Click to expand</small></summary>
+
 As these were part the internals of `PyErr` which have been reworked, these APIs no longer exist.
 
 If you used this API, it is recommended to use `PyException::new_err` (see [the section on
 Exception types](#exception-types-have-been-reworked)).
+</details>
 
 #### `Into<PyResult<T>>` for `PyErr` has been removed
 
-This implementation was redundant. Just construct the `Result::Err` variant directly.
+<details>
+<summary><small>Click to expand</small></summary>
+
+This implementation was redundant.
+Just construct the `Result::Err` variant directly.
 
 Before:
+
 ```rust,compile_fail
 let result: PyResult<()> = PyErr::new::<TypeError, _>("error message").into();
 ```
 
 After (also using the new reworked exception types; see the following section):
-```rust
+
+```rust,no_run
 # use pyo3::{PyResult, exceptions::PyTypeError};
 let result: PyResult<()> = Err(PyTypeError::new_err("error message"));
 ```
 
+</details>
+
 ### Exception types have been reworked
 
-Previously exception types were zero-sized marker types purely used to construct `PyErr`. In PyO3
-0.12, these types have been replaced with full definitions and are usable in the same way as `PyAny`, `PyDict` etc. This
-makes it possible to interact with Python exception objects.
+<details>
+<summary><small>Click to expand</small></summary>
 
-The new types also have names starting with the "Py" prefix. For example, before:
+Previously exception types were zero-sized marker types purely used to construct `PyErr`.
+In PyO3 0.12, these types have been replaced with full definitions and are usable in the same way as `PyAny`, `PyDict` etc. This makes it possible to interact with Python exception objects.
+
+The new types also have names starting with the "Py" prefix.
+For example, before:
 
 ```rust,ignore
 let err: PyErr = TypeError::py_err("error message");
@@ -1029,15 +2172,21 @@ assert_eq!(
 # }).unwrap();
 ```
 
+</details>
+
 ### `FromPy` has been removed
-To simplify the PyO3 conversion traits, the `FromPy` trait has been removed. Previously there were
-two ways to define the to-Python conversion for a type:
-`FromPy<T> for PyObject` and `IntoPy<PyObject> for T`.
+
+<details>
+<summary><small>Click to expand</small></summary>
+
+To simplify the PyO3 conversion traits, the `FromPy` trait has been removed.
+Previously there were two ways to define the to-Python conversion for a type: `FromPy<T> for PyObject` and `IntoPy<PyObject> for T`.
 
 Now there is only one way to define the conversion, `IntoPy`, so downstream crates may need to
 adjust accordingly.
 
 Before:
+
 ```rust,compile_fail
 # use pyo3::prelude::*;
 struct MyPyObjectWrapper(PyObject);
@@ -1050,10 +2199,13 @@ impl FromPy<MyPyObjectWrapper> for PyObject {
 ```
 
 After
-```rust
+
+```rust,ignore
 # use pyo3::prelude::*;
+# #[allow(dead_code)]
 struct MyPyObjectWrapper(PyObject);
 
+# #[allow(deprecated)]
 impl IntoPy<PyObject> for MyPyObjectWrapper {
     fn into_py(self, _py: Python<'_>) -> PyObject {
         self.0
@@ -1064,6 +2216,7 @@ impl IntoPy<PyObject> for MyPyObjectWrapper {
 Similarly, code which was using the `FromPy` trait can be trivially rewritten to use `IntoPy`.
 
 Before:
+
 ```rust,compile_fail
 # use pyo3::prelude::*;
 # Python::with_gil(|py| {
@@ -1072,26 +2225,39 @@ let obj = PyObject::from_py(1.234, py);
 ```
 
 After:
-```rust
+
+```rust,ignore
+# #![allow(deprecated)]
 # use pyo3::prelude::*;
 # Python::with_gil(|py| {
 let obj: PyObject = 1.234.into_py(py);
 # })
 ```
 
+</details>
+
 ### `PyObject` is now a type alias of `Py<PyAny>`
-This should change very little from a usage perspective. If you implemented traits for both
-`PyObject` and `Py<T>`, you may find you can just remove the `PyObject` implementation.
+
+<details>
+<summary><small>Click to expand</small></summary>
+
+This should change very little from a usage perspective.
+If you implemented traits for both `PyObject` and `Py<T>`, you may find you can just remove the `PyObject` implementation.
+</details>
 
 ### `AsPyRef` has been removed
-As `PyObject` has been changed to be just a type alias, the only remaining implementor of `AsPyRef`
-was `Py<T>`. This removed the need for a trait, so the `AsPyRef::as_ref` method has been moved to
-`Py::as_ref`.
+
+<details>
+<summary><small>Click to expand</small></summary>
+
+As `PyObject` has been changed to be just a type alias, the only remaining implementor of `AsPyRef` was `Py<T>`.
+This removed the need for a trait, so the `AsPyRef::as_ref` method has been moved to `Py::as_ref`.
 
 This should require no code changes except removing `use pyo3::AsPyRef` for code which did not use
 `pyo3::prelude::*`.
 
 Before:
+
 ```rust,ignore
 use pyo3::{AsPyRef, Py, types::PyList};
 # pyo3::Python::with_gil(|py| {
@@ -1101,6 +2267,7 @@ let list_ref: &PyList = list_py.as_ref(py);
 ```
 
 After:
+
 ```rust,ignore
 use pyo3::{Py, types::PyList};
 # pyo3::Python::with_gil(|py| {
@@ -1109,12 +2276,24 @@ let list_ref: &PyList = list_py.as_ref(py);
 # })
 ```
 
+</details>
+
 ## from 0.10.* to 0.11
 
 ### Stable Rust
-PyO3 now supports the stable Rust toolchain. The minimum required version is 1.39.0.
+
+<details>
+<summary><small>Click to expand</small></summary>
+
+PyO3 now supports the stable Rust toolchain.
+The minimum required version is 1.39.0.
+</details>
 
 ### `#[pyclass]` structs must now be `Send` or `unsendable`
+
+<details>
+<summary><small>Click to expand</small></summary>
+
 Because `#[pyclass]` structs can be sent between threads by the Python interpreter, they must implement
 `Send` or declared as `unsendable` (by `#[pyclass(unsendable)]`).
 Note that `unsendable` is added in PyO3 `0.11.1` and `Send` is always required in PyO3 `0.11.0`.
@@ -1123,10 +2302,11 @@ This may "break" some code which previously was accepted, even though it could b
 There can be two fixes:
 
 1. If you think that your `#[pyclass]` actually must be `Send`able, then let's implement `Send`.
-   A common, safer way is using thread-safe types. E.g., `Arc` instead of `Rc`, `Mutex` instead of
-   `RefCell`, and `Box<dyn Send + T>` instead of `Box<dyn T>`.
+   A common, safer way is using thread-safe types.
+   E.g., `Arc` instead of `Rc`, `Mutex` instead of `RefCell`, and `Box<dyn Send + T>` instead of `Box<dyn T>`.
 
    Before:
+
    ```rust,compile_fail
    use pyo3::prelude::*;
    use std::rc::Rc;
@@ -1140,7 +2320,8 @@ There can be two fixes:
    ```
 
    After:
-   ```rust
+
+   ```rust,ignore
    # #![allow(dead_code)]
    use pyo3::prelude::*;
    use std::sync::{Arc, Mutex};
@@ -1152,64 +2333,79 @@ There can be two fixes:
    }
    ```
 
-   In situations where you cannot change your `#[pyclass]` to automatically implement `Send`
-   (e.g., when it contains a raw pointer), you can use `unsafe impl Send`.
+   In situations where you cannot change your `#[pyclass]` to automatically implement `Send` (e.g., when it contains a raw pointer), you can use `unsafe impl Send`.
    In such cases, care should be taken to ensure the struct is actually thread safe.
    See [the Rustonomicon](https://doc.rust-lang.org/nomicon/send-and-sync.html) for more.
 
-2. If you think that your `#[pyclass]` should not be accessed by another thread, you can use
-   `unsendable` flag. A class marked with `unsendable` panics when accessed by another thread,
-   making it thread-safe to expose an unsendable object to the Python interpreter.
+2. If you think that your `#[pyclass]` should not be accessed by another thread, you can use `unsendable` flag.
+   A class marked with `unsendable` panics when accessed by another thread, making it thread-safe to expose an unsendable object to the Python interpreter.
 
    Before:
+
    ```rust,compile_fail
    use pyo3::prelude::*;
 
    #[pyclass]
    struct Unsendable {
-       pointers: Vec<*mut std::os::raw::c_char>,
+       pointers: Vec<*mut std::ffi::c_char>,
    }
    ```
 
    After:
-   ```rust
+
+   ```rust,no_run
    # #![allow(dead_code)]
    use pyo3::prelude::*;
 
    #[pyclass(unsendable)]
    struct Unsendable {
-       pointers: Vec<*mut std::os::raw::c_char>,
+       pointers: Vec<*mut std::ffi::c_char>,
    }
    ```
 
+</details>
+
 ### All `PyObject` and `Py<T>` methods now take `Python` as an argument
-Previously, a few methods such as `Object::get_refcnt` did not take `Python` as an argument (to
-ensure that the Python GIL was held by the current thread). Technically, this was not sound.
+
+<details>
+<summary><small>Click to expand</small></summary>
+
+Previously, a few methods such as `Object::get_refcnt` did not take `Python` as an argument (to ensure that the Python GIL was held by the current thread).
+Technically, this was not sound.
 To migrate, just pass a `py` argument to any calls to these methods.
 
 Before:
+
 ```rust,compile_fail
-# pyo3::Python::with_gil(|py| {
+# pyo3::Python::attach(|py| {
 py.None().get_refcnt();
 # })
 ```
 
 After:
+
 ```rust
-# pyo3::Python::with_gil(|py| {
+# pyo3::Python::attach(|py| {
 py.None().get_refcnt(py);
 # })
 ```
 
+</details>
+
 ## from 0.9.* to 0.10
 
 ### `ObjectProtocol` is removed
+
+<details>
+<summary><small>Click to expand</small></summary>
+
 All methods are moved to [`PyAny`].
 And since now all native types (e.g., `PyList`) implements `Deref<Target=PyAny>`,
 all you need to do is remove `ObjectProtocol` from your code.
 Or if you use `ObjectProtocol` by `use pyo3::prelude::*`, you have to do nothing.
 
 Before:
+
 ```rust,compile_fail,ignore
 use pyo3::ObjectProtocol;
 
@@ -1221,6 +2417,7 @@ assert_eq!(hi.len().unwrap(), 5);
 ```
 
 After:
+
 ```rust,ignore
 # pyo3::Python::with_gil(|py| {
 let obj = py.eval("lambda: 'Hi :)'", None, None).unwrap();
@@ -1229,17 +2426,29 @@ assert_eq!(hi.len().unwrap(), 5);
 # })
 ```
 
+</details>
+
 ### No `#![feature(specialization)]` in user code
+
+<details>
+<summary><small>Click to expand</small></summary>
+
 While PyO3 itself still requires specialization and nightly Rust,
 now you don't have to use `#![feature(specialization)]` in your crate.
+</details>
 
 ## from 0.8.* to 0.9
 
 ### `#[new]` interface
+
+<details>
+<summary><small>Click to expand</small></summary>
+
 [`PyRawObject`](https://docs.rs/pyo3/0.8.5/pyo3/type_object/struct.PyRawObject.html)
 is now removed and our syntax for constructors has changed.
 
 Before:
+
 ```rust,compile_fail
 #[pyclass]
 struct MyClass {}
@@ -1254,7 +2463,8 @@ impl MyClass {
 ```
 
 After:
-```rust
+
+```rust,no_run
 # use pyo3::prelude::*;
 #[pyclass]
 struct MyClass {}
@@ -1269,10 +2479,15 @@ impl MyClass {
 ```
 
 Basically you can return `Self` or `Result<Self>` directly.
-For more, see [the constructor section](class.html#constructor) of this guide.
+For more, see [the constructor section](class.md#constructor) of this guide.
+</details>
 
 ### PyCell
-PyO3 0.9 introduces [`PyCell`], which is a [`RefCell`]-like object wrapper
+
+<details>
+<summary><small>Click to expand</small></summary>
+
+PyO3 0.9 introduces `PyCell`, which is a [`RefCell`]-like object wrapper
 for ensuring Rust's rules regarding aliasing of references are upheld.
 For more detail, see the
 [Rust Book's section on Rust's rules of references](https://doc.rust-lang.org/book/ch04-02-references-and-borrowing.html#the-rules-of-references)
@@ -1282,6 +2497,7 @@ Python exceptions will automatically be raised when your functions are used in a
 rules of references.
 
 Here is an example.
+
 ```rust
 # use pyo3::prelude::*;
 
@@ -1300,8 +2516,8 @@ impl Names {
         self.names.append(&mut other.names)
     }
 }
-# Python::with_gil(|py| {
-#     let names = PyCell::new(py, Names::new()).unwrap();
+# Python::attach(|py| {
+#     let names = Py::new(py, Names::new()).unwrap();
 #     pyo3::py_run!(py, names, r"
 #     try:
 #        names.merge(names)
@@ -1311,6 +2527,7 @@ impl Names {
 #     ");
 # })
 ```
+
 `Names` has a `merge` method, which takes `&mut self` and another argument of type `&mut Self`.
 Given this `#[pyclass]`, calling `names.merge(names)` in Python raises
 a [`PyBorrowMutError`] exception, since it requires two mutable borrows of `names`.
@@ -1318,14 +2535,16 @@ a [`PyBorrowMutError`] exception, since it requires two mutable borrows of `name
 However, for `#[pyproto]` and some functions, you need to manually fix the code.
 
 #### Object creation
+
 In 0.8 object creation was done with `PyRef::new` and `PyRefMut::new`.
 In 0.9 these have both been removed.
 To upgrade code, please use
-[`PyCell::new`]({{#PYO3_DOCS_URL}}/pyo3/pycell/struct.PyCell.html#method.new) instead.
+`PyCell::new` instead.
 If you need [`PyRef`] or [`PyRefMut`], just call `.borrow()` or `.borrow_mut()`
 on the newly-created `PyCell`.
 
 Before:
+
 ```rust,compile_fail
 # use pyo3::prelude::*;
 # #[pyclass]
@@ -1336,7 +2555,8 @@ let obj_ref = PyRef::new(py, MyClass {}).unwrap();
 ```
 
 After:
-```rust
+
+```rust,ignore
 # use pyo3::prelude::*;
 # #[pyclass]
 # struct MyClass {}
@@ -1347,12 +2567,14 @@ let obj_ref = obj.borrow();
 ```
 
 #### Object extraction
+
 For `PyClass` types `T`, `&T` and `&mut T` no longer have [`FromPyObject`] implementations.
 Instead you should extract `PyRef<T>` or `PyRefMut<T>`, respectively.
 If `T` implements `Clone`, you can extract `T` itself.
 In addition, you can also extract `&PyCell<T>`, though you rarely need it.
 
 Before:
+
 ```compile_fail
 let obj: &PyAny = create_obj();
 let obj_ref: &MyClass = obj.extract().unwrap();
@@ -1360,6 +2582,7 @@ let obj_ref_mut: &mut MyClass = obj.extract().unwrap();
 ```
 
 After:
+
 ```rust,ignore
 # use pyo3::prelude::*;
 # use pyo3::types::IntoPyDict;
@@ -1380,14 +2603,15 @@ let obj_ref_mut: PyRefMut<'_, MyClass> = obj.extract().unwrap();
 # })
 ```
 
-
 #### `#[pyproto]`
+
 Most of the arguments to methods in `#[pyproto]` impls require a
 [`FromPyObject`] implementation.
 So if your protocol methods take `&T` or `&mut T` (where `T: PyClass`),
 please use [`PyRef`] or [`PyRefMut`] instead.
 
 Before:
+
 ```rust,compile_fail
 # use pyo3::prelude::*;
 # use pyo3::class::PySequenceProtocol;
@@ -1406,6 +2630,7 @@ impl PySequenceProtocol for ByteSequence {
 ```
 
 After:
+
 ```rust,compile_fail
 # use pyo3::prelude::*;
 # use pyo3::class::PySequenceProtocol;
@@ -1423,9 +2648,45 @@ impl PySequenceProtocol for ByteSequence {
 }
 ```
 
+</details>
+
+<style>
+    /* render details immediately below h3 headers */
+
+```text
+h3:has(+ details) {
+margin-bottom: 0;
+}
+```
+
+```text
+/* make summary text hint that it's clickable and increase the
+size of the clickable area by padding downwards */
+details > summary {
+cursor: pointer;
+padding-bottom: 0.5em;
+}
+```
+
+```text
+/* reduce margin from paragraph directly below the clickable space
+to avoid large gap */
+details > summary + p {
+margin-block-start: 0.5em;
+}
+```
+
+```text
+/* pack headings that aren't expanded slightly closer together */
+h3 + details:not([open]) + h3 {
+margin-top: 1.5em;
+}
+```
+
+</style>
+
 [`FromPyObject`]: {{#PYO3_DOCS_URL}}/pyo3/conversion/trait.FromPyObject.html
 [`PyAny`]: {{#PYO3_DOCS_URL}}/pyo3/types/struct.PyAny.html
-[`PyCell`]: {{#PYO3_DOCS_URL}}/pyo3/pycell/struct.PyCell.html
 [`PyBorrowMutError`]: {{#PYO3_DOCS_URL}}/pyo3/pycell/struct.PyBorrowMutError.html
 [`PyRef`]: {{#PYO3_DOCS_URL}}/pyo3/pycell/struct.PyRef.html
 [`PyRefMut`]: {{#PYO3_DOCS_URL}}/pyo3/pycell/struct.PyRef.html
diff --git a/guide/src/module.md b/guide/src/module.md
index 3d984f60d39..79d7fbdad32 100644
--- a/guide/src/module.md
+++ b/guide/src/module.md
@@ -2,7 +2,8 @@
 
 You can create a module using `#[pymodule]`:
 
-```rust
+```rust,no_run
+# mod declarative_module_basic_test {
 use pyo3::prelude::*;
 
 #[pyfunction]
@@ -12,19 +13,28 @@ fn double(x: usize) -> usize {
 
 /// This module is implemented in Rust.
 #[pymodule]
-fn my_extension(py: Python<'_>, m: &PyModule) -> PyResult<()> {
-    m.add_function(wrap_pyfunction!(double, m)?)?;
-    Ok(())
+mod my_extension {
+    use pyo3::prelude::*;
+
+    #[pymodule_export]
+    use super::double; // The double function is made available from Python, works also with classes
+
+    #[pyfunction] // Inline definition of a pyfunction, also made availlable to Python
+    fn triple(x: usize) -> usize {
+        x * 3
+    }
 }
+# }
 ```
 
-The `#[pymodule]` procedural macro takes care of exporting the initialization function of your
-module to Python.
+The `#[pymodule]` procedural macro takes care of creating the initialization function of your
+module and exposing it to Python.
 
-The module's name defaults to the name of the Rust function. You can override the module name by
-using `#[pyo3(name = "custom_name")]`:
+The module's name defaults to the name of the Rust module.
+You can override the module name by using `#[pyo3(name = "custom_name")]`:
 
-```rust
+```rust,no_run
+# mod declarative_module_custom_name_test {
 use pyo3::prelude::*;
 
 #[pyfunction]
@@ -32,27 +42,26 @@ fn double(x: usize) -> usize {
     x * 2
 }
 
-#[pymodule]
-#[pyo3(name = "custom_name")]
-fn my_extension(py: Python<'_>, m: &PyModule) -> PyResult<()> {
-    m.add_function(wrap_pyfunction!(double, m)?)?;
-    Ok(())
+#[pymodule(name = "custom_name")]
+mod my_extension {
+    #[pymodule_export]
+    use super::double;
 }
+# }
 ```
 
-The name of the module must match the name of the `.so` or `.pyd`
-file. Otherwise, you will get an import error in Python with the following message:
-`ImportError: dynamic module does not define module export function (PyInit_name_of_your_module)`
+The name of the module must match the name of the `.so` or `.pyd` file.
+Otherwise, you will get an import error in Python with the following message: `ImportError: dynamic module does not define module export function (PyInit_name_of_your_module)`
 
 To import the module, either:
- - copy the shared library as described in [Manual builds](building_and_distribution.html#manual-builds), or
- - use a tool, e.g. `maturin develop` with [maturin](https://github.com/PyO3/maturin) or
+
+- copy the shared library as described in [Manual builds](building-and-distribution.md#manual-builds), or
+- use a tool, e.g. `maturin develop` with [maturin](https://github.com/PyO3/maturin) or
 `python setup.py develop` with [setuptools-rust](https://github.com/PyO3/setuptools-rust).
 
 ## Documentation
 
-The [Rust doc comments](https://doc.rust-lang.org/stable/book/ch03-04-comments.html) of the module
-initialization function will be applied automatically as the Python docstring of your module.
+The [Rust doc comments](https://doc.rust-lang.org/stable/book/ch03-04-comments.html) of the Rust module will be applied automatically as the Python docstring of your module.
 
 For example, building off of the above code, this will print `This module is implemented in Rust.`:
 
@@ -64,44 +73,105 @@ print(my_extension.__doc__)
 
 ## Python submodules
 
-You can create a module hierarchy within a single extension module by using
-[`PyModule.add_submodule()`]({{#PYO3_DOCS_URL}}/pyo3/prelude/struct.PyModule.html#method.add_submodule).
-For example, you could define the modules `parent_module` and `parent_module.child_module`.
+You can create a module hierarchy within a single extension module by just `use`ing modules like functions or classes.
+For example, you could define the modules `parent_module` and `parent_module.child_module`:
 
 ```rust
 use pyo3::prelude::*;
 
 #[pymodule]
-fn parent_module(py: Python<'_>, m: &PyModule) -> PyResult<()> {
-    register_child_module(py, m)?;
-    Ok(())
+mod parent_module {
+    #[pymodule_export]
+    use super::child_module;
 }
 
-fn register_child_module(py: Python<'_>, parent_module: &PyModule) -> PyResult<()> {
-    let child_module = PyModule::new(py, "child_module")?;
-    child_module.add_function(wrap_pyfunction!(func, child_module)?)?;
-    parent_module.add_submodule(child_module)?;
-    Ok(())
+#[pymodule]
+mod child_module {
+    #[pymodule_export]
+    use super::func;
 }
 
 #[pyfunction]
 fn func() -> String {
     "func".to_string()
 }
-
-# Python::with_gil(|py| {
-#    use pyo3::wrap_pymodule;
-#    use pyo3::types::IntoPyDict;
-#    let parent_module = wrap_pymodule!(parent_module)(py);
-#    let ctx = [("parent_module", parent_module)].into_py_dict_bound(py);
 #
-#    py.run_bound("assert parent_module.child_module.func() == 'func'", None, Some(&ctx)).unwrap();
-# })
+# fn main() {
+#   Python::attach(|py| {
+#       use pyo3::wrap_pymodule;
+#       use pyo3::types::IntoPyDict;
+#       let parent_module = wrap_pymodule!(parent_module)(py);
+#       let ctx = [("parent_module", parent_module)].into_py_dict(py).unwrap();
+#
+#      py.run(c"assert parent_module.child_module.func() == 'func'", None, Some(&ctx)).unwrap();
+#   })
+}
 ```
 
-Note that this does not define a package, so this won’t allow Python code to directly import
-submodules by using `from parent_module import child_module`. For more information, see
-[#759](https://github.com/PyO3/pyo3/issues/759) and
-[#1517](https://github.com/PyO3/pyo3/issues/1517#issuecomment-808664021).
+Note that this does not define a package, so this won’t allow Python code to directly import submodules by using `from parent_module import child_module`.
+For more information, see [#759](https://github.com/PyO3/pyo3/issues/759) and [#1517](https://github.com/PyO3/pyo3/issues/1517#issuecomment-808664021).
+
+You can provide the `submodule` argument to `#[pymodule()]` for modules that are not top-level modules in order for them to properly generate the `#[pyclass]` `module` attribute automatically.
+
+## Inline declaration
+
+It is possible to declare functions, classes, sub-modules and constants inline in a module:
+
+For example:
+
+```rust,no_run
+# mod declarative_module_test {
+#[pyo3::pymodule]
+mod my_extension {
+    use pyo3::prelude::*;
 
-It is not necessary to add `#[pymodule]` on nested modules, which is only required on the top-level module.
+    #[pymodule_export]
+    const PI: f64 = std::f64::consts::PI; // Exports PI constant as part of the module
+
+    #[pyfunction] // This will be part of the module
+    fn double(x: usize) -> usize {
+        x * 2
+    }
+
+    #[pyclass] // This will be part of the module
+    struct Unit;
+
+    #[pymodule]
+    mod submodule {
+        // This is a submodule
+        use pyo3::prelude::*;
+
+        #[pyclass]
+        struct Nested;
+    }
+}
+# }
+```
+
+In this case, `#[pymodule]` macro automatically sets the `module` attribute of the `#[pyclass]` macros declared inside of it with its name.
+For nested modules, the name of the parent module is automatically added.
+In the previous example, the `Nested` class will have for `module` `my_extension.submodule`.
+
+## Procedural initialization
+
+If the macros provided by PyO3 are not enough, it is possible to run code at the module initialization:
+
+```rust,no_run
+# mod procedural_module_test {
+#[pyo3::pymodule]
+mod my_extension {
+    use pyo3::prelude::*;
+
+    #[pyfunction]
+    fn double(x: usize) -> usize {
+        x * 2
+    }
+
+    #[pymodule_init]
+    fn init(m: &Bound<'_, PyModule>) -> PyResult<()> {
+        // Arbitrary code to run at the module initialization
+        m.add("double2", m.getattr("double")?)
+    }
+}
+# }
+```
diff --git a/guide/src/parallelism.md b/guide/src/parallelism.md
index 195106b2420..6f36e1cf956 100644
--- a/guide/src/parallelism.md
+++ b/guide/src/parallelism.md
@@ -1,8 +1,17 @@
 # Parallelism
 
-CPython has the infamous [Global Interpreter Lock](https://docs.python.org/3/glossary.html#term-global-interpreter-lock), which prevents several threads from executing Python bytecode in parallel. This makes threading in Python a bad fit for [CPU-bound](https://stackoverflow.com/questions/868568/) tasks and often forces developers to accept the overhead of multiprocessing.
+Historically, CPython was limited by the [global interpreter lock](https://docs.python.org/3/glossary.html#term-global-interpreter-lock) (GIL), which only allowed a single thread to drive the Python interpreter at a time.
+This made threading in Python a bad fit for [CPU-bound](https://en.wikipedia.org/wiki/CPU-bound) tasks and often forced developers to accept the overhead of multiprocessing.
+
+Rust is well-suited to multithreaded code, and libraries like [`rayon`] can help you leverage safe parallelism with minimal effort.
+The [`Python::detach`] method can be used to allow the Python interpreter to do other work while the Rust work is ongoing.
+
+To enable full parallelism in your application, consider also using [free-threaded Python](./free-threading.md) which is supported since Python 3.14.
+
+## Parallelism under the Python GIL
+
+Let's take a look at our [word-count](https://github.com/PyO3/pyo3/blob/main/examples/word-count/src/lib.rs) example, where we have a `search` function that utilizes the [`rayon`] crate to count words in parallel.
 
-In PyO3 parallelism can be easily achieved in Rust-only code. Let's take a look at our [word-count](https://github.com/PyO3/pyo3/blob/main/examples/word-count/src/lib.rs) example, where we have a `search` function that utilizes the [rayon](https://github.com/rayon-rs/rayon) crate to count words in parallel.
 ```rust,no_run
 # #![allow(dead_code)]
 use pyo3::prelude::*;
@@ -31,7 +40,9 @@ fn search(contents: &str, needle: &str) -> usize {
 }
 ```
 
-But let's assume you have a long running Rust function which you would like to execute several times in parallel. For the sake of example let's take a sequential version of the word count:
+But let's assume you have a long running Rust function which you would like to execute several times in parallel.
+For the sake of example let's take a sequential version of the word count:
+
 ```rust,no_run
 # #![allow(dead_code)]
 # fn count_line(line: &str, needle: &str) -> usize {
@@ -49,7 +60,9 @@ fn search_sequential(contents: &str, needle: &str) -> usize {
 }
 ```
 
-To enable parallel execution of this function, the [`Python::allow_threads`] method can be used to temporarily release the GIL, thus allowing other Python threads to run. We then have a function exposed to the Python runtime which calls `search_sequential` inside a closure passed to [`Python::allow_threads`] to enable true parallelism:
+To enable parallel execution of this function, the [`Python::detach`] method can be used to temporarily release the GIL, thus allowing other Python threads to run.
+We then have a function exposed to the Python runtime which calls `search_sequential` inside a closure passed to [`Python::detach`] to enable true parallelism:
+
 ```rust,no_run
 # #![allow(dead_code)]
 # use pyo3::prelude::*;
@@ -68,23 +81,24 @@ To enable parallel execution of this function, the [`Python::allow_threads`] met
 #    contents.lines().map(|line| count_line(line, needle)).sum()
 # }
 #[pyfunction]
-fn search_sequential_allow_threads(py: Python<'_>, contents: &str, needle: &str) -> usize {
-    py.allow_threads(|| search_sequential(contents, needle))
+fn search_sequential_detached(py: Python<'_>, contents: &str, needle: &str) -> usize {
+    py.detach(|| search_sequential(contents, needle))
 }
 ```
 
 Now Python threads can use more than one CPU core, resolving the limitation which usually makes multi-threading in Python only good for IO-bound tasks:
+
 ```Python
 from concurrent.futures import ThreadPoolExecutor
-from word_count import search_sequential_allow_threads
+from word_count import search_sequential_detached
 
 executor = ThreadPoolExecutor(max_workers=2)
 
 future_1 = executor.submit(
-    word_count.search_sequential_allow_threads, contents, needle
+    word_count.search_sequential_detached, contents, needle
 )
 future_2 = executor.submit(
-    word_count.search_sequential_allow_threads, contents, needle
+    word_count.search_sequential_detached, contents, needle
 )
 result_1 = future_1.result()
 result_2 = future_2.result()
@@ -104,6 +118,7 @@ We are using `pytest-benchmark` to benchmark four word count functions:
 The benchmark script can be found [here](https://github.com/PyO3/pyo3/blob/main/examples/word-count/tests/test_word_count.py), and we can run `nox` in the `word-count` folder to benchmark these functions.
 
 While the results of the benchmark of course depend on your machine, the relative results should be similar to this (mid 2020):
+
 ```text
 -------------------------------------------------------------------------------------------------- benchmark: 4 tests -------------------------------------------------------------------------------------------------
 Name (time in ms)                                          Min                Max               Mean            StdDev             Median               IQR            Outliers       OPS            Rounds  Iterations
@@ -117,4 +132,54 @@ test_word_count_python_sequential                      27.3985 (15.82)    45.452
 
 You can see that the Python threaded version is not much slower than the Rust sequential version, which means compared to an execution on a single CPU core the speed has doubled.
 
-[`Python::allow_threads`]: {{#PYO3_DOCS_URL}}/pyo3/struct.Python.html#method.allow_threads
+## Sharing Python objects between Rust threads
+
+In the example above we made a Python interface to a low-level rust function, and then leveraged the python `threading` module to run the low-level function in parallel.
+It is also possible to spawn threads in Rust that acquire the GIL and operate on Python objects.
+However, care must be taken to avoid writing code that deadlocks with the GIL in these cases.
+
+- Note: This example is meant to illustrate how to drop and re-acquire the GIL
+        to avoid creating deadlocks. Unless the spawned threads subsequently
+        release the GIL or you are using the free-threaded build of CPython, you
+        will not see any speedups due to multi-threaded parallelism using `rayon`
+        to parallelize code that acquires and holds the GIL for the entire
+        execution of the spawned thread.
+
+In the example below, we share a `Vec` of User ID objects defined using the
+`pyclass` macro and spawn threads to process the collection of data into a `Vec`
+of booleans based on a predicate using a `rayon` parallel iterator:
+
+```rust,no_run
+use pyo3::prelude::*;
+
+// These traits let us use int_par_iter and map
+use rayon::iter::{IntoParallelRefIterator, ParallelIterator};
+
+#[pyclass]
+struct UserID {
+    id: i64,
+}
+
+let allowed_ids: Vec<bool> = Python::attach(|outer_py| {
+    let instances: Vec<Py<UserID>> = (0..10).map(|x| Py::new(outer_py, UserID { id: x }).unwrap()).collect();
+    outer_py.detach(|| {
+        instances.par_iter().map(|instance| {
+            Python::attach(|inner_py| {
+                instance.borrow(inner_py).id > 5
+            })
+        }).collect()
+    })
+});
+assert!(allowed_ids.into_iter().filter(|b| *b).count() == 4);
+```
+
+It's important to note that there is an `outer_py` Python token as well as an `inner_py` token.
+Sharing Python tokens between threads is not allowed and threads must individually attach to the interpreter to access data wrapped by a Python object.
+
+It's also important to see that this example uses [`Python::detach`] to wrap the code that spawns OS threads via `rayon`.
+If this example didn't use `detach`, a `rayon` worker thread would block on acquiring the GIL while a thread that owns the GIL spins forever waiting for the result of the `rayon` thread.
+Calling `detach` allows the GIL to be released in the thread collecting the results from the worker threads.
+You should always call `detach` in situations that spawn worker threads, but especially so in cases where worker threads need to acquire the GIL, to prevent deadlocks.
+
+[`Python::detach`]: {{#PYO3_DOCS_URL}}/pyo3/marker/struct.Python.html#method.detach
+[`rayon`]: https://github.com/rayon-rs/rayon
diff --git a/guide/src/performance.md b/guide/src/performance.md
index 23fb59c4e90..86912829797 100644
--- a/guide/src/performance.md
+++ b/guide/src/performance.md
@@ -2,28 +2,29 @@
 
 To achieve the best possible performance, it is useful to be aware of several tricks and sharp edges concerning PyO3's API.
 
-## `extract` versus `downcast`
+## `extract` versus `cast`
 
-Pythonic API implemented using PyO3 are often polymorphic, i.e. they will accept `&PyAny` and try to turn this into multiple more concrete types to which the requested operation is applied. This often leads to chains of calls to `extract`, e.g.
+Pythonic API implemented using PyO3 are often polymorphic, i.e. they will accept `&Bound<'_, PyAny>` and try to turn this into multiple more concrete types to which the requested operation is applied.
+This often leads to chains of calls to `extract`, e.g.
 
-```rust
+```rust,no_run
 # #![allow(dead_code)]
 # use pyo3::prelude::*;
 # use pyo3::{exceptions::PyTypeError, types::PyList};
 
-fn frobnicate_list(list: &PyList) -> PyResult<&PyAny> {
+fn frobnicate_list<'py>(list: &Bound<'_, PyList>) -> PyResult<Bound<'py, PyAny>> {
     todo!()
 }
 
-fn frobnicate_vec(vec: Vec<&PyAny>) -> PyResult<&PyAny> {
+fn frobnicate_vec<'py>(vec: Vec<Bound<'py, PyAny>>) -> PyResult<Bound<'py, PyAny>> {
     todo!()
 }
 
 #[pyfunction]
-fn frobnicate(value: &PyAny) -> PyResult<&PyAny> {
-    if let Ok(list) = value.extract::<&PyList>() {
-        frobnicate_list(list)
-    } else if let Ok(vec) = value.extract::<Vec<&PyAny>>() {
+fn frobnicate<'py>(value: &Bound<'py, PyAny>) -> PyResult<Bound<'py, PyAny>> {
+    if let Ok(list) = value.extract::<Bound<'_, PyList>>() {
+        frobnicate_list(&list)
+    } else if let Ok(vec) = value.extract::<Vec<Bound<'_, PyAny>>>() {
         frobnicate_vec(vec)
     } else {
         Err(PyTypeError::new_err("Cannot frobnicate that type."))
@@ -31,21 +32,23 @@ fn frobnicate(value: &PyAny) -> PyResult<&PyAny> {
 }
 ```
 
-This suboptimal as the `FromPyObject<T>` trait requires `extract` to have a `Result<T, PyErr>` return type. For native types like `PyList`, it faster to use `downcast` (which `extract` calls internally) when the error value is ignored. This avoids the costly conversion of a `PyDowncastError` to a `PyErr` required to fulfil the `FromPyObject` contract, i.e.
+This suboptimal as the `FromPyObject<T>` trait requires `extract` to have a `Result<T, PyErr>` return type.
+For native types like `PyList`, it faster to use `cast` (which `extract` calls internally) when the error value is ignored.
+This avoids the costly conversion of a `PyDowncastError` to a `PyErr` required to fulfil the `FromPyObject` contract, i.e.
 
-```rust
+```rust,no_run
 # #![allow(dead_code)]
 # use pyo3::prelude::*;
 # use pyo3::{exceptions::PyTypeError, types::PyList};
-# fn frobnicate_list(list: &PyList) -> PyResult<&PyAny> { todo!() }
-# fn frobnicate_vec(vec: Vec<&PyAny>) -> PyResult<&PyAny> { todo!() }
+# fn frobnicate_list<'py>(list: &Bound<'_, PyList>) -> PyResult<Bound<'py, PyAny>> { todo!() }
+# fn frobnicate_vec<'py>(vec: Vec<Bound<'py, PyAny>>) -> PyResult<Bound<'py, PyAny>> { todo!() }
 #
 #[pyfunction]
-fn frobnicate(value: &PyAny) -> PyResult<&PyAny> {
-    // Use `downcast` instead of `extract` as turning `PyDowncastError` into `PyErr` is quite costly.
-    if let Ok(list) = value.downcast::<PyList>() {
+fn frobnicate<'py>(value: &Bound<'py, PyAny>) -> PyResult<Bound<'py, PyAny>> {
+    // Use `cast` instead of `extract` as turning `PyDowncastError` into `PyErr` is quite costly.
+    if let Ok(list) = value.cast::<PyList>() {
         frobnicate_list(list)
-    } else if let Ok(vec) = value.extract::<Vec<&PyAny>>() {
+    } else if let Ok(vec) = value.extract::<Vec<Bound<'_, PyAny>>>() {
         frobnicate_vec(vec)
     } else {
         Err(PyTypeError::new_err("Cannot frobnicate that type."))
@@ -53,42 +56,125 @@ fn frobnicate(value: &PyAny) -> PyResult<&PyAny> {
 }
 ```
 
-## Access to GIL-bound reference implies access to GIL token
+## Access to Bound implies access to Python token
 
-Calling `Python::with_gil` is effectively a no-op when the GIL is already held, but checking that this is the case still has a cost. If an existing GIL token can not be accessed, for example when implementing a pre-existing trait, but a GIL-bound reference is available, this cost can be avoided by exploiting that access to GIL-bound reference gives zero-cost access to a GIL token via `PyAny::py`.
+Calling `Python::attach` is effectively a no-op when we're already attached to the interpreter, but checking that this is the case still has a cost.
+If an existing Python token can not be accessed, for example when implementing a pre-existing trait, but a Python-bound reference is available, this cost can be avoided by exploiting that access to Python-bound reference gives zero-cost access to a Python token via `Bound::py`.
 
 For example, instead of writing
 
-```rust
+```rust,no_run
 # #![allow(dead_code)]
 # use pyo3::prelude::*;
 # use pyo3::types::PyList;
 
 struct Foo(Py<PyList>);
 
-struct FooRef<'a>(&'a PyList);
+struct FooBound<'py>(Bound<'py, PyList>);
 
-impl PartialEq<Foo> for FooRef<'_> {
+impl PartialEq<Foo> for FooBound<'_> {
     fn eq(&self, other: &Foo) -> bool {
-        Python::with_gil(|py| self.0.len() == other.0.as_ref(py).len())
+        Python::attach(|py| {
+            let len = other.0.bind(py).len();
+            self.0.len() == len
+        })
     }
 }
 ```
 
-use more efficient
+use the more efficient
 
-```rust
+```rust,no_run
 # #![allow(dead_code)]
 # use pyo3::prelude::*;
 # use pyo3::types::PyList;
 # struct Foo(Py<PyList>);
-# struct FooRef<'a>(&'a PyList);
+# struct FooBound<'py>(Bound<'py, PyList>);
 #
-impl PartialEq<Foo> for FooRef<'_> {
+impl PartialEq<Foo> for FooBound<'_> {
     fn eq(&self, other: &Foo) -> bool {
-        // Access to `&'a PyAny` implies access to `Python<'a>`.
+        // Access to `&Bound<'py, PyAny>` implies access to `Python<'py>`.
         let py = self.0.py();
-        self.0.len() == other.0.as_ref(py).len()
+        let len = other.0.bind(py).len();
+        self.0.len() == len
     }
 }
 ```
+
+## Calling Python callables (`__call__`)
+
+CPython support multiple calling protocols: [`tp_call`] and [`vectorcall`]. [`vectorcall`] is a more efficient protocol unlocking faster calls.
+PyO3 will try to dispatch Python `call`s using the [`vectorcall`] calling convention to archive maximum performance if possible and falling back to [`tp_call`] otherwise.
+This is implemented using the (internal) `PyCallArgs` trait.
+It defines how Rust types can be used as Python `call` arguments.
+This trait is currently implemented for
+
+- Rust tuples, where each member implements `IntoPyObject`,
+- `Bound<'_, PyTuple>`
+- `Py<PyTuple>`
+
+Rust tuples may make use of [`vectorcall`] where as `Bound<'_, PyTuple>` and `Py<PyTuple>` can only use [`tp_call`].
+For maximum performance prefer using Rust tuples as arguments.
+
+[`tp_call`]: https://docs.python.org/3/c-api/call.html#the-tp-call-protocol
+[`vectorcall`]: https://docs.python.org/3/c-api/call.html#the-vectorcall-protocol
+
+## Detach from the interpreter for long-running Rust-only work
+
+When executing Rust code which does not need to interact with the Python interpreter, use [`Python::detach`] to allow the Python interpreter to proceed without waiting for the current thread.
+
+On the GIL-enabled build, this is crucial for best performance as only a single thread may ever be attached at a time.
+
+On the free-threaded build, this is still best practice as there are several "stop the world" events (such as garbage collection) where all threads attached to the Python interpreter are forced to wait.
+
+As a rule of thumb, attaching and detaching from the Python interpreter takes less than a millisecond, so any work which is expected to take multiple milliseconds can likely benefit from detaching from the interpreter.
+
+[`Python::detach`]: {{#PYO3_DOCS_URL}}/pyo3/marker/struct.Python.html#method.detach
+
+## Disable the global reference pool
+
+PyO3 uses global mutable state to keep track of deferred reference count updates implied by `impl<T> Drop for Py<T>` being called without being attached to the interpreter.
+The necessary synchronization to obtain and apply these reference count updates when PyO3-based code next attaches to the interpreter is somewhat expensive and can become a significant part of the cost of crossing the Python-Rust boundary.
+
+This functionality can be avoided by setting the `pyo3_disable_reference_pool` conditional compilation flag.
+This removes the global reference pool and the associated costs completely.
+However, it does _not_ remove the `Drop` implementation for `Py<T>` which is necessary to interoperate with existing Rust code written without PyO3-based code in mind.
+To stay compatible with the wider Rust ecosystem in these cases, we keep the implementation but abort when `Drop` is called without being attached to the interpreter.
+If `pyo3_leak_on_drop_without_reference_pool` is additionally enabled, objects dropped without being attached to Python will be leaked instead which is always sound but might have determinal effects like resource exhaustion in the long term.
+
+This limitation is important to keep in mind when this setting is used, especially when embedding Python code into a Rust application as it is quite easy to accidentally drop a `Py<T>` (or types containing it like `PyErr`, `PyBackedStr` or `PyBackedBytes`) returned from `Python::attach` without making sure to re-attach beforehand.
+For example, the following code
+
+```rust,ignore
+# use pyo3::prelude::*;
+# use pyo3::types::PyList;
+let numbers: Py<PyList> = Python::attach(|py| PyList::empty(py).unbind());
+
+Python::attach(|py| {
+    numbers.bind(py).append(23).unwrap();
+});
+
+Python::attach(|py| {
+    numbers.bind(py).append(42).unwrap();
+});
+```
+
+will abort if the list not explicitly disposed via
+
+```rust
+# use pyo3::prelude::*;
+# use pyo3::types::PyList;
+let numbers: Py<PyList> = Python::attach(|py| PyList::empty(py).unbind());
+
+Python::attach(|py| {
+    numbers.bind(py).append(23).unwrap();
+});
+
+Python::attach(|py| {
+    numbers.bind(py).append(42).unwrap();
+});
+
+Python::attach(move |py| {
+    drop(numbers);
+});
+```
diff --git a/guide/src/python-from-rust.md b/guide/src/python-from-rust.md
new file mode 100644
index 00000000000..87a80b95a72
--- /dev/null
+++ b/guide/src/python-from-rust.md
@@ -0,0 +1,65 @@
+# Calling Python in Rust code
+
+This chapter of the guide documents some ways to interact with Python code from Rust.
+
+Below is an introduction to the `'py` lifetime and some general remarks about how PyO3's API reasons about Python code.
+
+The subchapters also cover the following topics:
+
+- Python object types available in PyO3's API
+- How to work with Python exceptions
+- How to call Python functions
+- How to execute existing Python code
+
+## The `'py` lifetime
+
+To safely interact with the Python interpreter a Rust thread must be [attached] to the Python interpreter.
+PyO3 has a `Python<'py>` token that is used to prove that these conditions are met.
+Its lifetime `'py` is a central part of PyO3's API.
+
+The `Python<'py>` token serves three purposes:
+
+- It provides global APIs for the Python interpreter, such as [`py.eval()`][eval] and [`py.import()`][import].
+- It can be passed to functions that require a proof of attachment, such as [`Py::clone_ref`][clone_ref].
+- Its lifetime `'py` is used to bind many of PyO3's types to the Python interpreter, such as [`Bound<'py, T>`][Bound].
+
+PyO3's types that are bound to the `'py` lifetime, for example `Bound<'py, T>`, all contain a `Python<'py>` token.
+This means they have full access to the Python interpreter and offer a complete API for interacting with Python objects.
+
+Consult [PyO3's API documentation][obtaining-py] to learn how to acquire one of these tokens.
+
+### The Global Interpreter Lock
+
+Prior to the introduction of free-threaded Python (first available in 3.13, fully supported in 3.14), the Python interpreter was made thread-safe by the [global interpreter lock].
+This ensured that only one Python thread can use the Python interpreter and its API at the same time.
+Historically, Rust code was able to use the GIL as a synchronization guarantee, but the introduction of free-threaded Python removed this possibility.
+
+The [`pyo3::sync`] module offers synchronization tools which abstract over both Python builds.
+
+To enable any parallelism on the GIL-enabled build, and best throughput on the free-threaded build, non-Python operations (system calls and native Rust code) should consider detaching from the Python interpreter to allow other work to proceed.
+See [the section on parallelism](parallelism.md) for how to do that using PyO3's API.
+
+## Python's memory model
+
+Python's memory model differs from Rust's memory model in two key ways:
+
+- There is no concept of ownership; all Python objects are shared and usually implemented via reference counting
+- There is no concept of exclusive (`&mut`) references; any reference can mutate a Python object
+
+PyO3's API reflects this by providing [smart pointer][smart-pointers] types, `Py<T>`, `Bound<'py, T>`, and (the very rarely used) `Borrowed<'a, 'py, T>`.
+These smart pointers all use Python reference counting.
+See the [subchapter on types](./types.md) for more detail on these types.
+
+Because of the lack of exclusive `&mut` references, PyO3's APIs for Python objects, for example [`PyListMethods::append`], use shared references.
+This is safe because Python objects have internal mechanisms to prevent data races (as of time of writing, the Python GIL).
+
+[attached]: https://docs.python.org/3.14/glossary.html#term-attached-thread-state
+[global interpreter lock]: https://docs.python.org/3/c-api/init.html#thread-state-and-the-global-interpreter-lock
+[smart-pointers]: https://doc.rust-lang.org/book/ch15-00-smart-pointers.html
+[obtaining-py]: {{#PYO3_DOCS_URL}}/pyo3/marker/struct.Python.html#obtaining-a-python-token
+[`pyo3::sync`]: {{#PYO3_DOCS_URL}}/pyo3/sync/index.html
+[eval]: {{#PYO3_DOCS_URL}}/pyo3/marker/struct.Python.html#method.eval
+[import]: {{#PYO3_DOCS_URL}}/pyo3/marker/struct.Python.html#method.import
+[clone_ref]: {{#PYO3_DOCS_URL}}/pyo3/prelude/struct.Py.html#method.clone_ref
+[Bound]: {{#PYO3_DOCS_URL}}/pyo3/struct.Bound.html
+[`PyListMethods::append`]: {{#PYO3_DOCS_URL}}/pyo3/types/trait.PyListMethods.html#tymethod.append
diff --git a/guide/src/python-from-rust/calling-existing-code.md b/guide/src/python-from-rust/calling-existing-code.md
new file mode 100644
index 00000000000..b54aee76dcf
--- /dev/null
+++ b/guide/src/python-from-rust/calling-existing-code.md
@@ -0,0 +1,403 @@
+# Executing existing Python code
+
+If you already have some existing Python code that you need to execute from Rust, the following FAQs can help you select the right PyO3 functionality for your situation:
+
+## Want to access Python APIs? Then use `PyModule::import`
+
+[`PyModule::import`] can be used to get handle to a Python module from Rust.
+You can use this to import and use any Python module available in your environment.
+
+```rust
+use pyo3::prelude::*;
+
+fn main() -> PyResult<()> {
+    Python::attach(|py| {
+        let builtins = PyModule::import(py, "builtins")?;
+        let total: i32 = builtins
+            .getattr("sum")?
+            .call1((vec![1, 2, 3],))?
+            .extract()?;
+        assert_eq!(total, 6);
+        Ok(())
+    })
+}
+```
+
+[`PyModule::import`]: {{#PYO3_DOCS_URL}}/pyo3/types/struct.PyModule.html#method.import
+
+## Want to run just an expression? Then use `eval`
+
+[`Python::eval`]({{#PYO3_DOCS_URL}}/pyo3/marker/struct.Python.html#method.eval) is
+a method to execute a [Python expression](https://docs.python.org/3/reference/expressions.html)
+and return the evaluated value as a `Bound<'py, PyAny>` object.
+
+```rust
+use pyo3::prelude::*;
+
+# fn main() -> Result<(), ()> {
+Python::attach(|py| {
+    let result = py
+        .eval(c"[i * 10 for i in range(5)]", None, None)
+        .map_err(|e| {
+            e.print_and_set_sys_last_vars(py);
+        })?;
+    let res: Vec<i64> = result.extract().unwrap();
+    assert_eq!(res, vec![0, 10, 20, 30, 40]);
+    Ok(())
+})
+# }
+```
+
+## Want to run statements? Then use `run`
+
+[`Python::run`] is a method to execute one or more
+[Python statements](https://docs.python.org/3/reference/simple_stmts.html).
+This method returns nothing (like any Python statement), but you can get
+access to manipulated objects via the `locals` dict.
+
+You can also use the [`py_run!`] macro, which is a shorthand for [`Python::run`].
+Since [`py_run!`] panics on exceptions, we recommend you use this macro only for
+quickly testing your Python extensions.
+
+```rust
+use pyo3::prelude::*;
+use pyo3::py_run;
+
+# fn main() {
+#[pyclass]
+struct UserData {
+    id: u32,
+    name: String,
+}
+
+#[pymethods]
+impl UserData {
+    fn as_tuple(&self) -> (u32, String) {
+        (self.id, self.name.clone())
+    }
+
+    fn __repr__(&self) -> PyResult<String> {
+        Ok(format!("User {}(id: {})", self.name, self.id))
+    }
+}
+
+Python::attach(|py| {
+    let userdata = UserData {
+        id: 34,
+        name: "Yu".to_string(),
+    };
+    let userdata = Py::new(py, userdata).unwrap();
+    let userdata_as_tuple = (34, "Yu");
+    py_run!(py, userdata userdata_as_tuple, r#"
+assert repr(userdata) == "User Yu(id: 34)"
+assert userdata.as_tuple() == userdata_as_tuple
+    "#);
+})
+# }
+```
+
+## You have a Python file or code snippet? Then use `PyModule::from_code`
+
+[`PyModule::from_code`]({{#PYO3_DOCS_URL}}/pyo3/types/struct.PyModule.html#method.from_code)
+can be used to generate a Python module which can then be used just as if it was imported with
+`PyModule::import`.
+
+**Warning**: This will compile and execute code. **Never** pass untrusted code
+to this function!
+
+```rust
+use pyo3::{prelude::*, types::IntoPyDict};
+
+# fn main() -> PyResult<()> {
+Python::attach(|py| {
+    let activators = PyModule::from_code(
+        py,
+        cr#"
+def relu(x):
+    """see https://en.wikipedia.org/wiki/Rectifier_(neural_networks)"""
+    return max(0.0, x)
+
+def leaky_relu(x, slope=0.01):
+    return x if x >= 0 else x * slope
+    "#,
+        c"activators.py",
+        c"activators",
+    )?;
+
+    let relu_result: f64 = activators.getattr("relu")?.call1((-1.0,))?.extract()?;
+    assert_eq!(relu_result, 0.0);
+
+    let kwargs = [("slope", 0.2)].into_py_dict(py)?;
+    let lrelu_result: f64 = activators
+        .getattr("leaky_relu")?
+        .call((-1.0,), Some(&kwargs))?
+        .extract()?;
+    assert_eq!(lrelu_result, -0.2);
+#    Ok(())
+})
+# }
+```
+
+## Want to embed Python in Rust with additional modules?
+
+Python maintains the `sys.modules` dict as a cache of all imported modules.
+An import in Python will first attempt to lookup the module from this dict,
+and if not present will use various strategies to attempt to locate and load
+the module.
+
+The [`append_to_inittab`]({{#PYO3_DOCS_URL}}/pyo3/macro.append_to_inittab.html) macro can be used to add additional `#[pymodule]` modules to an embedded Python interpreter.
+The macro **must** be invoked _before_ initializing Python.
+
+As an example, the below adds the module `foo` to the embedded interpreter:
+
+```rust
+use pyo3::prelude::*;
+
+#[pymodule]
+mod foo {
+    use pyo3::prelude::*;
+
+    #[pyfunction]
+    fn add_one(x: i64) -> i64 {
+        x + 1
+    }
+}
+
+fn main() -> PyResult<()> {
+    pyo3::append_to_inittab!(foo);
+    Python::attach(|py| Python::run(py, c"import foo; foo.add_one(6)", None, None))
+}
+```
+
+If `append_to_inittab` cannot be used due to constraints in the program,
+an alternative is to create a module using [`PyModule::new`]
+and insert it manually into `sys.modules`:
+
+```rust
+use pyo3::prelude::*;
+use pyo3::types::PyDict;
+
+#[pyfunction]
+pub fn add_one(x: i64) -> i64 {
+    x + 1
+}
+
+fn main() -> PyResult<()> {
+    Python::attach(|py| {
+        // Create new module
+        let foo_module = PyModule::new(py, "foo")?;
+        foo_module.add_function(wrap_pyfunction!(add_one, &foo_module)?)?;
+
+        // Import and get sys.modules
+        let sys = PyModule::import(py, "sys")?;
+        let py_modules: Bound<'_, PyDict> = sys.getattr("modules")?.cast_into()?;
+
+        // Insert foo into sys.modules
+        py_modules.set_item("foo", foo_module)?;
+
+        // Now we can import + run our python code
+        Python::run(py, c"import foo; foo.add_one(6)", None, None)
+    })
+}
+```
+
+## Include multiple Python files
+
+You can include a file at compile time by using
+[`std::include_str`](https://doc.rust-lang.org/std/macro.include_str.html) macro.
+
+Or you can load a file at runtime by using
+[`std::fs::read_to_string`](https://doc.rust-lang.org/std/fs/fn.read_to_string.html) function.
+
+Many Python files can be included and loaded as modules.
+If one file depends on another you must preserve correct order while declaring `PyModule`.
+
+Example directory structure:
+
+```text
+.
+├── Cargo.lock
+├── Cargo.toml
+├── python_app
+│   ├── app.py
+│   └── utils
+│       └── foo.py
+└── src
+    └── main.rs
+```
+
+`python_app/app.py`:
+
+```python
+from utils.foo import bar
+
+
+def run():
+    return bar()
+```
+
+`python_app/utils/foo.py`:
+
+```python
+def bar():
+    return "baz"
+```
+
+The example below shows:
+
+- how to include content of `app.py` and `utils/foo.py` into your rust binary
+- how to call function `run()` (declared in `app.py`) that needs function
+  imported from `utils/foo.py`
+
+`src/main.rs`:
+
+```rust,ignore
+use pyo3::prelude::*;
+use pyo3_ffi::c_str;
+
+fn main() -> PyResult<()> {
+    let py_foo = c_str!(include_str!(concat!(
+        env!("CARGO_MANIFEST_DIR"),
+        "/python_app/utils/foo.py"
+    )));
+    let py_app = c_str!(include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/python_app/app.py")));
+    let from_python = Python::attach(|py| -> PyResult<Py<PyAny>> {
+        PyModule::from_code(py, py_foo, c"foo.py", c"utils.foo")?;
+        let app: Py<PyAny> = PyModule::from_code(py, py_app, c"app.py", c"")?
+            .getattr("run")?
+            .into();
+        app.call0(py)
+    });
+
+    println!("py: {}", from_python?);
+    Ok(())
+}
+```
+
+The example below shows:
+
+- how to load content of `app.py` at runtime so that it sees its dependencies
+  automatically
+- how to call function `run()` (declared in `app.py`) that needs function
+  imported from `utils/foo.py`
+
+It is recommended to use absolute paths because then your binary can be run
+from anywhere as long as your `app.py` is in the expected directory (in this example
+that directory is `/usr/share/python_app`).
+
+`src/main.rs`:
+
+```rust,no_run
+use pyo3::prelude::*;
+use pyo3::types::PyList;
+use std::fs;
+use std::path::Path;
+use std::ffi::CString;
+
+fn main() -> PyResult<()> {
+    let path = Path::new("/usr/share/python_app");
+    let py_app = CString::new(fs::read_to_string(path.join("app.py"))?)?;
+    let from_python = Python::attach(|py| -> PyResult<Py<PyAny>> {
+        let syspath = py
+            .import("sys")?
+            .getattr("path")?
+            .cast_into::<PyList>()?;
+        syspath.insert(0, path)?;
+        let app: Py<PyAny> = PyModule::from_code(py, py_app.as_c_str(), c"app.py", c"")?
+            .getattr("run")?
+            .into();
+        app.call0(py)
+    });
+
+    println!("py: {}", from_python?);
+    Ok(())
+}
+```
+
+## Need to use a context manager from Rust?
+
+Use context managers by directly invoking `__enter__` and `__exit__`.
+
+```rust
+use pyo3::prelude::*;
+
+fn main() {
+    Python::attach(|py| {
+        let custom_manager = PyModule::from_code(
+            py,
+            cr#"
+class House(object):
+    def __init__(self, address):
+        self.address = address
+    def __enter__(self):
+        print(f"Welcome to {self.address}!")
+    def __exit__(self, type, value, traceback):
+        if type:
+            print(f"Sorry you had {type} trouble at {self.address}")
+        else:
+            print(f"Thank you for visiting {self.address}, come again soon!")
+
+        "#,
+            c"house.py",
+            c"house",
+        )
+        .unwrap();
+
+        let house_class = custom_manager.getattr("House").unwrap();
+        let house = house_class.call1(("123 Main Street",)).unwrap();
+
+        house.call_method0("__enter__").unwrap();
+
+        let result = py.eval(c"undefined_variable + 1", None, None);
+
+        // If the eval threw an exception we'll pass it through to the context manager.
+        // Otherwise, __exit__  is called with empty arguments (Python "None").
+        match result {
+            Ok(_) => {
+                let none = py.None();
+                house
+                    .call_method1("__exit__", (&none, &none, &none))
+                    .unwrap();
+            }
+            Err(e) => {
+                house
+                    .call_method1(
+                        "__exit__",
+                        (
+                            e.get_type(py),
+                            e.value(py),
+                            e.traceback(py),
+                        ),
+                    )
+                    .unwrap();
+            }
+        }
+    })
+}
+```
+
+## Handling system signals/interrupts (Ctrl-C)
+
+The best way to handle system signals when running Rust code is to periodically call `Python::check_signals` to handle any signals captured by Python's signal handler.
+See also [the FAQ entry](../faq.md#ctrl-c-doesnt-do-anything-while-my-rust-code-is-executing).
+
+Alternatively, set Python's `signal` module to take the default action for a signal:
+
+```rust
+use pyo3::prelude::*;
+
+# fn main() -> PyResult<()> {
+Python::attach(|py| -> PyResult<()> {
+    let signal = py.import("signal")?;
+    // Set SIGINT to have the default action
+    signal
+        .getattr("signal")?
+        .call1((signal.getattr("SIGINT")?, signal.getattr("SIG_DFL")?))?;
+    Ok(())
+})
+# }
+```
+
+[`py_run!`]: {{#PYO3_DOCS_URL}}/pyo3/macro.py_run.html
+[`Python::run`]: {{#PYO3_DOCS_URL}}/pyo3/marker/struct.Python.html#method.run
+[`PyModule::new`]: {{#PYO3_DOCS_URL}}/pyo3/types/struct.PyModule.html#method.new
diff --git a/guide/src/python-from-rust/function-calls.md b/guide/src/python-from-rust/function-calls.md
new file mode 100644
index 00000000000..6574b86a356
--- /dev/null
+++ b/guide/src/python-from-rust/function-calls.md
@@ -0,0 +1,115 @@
+# Calling Python functions
+
+The `Bound<'py, T>` smart pointer (such as `Bound<'py, PyAny>`, `Bound<'py, PyList>`, or `Bound<'py, MyClass>`) can be used to call Python functions.
+
+PyO3 offers two APIs to make function calls:
+
+- [`call`]({{#PYO3_DOCS_URL}}/pyo3/types/trait.PyAnyMethods.html#tymethod.call) - call any callable Python object.
+- [`call_method`]({{#PYO3_DOCS_URL}}/pyo3/types/trait.PyAnyMethods.html#tymethod.call_method) - call a method on the Python object.
+
+Both of these APIs take `args` and `kwargs` arguments (for positional and keyword arguments respectively).
+There are variants for less complex calls:
+
+- [`call1`]({{#PYO3_DOCS_URL}}/pyo3/types/trait.PyAnyMethods.html#tymethod.call1) and [`call_method1`]({{#PYO3_DOCS_URL}}/pyo3/types/trait.PyAnyMethods.html#tymethod.call_method1) to call only with positional `args`.
+- [`call0`]({{#PYO3_DOCS_URL}}/pyo3/types/trait.PyAnyMethods.html#tymethod.call0) and [`call_method0`]({{#PYO3_DOCS_URL}}/pyo3/types/trait.PyAnyMethods.html#tymethod.call_method0) to call with no arguments.
+
+For convenience the [`Py<T>`](../types.md#pyt) smart pointer also exposes these same six API methods, but needs a `Python` token as an additional first argument to prove the thread is attached to the Python interpreter.
+
+The example below calls a Python function behind a `Py<PyAny>` reference:
+
+```rust
+use pyo3::prelude::*;
+use pyo3::types::PyTuple;
+
+fn main() -> PyResult<()> {
+    let arg1 = "arg1";
+    let arg2 = "arg2";
+    let arg3 = "arg3";
+
+    Python::attach(|py| {
+        let fun: Py<PyAny> = PyModule::from_code(
+            py,
+            c"def example(*args, **kwargs):
+                if args != ():
+                    print('called with args', args)
+                if kwargs != {}:
+                    print('called with kwargs', kwargs)
+                if args == () and kwargs == {}:
+                    print('called with no arguments')",
+            c"example.py",
+            c"",
+        )?
+        .getattr("example")?
+        .into();
+
+        // call object without any arguments
+        fun.call0(py)?;
+
+        // pass object with Rust tuple of positional arguments
+        let args = (arg1, arg2, arg3);
+        fun.call1(py, args)?;
+
+        // call object with Python tuple of positional arguments
+        let args = PyTuple::new(py, &[arg1, arg2, arg3])?;
+        fun.call1(py, args)?;
+        Ok(())
+    })
+}
+```
+
+## Creating keyword arguments
+
+For the `call` and `call_method` APIs, `kwargs` are `Option<&Bound<'py, PyDict>>`, so can either be `None` or `Some(&dict)`.
+You can use the [`IntoPyDict`]({{#PYO3_DOCS_URL}}/pyo3/types/trait.IntoPyDict.html) trait to convert other dict-like containers, e.g. `HashMap` or `BTreeMap`, as well as tuples with up to 10 elements and `Vec`s where each element is a two-element tuple.
+To pass keyword arguments of different types, construct a `PyDict` object.
+
+```rust
+use pyo3::prelude::*;
+use pyo3::types::{PyDict, IntoPyDict};
+use std::collections::HashMap;
+
+fn main() -> PyResult<()> {
+    let key1 = "key1";
+    let val1 = 1;
+    let key2 = "key2";
+    let val2 = 2;
+
+    Python::attach(|py| {
+        let fun: Py<PyAny> = PyModule::from_code(
+            py,
+            c"def example(*args, **kwargs):
+                if args != ():
+                    print('called with args', args)
+                if kwargs != {}:
+                    print('called with kwargs', kwargs)
+                if args == () and kwargs == {}:
+                    print('called with no arguments')",
+            c"example.py",
+            c"",
+        )?
+        .getattr("example")?
+        .into();
+
+        // call object with PyDict
+        let kwargs = [(key1, val1)].into_py_dict(py)?;
+        fun.call(py, (), Some(&kwargs))?;
+
+        // pass arguments as Vec
+        let kwargs = vec![(key1, val1), (key2, val2)];
+        fun.call(py, (), Some(&kwargs.into_py_dict(py)?))?;
+
+        // pass arguments as HashMap
+        let mut kwargs = HashMap::<&str, i32>::new();
+        kwargs.insert(key1, 1);
+        fun.call(py, (), Some(&kwargs.into_py_dict(py)?))?;
+
+        // pass arguments of different types as PyDict
+        let kwargs = PyDict::new(py);
+        kwargs.set_item(key1, val1)?;
+        kwargs.set_item(key2, "string")?;
+        fun.call(py, (), Some(&kwargs))?;
+
+        Ok(())
+    })
+}
+```
diff --git a/guide/src/python_typing_hints.md b/guide/src/python-typing-hints.md
similarity index 50%
rename from guide/src/python_typing_hints.md
rename to guide/src/python-typing-hints.md
index 43a15a21a6e..7f6661a2743 100644
--- a/guide/src/python_typing_hints.md
+++ b/guide/src/python-typing-hints.md
@@ -1,20 +1,25 @@
 # Typing and IDE hints for your Python package
 
-PyO3 provides an easy to use interface to code native Python libraries in Rust. The accompanying Maturin allows you to build and publish them as a package. Yet, for a better user experience, Python libraries should provide typing hints and documentation for all public entities, so that IDEs can show them during development and type analyzing tools such as `mypy` can use them to properly verify the code.
+PyO3 provides an easy to use interface to code native Python libraries in Rust.
+The accompanying Maturin allows you to build and publish them as a package.
+Yet, for a better user experience, Python libraries should provide typing hints and documentation for all public entities, so that IDEs can show them during development and type analyzing tools such as `mypy` can use them to properly verify the code.
 
 Currently the best solution for the problem is to manually maintain `*.pyi` files and ship them along with the package.
 
-There is a sketch of a roadmap towards completing [the `experimental-inspect` feature](./features.md#experimental-inspect) which may eventually lead to automatic type annotations generated by PyO3. This needs more testing and implementation, please see [issue #2454](https://github.com/PyO3/pyo3/issues/2454).
+PyO3 is working on automated their generation.
+See the [type stub generation](type-stub.md) documentation for a description of the current state of automated generation.
 
 ## Introduction to `pyi` files
 
-`pyi` files (an abbreviation for `Python Interface`) are called "stub files" in most of the documentation related to them. A very good definition of what it is can be found in [old MyPy documentation](https://github.com/python/mypy/wiki/Creating-Stubs-For-Python-Modules):
+`pyi` files (an abbreviation for `Python Interface`) are called "stub files" in most of the documentation related to them.
+A very good definition of what it is can be found in [old MyPy documentation](https://github.com/python/mypy/wiki/Creating-Stubs-For-Python-Modules):
 
 > A stubs file only contains a description of the public interface of the module without any implementations.
 
 There is also [extensive documentation on type stubs on the official Python typing documentation](https://typing.readthedocs.io/en/latest/source/stubs.html).
 
-Most Python developers probably already encountered them when trying to use their IDE's "Go to Definition" function on any builtin type. For example, the definitions of a few standard exceptions look like this:
+Most Python developers probably already encountered them when trying to use their IDE's "Go to Definition" function on any builtin type.
+For example, the definitions of a few standard exceptions look like this:
 
 ```python
 class BaseException(object):
@@ -37,11 +42,12 @@ class StopIteration(Exception):
     value: Any
 ```
 
-As we can see, those are not full definitions containing implementation, but just a description of the interface. It is usually all that the user of the library needs.
+As we can see, those are not full definitions containing implementation, but just a description of the interface.
+It is usually all that the user of the library needs.
 
 ### What do the PEPs say?
 
-At the time of writing this documentation, the `pyi` files are referenced in three PEPs.
+At the time of writing this documentation, the `pyi` files are referenced in four PEPs.
 
 [PEP8 - Style Guide for Python Code - #Function Annotations](https://www.python.org/dev/peps/pep-0008/#function-annotations) (last point) recommends all third party library creators to provide stub files as the source of knowledge about the package for type checker tools.
 
@@ -53,29 +59,37 @@ At the time of writing this documentation, the `pyi` files are referenced in thr
 
 It contains a specification for them (highly recommended reading, since it contains at least one thing that is not used in normal Python code) and also some general information about where to store the stub files.
 
-[PEP561 - Distributing and Packaging Type Information](https://www.python.org/dev/peps/pep-0561/) describes in detail how to build packages that will enable type checking. In particular it contains information about how the stub files must be distributed in order for type checkers to use them.
+[PEP561 - Distributing and Packaging Type Information](https://www.python.org/dev/peps/pep-0561/) describes in detail how to build packages that will enable type checking.
+In particular it contains information about how the stub files must be distributed in order for type checkers to use them.
+
+[PEP560 - Core support for typing module and generic types](https://www.python.org/dev/peps/pep-0560/) describes the details on how Python's type system internally supports generics, including both runtime behavior and integration with static type checkers.
 
 ## How to do it?
 
 [PEP561](https://www.python.org/dev/peps/pep-0561/) recognizes three ways of distributing type information:
 
-* `inline` - the typing is placed directly in source (`py`) files;
-* `separate package with stub files` - the typing is placed in `pyi` files distributed in their own, separate package;
-* `in-package stub files` - the typing is placed in `pyi` files distributed in the same package as source files.
+- `inline` - the typing is placed directly in source (`py`) files;
+- `separate package with stub files` - the typing is placed in `pyi` files distributed in their own, separate package;
+- `in-package stub files` - the typing is placed in `pyi` files distributed in the same package as source files.
 
-The first way is tricky with PyO3 since we do not have `py` files. When it has been investigated and necessary changes are implemented, this document will be updated.
+The first way is tricky with PyO3 since we do not have `py` files.
+When it has been investigated and necessary changes are implemented, this document will be updated.
 
-The second way is easy to do, and the whole work can be fully separated from the main library code. The example repo for the package with stub files can be found in [PEP561 references section](https://www.python.org/dev/peps/pep-0561/#references): [Stub package repository](https://github.com/ethanhs/stub-package)
+The second way is easy to do, and the whole work can be fully separated from the main library code.
+The example repo for the package with stub files can be found in [PEP561 references section](https://www.python.org/dev/peps/pep-0561/#references): [Stub package repository](https://github.com/ethanhs/stub-package)
 
 The third way is described below.
 
 ### Including `pyi` files in your PyO3/Maturin build package
 
-When source files are in the same package as stub files, they should be placed next to each other. We need a way to do that with Maturin. Also, in order to mark our package as typing-enabled we need to add an empty file named `py.typed` to the package.
+When source files are in the same package as stub files, they should be placed next to each other.
+We need a way to do that with Maturin.
+Also, in order to mark our package as typing-enabled we need to add an empty file named `py.typed` to the package.
 
 #### If you do not have other Python files
 
-If you do not need to add any other Python files apart from `pyi` to the package, Maturin provides a way to do most of the work for you. As documented in the [Maturin Guide](https://github.com/PyO3/maturin/#mixed-rustpython-projects), the only thing you need to do is to create a stub file for your module named `<module_name>.pyi` in your project root and Maturin will do the rest.
+If you do not need to add any other Python files apart from `pyi` to the package, Maturin provides a way to do most of the work for you.
+As documented in the [Maturin Guide](https://github.com/PyO3/maturin/#mixed-rustpython-projects), the only thing you need to do is to create a stub file for your module named `<module_name>.pyi` in your project root and Maturin will do the rest.
 
 ```text
 my-rust-project/
@@ -90,7 +104,9 @@ For an example `pyi` file see the [`my_project.pyi` content](#my_projectpyi-cont
 
 #### If you need other Python files
 
-If you need to add other Python files apart from `pyi` to the package, you can do it also, but that requires some more work. Maturin provides an easy way to add files to a package ([documentation](https://github.com/PyO3/maturin/blob/0dee40510083c03607834c821eea76964140a126/Readme.md#mixed-rustpython-projects)). You just need to create a folder with the name of your module next to the `Cargo.toml` file (for customization see documentation linked above).
+If you need to add other Python files apart from `pyi` to the package, you can do it also, but that requires some more work.
+Maturin provides an easy way to add files to a package ([documentation](https://github.com/PyO3/maturin/blob/0dee40510083c03607834c821eea76964140a126/Readme.md#mixed-rustpython-projects)).
+You just need to create a folder with the name of your module next to the `Cargo.toml` file (for customization see documentation linked above).
 
 The folder structure would be:
 
@@ -112,7 +128,9 @@ Let's go a little bit more into detail regarding the files inside the package fo
 
 ##### `__init__.py` content
 
-As we now specify our own package content, we have to provide the `__init__.py` file, so the folder is treated as a package and we can import things from it. We can always use the same content that Maturin creates for us if we do not specify a Python source folder. For PyO3 bindings it would be:
+As we now specify our own package content, we have to provide the `__init__.py` file, so the folder is treated as a package and we can import things from it.
+We can always use the same content that Maturin creates for us if we do not specify a Python source folder.
+For PyO3 bindings it would be:
 
 ```python
 from .my_project import *
@@ -125,7 +143,8 @@ That way everything that is exposed by our native module can be imported directl
 As stated in [PEP561](https://www.python.org/dev/peps/pep-0561/):
 > Package maintainers who wish to support type checking of their code MUST add a marker file named py.typed to their package supporting typing. This marker applies recursively: if a top-level package includes it, all its sub-packages MUST support type checking as well.
 
-If we do not include that file, some IDEs might still use our `pyi` files to show hints, but the type checkers might not. MyPy will raise an error in this situation:
+If we do not include that file, some IDEs might still use our `pyi` files to show hints, but the type checkers might not.
+MyPy will raise an error in this situation:
 
 ```text
 error: Skipping analyzing "my_project": found module but no type hints or library stubs
@@ -135,7 +154,8 @@ The file is just a marker file, so it should be empty.
 
 ##### `my_project.pyi` content
 
-Our module stub file. This document does not aim at describing how to write them, since you can find a lot of documentation on it, starting from the already quoted [PEP484](https://www.python.org/dev/peps/pep-0484/#stub-files).
+Our module stub file.
+This document does not aim at describing how to write them, since you can find a lot of documentation on it, starting from the already quoted [PEP484](https://www.python.org/dev/peps/pep-0484/#stub-files).
 
 The example can look like this:
 
@@ -165,3 +185,75 @@ class Car:
         :return: the name of the color our great algorithm thinks is the best for this car
         """
 ```
+
+### Supporting Generics
+
+Type annotations can also be made generic in Python.
+They are useful for working with different types while maintaining type safety.
+Usually, generic classes inherit from the `typing.Generic` metaclass.
+
+Take for example the following `.pyi` file that specifies a `Car` that can
+accept multiple types of wheels:
+
+```python
+from typing import Generic, TypeVar
+
+W = TypeVar('W')
+
+class Car(Generic[W]):
+    def __init__(self, wheels: list[W]) -> None: ...
+
+    def get_wheels(self) -> list[W]: ...
+
+    def change_wheel(self, wheel_number: int, wheel: W) -> None: ...
+```
+
+This way, the end-user can specify the type with variables such as `truck: Car[SteelWheel] = ...`
+and `f1_car: Car[AlloyWheel] = ...`.
+
+There is also a special syntax for specifying generic types in Python 3.12+:
+
+```python
+class Car[W]:
+    def __init__(self, wheels: list[W]) -> None: ...
+
+    def get_wheels(self) -> list[W]: ...
+```
+
+#### Runtime Behaviour
+
+Stub files (`pyi`) are only useful for static type checkers and ignored at runtime.
+Therefore, PyO3 classes do not inherit from `typing.Generic` even if specified in the stub files.
+
+This can cause some runtime issues, as annotating a variable like `f1_car: Car[AlloyWheel] = ...`
+can make Python call magic methods that are not defined.
+
+To overcome this limitation, implementers can pass the `generic` parameter to `pyclass` in Rust:
+
+```rust ignore
+#[pyclass(generic)]
+```
+
+#### Advanced Users
+
+`#[pyclass(generic)]` implements a very simple runtime behavior that accepts any generic argument.
+Advanced users can opt to manually implement [`__class_geitem__`](https://docs.python.org/3/reference/datamodel.html#emulating-generic-types) for the generic class to have more control.
+
+```rust ignore
+impl MyClass {
+    #[classmethod]
+    #[pyo3(signature = (key, /))]
+    pub fn __class_getitem__(
+        cls: &Bound<'_, PyType>,
+        key: &Bound<'_, PyAny>,
+    ) -> PyResult<Py<PyAny>> {
+        /* implementation details */
+    }
+}
+```
+
+Note that [`pyo3::types::PyGenericAlias`][pygenericalias] can be helpful when implementing
+`__class_getitem__` as it can create [`types.GenericAlias`][genericalias] objects from Rust.
+
+[pygenericalias]: {{#PYO3_DOCS_URL}}/pyo3/types/struct.PyGenericAlias.html
+[genericalias]: https://docs.python.org/3/library/types.html#types.GenericAlias
diff --git a/guide/src/python_from_rust.md b/guide/src/python_from_rust.md
deleted file mode 100644
index 1ac1a7c217a..00000000000
--- a/guide/src/python_from_rust.md
+++ /dev/null
@@ -1,512 +0,0 @@
-# Calling Python in Rust code
-
-This chapter of the guide documents some ways to interact with Python code from Rust:
- - How to call Python functions
- - How to execute existing Python code
-
-## Calling Python functions
-
-Any Python-native object reference (such as `&PyAny`, `&PyList`, or `&PyCell<MyClass>`) can be used to call Python functions.
-
-PyO3 offers two APIs to make function calls:
-
-* [`call`]({{#PYO3_DOCS_URL}}/pyo3/prelude/trait.PyAnyMethods#tymethod.call) - call any callable Python object.
-* [`call_method`]({{#PYO3_DOCS_URL}}/pyo3/prelude/trait.PyAnyMethods#tymethod.call_method) - call a method on the Python object.
-
-Both of these APIs take `args` and `kwargs` arguments (for positional and keyword arguments respectively). There are variants for less complex calls:
-
-* [`call1`]({{#PYO3_DOCS_URL}}/pyo3/prelude/trait.PyAnyMethods#tymethod.call1) and [`call_method1`]({{#PYO3_DOCS_URL}}/pyo3/prelude/trait.PyAnyMethods#tymethod.call_method1) to call only with positional `args`.
-* [`call0`]({{#PYO3_DOCS_URL}}/pyo3/prelude/trait.PyAnyMethods#tymethod.call0) and [`call_method0`]({{#PYO3_DOCS_URL}}/pyo3/prelude/trait.PyAnyMethods#tymethod.call_method0) to call with no arguments.
-
-For convenience the [`Py<T>`](types.html#pyt-and-pyobject) smart pointer also exposes these same six API methods, but needs a `Python` token as an additional first argument to prove the GIL is held.
-
-The example below calls a Python function behind a `PyObject` (aka `Py<PyAny>`) reference:
-
-```rust
-use pyo3::prelude::*;
-use pyo3::types::PyTuple;
-
-fn main() -> PyResult<()> {
-    let arg1 = "arg1";
-    let arg2 = "arg2";
-    let arg3 = "arg3";
-
-    Python::with_gil(|py| {
-        let fun: Py<PyAny> = PyModule::from_code(
-            py,
-            "def example(*args, **kwargs):
-                if args != ():
-                    print('called with args', args)
-                if kwargs != {}:
-                    print('called with kwargs', kwargs)
-                if args == () and kwargs == {}:
-                    print('called with no arguments')",
-            "",
-            "",
-        )?
-        .getattr("example")?
-        .into();
-
-        // call object without any arguments
-        fun.call0(py)?;
-
-        // call object with PyTuple
-        let args = PyTuple::new_bound(py, &[arg1, arg2, arg3]);
-        fun.call1(py, args)?;
-
-        // pass arguments as rust tuple
-        let args = (arg1, arg2, arg3);
-        fun.call1(py, args)?;
-        Ok(())
-    })
-}
-```
-
-### Creating keyword arguments
-
-For the `call` and `call_method` APIs, `kwargs` can be `None` or `Some(&PyDict)`. You can use the [`IntoPyDict`]({{#PYO3_DOCS_URL}}/pyo3/types/trait.IntoPyDict.html) trait to convert other dict-like containers, e.g. `HashMap` or `BTreeMap`, as well as tuples with up to 10 elements and `Vec`s where each element is a two-element tuple.
-
-```rust
-use pyo3::prelude::*;
-use pyo3::types::IntoPyDict;
-use std::collections::HashMap;
-
-fn main() -> PyResult<()> {
-    let key1 = "key1";
-    let val1 = 1;
-    let key2 = "key2";
-    let val2 = 2;
-
-    Python::with_gil(|py| {
-        let fun: Py<PyAny> = PyModule::from_code(
-            py,
-            "def example(*args, **kwargs):
-                if args != ():
-                    print('called with args', args)
-                if kwargs != {}:
-                    print('called with kwargs', kwargs)
-                if args == () and kwargs == {}:
-                    print('called with no arguments')",
-            "",
-            "",
-        )?
-        .getattr("example")?
-        .into();
-
-        // call object with PyDict
-        let kwargs = [(key1, val1)].into_py_dict_bound(py);
-        fun.call_bound(py, (), Some(&kwargs))?;
-
-        // pass arguments as Vec
-        let kwargs = vec![(key1, val1), (key2, val2)];
-        fun.call_bound(py, (), Some(&kwargs.into_py_dict_bound(py)))?;
-
-        // pass arguments as HashMap
-        let mut kwargs = HashMap::<&str, i32>::new();
-        kwargs.insert(key1, 1);
-        fun.call_bound(py, (), Some(&kwargs.into_py_dict_bound(py)))?;
-
-        Ok(())
-    })
-}
-```
-
-<div class="warning">
-
-During PyO3's [migration from "GIL Refs" to the `Bound<T>` smart pointer](./migration.md#migrating-from-the-gil-refs-api-to-boundt), [`Py<T>::call`]({{#PYO3_DOCS_URL}}/pyo3/struct.py#method.call) is temporarily named `call_bound` (and `call_method` is temporarily `call_method_bound`).
-
-(This temporary naming is only the case for the `Py<T>` smart pointer. The methods on the `&PyAny` GIL Ref such as `call` have not been given replacements, and the methods on the `Bound<PyAny>` smart pointer such as [`Bound<PyAny>::call`]({#PYO3_DOCS_URL}}/pyo3/prelude/trait.pyanymethods#tymethod.call) already use follow the newest API conventions.)
-
-</div>
-
-## Executing existing Python code
-
-If you already have some existing Python code that you need to execute from Rust, the following FAQs can help you select the right PyO3 functionality for your situation:
-
-### Want to access Python APIs? Then use `PyModule::import`.
-
-[`Pymodule::import`]({{#PYO3_DOCS_URL}}/pyo3/types/struct.PyModule.html#method.import) can
-be used to get handle to a Python module from Rust. You can use this to import and use any Python
-module available in your environment.
-
-```rust
-use pyo3::prelude::*;
-
-fn main() -> PyResult<()> {
-    Python::with_gil(|py| {
-        let builtins = PyModule::import(py, "builtins")?;
-        let total: i32 = builtins
-            .getattr("sum")?
-            .call1((vec![1, 2, 3],))?
-            .extract()?;
-        assert_eq!(total, 6);
-        Ok(())
-    })
-}
-```
-
-### Want to run just an expression? Then use `eval`.
-
-[`Python::eval`]({{#PYO3_DOCS_URL}}/pyo3/marker/struct.Python.html#method.eval) is
-a method to execute a [Python expression](https://docs.python.org/3.7/reference/expressions.html)
-and return the evaluated value as a `&PyAny` object.
-
-```rust
-use pyo3::prelude::*;
-
-# fn main() -> Result<(), ()> {
-Python::with_gil(|py| {
-    let result = py
-        .eval_bound("[i * 10 for i in range(5)]", None, None)
-        .map_err(|e| {
-            e.print_and_set_sys_last_vars(py);
-        })?;
-    let res: Vec<i64> = result.extract().unwrap();
-    assert_eq!(res, vec![0, 10, 20, 30, 40]);
-    Ok(())
-})
-# }
-```
-
-### Want to run statements? Then use `run`.
-
-[`Python::run`] is a method to execute one or more
-[Python statements](https://docs.python.org/3.7/reference/simple_stmts.html).
-This method returns nothing (like any Python statement), but you can get
-access to manipulated objects via the `locals` dict.
-
-You can also use the [`py_run!`] macro, which is a shorthand for [`Python::run`].
-Since [`py_run!`] panics on exceptions, we recommend you use this macro only for
-quickly testing your Python extensions.
-
-```rust
-use pyo3::prelude::*;
-use pyo3::{PyCell, py_run};
-
-# fn main() {
-#[pyclass]
-struct UserData {
-    id: u32,
-    name: String,
-}
-
-#[pymethods]
-impl UserData {
-    fn as_tuple(&self) -> (u32, String) {
-        (self.id, self.name.clone())
-    }
-
-    fn __repr__(&self) -> PyResult<String> {
-        Ok(format!("User {}(id: {})", self.name, self.id))
-    }
-}
-
-Python::with_gil(|py| {
-    let userdata = UserData {
-        id: 34,
-        name: "Yu".to_string(),
-    };
-    let userdata = PyCell::new(py, userdata).unwrap();
-    let userdata_as_tuple = (34, "Yu");
-    py_run!(py, userdata userdata_as_tuple, r#"
-assert repr(userdata) == "User Yu(id: 34)"
-assert userdata.as_tuple() == userdata_as_tuple
-    "#);
-})
-# }
-```
-
-## You have a Python file or code snippet? Then use `PyModule::from_code`.
-
-[`PyModule::from_code`]({{#PYO3_DOCS_URL}}/pyo3/types/struct.PyModule.html#method.from_code)
-can be used to generate a Python module which can then be used just as if it was imported with
-`PyModule::import`.
-
-**Warning**: This will compile and execute code. **Never** pass untrusted code
-to this function!
-
-```rust
-use pyo3::{
-    prelude::*,
-    types::{IntoPyDict, PyModule},
-};
-
-# fn main() -> PyResult<()> {
-Python::with_gil(|py| {
-    let activators = PyModule::from_code(
-        py,
-        r#"
-def relu(x):
-    """see https://en.wikipedia.org/wiki/Rectifier_(neural_networks)"""
-    return max(0.0, x)
-
-def leaky_relu(x, slope=0.01):
-    return x if x >= 0 else x * slope
-    "#,
-        "activators.py",
-        "activators",
-    )?;
-
-    let relu_result: f64 = activators.getattr("relu")?.call1((-1.0,))?.extract()?;
-    assert_eq!(relu_result, 0.0);
-
-    let kwargs = [("slope", 0.2)].into_py_dict_bound(py);
-    let lrelu_result: f64 = activators
-        .getattr("leaky_relu")?
-        .call((-1.0,), Some(kwargs.as_gil_ref()))?
-        .extract()?;
-    assert_eq!(lrelu_result, -0.2);
-#    Ok(())
-})
-# }
-```
-
-### Want to embed Python in Rust with additional modules?
-
-Python maintains the `sys.modules` dict as a cache of all imported modules.
-An import in Python will first attempt to lookup the module from this dict,
-and if not present will use various strategies to attempt to locate and load
-the module.
-
-The [`append_to_inittab`]({{#PYO3_DOCS_URL}}/pyo3/macro.append_to_inittab.html)
-macro can be used to add additional `#[pymodule]` modules to an embedded
-Python interpreter. The macro **must** be invoked _before_ initializing Python.
-
-As an example, the below adds the module `foo` to the embedded interpreter:
-
-```rust
-use pyo3::prelude::*;
-
-#[pyfunction]
-fn add_one(x: i64) -> i64 {
-    x + 1
-}
-
-#[pymodule]
-fn foo(_py: Python<'_>, foo_module: &PyModule) -> PyResult<()> {
-    foo_module.add_function(wrap_pyfunction!(add_one, foo_module)?)?;
-    Ok(())
-}
-
-fn main() -> PyResult<()> {
-    pyo3::append_to_inittab!(foo);
-    Python::with_gil(|py| Python::run_bound(py, "import foo; foo.add_one(6)", None, None))
-}
-```
-
-If `append_to_inittab` cannot be used due to constraints in the program,
-an alternative is to create a module using [`PyModule::new`]
-and insert it manually into `sys.modules`:
-
-```rust
-use pyo3::prelude::*;
-use pyo3::types::PyDict;
-
-#[pyfunction]
-pub fn add_one(x: i64) -> i64 {
-    x + 1
-}
-
-fn main() -> PyResult<()> {
-    Python::with_gil(|py| {
-        // Create new module
-        let foo_module = PyModule::new(py, "foo")?;
-        foo_module.add_function(wrap_pyfunction!(add_one, foo_module)?)?;
-
-        // Import and get sys.modules
-        let sys = PyModule::import(py, "sys")?;
-        let py_modules: &PyDict = sys.getattr("modules")?.downcast()?;
-
-        // Insert foo into sys.modules
-        py_modules.set_item("foo", foo_module)?;
-
-        // Now we can import + run our python code
-        Python::run_bound(py, "import foo; foo.add_one(6)", None, None)
-    })
-}
-```
-
-### Include multiple Python files
-
-You can include a file at compile time by using
-[`std::include_str`](https://doc.rust-lang.org/std/macro.include_str.html) macro.
-
-Or you can load a file at runtime by using
-[`std::fs::read_to_string`](https://doc.rust-lang.org/std/fs/fn.read_to_string.html) function.
-
-Many Python files can be included and loaded as modules. If one file depends on
-another you must preserve correct order while declaring `PyModule`.
-
-Example directory structure:
-```text
-.
-├── Cargo.lock
-├── Cargo.toml
-├── python_app
-│   ├── app.py
-│   └── utils
-│       └── foo.py
-└── src
-    └── main.rs
-```
-
-`python_app/app.py`:
-```python
-from utils.foo import bar
-
-
-def run():
-    return bar()
-```
-
-`python_app/utils/foo.py`:
-```python
-def bar():
-    return "baz"
-```
-
-The example below shows:
-* how to include content of `app.py` and `utils/foo.py` into your rust binary
-* how to call function `run()` (declared in `app.py`) that needs function
-  imported from `utils/foo.py`
-
-`src/main.rs`:
-```rust,ignore
-use pyo3::prelude::*;
-
-fn main() -> PyResult<()> {
-    let py_foo = include_str!(concat!(
-        env!("CARGO_MANIFEST_DIR"),
-        "/python_app/utils/foo.py"
-    ));
-    let py_app = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/python_app/app.py"));
-    let from_python = Python::with_gil(|py| -> PyResult<Py<PyAny>> {
-        PyModule::from_code(py, py_foo, "utils.foo", "utils.foo")?;
-        let app: Py<PyAny> = PyModule::from_code(py, py_app, "", "")?
-            .getattr("run")?
-            .into();
-        app.call0(py)
-    });
-
-    println!("py: {}", from_python?);
-    Ok(())
-}
-```
-
-The example below shows:
-* how to load content of `app.py` at runtime so that it sees its dependencies
-  automatically
-* how to call function `run()` (declared in `app.py`) that needs function
-  imported from `utils/foo.py`
-
-It is recommended to use absolute paths because then your binary can be run
-from anywhere as long as your `app.py` is in the expected directory (in this example
-that directory is `/usr/share/python_app`).
-
-`src/main.rs`:
-```rust,no_run
-use pyo3::prelude::*;
-use pyo3::types::PyList;
-use std::fs;
-use std::path::Path;
-
-fn main() -> PyResult<()> {
-    let path = Path::new("/usr/share/python_app");
-    let py_app = fs::read_to_string(path.join("app.py"))?;
-    let from_python = Python::with_gil(|py| -> PyResult<Py<PyAny>> {
-        let syspath = py.import_bound("sys")?.getattr("path")?.downcast_into::<PyList>()?;
-        syspath.insert(0, &path)?;
-        let app: Py<PyAny> = PyModule::from_code(py, &py_app, "", "")?
-            .getattr("run")?
-            .into();
-        app.call0(py)
-    });
-
-    println!("py: {}", from_python?);
-    Ok(())
-}
-```
-
-
-[`Python::run`]: {{#PYO3_DOCS_URL}}/pyo3/struct.Python.html#method.run
-[`py_run!`]: {{#PYO3_DOCS_URL}}/pyo3/macro.py_run.html
-
-## Need to use a context manager from Rust?
-
-Use context managers by directly invoking `__enter__` and `__exit__`.
-
-```rust
-use pyo3::prelude::*;
-use pyo3::types::PyModule;
-
-fn main() {
-    Python::with_gil(|py| {
-        let custom_manager = PyModule::from_code(
-            py,
-            r#"
-class House(object):
-    def __init__(self, address):
-        self.address = address
-    def __enter__(self):
-        print(f"Welcome to {self.address}!")
-    def __exit__(self, type, value, traceback):
-        if type:
-            print(f"Sorry you had {type} trouble at {self.address}")
-        else:
-            print(f"Thank you for visiting {self.address}, come again soon!")
-
-        "#,
-            "house.py",
-            "house",
-        )
-        .unwrap();
-
-        let house_class = custom_manager.getattr("House").unwrap();
-        let house = house_class.call1(("123 Main Street",)).unwrap();
-
-        house.call_method0("__enter__").unwrap();
-
-        let result = py.eval_bound("undefined_variable + 1", None, None);
-
-        // If the eval threw an exception we'll pass it through to the context manager.
-        // Otherwise, __exit__  is called with empty arguments (Python "None").
-        match result {
-            Ok(_) => {
-                let none = py.None();
-                house
-                    .call_method1("__exit__", (&none, &none, &none))
-                    .unwrap();
-            }
-            Err(e) => {
-                house
-                    .call_method1("__exit__", (e.get_type_bound(py), e.value(py), e.traceback_bound(py)))
-                    .unwrap();
-            }
-        }
-    })
-}
-```
-
-## Handling system signals/interrupts (Ctrl-C)
-
-The best way to handle system signals when running Rust code is to periodically call `Python::check_signals` to handle any signals captured by Python's signal handler. See also [the FAQ entry](./faq.md#ctrl-c-doesnt-do-anything-while-my-rust-code-is-executing).
-
-Alternatively, set Python's `signal` module to take the default action for a signal:
-
-```rust
-use pyo3::prelude::*;
-
-# fn main() -> PyResult<()> {
-Python::with_gil(|py| -> PyResult<()> {
-    let signal = py.import_bound("signal")?;
-    // Set SIGINT to have the default action
-    signal
-        .getattr("signal")?
-        .call1((signal.getattr("SIGINT")?, signal.getattr("SIG_DFL")?))?;
-    Ok(())
-})
-# }
-```
-
-
-[`PyModule::new`]: {{#PYO3_DOCS_URL}}/pyo3/types/struct.PyModule.html#method.new
diff --git a/guide/src/rust-from-python.md b/guide/src/rust-from-python.md
new file mode 100644
index 00000000000..3b525d399df
--- /dev/null
+++ b/guide/src/rust-from-python.md
@@ -0,0 +1,13 @@
+# Using Rust from Python
+
+This chapter of the guide is dedicated to explaining how to wrap Rust code into Python objects.
+
+PyO3 uses Rust's "procedural macros" to provide a powerful yet simple API to denote what Rust code should map into Python objects.
+
+PyO3 can create three types of Python objects:
+
+- Python modules, via the `#[pymodule]` macro
+- Python functions, via the `#[pyfunction]` macro
+- Python classes, via the `#[pyclass]` macro (plus `#[pymethods]` to define methods for those classes)
+
+The following subchapters go through each of these in turn.
diff --git a/guide/src/trait_bounds.md b/guide/src/trait-bounds.md
similarity index 84%
rename from guide/src/trait_bounds.md
rename to guide/src/trait-bounds.md
index e0dd988412f..578019c8dfc 100644
--- a/guide/src/trait_bounds.md
+++ b/guide/src/trait-bounds.md
@@ -1,17 +1,19 @@
 # Using in Python a Rust function with trait bounds
 
-PyO3 allows for easy conversion from Rust to Python for certain functions and classes (see the [conversion table](conversions/tables.html).
+PyO3 allows for easy conversion from Rust to Python for certain functions and classes (see the [conversion table](conversions/tables.md)).
 However, it is not always straightforward to convert Rust code that requires a given trait implementation as an argument.
 
 This tutorial explains how to convert a Rust function that takes a trait as argument for use in Python with classes implementing the same methods as the trait.
 
 Why is this useful?
 
-### Pros
+## Pros
+
 - Make your Rust code available to Python users
 - Code complex algorithms in Rust with the help of the borrow checker
 
 ### Cons
+
 - Not as fast as native Rust (type conversion has to be performed and one part of the code runs in Python)
 - You need to adapt your code to expose it
 
@@ -22,7 +24,7 @@ Let's work with the following basic example of an implementation of a optimizati
 Let's say we have a function `solve` that operates on a model and mutates its state.
 The argument of the function can be any model that implements the `Model` trait :
 
-```rust
+```rust,no_run
 # #![allow(dead_code)]
 pub trait Model {
     fn set_variables(&mut self, inputs: &Vec<f64>);
@@ -34,9 +36,12 @@ pub fn solve<T: Model>(model: &mut T) {
     println!("Magic solver that mutates the model into a resolved state");
 }
 ```
+
 Let's assume we have the following constraints:
+
 - We cannot change that code as it runs on many Rust models.
 - We also have many Python models that cannot be solved as this solver is not available in that language.
+
 Rewriting it in Python would be cumbersome and error-prone, as everything is already available in Rust.
 
 How could we expose this solver to Python thanks to PyO3 ?
@@ -44,7 +49,7 @@ How could we expose this solver to Python thanks to PyO3 ?
 ## Implementation of the trait bounds for the Python class
 
 If a Python class implements the same three methods as the `Model` trait, it seems logical it could be adapted to use the solver.
-However, it is not possible to pass a `PyObject` to it as it does not implement the Rust trait (even if the Python model has the required methods).
+However, it is not possible to pass a `Py<PyAny>` to it as it does not implement the Rust trait (even if the Python model has the required methods).
 
 In order to implement the trait, we must write a wrapper around the calls in Rust to the Python model.
 The method signatures must be the same as the trait, keeping in mind that the Rust trait cannot be changed for the purpose of making the code available in Python.
@@ -63,9 +68,10 @@ class Model:
 
 The following wrapper will call the Python model from Rust, using a struct to hold the model as a `PyAny` object:
 
-```rust
+```rust,no_run
 # #![allow(dead_code)]
 use pyo3::prelude::*;
+use pyo3::types::PyList;
 
 # pub trait Model {
 #   fn set_variables(&mut self, inputs: &Vec<f64>);
@@ -80,21 +86,19 @@ struct UserModel {
 impl Model for UserModel {
     fn set_variables(&mut self, var: &Vec<f64>) {
         println!("Rust calling Python to set the variables");
-        Python::with_gil(|py| {
-            let values: Vec<f64> = var.clone();
-            let list: PyObject = values.into_py(py);
-            let py_model = self.model.as_ref(py);
-            py_model
-                .call_method("set_variables", (list,), None)
+        Python::attach(|py| {
+            self.model
+                .bind(py)
+                .call_method("set_variables", (PyList::new(py, var).unwrap(),), None)
                 .unwrap();
         })
     }
 
     fn get_results(&self) -> Vec<f64> {
         println!("Rust calling Python to get the results");
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             self.model
-                .as_ref(py)
+                .bind(py)
                 .call_method("get_results", (), None)
                 .unwrap()
                 .extract()
@@ -104,9 +108,9 @@ impl Model for UserModel {
 
     fn compute(&mut self) {
         println!("Rust calling Python to perform the computation");
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             self.model
-                .as_ref(py)
+                .bind(py)
                 .call_method("compute", (), None)
                 .unwrap();
         })
@@ -117,8 +121,9 @@ impl Model for UserModel {
 Now that this bit is implemented, let's expose the model wrapper to Python.
 Let's add the PyO3 annotations and add a constructor:
 
-```rust
+```rust,no_run
 # #![allow(dead_code)]
+# fn main() {}
 # pub trait Model {
 #   fn set_variables(&mut self, inputs: &Vec<f64>);
 #   fn compute(&mut self);
@@ -131,12 +136,6 @@ struct UserModel {
     model: Py<PyAny>,
 }
 
-#[pymodule]
-fn trait_exposure(_py: Python<'_>, m: &PyModule) -> PyResult<()> {
-    m.add_class::<UserModel>()?;
-    Ok(())
-}
-
 #[pymethods]
 impl UserModel {
     #[new]
@@ -144,6 +143,12 @@ impl UserModel {
         UserModel { model }
     }
 }
+
+#[pymodule]
+mod trait_exposure {
+    #[pymodule_export]
+    use super::UserModel;
+}
 ```
 
 Now we add the PyO3 annotations to the trait implementation:
@@ -155,16 +160,17 @@ impl Model for UserModel {
 }
 ```
 
-However, the previous code will not compile. The compilation error is the following one:
-`error: #[pymethods] cannot be used on trait impl blocks`
+However, the previous code will not compile.
+The compilation error is the following one: `error: #[pymethods] cannot be used on trait impl blocks`
 
 That's a bummer!
 However, we can write a second wrapper around these functions to call them directly.
 This wrapper will also perform the type conversions between Python and Rust.
 
-```rust
+```rust,no_run
 # #![allow(dead_code)]
 # use pyo3::prelude::*;
+# use pyo3::types::PyList;
 #
 # pub trait Model {
 #   fn set_variables(&mut self, inputs: &Vec<f64>);
@@ -180,21 +186,18 @@ This wrapper will also perform the type conversions between Python and Rust.
 # impl Model for UserModel {
 #  fn set_variables(&mut self, var: &Vec<f64>) {
 #      println!("Rust calling Python to set the variables");
-#      Python::with_gil(|py| {
-#          let values: Vec<f64> = var.clone();
-#          let list: PyObject = values.into_py(py);
-#          let py_model = self.model.as_ref(py);
-#          py_model
-#              .call_method("set_variables", (list,), None)
+#      Python::attach(|py| {
+#          self.model.bind(py)
+#              .call_method("set_variables", (PyList::new(py, var).unwrap(),), None)
 #              .unwrap();
 #      })
 #  }
 #
 #  fn get_results(&self) -> Vec<f64> {
 #      println!("Rust calling Python to get the results");
-#      Python::with_gil(|py| {
+#      Python::attach(|py| {
 #          self.model
-#              .as_ref(py)
+#              .bind(py)
 #              .call_method("get_results", (), None)
 #              .unwrap()
 #              .extract()
@@ -204,9 +207,9 @@ This wrapper will also perform the type conversions between Python and Rust.
 #
 #  fn compute(&mut self) {
 #      println!("Rust calling Python to perform the computation");
-#      Python::with_gil(|py| {
+#      Python::attach(|py| {
 #          self.model
-#              .as_ref(py)
+#              .bind(py)
 #              .call_method("compute", (), None)
 #              .unwrap();
 #      })
@@ -232,8 +235,10 @@ impl UserModel {
     }
 }
 ```
+
 This wrapper handles the type conversion between the PyO3 requirements and the trait.
 In order to meet PyO3 requirements, this wrapper must:
+
 - return an object of type `PyResult`
 - use only values, not references in the method signatures
 
@@ -282,7 +287,6 @@ We will now expose the `solve` function, but before, let's talk about types erro
 
 What happens if you have type errors when using Python and how can you improve the error messages?
 
-
 ### Wrong types in Python function arguments
 
 Let's assume in the first case that you will use in your Python file `my_rust_model.set_variables(2.0)` instead of `my_rust_model.set_variables([2.0])`.
@@ -331,9 +335,10 @@ Let's modify the code performing the type conversion to give a helpful error mes
 
 We used in our `get_results` method the following call that performs the type conversion:
 
-```rust
+```rust,no_run
 # #![allow(dead_code)]
 # use pyo3::prelude::*;
+# use pyo3::types::PyList;
 #
 # pub trait Model {
 #   fn set_variables(&mut self, inputs: &Vec<f64>);
@@ -349,9 +354,9 @@ We used in our `get_results` method the following call that performs the type co
 impl Model for UserModel {
     fn get_results(&self) -> Vec<f64> {
         println!("Rust calling Python to get the results");
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             self.model
-                .as_ref(py)
+                .bind(py)
                 .call_method("get_results", (), None)
                 .unwrap()
                 .extract()
@@ -360,21 +365,18 @@ impl Model for UserModel {
     }
 #     fn set_variables(&mut self, var: &Vec<f64>) {
 #         println!("Rust calling Python to set the variables");
-#         Python::with_gil(|py| {
-#             let values: Vec<f64> = var.clone();
-#             let list: PyObject = values.into_py(py);
-#             let py_model = self.model.as_ref(py);
-#             py_model
-#                 .call_method("set_variables", (list,), None)
+#         Python::attach(|py| {
+#             self.model.bind(py)
+#                 .call_method("set_variables", (PyList::new(py, var).unwrap(),), None)
 #                 .unwrap();
 #         })
 #     }
 #
 #     fn compute(&mut self) {
 #         println!("Rust calling Python to perform the computation");
-#         Python::with_gil(|py| {
+#         Python::attach(|py| {
 #             self.model
-#                 .as_ref(py)
+#                 .bind(py)
 #                 .call_method("compute", (), None)
 #                 .unwrap();
 #         })
@@ -384,9 +386,10 @@ impl Model for UserModel {
 
 Let's break it down in order to perform better error handling:
 
-```rust
+```rust,no_run
 # #![allow(dead_code)]
 # use pyo3::prelude::*;
+# use pyo3::types::PyList;
 #
 # pub trait Model {
 #   fn set_variables(&mut self, inputs: &Vec<f64>);
@@ -402,10 +405,10 @@ Let's break it down in order to perform better error handling:
 impl Model for UserModel {
     fn get_results(&self) -> Vec<f64> {
         println!("Get results from Rust calling Python");
-        Python::with_gil(|py| {
-            let py_result: &PyAny = self
+        Python::attach(|py| {
+            let py_result: Bound<'_, PyAny> = self
                 .model
-                .as_ref(py)
+                .bind(py)
                 .call_method("get_results", (), None)
                 .unwrap();
 
@@ -421,21 +424,18 @@ impl Model for UserModel {
     }
 #     fn set_variables(&mut self, var: &Vec<f64>) {
 #         println!("Rust calling Python to set the variables");
-#         Python::with_gil(|py| {
-#             let values: Vec<f64> = var.clone();
-#             let list: PyObject = values.into_py(py);
-#             let py_model = self.model.as_ref(py);
-#             py_model
-#                 .call_method("set_variables", (list,), None)
+#         Python::attach(|py| {
+#             let py_model = self.model.bind(py)
+#                 .call_method("set_variables", (PyList::new(py, var).unwrap(),), None)
 #                 .unwrap();
 #         })
 #     }
 #
 #     fn compute(&mut self) {
 #         println!("Rust calling Python to perform the computation");
-#         Python::with_gil(|py| {
+#         Python::attach(|py| {
 #             self.model
-#                 .as_ref(py)
+#                 .bind(py)
 #                 .call_method("compute", (), None)
 #                 .unwrap();
 #         })
@@ -463,9 +463,11 @@ Because of this, we can write a function wrapper that takes the `UserModel`--whi
 
 It is also required to make the struct public.
 
-```rust
+```rust,no_run
 # #![allow(dead_code)]
+# fn main() {}
 use pyo3::prelude::*;
+use pyo3::types::PyList;
 
 pub trait Model {
     fn set_variables(&mut self, var: &Vec<f64>);
@@ -488,13 +490,6 @@ pub struct UserModel {
     model: Py<PyAny>,
 }
 
-#[pymodule]
-fn trait_exposure(_py: Python<'_>, m: &PyModule) -> PyResult<()> {
-    m.add_class::<UserModel>()?;
-    m.add_function(wrap_pyfunction!(solve_wrapper, m)?)?;
-    Ok(())
-}
-
 #[pymethods]
 impl UserModel {
     #[new]
@@ -517,25 +512,29 @@ impl UserModel {
     }
 }
 
+#[pymodule]
+mod trait_exposure {
+    #[pymodule_export]
+    use super::{UserModel, solve_wrapper};
+}
+
 impl Model for UserModel {
     fn set_variables(&mut self, var: &Vec<f64>) {
         println!("Rust calling Python to set the variables");
-        Python::with_gil(|py| {
-            let values: Vec<f64> = var.clone();
-            let list: PyObject = values.into_py(py);
-            let py_model = self.model.as_ref(py);
-            py_model
-                .call_method("set_variables", (list,), None)
+        Python::attach(|py| {
+            self.model
+                .bind(py)
+                .call_method("set_variables", (PyList::new(py, var).unwrap(),), None)
                 .unwrap();
         })
     }
 
     fn get_results(&self) -> Vec<f64> {
         println!("Get results from Rust calling Python");
-        Python::with_gil(|py| {
-            let py_result: &PyAny = self
+        Python::attach(|py| {
+            let py_result: Bound<'_, PyAny> = self
                 .model
-                .as_ref(py)
+                .bind(py)
                 .call_method("get_results", (), None)
                 .unwrap();
 
@@ -552,9 +551,9 @@ impl Model for UserModel {
 
     fn compute(&mut self) {
         println!("Rust calling Python to perform the computation");
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             self.model
-                .as_ref(py)
+                .bind(py)
                 .call_method("compute", (), None)
                 .unwrap();
         })
diff --git a/guide/src/type-stub.md b/guide/src/type-stub.md
new file mode 100644
index 00000000000..8214984a6a7
--- /dev/null
+++ b/guide/src/type-stub.md
@@ -0,0 +1,87 @@
+# Type stub generation (`*.pyi` files) and introspection
+
+*This feature is still in active development. See [the related issue](https://github.com/PyO3/pyo3/issues/5137).*
+
+*For documentation on type stubs and how to use them with stable PyO3, refer to [this page](python-typing-hints.md)*
+
+PyO3 has a work in progress support to generate [type stub files](https://typing.python.org/en/latest/spec/distributing.html#stub-files).
+
+It works using:
+
+1. PyO3 macros (`#[pyclass]`) that generate constant JSON strings that are then included in the built binaries by rustc if the `experimental-inspect` feature is enabled.
+2. The `pyo3-introspection` crate that can parse the generated binaries, extract the JSON strings and build stub files from it.
+3. \[Not done yet\] Build tools like `maturin` exposing `pyo3-introspection` features in their CLI API.
+
+For example, the following Rust code
+
+```rust
+#[pymodule]
+pub mod example {
+    use pyo3::prelude::*;
+
+    #[pymodule_export]
+    pub const CONSTANT: &str = "FOO";
+
+    #[pyclass(eq)]
+    #[derive(Eq)]
+    struct Class {
+        value: usize
+    }
+
+    #[pymethods]
+    impl Class {
+        #[new]
+        fn new(value: usize) -> Self {
+            Self { value }
+        }
+
+        #[getter]
+        fn value(&self) -> usize {
+            self.value
+        }
+    }
+
+    #[pyfunction]
+    #[pyo3(signature = (arg: "list[int]") -> "list[int]")]
+    fn list_of_int_identity(arg: Bound<'_, PyAny>) -> Bound<'_, PyAny> {
+        arg
+    }
+}
+```
+
+will generate the following stub file:
+
+```python
+import typing
+
+CONSTANT: typing.Final = "FOO"
+
+class Class:
+    def __init__(self, value: int) -> None: ...
+
+    @property
+    def value(self) -> int: ...
+
+    def __eq__(self, other: Class) -> bool: ...
+    def __ne__(self, other: Class) -> bool: ...
+
+def list_of_int_identity(arg: list[int]) -> list[int]: ...
+```
+
+The only piece of added syntax is that the `#[pyo3(signature = ...)]` attribute
+can now contain type annotations like `#[pyo3(signature = (arg: "list[int]") -> "list[int]")]`
+(note the `""` around type annotations).
+This is useful when PyO3 is not able to derive proper type annotations by itself.
+
+## Constraints and limitations
+
+- The `experimental-inspect` feature is required to generate the introspection fragments.
+- Lots of features are not implemented yet.
+  See [the related issue](https://github.com/PyO3/pyo3/issues/5137) for a list of them.
+- Introspection only works with Python modules declared with an inline Rust module.
+  Modules declared using a function are not supported.
+- `FromPyObject::INPUT_TYPE` and `IntoPyObject::OUTPUT_TYPE` must be implemented for PyO3 to get the proper input/output type annotations to use.
+- Because `FromPyObject::INPUT_TYPE` and `IntoPyObject::OUTPUT_TYPE` are `const` it is not possible to build yet smart generic annotations for containers like `concat!("list[", T::OUTPUT_TYPE, "]")`.
+  See [this tracking issue](https://github.com/rust-lang/rust/issues/76560).
+- PyO3 is not able to introspect the content of `#[pymodule]` and `#[pymodule_init]` functions.
+  If they are present, the module is tagged as incomplete using a fake `def __getattr__(name: str) -> Incomplete: ...` function [following best practices](https://typing.python.org/en/latest/guides/writing_stubs.html#incomplete-stubs).
diff --git a/guide/src/types.md b/guide/src/types.md
index 882baddb33c..585a895f9e1 100644
--- a/guide/src/types.md
+++ b/guide/src/types.md
@@ -1,306 +1,371 @@
-# GIL lifetimes, mutability and Python object types
+# Python object types
 
-On first glance, PyO3 provides a huge number of different types that can be used
-to wrap or refer to Python objects.  This page delves into the details and gives
-an overview of their intended meaning, with examples when each type is best
-used.
+PyO3 offers two main sets of types to interact with Python objects.
+This section of the guide expands into detail about these types and how to choose which to use.
 
+The first set of types are the [smart pointers][smart-pointers] which all Python objects are wrapped in.
+These are `Py<T>`, `Bound<'py, T>`, and `Borrowed<'a, 'py, T>`.
+The [first section below](#pyo3s-smart-pointers) expands on each of these in detail and why there are three of them.
 
-## The Python GIL, mutability, and Rust types
+The second set of types are types which fill in the generic parameter `T` of the smart pointers.
+The most common is `PyAny`, which represents any Python object (similar to Python's `typing.Any`).
+There are also concrete types for many Python built-in types, such as `PyList`, `PyDict`, and `PyTuple`.
+User defined `#[pyclass]` types also fit this category.
+The [second section below](#concrete-python-types) expands on how to use these types.
 
-Since Python has no concept of ownership, and works solely with boxed objects,
-any Python object can be referenced any number of times, and mutation is allowed
-from any reference.
+## PyO3's smart pointers
 
-The situation is helped a little by the Global Interpreter Lock (GIL), which
-ensures that only one thread can use the Python interpreter and its API at the
-same time, while non-Python operations (system calls and extension code) can
-unlock the GIL.  (See [the section on parallelism](parallelism.md) for how to do
-that in PyO3.)
+PyO3's API offers three generic smart pointers: `Py<T>`, `Bound<'py, T>` and `Borrowed<'a, 'py, T>`.
+For each of these the type parameter `T` will be filled by a [concrete Python type](#concrete-python-types).
+For example, a Python list object can be represented by `Py<PyList>`, `Bound<'py, PyList>`, and `Borrowed<'a, 'py, PyList>`.
 
-In PyO3, holding the GIL is modeled by acquiring a token of the type
-`Python<'py>`, which serves three purposes:
+These smart pointers behave differently due to their lifetime parameters. `Py<T>` has no lifetime parameters, `Bound<'py, T>` has [the `'py` lifetime](./python-from-rust.md#the-py-lifetime) as a parameter, and `Borrowed<'a, 'py, T>` has the `'py` lifetime plus an additional lifetime `'a` to denote the lifetime it is borrowing data for. (You can read more about these lifetimes in the subsections below).
 
-* It provides some global API for the Python interpreter, such as
-  [`eval`][eval].
-* It can be passed to functions that require a proof of holding the GIL,
-  such as [`Py::clone_ref`][clone_ref].
-* Its lifetime can be used to create Rust references that implicitly guarantee
-  holding the GIL, such as [`&'py PyAny`][PyAny].
+Python objects are reference counted, like [`std::sync::Arc`](https://doc.rust-lang.org/stable/std/sync/struct.Arc.html).
+A major reason for these smart pointers is to bring Python's reference counting to a Rust API.
 
-The latter two points are the reason why some APIs in PyO3 require the `py:
-Python` argument, while others don't.
+The recommendation of when to use each of these smart pointers is as follows:
 
-The PyO3 API for Python objects is written such that instead of requiring a
-mutable Rust reference for mutating operations such as
-[`PyList::append`][PyList_append], a shared reference (which, in turn, can only
-be created through `Python<'_>` with a GIL lifetime) is sufficient.
+- Use `Bound<'py, T>` for as much as possible, as it offers the most efficient and complete API.
+- Use `Py<T>` mostly just for storage inside Rust `struct`s which do not want to or can't add a lifetime parameter for `Bound<'py, T>`.
+- `Borrowed<'a, 'py, T>` is almost never used.
+  It is occasionally present at the boundary between Rust and the Python interpreter, for example when borrowing data from Python tuples (which is safe because they are immutable).
 
-However, Rust structs wrapped as Python objects (called `pyclass` types) usually
-*do* need `&mut` access.  Due to the GIL, PyO3 *can* guarantee thread-safe access
-to them, but it cannot statically guarantee uniqueness of `&mut` references once
-an object's ownership has been passed to the Python interpreter, ensuring
-references is done at runtime using `PyCell`, a scheme very similar to
-`std::cell::RefCell`.
+The sections below also explain these smart pointers in a little more detail.
 
-### Accessing the Python GIL
+### `Py<T>`
 
-To get hold of a `Python<'py>` token to prove the GIL is held, consult [PyO3's documentation][obtaining-py].
+[`Py<T>`][Py] is the foundational smart pointer in PyO3's API.
+The type parameter `T` denotes the type of the Python object.
+Very frequently this is `PyAny`, meaning any Python object.
 
-## Object types
+Because `Py<T>` is not bound to [the `'py` lifetime](./python-from-rust.md#the-py-lifetime), it is the type to use when storing a Python object inside a Rust `struct` or `enum` which do not want to have a lifetime parameter.
+In particular, [`#[pyclass]`][pyclass] types are not permitted to have a lifetime, so `Py<T>` is the correct type to store Python objects inside them.
 
-### [`PyAny`][PyAny]
+The lack of binding to the `'py` lifetime also carries drawbacks:
 
-**Represents:** a Python object of unspecified type, restricted to a GIL
-lifetime.  Currently, `PyAny` can only ever occur as a reference, `&PyAny`.
+- Almost all methods on `Py<T>` require a `Python<'py>` token as the first argument
+- Other functionality, such as [`Drop`][Drop], needs to check at runtime for attachment to the Python interpreter, at a small performance cost
 
-**Used:** Whenever you want to refer to some Python object and will have the
-GIL for the whole duration you need to access that object. For example,
-intermediate values and arguments to `pyfunction`s or `pymethod`s implemented
-in Rust where any type is allowed.
+Because of the drawbacks `Bound<'py, T>` is preferred for many of PyO3's APIs.
+In particular, `Bound<'py, T>` is better for function arguments.
 
-Many general methods for interacting with Python objects are on the `PyAny` struct,
-such as `getattr`, `setattr`, and `.call`.
+To convert a `Py<T>` into a `Bound<'py, T>`, the `Py::bind` and `Py::into_bound` methods are available. `Bound<'py, T>` can be converted back into `Py<T>` using [`Bound::unbind`].
 
-**Conversions:**
+### `Bound<'py, T>`
 
-For a `&PyAny` object reference `any` where the underlying object is a Python-native type such as
-a list:
+[`Bound<'py, T>`][Bound] is the counterpart to `Py<T>` which is also bound to the `'py` lifetime.
+It can be thought of as equivalent to the Rust tuple `(Python<'py>, Py<T>)`.
 
-```rust
-# use pyo3::prelude::*;
-# use pyo3::types::PyList;
-# Python::with_gil(|py| -> PyResult<()> {
-#[allow(deprecated)]  // PyList::empty is part of the deprecated "GIL Refs" API.
-let obj: &PyAny = PyList::empty(py);
+By having the binding to the `'py` lifetime, `Bound<'py, T>` can offer the complete PyO3 API at maximum efficiency.
+This means that `Bound<'py, T>` should usually be used whenever carrying this lifetime is acceptable, and `Py<T>` otherwise.
 
-// To &PyList with PyAny::downcast
-let _: &PyList = obj.downcast()?;
+`Bound<'py, T>` engages in Python reference counting.
+This means that `Bound<'py, T>` owns a Python object.
+Rust code which just wants to borrow a Python object should use a shared reference `&Bound<'py, T>`.
+Just like `std::sync::Arc`, using `.clone()` and `drop()` will cheaply increment and decrement the reference count of the object (just in this case, the reference counting is implemented by the Python interpreter itself).
 
-// To Py<PyAny> (aka PyObject) with .into()
-let _: Py<PyAny> = obj.into();
+To give an example of how `Bound<'py, T>` is PyO3's primary API type, consider the following Python code:
 
-// To Py<PyList> with PyAny::extract
-let _: Py<PyList> = obj.extract()?;
-# Ok(())
-# }).unwrap();
+```python
+def example():
+    x = list()   # create a Python list
+    x.append(1)  # append the integer 1 to it
+    y = x        # create a second reference to the list
+    del x        # delete the original reference
 ```
 
-For a `&PyAny` object reference `any` where the underlying object is a `#[pyclass]`:
+Using PyO3's API, and in particular `Bound<'py, PyList>`, this code translates into the following Rust code:
 
 ```rust
-# use pyo3::prelude::*;
-# #[pyclass] #[derive(Clone)] struct MyClass { }
-# Python::with_gil(|py| -> PyResult<()> {
-let obj: &PyAny = Py::new(py, MyClass {})?.into_ref(py);
-
-// To &PyCell<MyClass> with PyAny::downcast
-let _: &PyCell<MyClass> = obj.downcast()?;
+use pyo3::prelude::*;
+use pyo3::types::PyList;
+
+fn example<'py>(py: Python<'py>) -> PyResult<()> {
+    let x: Bound<'py, PyList> = PyList::empty(py);
+    x.append(1)?;
+    let y: Bound<'py, PyList> = x.clone(); // y is a new reference to the same list
+    drop(x); // release the original reference x
+    Ok(())
+}
+# Python::attach(example).unwrap();
+```
 
-// To Py<PyAny> (aka PyObject) with .into()
-let _: Py<PyAny> = obj.into();
+Or, without the type annotations:
 
-// To Py<MyClass> with PyAny::extract
-let _: Py<MyClass> = obj.extract()?;
+```rust
+use pyo3::prelude::*;
+use pyo3::types::PyList;
+
+fn example(py: Python<'_>) -> PyResult<()> {
+    let x = PyList::empty(py);
+    x.append(1)?;
+    let y = x.clone();
+    drop(x);
+    Ok(())
+}
+# Python::attach(example).unwrap();
+```
 
-// To MyClass with PyAny::extract, if MyClass: Clone
-let _: MyClass = obj.extract()?;
+#### Function argument lifetimes
 
-// To PyRef<'_, MyClass> or PyRefMut<'_, MyClass> with PyAny::extract
-let _: PyRef<'_, MyClass> = obj.extract()?;
-let _: PyRefMut<'_, MyClass> = obj.extract()?;
-# Ok(())
-# }).unwrap();
-```
+Because the `'py` lifetime often appears in many function arguments as part of the `Bound<'py, T>` smart pointer, the Rust compiler will often require annotations of input and output lifetimes.
+This occurs when the function output has at least one lifetime, and there is more than one lifetime present on the inputs.
 
-### `PyTuple`, `PyDict`, and many more
+To demonstrate, consider this function which takes accepts Python objects and applies the [Python `+` operation][PyAnyMethods::add] to them:
 
-**Represents:** a native Python object of known type, restricted to a GIL
-lifetime just like `PyAny`.
+```rust,compile_fail
+# use pyo3::prelude::*;
+fn add(left: &'_ Bound<'_, PyAny>, right: &'_ Bound<'_, PyAny>) -> PyResult<Bound<'_, PyAny>> {
+    left.add(right)
+}
+```
 
-**Used:** Whenever you want to operate with native Python types while holding
-the GIL.  Like `PyAny`, this is the most convenient form to use for function
-arguments and intermediate values.
+Because the Python `+` operation might raise an exception, this function returns `PyResult<Bound<'_, PyAny>>`.
+It doesn't need ownership of the inputs, so it takes `&Bound<'_, PyAny>` shared references.
+To demonstrate the point, all lifetimes have used the wildcard `'_` to allow the Rust compiler to attempt to infer them.
+Because there are four input lifetimes (two lifetimes of the shared references, and two `'py` lifetimes unnamed inside the `Bound<'_, PyAny>` pointers), the compiler cannot reason about which must be connected to the output.
 
-These types all implement `Deref<Target = PyAny>`, so they all expose the same
-methods which can be found on `PyAny`.
+The correct way to solve this is to add the `'py` lifetime as a parameter for the function, and name all the `'py` lifetimes inside the `Bound<'py, PyAny>` smart pointers.
+For the shared references, it's also fine to reduce `&'_` to just `&`.
+The working end result is below:
 
-To see all Python types exposed by `PyO3` you should consult the
-[`pyo3::types`][pyo3::types] module.
+```rust
+# use pyo3::prelude::*;
+fn add<'py>(
+    left: &Bound<'py, PyAny>,
+    right: &Bound<'py, PyAny>,
+) -> PyResult<Bound<'py, PyAny>> {
+    left.add(right)
+}
+# Python::attach(|py| {
+#     let s = pyo3::types::PyString::new(py, "s");
+#     assert!(add(&s, &s).unwrap().eq("ss").unwrap());
+# })
+```
 
-**Conversions:**
+If naming the `'py` lifetime adds unwanted complexity to the function signature, it is also acceptable to return `Py<PyAny>`, which has no lifetime.
+The cost is instead paid by a slight increase in implementation complexity, as seen by the introduction of a call to [`Bound::unbind`]:
 
 ```rust
 # use pyo3::prelude::*;
-# use pyo3::types::PyList;
-# Python::with_gil(|py| -> PyResult<()> {
-#[allow(deprecated)]  // PyList::empty is part of the deprecated "GIL Refs" API.
-let list = PyList::empty(py);
+fn add(left: &Bound<'_, PyAny>, right: &Bound<'_, PyAny>) -> PyResult<Py<PyAny>> {
+    let output: Bound<'_, PyAny> = left.add(right)?;
+    Ok(output.unbind())
+}
+# Python::attach(|py| {
+#     let s = pyo3::types::PyString::new(py, "s");
+#     assert!(add(&s, &s).unwrap().bind(py).eq("ss").unwrap());
+# })
+```
 
-// Use methods from PyAny on all Python types with Deref implementation
-let _ = list.repr()?;
+### `Borrowed<'a, 'py, T>`
 
-// To &PyAny automatically with Deref implementation
-let _: &PyAny = list;
+[`Borrowed<'a, 'py, T>`][Borrowed] is an advanced type used just occasionally at the edge of interaction with the Python interpreter.
+It can be thought of as analogous to the shared reference `&'a Bound<'py, T>`.
+The difference is that `Borrowed<'a, 'py, T>` is just a smart pointer rather than a reference-to-a-smart-pointer, which is a helpful reduction in indirection in specific interactions with the Python interpreter.
 
-// To &PyAny explicitly with .as_ref()
-let _: &PyAny = list.as_ref();
+`Borrowed<'a, 'py, T>` dereferences to `Bound<'py, T>`, so all methods on `Bound<'py, T>` are available on `Borrowed<'a, 'py, T>`.
 
-// To Py<T> with .into() or Py::from()
-let _: Py<PyList> = list.into();
+An example where `Borrowed<'a, 'py, T>` is used is in [`PyTupleMethods::get_borrowed_item`]({{#PYO3_DOCS_URL}}/pyo3/types/trait.PyTupleMethods.html#tymethod.get_item):
 
-// To PyObject with .into() or .to_object(py)
-let _: PyObject = list.into();
+```rust
+use pyo3::prelude::*;
+use pyo3::types::PyTuple;
+
+# fn example<'py>(py: Python<'py>) -> PyResult<()> {
+// Create a new tuple with the elements (0, 1, 2)
+let t = PyTuple::new(py, [0, 1, 2])?;
+for i in 0..=2 {
+    let entry: Borrowed<'_, 'py, PyAny> = t.get_borrowed_item(i)?;
+    // `PyAnyMethods::extract` is available on `Borrowed`
+    // via the dereference to `Bound`
+    let value: usize = entry.extract()?;
+    assert_eq!(i, value);
+}
 # Ok(())
-# }).unwrap();
+# }
+# Python::attach(example).unwrap();
 ```
 
-### `Py<T>` and `PyObject`
+### Casting between smart pointer types
 
-**Represents:** a GIL-independent reference to a Python object. This can be a Python native type
-(like `PyTuple`), or a `pyclass` type implemented in Rust. The most commonly-used variant,
-`Py<PyAny>`, is also known as `PyObject`.
+To convert between `Py<T>` and `Bound<'py, T>` use the `bind()` / `into_bound()` methods.
+Use the `as_unbound()` / `unbind()` methods to go back from `Bound<'py, T>` to `Py<T>`.
 
-**Used:** Whenever you want to carry around references to a Python object without caring about a
-GIL lifetime.  For example, storing Python object references in a Rust struct that outlives the
-Python-Rust FFI boundary, or returning objects from functions implemented in Rust back to Python.
+```rust,ignore
+let obj: Py<PyAny> = ...;
+let bound: &Bound<'py, PyAny> = obj.bind(py);
+let bound: Bound<'py, PyAny> = obj.into_bound(py);
 
-Can be cloned using Python reference counts with `.clone()`.
+let obj: &Py<PyAny> = bound.as_unbound();
+let obj: Py<PyAny> = bound.unbind();
+```
 
-**Conversions:**
+To convert between `Bound<'py, T>` and `Borrowed<'a, 'py, T>` use the `as_borrowed()` method. `Borrowed<'a, 'py, T>` has a deref coercion to `Bound<'py, T>`.
+Use the `to_owned()` method to increment the Python reference count and to create a new `Bound<'py, T>` from the `Borrowed<'a, 'py, T>`.
 
-For a `Py<PyList>`, the conversions are as below:
+```rust,ignore
+let bound: Bound<'py, PyAny> = ...;
+let borrowed: Borrowed<'_, 'py, PyAny> = bound.as_borrowed();
 
-```rust
-# use pyo3::prelude::*;
-# use pyo3::types::PyList;
-# Python::with_gil(|py| {
-let list: Py<PyList> = PyList::empty_bound(py).unbind();
+// deref coercion
+let bound: &Bound<'py, PyAny> = &borrowed;
 
-// To &PyList with Py::as_ref() (borrows from the Py)
-let _: &PyList = list.as_ref(py);
+// create a new Bound by increase the Python reference count
+let bound: Bound<'py, PyAny> = borrowed.to_owned();
+```
 
-# let list_clone = list.clone(); // Because `.into_ref()` will consume `list`.
-// To &PyList with Py::into_ref() (moves the pointer into PyO3's object storage)
-let _: &PyList = list.into_ref(py);
+To convert between `Py<T>` and `Borrowed<'a, 'py, T>` use the `bind_borrowed()` method.
+Use either `as_unbound()` or `.to_owned().unbind()` to go back to `Py<T>` from `Borrowed<'a, 'py, T>`, via `Bound<'py, T>`.
 
-# let list = list_clone;
-// To Py<PyAny> (aka PyObject) with .into()
-let _: Py<PyAny> = list.into();
-# })
-```
+```rust,ignore
+let obj: Py<PyAny> = ...;
+let borrowed: Borrowed<'_, 'py, PyAny> = bound.as_borrowed();
 
-For a `#[pyclass] struct MyClass`, the conversions for `Py<MyClass>` are below:
+// via deref coercion to Bound and then using Bound::as_unbound
+let obj: &Py<PyAny> = borrowed.as_unbound();
 
-```rust
-# use pyo3::prelude::*;
-# Python::with_gil(|py| {
-# #[pyclass] struct MyClass { }
-# Python::with_gil(|py| -> PyResult<()> {
-let my_class: Py<MyClass> = Py::new(py, MyClass { })?;
+// via a new Bound by increasing the Python reference count, and unbind it
+let obj: Py<PyAny> = borrowed.to_owned().unbind().
+```
 
-// To &PyCell<MyClass> with Py::as_ref() (borrows from the Py)
-let _: &PyCell<MyClass> = my_class.as_ref(py);
+## Concrete Python types
 
-# let my_class_clone = my_class.clone(); // Because `.into_ref()` will consume `my_class`.
-// To &PyCell<MyClass> with Py::into_ref() (moves the pointer into PyO3's object storage)
-let _: &PyCell<MyClass> = my_class.into_ref(py);
+In all of `Py<T>`, `Bound<'py, T>`, and `Borrowed<'a, 'py, T>`, the type parameter `T` denotes the type of the Python object referred to by the smart pointer.
 
-# let my_class = my_class_clone.clone();
-// To Py<PyAny> (aka PyObject) with .into_py(py)
-let _: Py<PyAny> = my_class.into_py(py);
+This parameter `T` can be filled by:
 
-# let my_class = my_class_clone;
-// To PyRef<'_, MyClass> with Py::borrow or Py::try_borrow
-let _: PyRef<'_, MyClass> = my_class.try_borrow(py)?;
+- [`PyAny`][PyAny], which represents any Python object,
+- Native Python types such as `PyList`, `PyTuple`, and `PyDict`, and
+- [`#[pyclass]`][pyclass] types defined from Rust
 
-// To PyRefMut<'_, MyClass> with Py::borrow_mut or Py::try_borrow_mut
-let _: PyRefMut<'_, MyClass> = my_class.try_borrow_mut(py)?;
-# Ok(())
-# }).unwrap();
-# });
-```
+The following subsections covers some further detail about how to work with these types:
+
+- the APIs that are available for these concrete types,
+- how to cast `Bound<'py, T>` to a specific concrete type, and
+- how to get Rust data out of a `Bound<'py, T>`.
 
-### `PyCell<SomeType>`
+### Using APIs for concrete Python types
 
-**Represents:** a reference to a Rust object (instance of `PyClass`) which is
-wrapped in a Python object.  The cell part is an analog to stdlib's
-[`RefCell`][RefCell] to allow access to `&mut` references.
+Each concrete Python type such as `PyAny`, `PyTuple` and `PyDict` exposes its API on the corresponding bound smart pointer `Bound<'py, PyAny>`, `Bound<'py, PyTuple>` and `Bound<'py, PyDict>`.
 
-**Used:** for accessing pure-Rust API of the instance (members and functions
-taking `&SomeType` or `&mut SomeType`) while maintaining the aliasing rules of
-Rust references.
+Each type's API is exposed as a trait: [`PyAnyMethods`], [`PyTupleMethods`], [`PyDictMethods`], and so on for all concrete types.
+Using traits rather than associated methods on the `Bound` smart pointer is done for a couple of reasons:
 
-Like PyO3's Python native types, `PyCell<T>` implements `Deref<Target = PyAny>`,
-so it also exposes all of the methods on `PyAny`.
+- Clarity of documentation: each trait gets its own documentation page in the PyO3 API docs.
+  If all methods were on the `Bound` smart pointer directly, the vast majority of PyO3's API would be on a single, extremely long, documentation page.
+- Consistency: downstream code implementing Rust APIs for existing Python types can also follow this pattern of using a trait.
+  Downstream code would not be allowed to add new associated methods directly on the `Bound` type.
+- Future design: it is hoped that a future Rust with [arbitrary self types](https://github.com/rust-lang/rust/issues/44874) will remove the need for these traits in favour of placing the methods directly on `PyAny`, `PyTuple`, `PyDict`, and so on.
 
-**Conversions:**
+These traits are all included in the `pyo3::prelude` module, so with the glob import `use pyo3::prelude::*` the full PyO3 API is made available to downstream code.
 
-`PyCell<T>` can be used to access `&T` and `&mut T` via `PyRef<T>` and `PyRefMut<T>` respectively.
+The following function accesses the first item in the input Python list, using the `.get_item()` method from the `PyListMethods` trait:
 
 ```rust
-# use pyo3::prelude::*;
-# #[pyclass] struct MyClass { }
-# Python::with_gil(|py| -> PyResult<()> {
-let cell: &PyCell<MyClass> = PyCell::new(py, MyClass {})?;
-
-// To PyRef<T> with .borrow() or .try_borrow()
-let py_ref: PyRef<'_, MyClass> = cell.try_borrow()?;
-let _: &MyClass = &*py_ref;
-# drop(py_ref);
-
-// To PyRefMut<T> with .borrow_mut() or .try_borrow_mut()
-let mut py_ref_mut: PyRefMut<'_, MyClass> = cell.try_borrow_mut()?;
-let _: &mut MyClass = &mut *py_ref_mut;
-# Ok(())
-# }).unwrap();
+use pyo3::prelude::*;
+use pyo3::types::PyList;
+
+fn get_first_item<'py>(list: &Bound<'py, PyList>) -> PyResult<Bound<'py, PyAny>> {
+    list.get_item(0)
+}
+# Python::attach(|py| {
+#     let l = PyList::new(py, ["hello world"]).unwrap();
+#     assert!(get_first_item(&l).unwrap().eq("hello world").unwrap());
+# })
 ```
 
-`PyCell<T>` can also be accessed like a Python-native type.
+### Casting between Python object types
+
+To cast `Bound<'py, T>` smart pointers to some other type, use the [`.cast()`][Bound::cast] family of functions.
+This converts `&Bound<'py, T>` to a different `&Bound<'py, U>`, without transferring ownership.
+There is also [`.cast_into()`][Bound::cast_into] to convert `Bound<'py, T>` to `Bound<'py, U>` with transfer of ownership.
+These methods are available for all types `T` which implement the [`PyTypeCheck`] trait.
+
+Casting to `Bound<'py, PyAny>` can be done with `.as_any()` or `.into_any()`.
+
+For example, the following snippet shows how to cast `Bound<'py, PyAny>` to `Bound<'py, PyTuple>`:
 
 ```rust
 # use pyo3::prelude::*;
-# #[pyclass] struct MyClass { }
-# Python::with_gil(|py| -> PyResult<()> {
-let cell: &PyCell<MyClass> = PyCell::new(py, MyClass {})?;
+# use pyo3::types::PyTuple;
+# fn example<'py>(py: Python<'py>) -> PyResult<()> {
+// create a new Python `tuple`, and use `.into_any()` to erase the type
+let obj: Bound<'py, PyAny> = PyTuple::empty(py).into_any();
 
-// Use methods from PyAny on PyCell<T> with Deref implementation
-let _ = cell.repr()?;
+// use `.cast()` to cast to `PyTuple` without transferring ownership
+let _: &Bound<'py, PyTuple> = obj.cast()?;
 
-// To &PyAny automatically with Deref implementation
-let _: &PyAny = cell;
-
-// To &PyAny explicitly with .as_ref()
-let _: &PyAny = cell.as_ref();
+// use `.cast_into()` to cast to `PyTuple` with transfer of ownership
+let _: Bound<'py, PyTuple> = obj.cast_into()?;
 # Ok(())
-# }).unwrap();
+# }
+# Python::attach(example).unwrap()
 ```
 
-### `PyRef<SomeType>` and `PyRefMut<SomeType>`
+Custom [`#[pyclass]`][pyclass] types implement [`PyTypeCheck`], so `.cast()` also works for these types.
+The snippet below is the same as the snippet above casting instead to a custom type `MyClass`:
 
-**Represents:** reference wrapper types employed by `PyCell` to keep track of
-borrows, analog to `Ref` and `RefMut` used by `RefCell`.
+```rust
+use pyo3::prelude::*;
 
-**Used:** while borrowing a `PyCell`.  They can also be used with `.extract()`
-on types like `Py<T>` and `PyAny` to get a reference quickly.
+#[pyclass]
+struct MyClass {}
 
+# fn example<'py>(py: Python<'py>) -> PyResult<()> {
+// create a new Python `tuple`, and use `.into_any()` to erase the type
+let obj: Bound<'py, PyAny> = Bound::new(py, MyClass {})?.into_any();
 
-## Related traits and types
+// use `.cast()` to cast to `MyClass` without transferring ownership
+let _: &Bound<'py, MyClass> = obj.cast()?;
 
-### `PyClass`
+// use `.cast_into()` to cast to `MyClass` with transfer of ownership
+let _: Bound<'py, MyClass> = obj.cast_into()?;
+# Ok(())
+# }
+# Python::attach(example).unwrap()
+```
 
-This trait marks structs defined in Rust that are also usable as Python classes,
-usually defined using the `#[pyclass]` macro.
+### Extracting Rust data from Python objects
 
-### `PyNativeType`
+To extract Rust data from Python objects, use [`.extract()`][PyAnyMethods::extract] instead of `.cast()`.
+This method is available for all types which implement the [`FromPyObject`] trait.
 
-This trait marks structs that mirror native Python types, such as `PyList`.
+For example, the following snippet extracts a Rust tuple of integers from a Python tuple:
 
+```rust
+# use pyo3::prelude::*;
+# use pyo3::types::PyTuple;
+# fn example<'py>(py: Python<'py>) -> PyResult<()> {
+// create a new Python `tuple`, and use `.into_any()` to erase the type
+let obj: Bound<'py, PyAny> = PyTuple::new(py, [1, 2, 3])?.into_any();
+
+// extracting the Python `tuple` to a rust `(i32, i32, i32)` tuple
+let (x, y, z) = obj.extract::<(i32, i32, i32)>()?;
+assert_eq!((x, y, z), (1, 2, 3));
+# Ok(())
+# }
+# Python::attach(example).unwrap()
+```
 
-[eval]: {{#PYO3_DOCS_URL}}/pyo3/marker/struct.Python.html#method.eval
-[clone_ref]: {{#PYO3_DOCS_URL}}/pyo3/struct.Py.html#method.clone_ref
-[pyo3::types]: {{#PYO3_DOCS_URL}}/pyo3/types/index.html
+To avoid copying data, [`#[pyclass]`][pyclass] types can directly reference Rust data stored within the Python objects without needing to `.extract()`.
+See the [corresponding documentation in the class section of the guide](./class.md#bound-and-interior-mutability) for more detail.
+
+[Bound]: {{#PYO3_DOCS_URL}}/pyo3/struct.Bound.html
+[`Bound::unbind`]: {{#PYO3_DOCS_URL}}/pyo3/struct.Bound.html#method.unbind
+[Py]: {{#PYO3_DOCS_URL}}/pyo3/struct.Py.html
+[PyAnyMethods::add]: {{#PYO3_DOCS_URL}}/pyo3/types/trait.PyAnyMethods.html#tymethod.add
+[PyAnyMethods::extract]: {{#PYO3_DOCS_URL}}/pyo3/types/trait.PyAnyMethods.html#tymethod.extract
+[Bound::cast]: {{#PYO3_DOCS_URL}}/pyo3/struct.Bound.html#method.cast
+[Bound::cast_into]: {{#PYO3_DOCS_URL}}/pyo3/struct.Bound.html#method.cast_into
+[`PyTypeCheck`]: {{#PYO3_DOCS_URL}}/pyo3/type_object/trait.PyTypeCheck.html
+[`PyAnyMethods`]: {{#PYO3_DOCS_URL}}/pyo3/types/trait.PyAnyMethods.html
+[`PyDictMethods`]: {{#PYO3_DOCS_URL}}/pyo3/types/trait.PyDictMethods.html
+[`PyTupleMethods`]: {{#PYO3_DOCS_URL}}/pyo3/types/trait.PyTupleMethods.html
+[pyclass]: class.md
+[Borrowed]: {{#PYO3_DOCS_URL}}/pyo3/struct.Borrowed.html
+[Drop]: https://doc.rust-lang.org/std/ops/trait.Drop.html
 [PyAny]: {{#PYO3_DOCS_URL}}/pyo3/types/struct.PyAny.html
-[PyList_append]: {{#PYO3_DOCS_URL}}/pyo3/types/struct.PyList.html#method.append
-[RefCell]: https://doc.rust-lang.org/std/cell/struct.RefCell.html
-[obtaining-py]: {{#PYO3_DOCS_URL}}/pyo3/marker/struct.Python.html#obtaining-a-python-token
+[smart-pointers]: https://doc.rust-lang.org/book/ch15-00-smart-pointers.html
+[`FromPyObject`]: {{#PYO3_DOCS_URL}}/pyo3/conversion/trait.FromPyObject.html
diff --git a/guide/theme/tabs.css b/guide/theme/tabs.css
new file mode 100644
index 00000000000..8712b859c0b
--- /dev/null
+++ b/guide/theme/tabs.css
@@ -0,0 +1,25 @@
+.mdbook-tabs {
+    display: flex;
+}
+
+.mdbook-tab {
+    background-color: var(--table-alternate-bg);
+    padding: 0.5rem 1rem;
+    cursor: pointer;
+    border: none;
+    font-size: 1.6rem;
+    line-height: 1.45em;
+}
+
+.mdbook-tab.active {
+    background-color: var(--table-header-bg);
+    font-weight: bold;
+}
+
+.mdbook-tab-content {
+    padding: 1rem 0rem;
+}
+
+.mdbook-tab-content table {
+    margin: unset;
+}
diff --git a/guide/theme/tabs.js b/guide/theme/tabs.js
new file mode 100644
index 00000000000..8ba5e878c39
--- /dev/null
+++ b/guide/theme/tabs.js
@@ -0,0 +1,75 @@
+/**
+ * Change active tab of tabs.
+ *
+ * @param {Element} container
+ * @param {string} name
+ */
+const changeTab = (container, name) => {
+    for (const child of container.children) {
+        if (!(child instanceof HTMLElement)) {
+            continue;
+        }
+
+        if (child.classList.contains('mdbook-tabs')) {
+            for (const tab of child.children) {
+                if (!(tab instanceof HTMLElement)) {
+                    continue;
+                }
+
+                if (tab.dataset.tabname === name) {
+                    tab.classList.add('active');
+                } else {
+                    tab.classList.remove('active');
+                }
+            }
+        } else if (child.classList.contains('mdbook-tab-content')) {
+            if (child.dataset.tabname === name) {
+                child.classList.remove('hidden');
+            } else {
+                child.classList.add('hidden');
+            }
+        }
+    }
+};
+
+document.addEventListener('DOMContentLoaded', () => {
+    const tabs = document.querySelectorAll('.mdbook-tab');
+    for (const tab of tabs) {
+        tab.addEventListener('click', () => {
+            if (!(tab instanceof HTMLElement)) {
+                return;
+            }
+
+            if (!tab.parentElement || !tab.parentElement.parentElement) {
+                return;
+            }
+
+            const container = tab.parentElement.parentElement;
+            const name = tab.dataset.tabname;
+            const global = container.dataset.tabglobal;
+
+            changeTab(container, name);
+
+            if (global) {
+                localStorage.setItem(`mdbook-tabs-${global}`, name);
+
+                const globalContainers = document.querySelectorAll(
+                    `.mdbook-tabs-container[data-tabglobal="${global}"]`
+                );
+                for (const globalContainer of globalContainers) {
+                    changeTab(globalContainer, name);
+                }
+            }
+        });
+    }
+
+    const containers = document.querySelectorAll('.mdbook-tabs-container[data-tabglobal]');
+    for (const container of containers) {
+        const global = container.dataset.tabglobal;
+
+        const name = localStorage.getItem(`mdbook-tabs-${global}`);
+        if (name && document.querySelector(`.mdbook-tab[data-tabname=${name}]`)) {
+            changeTab(container, name);
+        }
+    }
+});
diff --git a/newsfragments/3514.added.md b/newsfragments/3514.added.md
deleted file mode 100644
index 7fbf662b2ec..00000000000
--- a/newsfragments/3514.added.md
+++ /dev/null
@@ -1 +0,0 @@
-Add `PyMemoryView` type.
diff --git a/newsfragments/3532.changed.md b/newsfragments/3532.changed.md
deleted file mode 100644
index b65f240931e..00000000000
--- a/newsfragments/3532.changed.md
+++ /dev/null
@@ -1 +0,0 @@
-- `PyDict::from_sequence` now takes a single argument of type `&PyAny` (previously took two arguments `Python` and `PyObject`).
diff --git a/newsfragments/3540.added.md b/newsfragments/3540.added.md
deleted file mode 100644
index 2b113193bef..00000000000
--- a/newsfragments/3540.added.md
+++ /dev/null
@@ -1 +0,0 @@
-Support `async fn` in macros with coroutine implementation
\ No newline at end of file
diff --git a/newsfragments/3577.added.md b/newsfragments/3577.added.md
deleted file mode 100644
index 632274984ec..00000000000
--- a/newsfragments/3577.added.md
+++ /dev/null
@@ -1 +0,0 @@
-Implement `PyTypeInfo` for `PyEllipsis`, `PyNone` and `PyNotImplemented`.
diff --git a/newsfragments/3577.changed.md b/newsfragments/3577.changed.md
deleted file mode 100644
index a7e6629d6a5..00000000000
--- a/newsfragments/3577.changed.md
+++ /dev/null
@@ -1 +0,0 @@
-Deprecate `Py::is_ellipsis` and `PyAny::is_ellipsis` in favour of `any.is(py.Ellipsis())`.
diff --git a/newsfragments/3582.added.md b/newsfragments/3582.added.md
deleted file mode 100644
index 59659a8819d..00000000000
--- a/newsfragments/3582.added.md
+++ /dev/null
@@ -1 +0,0 @@
-Support `#[pyclass]` on enums that have non-unit variants.
diff --git a/newsfragments/3588.added.md b/newsfragments/3588.added.md
deleted file mode 100644
index acddf296a6f..00000000000
--- a/newsfragments/3588.added.md
+++ /dev/null
@@ -1 +0,0 @@
-Add `__name__`/`__qualname__` attributes to `Coroutine`
\ No newline at end of file
diff --git a/newsfragments/3599.added.md b/newsfragments/3599.added.md
deleted file mode 100644
index 36078fbcdb6..00000000000
--- a/newsfragments/3599.added.md
+++ /dev/null
@@ -1 +0,0 @@
-Add `coroutine::CancelHandle` to catch coroutine cancellation
\ No newline at end of file
diff --git a/newsfragments/3600.changed.md b/newsfragments/3600.changed.md
deleted file mode 100644
index c8701ef4b25..00000000000
--- a/newsfragments/3600.changed.md
+++ /dev/null
@@ -1 +0,0 @@
-Split some `PyTypeInfo` functionality into new traits `HasPyGilRef` and `PyTypeCheck`.
diff --git a/newsfragments/3601.changed.md b/newsfragments/3601.changed.md
deleted file mode 100644
index 413765ecad5..00000000000
--- a/newsfragments/3601.changed.md
+++ /dev/null
@@ -1 +0,0 @@
-Deprecate `PyTryFrom` and `PyTryInto` traits in favor of `any.downcast()` via the `PyTypeCheck` and `PyTypeInfo` traits.
diff --git a/newsfragments/3603.removed.md b/newsfragments/3603.removed.md
deleted file mode 100644
index e8f5004e3b9..00000000000
--- a/newsfragments/3603.removed.md
+++ /dev/null
@@ -1 +0,0 @@
-Remove all functionality deprecated in PyO3 0.19.
diff --git a/newsfragments/3609.changed.md b/newsfragments/3609.changed.md
deleted file mode 100644
index 7979ea71960..00000000000
--- a/newsfragments/3609.changed.md
+++ /dev/null
@@ -1 +0,0 @@
-Allow async methods to accept `&self`/`&mut self`
\ No newline at end of file
diff --git a/newsfragments/3619.fixed.md b/newsfragments/3619.fixed.md
deleted file mode 100644
index 690542409f4..00000000000
--- a/newsfragments/3619.fixed.md
+++ /dev/null
@@ -1 +0,0 @@
-Use portable-atomic to support platforms without 64-bit atomics
diff --git a/newsfragments/3632.added.md b/newsfragments/3632.added.md
deleted file mode 100644
index d9c954fa0b4..00000000000
--- a/newsfragments/3632.added.md
+++ /dev/null
@@ -1 +0,0 @@
-Add support for extracting Rust set types from `frozenset`.
diff --git a/newsfragments/3638.changed.md b/newsfragments/3638.changed.md
deleted file mode 100644
index 6bdafde8422..00000000000
--- a/newsfragments/3638.changed.md
+++ /dev/null
@@ -1 +0,0 @@
-Values of type `bool` can now be extracted from NumPy's `bool_`.
diff --git a/newsfragments/3653.changed.md b/newsfragments/3653.changed.md
deleted file mode 100644
index 75fea03cb71..00000000000
--- a/newsfragments/3653.changed.md
+++ /dev/null
@@ -1 +0,0 @@
-Add `AsRefSource` to `PyNativeType`.
diff --git a/newsfragments/3657.changed.md b/newsfragments/3657.changed.md
deleted file mode 100644
index 0a519b09d62..00000000000
--- a/newsfragments/3657.changed.md
+++ /dev/null
@@ -1 +0,0 @@
-Changed `.is_true` to `.is_truthy` on `PyAny` and `Py<PyAny>` to clarify that the test is not based on identity with or equality to the True singleton.
diff --git a/newsfragments/3660.changed.md b/newsfragments/3660.changed.md
deleted file mode 100644
index 8b4a3f734e1..00000000000
--- a/newsfragments/3660.changed.md
+++ /dev/null
@@ -1 +0,0 @@
-`PyType::name` is now `PyType::qualname` whereas `PyType::name` efficiently accesses the full name which includes the module name.
diff --git a/newsfragments/3661.changed.md b/newsfragments/3661.changed.md
deleted file mode 100644
index 8245a6f1a80..00000000000
--- a/newsfragments/3661.changed.md
+++ /dev/null
@@ -1 +0,0 @@
-The `Iter(A)NextOutput` types are now deprecated and `__(a)next__` can directly return anything which can be converted into Python objects, i.e. awaitables do not need to be wrapped into `IterANextOutput` or `Option` any more. `Option` can still be used as well and returning `None` will trigger the fast path for `__next__`, stopping iteration without having to raise a `StopIteration` exception.
diff --git a/newsfragments/3663.changed.md b/newsfragments/3663.changed.md
deleted file mode 100644
index 13c07e01f2d..00000000000
--- a/newsfragments/3663.changed.md
+++ /dev/null
@@ -1 +0,0 @@
-Implements `FromPyObject` on `chrono::DateTime<Tz>` for all `Tz` and not only `FixedOffset` and `Utc`
\ No newline at end of file
diff --git a/newsfragments/3664.changed.md b/newsfragments/3664.changed.md
deleted file mode 100644
index 3a167d2f9d2..00000000000
--- a/newsfragments/3664.changed.md
+++ /dev/null
@@ -1 +0,0 @@
-`chrono` conversions are compatible with `abi3`
\ No newline at end of file
diff --git a/newsfragments/3670.added.md b/newsfragments/3670.added.md
deleted file mode 100644
index a524261e9d9..00000000000
--- a/newsfragments/3670.added.md
+++ /dev/null
@@ -1 +0,0 @@
-`FromPyObject`, `IntoPy<PyObject>` and `ToPyObject` are implemented on `std::duration::Duration`
\ No newline at end of file
diff --git a/newsfragments/3677.added.md b/newsfragments/3677.added.md
deleted file mode 100644
index 3e6bc56d582..00000000000
--- a/newsfragments/3677.added.md
+++ /dev/null
@@ -1 +0,0 @@
-Add `PyString::to_cow`. Add `Py<PyString>::to_str`, `Py<PyString>::to_cow`, and `Py<PyString>::to_string_lossy`, as ways to access Python string data safely beyond the GIL lifetime.
diff --git a/newsfragments/3679.changed.md b/newsfragments/3679.changed.md
deleted file mode 100644
index ab46598ad65..00000000000
--- a/newsfragments/3679.changed.md
+++ /dev/null
@@ -1 +0,0 @@
-Add lifetime parameter to `PyTzInfoAccess` trait. For the deprecated gil-ref API, the trait is now implemented for `&'py PyTime` and `&'py PyDateTime` instead of `PyTime` and `PyDate`.
diff --git a/newsfragments/3686.added.md b/newsfragments/3686.added.md
deleted file mode 100644
index f808df3685a..00000000000
--- a/newsfragments/3686.added.md
+++ /dev/null
@@ -1 +0,0 @@
-Add `Bound<T>` and `Borrowed<T>` smart pointers as a new API for accessing Python objects.
diff --git a/newsfragments/3689.changed.md b/newsfragments/3689.changed.md
deleted file mode 100644
index 30928e82f64..00000000000
--- a/newsfragments/3689.changed.md
+++ /dev/null
@@ -1 +0,0 @@
-Calls to `__traverse__` become no-ops for unsendable pyclasses if on the wrong thread, thereby avoiding hard aborts at the cost of potential leakage.
diff --git a/newsfragments/3692.added.md b/newsfragments/3692.added.md
deleted file mode 100644
index 45cdd5aba28..00000000000
--- a/newsfragments/3692.added.md
+++ /dev/null
@@ -1 +0,0 @@
-Add `PyNativeType::as_bound` to convert "GIL refs" to the new `Bound` smart pointer.
diff --git a/newsfragments/3692.changed.md b/newsfragments/3692.changed.md
deleted file mode 100644
index 9535cbb23db..00000000000
--- a/newsfragments/3692.changed.md
+++ /dev/null
@@ -1 +0,0 @@
-Include `PyNativeType` in `pyo3::prelude`.
diff --git a/newsfragments/3706.added.md b/newsfragments/3706.added.md
deleted file mode 100644
index 31db8b96cef..00000000000
--- a/newsfragments/3706.added.md
+++ /dev/null
@@ -1 +0,0 @@
-Add `FromPyObject::extract_bound` method, which can be implemented to avoid using the GIL Ref API in `FromPyObject` implementations.
diff --git a/newsfragments/3707.added.md b/newsfragments/3707.added.md
deleted file mode 100644
index bc92e2c0f95..00000000000
--- a/newsfragments/3707.added.md
+++ /dev/null
@@ -1 +0,0 @@
-Add `gil-refs` feature to allow continued use of the deprecated GIL Refs APIs.
diff --git a/newsfragments/3712.added.md b/newsfragments/3712.added.md
deleted file mode 100644
index d7390f77c14..00000000000
--- a/newsfragments/3712.added.md
+++ /dev/null
@@ -1 +0,0 @@
-Added methods to `PyAnyMethods` for binary operators (`add`, `sub`, etc.)
diff --git a/newsfragments/3730.added.md b/newsfragments/3730.added.md
deleted file mode 100644
index 7e287245eb1..00000000000
--- a/newsfragments/3730.added.md
+++ /dev/null
@@ -1 +0,0 @@
-`chrono-tz` feature allowing conversion between `chrono_tz::Tz` and `zoneinfo.ZoneInfo`
\ No newline at end of file
diff --git a/newsfragments/3734.added.md b/newsfragments/3734.added.md
deleted file mode 100644
index e58c2038e70..00000000000
--- a/newsfragments/3734.added.md
+++ /dev/null
@@ -1 +0,0 @@
-Add definition for `PyType_GetModuleByDef` to `pyo3_ffi`.
diff --git a/newsfragments/3736.added.md b/newsfragments/3736.added.md
deleted file mode 100644
index 0d3a4a08c1a..00000000000
--- a/newsfragments/3736.added.md
+++ /dev/null
@@ -1 +0,0 @@
-Conversion between `std::time::SystemTime` and `datetime.datetime`
\ No newline at end of file
diff --git a/newsfragments/3742.changed.md b/newsfragments/3742.changed.md
deleted file mode 100644
index b8805abafda..00000000000
--- a/newsfragments/3742.changed.md
+++ /dev/null
@@ -1 +0,0 @@
-Improve performance of `extract::<i64>` (and other integer types) by avoiding call to `__index__()` converting the value to an integer for 3.10+. Gives performance improvement of around 30% for successful extraction.
diff --git a/newsfragments/3757.fixed.md b/newsfragments/3757.fixed.md
deleted file mode 100644
index 103a634af9f..00000000000
--- a/newsfragments/3757.fixed.md
+++ /dev/null
@@ -1 +0,0 @@
-Match PyPy 7.3.14 in removing PyPy-only symbol `Py_MAX_NDIMS` in favour of `PyBUF_MAX_NDIM`.
diff --git a/newsfragments/3776.changed.md b/newsfragments/3776.changed.md
deleted file mode 100644
index 71ffd893a18..00000000000
--- a/newsfragments/3776.changed.md
+++ /dev/null
@@ -1 +0,0 @@
-Relax bound of `FromPyObject` for `Py<T>` to just `T: PyTypeCheck`.
diff --git a/newsfragments/3785.added.md b/newsfragments/3785.added.md
deleted file mode 100644
index 6af3bb999f8..00000000000
--- a/newsfragments/3785.added.md
+++ /dev/null
@@ -1 +0,0 @@
-Add `Py::as_any` and `Py::into_any`.
diff --git a/newsfragments/3801.added.md b/newsfragments/3801.added.md
deleted file mode 100644
index 78f45032ba2..00000000000
--- a/newsfragments/3801.added.md
+++ /dev/null
@@ -1 +0,0 @@
-Add `PyStringMethods::encode_utf8`.
diff --git a/newsfragments/3802.added.md b/newsfragments/3802.added.md
deleted file mode 100644
index 86b98e9df97..00000000000
--- a/newsfragments/3802.added.md
+++ /dev/null
@@ -1 +0,0 @@
-Add `PyBackedStr` and `PyBackedBytes`, as alternatives to `&str` and `&bytes` where a Python object owns the data.
diff --git a/newsfragments/3818.fixed.md b/newsfragments/3818.fixed.md
deleted file mode 100644
index 76fe01a545c..00000000000
--- a/newsfragments/3818.fixed.md
+++ /dev/null
@@ -1 +0,0 @@
-Fix segmentation fault using `datetime` types when an invalid `datetime` module is on sys.path.
diff --git a/newsfragments/3821.packaging.md b/newsfragments/3821.packaging.md
deleted file mode 100644
index 4bd89355086..00000000000
--- a/newsfragments/3821.packaging.md
+++ /dev/null
@@ -1 +0,0 @@
-Check maximum version of Python at build time and for versions not yet supported require opt-in to the `abi3` stable ABI by the environment variable `PYO3_USE_ABI3_FORWARD_COMPATIBILITY=1`.
diff --git a/newsfragments/5438.changed.md b/newsfragments/5438.changed.md
new file mode 100644
index 00000000000..bcd7885673d
--- /dev/null
+++ b/newsfragments/5438.changed.md
@@ -0,0 +1,2 @@
+Introspection: introduce `TypeHint` and make use of it to encode type hint annotations.
+Rename `PyType{Info,Check}::TYPE_INFO` into `PyType{Info,Check}::TYPE_HINT`
diff --git a/newsfragments/5531.packaging.md b/newsfragments/5531.packaging.md
new file mode 100644
index 00000000000..8bf82fe545b
--- /dev/null
+++ b/newsfragments/5531.packaging.md
@@ -0,0 +1,2 @@
+Bump MSRV to Rust 1.83.
+Bump minimum supported `quote` version to 1.0.37.
diff --git a/newsfragments/5538.changed.md b/newsfragments/5538.changed.md
new file mode 100644
index 00000000000..56493d0862f
--- /dev/null
+++ b/newsfragments/5538.changed.md
@@ -0,0 +1 @@
+silence a clippy warning on rust 1.83
diff --git a/newsfragments/5539.changed.md b/newsfragments/5539.changed.md
new file mode 100644
index 00000000000..2ea40282f2d
--- /dev/null
+++ b/newsfragments/5539.changed.md
@@ -0,0 +1 @@
+Expose types::iterator::PySendResult in public API
diff --git a/newsfragments/5542.packaging.md b/newsfragments/5542.packaging.md
new file mode 100644
index 00000000000..dd381c6f005
--- /dev/null
+++ b/newsfragments/5542.packaging.md
@@ -0,0 +1 @@
+Bump supported GraalPy version to 25.0.
diff --git a/newsfragments/5545.packaging.md b/newsfragments/5545.packaging.md
new file mode 100644
index 00000000000..2591f9d8798
--- /dev/null
+++ b/newsfragments/5545.packaging.md
@@ -0,0 +1 @@
+Drop `memoffset` dependency.
diff --git a/noxfile.py b/noxfile.py
index 3981e62e100..fc1d2b50c9b 100644
--- a/noxfile.py
+++ b/noxfile.py
@@ -1,24 +1,88 @@
-from contextlib import contextmanager
+import io
 import json
 import os
 import re
+import shutil
 import subprocess
 import sys
+import sysconfig
+import tarfile
 import tempfile
+from contextlib import ExitStack, contextmanager
 from functools import lru_cache
 from glob import glob
 from pathlib import Path
-from typing import Any, Callable, Dict, Iterator, List, Optional, Tuple
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    Iterable,
+    Iterator,
+    List,
+    Optional,
+    Tuple,
+)
 
-import nox
 import nox.command
 
-nox.options.sessions = ["test", "clippy", "rustfmt", "ruff", "docs"]
+try:
+    import tomllib as toml
+except ImportError:
+    try:
+        import toml
+    except ImportError:
+        toml = None
+
+try:
+    import requests
+except ImportError:
+    requests = None
 
+nox.options.sessions = ["test", "clippy", "rustfmt", "ruff", "rumdl", "docs"]
 
 PYO3_DIR = Path(__file__).parent
-PY_VERSIONS = ("3.7", "3.8", "3.9", "3.10", "3.11", "3.12")
-PYPY_VERSIONS = ("3.7", "3.8", "3.9", "3.10")
+PYO3_TARGET = Path(os.environ.get("CARGO_TARGET_DIR", PYO3_DIR / "target")).absolute()
+PYO3_GUIDE_SRC = PYO3_DIR / "guide" / "src"
+PYO3_GUIDE_TARGET = PYO3_TARGET / "guide"
+PYO3_DOCS_TARGET = PYO3_TARGET / "doc"
+FREE_THREADED_BUILD = bool(sysconfig.get_config_var("Py_GIL_DISABLED"))
+
+
+def _get_output(*args: str) -> str:
+    return subprocess.run(args, capture_output=True, text=True, check=True).stdout
+
+
+def _parse_supported_interpreter_version(
+    python_impl: str,  # Literal["cpython", "pypy"], TODO update after 3.7 dropped
+) -> Tuple[str, str]:
+    output = _get_output("cargo", "metadata", "--format-version=1", "--no-deps")
+    cargo_packages = json.loads(output)["packages"]
+    # Check Python interpreter version support in package metadata
+    package = "pyo3-ffi"
+    metadata = next(pkg["metadata"] for pkg in cargo_packages if pkg["name"] == package)
+    version_info = metadata[python_impl]
+    assert "min-version" in version_info, f"missing min-version for {python_impl}"
+    assert "max-version" in version_info, f"missing max-version for {python_impl}"
+    return version_info["min-version"], version_info["max-version"]
+
+
+def _supported_interpreter_versions(
+    python_impl: str,  # Literal["cpython", "pypy"], TODO update after 3.7 dropped
+) -> List[str]:
+    min_version, max_version = _parse_supported_interpreter_version(python_impl)
+    major = int(min_version.split(".")[0])
+    assert major == 3, f"unsupported Python major version {major}"
+    min_minor = int(min_version.split(".")[1])
+    max_minor = int(max_version.split(".")[1])
+    versions = [f"{major}.{minor}" for minor in range(min_minor, max_minor + 1)]
+    # Add free-threaded builds for 3.13+
+    if python_impl == "cpython":
+        versions += [f"{major}.{minor}t" for minor in range(13, max_minor + 1)]
+    return versions
+
+
+PY_VERSIONS = _supported_interpreter_versions("cpython")
+PYPY_VERSIONS = _supported_interpreter_versions("pypy")
 
 
 @nox.session(venv_backend="none")
@@ -32,13 +96,48 @@ def test_rust(session: nox.Session):
     _run_cargo_test(session, package="pyo3-build-config")
     _run_cargo_test(session, package="pyo3-macros-backend")
     _run_cargo_test(session, package="pyo3-macros")
-    _run_cargo_test(session, package="pyo3-ffi")
 
-    _run_cargo_test(session)
-    _run_cargo_test(session, features="abi3")
-    if "skip-full" not in session.posargs:
-        _run_cargo_test(session, features="full")
-        _run_cargo_test(session, features="abi3 full")
+    extra_flags = []
+    # pypy and graalpy don't have Py_Initialize APIs, so we can only
+    # build the main tests, not run them
+    if sys.implementation.name in ("pypy", "graalpy"):
+        extra_flags.append("--no-run")
+
+    _run_cargo_test(session, package="pyo3-ffi", extra_flags=extra_flags)
+
+    extra_flags.append("--no-default-features")
+
+    for feature_set in _get_feature_sets():
+        flags = extra_flags.copy()
+
+        if feature_set is None or "full" not in feature_set:
+            # doctests require at least the macros feature, which is
+            # activated by the full feature set
+            #
+            # using `--all-targets` makes cargo run everything except doctests
+            flags.append("--all-targets")
+
+        # We need to pass the feature set to the test command
+        # so that it can be used in the test code
+        # (e.g. for `#[cfg(feature = "abi3-py37")]`)
+        if feature_set and "abi3" in feature_set and FREE_THREADED_BUILD:
+            # free-threaded builds don't support abi3 yet
+            continue
+
+        _run_cargo_test(session, features=feature_set, extra_flags=flags)
+
+        if (
+            feature_set
+            and "abi3" in feature_set
+            and "full" in feature_set
+            and sys.version_info >= (3, 7)
+        ):
+            # run abi3-py37 tests to check abi3 forward compatibility
+            _run_cargo_test(
+                session,
+                features=feature_set.replace("abi3", "abi3-py37"),
+                extra_flags=flags,
+            )
 
 
 @nox.session(name="test-py", venv_backend="none")
@@ -46,6 +145,8 @@ def test_py(session: nox.Session) -> None:
     _run(session, "nox", "-f", "pytests/noxfile.py", external=True)
     for example in glob("examples/*/noxfile.py"):
         _run(session, "nox", "-f", example, external=True)
+    for example in glob("pyo3-ffi/examples/*/noxfile.py"):
+        _run(session, "nox", "-f", example, external=True)
 
 
 @nox.session(venv_backend="none")
@@ -53,6 +154,26 @@ def coverage(session: nox.Session) -> None:
     session.env.update(_get_coverage_env())
     _run_cargo(session, "llvm-cov", "clean", "--workspace")
     test(session)
+    generate_coverage_report(session)
+
+
+@nox.session(name="set-coverage-env", venv_backend="none")
+def set_coverage_env(session: nox.Session) -> None:
+    """For use in GitHub Actions to set coverage environment variables."""
+    with open(os.environ["GITHUB_ENV"], "a") as env_file:
+        for k, v in _get_coverage_env().items():
+            print(f"{k}={v}", file=env_file)
+
+
+@nox.session(name="generate-coverage-report", venv_backend="none")
+def generate_coverage_report(session: nox.Session) -> None:
+    cov_format = "codecov"
+    output_file = "coverage.json"
+
+    if "lcov" in session.posargs:
+        cov_format = "lcov"
+        output_file = "lcov.info"
+
     _run_cargo(
         session,
         "llvm-cov",
@@ -62,9 +183,9 @@ def coverage(session: nox.Session) -> None:
         "--package=pyo3-macros",
         "--package=pyo3-ffi",
         "report",
-        "--codecov",
+        f"--{cov_format}",
         "--output-path",
-        "coverage.json",
+        output_file,
     )
 
 
@@ -81,9 +202,19 @@ def ruff(session: nox.Session):
     _run(session, "ruff", "check", ".")
 
 
+@nox.session(name="rumdl")
+def rumdl(session: nox.Session):
+    """Run rumdl to check markdown formatting in the guide.
+
+    Can also run with uv directly, e.g. `uvx rumdl check guide`.
+    """
+    session.install("rumdl")
+    _run(session, "rumdl", "check", "guide", *session.posargs)
+
+
 @nox.session(name="clippy", venv_backend="none")
 def clippy(session: nox.Session) -> bool:
-    if not _clippy(session) and _clippy_additional_workspaces(session):
+    if not (_clippy(session) and _clippy_additional_workspaces(session)):
         session.error("one or more jobs failed")
 
 
@@ -95,7 +226,8 @@ def _clippy(session: nox.Session, *, env: Dict[str, str] = None) -> bool:
             _run_cargo(
                 session,
                 "clippy",
-                *feature_set,
+                "--no-default-features",
+                *((f"--features={feature_set}",) if feature_set else ()),
                 "--all-targets",
                 "--workspace",
                 "--",
@@ -172,7 +304,8 @@ def _check(env: Dict[str, str]) -> None:
                 _run_cargo(
                     session,
                     "check",
-                    *feature_set,
+                    "--no-default-features",
+                    *((f"--features={feature_set}",) if feature_set else ()),
                     "--all-targets",
                     "--workspace",
                     env=env,
@@ -193,6 +326,7 @@ def publish(session: nox.Session) -> None:
     _run_cargo_publish(session, package="pyo3-macros")
     _run_cargo_publish(session, package="pyo3-ffi")
     _run_cargo_publish(session, package="pyo3")
+    _run_cargo_publish(session, package="pyo3-introspection")
 
 
 @nox.session(venv_backend="none")
@@ -298,11 +432,13 @@ def test_emscripten(session: nox.Session):
             f"-C link-arg=-lpython{info.pymajorminor}",
             "-C link-arg=-lexpat",
             "-C link-arg=-lmpdec",
+            "-C link-arg=-lsqlite3",
             "-C link-arg=-lz",
             "-C link-arg=-lbz2",
             "-C link-arg=-sALLOW_MEMORY_GROWTH=1",
         ]
     )
+    session.env["RUSTDOCFLAGS"] = session.env["RUSTFLAGS"]
     session.env["CARGO_BUILD_TARGET"] = target
     session.env["PYO3_CROSS_LIB_DIR"] = pythonlibdir
     _run(session, "rustup", "target", "add", target, "--toolchain", "stable")
@@ -310,25 +446,91 @@ def test_emscripten(session: nox.Session):
         session,
         "bash",
         "-c",
-        f"source {info.builddir/'emsdk/emsdk_env.sh'} && cargo test",
+        f"source {info.builddir / 'emsdk/emsdk_env.sh'} && cargo test",
+    )
+
+
+@nox.session(name="test-cross-compilation-windows")
+def test_cross_compilation_windows(session: nox.Session):
+    session.install("cargo-xwin")
+
+    env = os.environ.copy()
+    env["XWIN_ARCH"] = "x86_64"
+
+    # abi3
+    _run_cargo(
+        session,
+        "build",
+        "--manifest-path",
+        "examples/maturin-starter/Cargo.toml",
+        "--features",
+        "abi3",
+        "--target",
+        "x86_64-pc-windows-gnu",
+        env=env,
+    )
+    _run_cargo(
+        session,
+        "xwin",
+        "build",
+        "--cross-compiler",
+        "clang",
+        "--manifest-path",
+        "examples/maturin-starter/Cargo.toml",
+        "--features",
+        "abi3",
+        "--target",
+        "x86_64-pc-windows-msvc",
+        env=env,
+    )
+
+    # non-abi3
+    env["PYO3_CROSS_PYTHON_VERSION"] = "3.13"
+    _run_cargo(
+        session,
+        "build",
+        "--manifest-path",
+        "examples/maturin-starter/Cargo.toml",
+        "--features",
+        "generate-import-lib",
+        "--target",
+        "x86_64-pc-windows-gnu",
+        env=env,
+    )
+    _run_cargo(
+        session,
+        "xwin",
+        "build",
+        "--cross-compiler",
+        "clang",
+        "--manifest-path",
+        "examples/maturin-starter/Cargo.toml",
+        "--features",
+        "generate-import-lib",
+        "--target",
+        "x86_64-pc-windows-msvc",
+        env=env,
     )
 
 
 @nox.session(venv_backend="none")
-def docs(session: nox.Session) -> None:
+def docs(session: nox.Session, nightly: bool = False, internal: bool = False) -> None:
     rustdoc_flags = ["-Dwarnings"]
     toolchain_flags = []
     cargo_flags = []
 
+    nightly = nightly or ("nightly" in session.posargs)
+    internal = internal or ("internal" in session.posargs)
+
     if "open" in session.posargs:
         cargo_flags.append("--open")
 
-    if "nightly" in session.posargs:
+    if nightly:
         rustdoc_flags.append("--cfg docsrs")
         toolchain_flags.append("+nightly")
         cargo_flags.extend(["-Z", "unstable-options", "-Z", "rustdoc-scrape-examples"])
 
-    if "nightly" in session.posargs and "internal" in session.posargs:
+    if internal:
         rustdoc_flags.append("--Z unstable-options")
         rustdoc_flags.append("--document-hidden-items")
         rustdoc_flags.extend(("--html-after-content", ".netlify/internal_banner.html"))
@@ -339,13 +541,16 @@ def docs(session: nox.Session) -> None:
     rustdoc_flags.append(session.env.get("RUSTDOCFLAGS", ""))
     session.env["RUSTDOCFLAGS"] = " ".join(rustdoc_flags)
 
+    features = "full"
+
+    shutil.rmtree(PYO3_DOCS_TARGET, ignore_errors=True)
     _run_cargo(
         session,
         *toolchain_flags,
         "doc",
         "--lib",
         "--no-default-features",
-        "--features=full",
+        f"--features={features}",
         "--no-deps",
         "--workspace",
         *cargo_flags,
@@ -354,7 +559,204 @@ def docs(session: nox.Session) -> None:
 
 @nox.session(name="build-guide", venv_backend="none")
 def build_guide(session: nox.Session):
-    _run(session, "mdbook", "build", "-d", "../target/guide", "guide", *session.posargs)
+    shutil.rmtree(PYO3_GUIDE_TARGET, ignore_errors=True)
+    _run(
+        session,
+        "mdbook",
+        "build",
+        "-d",
+        str(PYO3_GUIDE_TARGET),
+        "guide",
+        *session.posargs,
+        external=True,
+    )
+    for license in ("LICENSE-APACHE", "LICENSE-MIT"):
+        target_file = PYO3_GUIDE_TARGET / license
+        target_file.unlink(missing_ok=True)
+        shutil.copy(PYO3_DIR / license, target_file)
+
+
+@nox.session(name="build-netlify-site")
+def build_netlify_site(session: nox.Session):
+    # Remove netlify_build directory if it exists
+    netlify_build = Path("netlify_build")
+    if netlify_build.exists():
+        shutil.rmtree(netlify_build)
+
+    url = "https://github.com/PyO3/pyo3/archive/gh-pages.tar.gz"
+    response = requests.get(url, stream=True)
+    response.raise_for_status()
+    with tarfile.open(fileobj=io.BytesIO(response.content), mode="r:gz") as tar:
+        tar.extractall()
+    shutil.move("pyo3-gh-pages", "netlify_build")
+
+    preview = "--preview" in session.posargs
+    if preview:
+        session.posargs.remove("--preview")
+
+    _build_netlify_redirects(preview)
+
+    session.install("towncrier")
+    # Save a copy of the changelog to restore later
+    changelog = (PYO3_DIR / "CHANGELOG.md").read_text()
+
+    # Build the changelog
+    session.run(
+        "towncrier", "build", "--keep", "--version", "Unreleased", "--date", "TBC"
+    )
+
+    # Build the guide
+    build_guide(session)
+    PYO3_GUIDE_TARGET.rename("netlify_build/main")
+
+    # Restore the original changelog
+    (PYO3_DIR / "CHANGELOG.md").write_text(changelog)
+    session.run("git", "restore", "--staged", "CHANGELOG.md", external=True)
+
+    # Build the main branch docs
+    docs(session)
+    PYO3_DOCS_TARGET.rename("netlify_build/main/doc")
+
+    Path("netlify_build/main/doc/index.html").write_text(
+        "<meta http-equiv=refresh content=0;url=pyo3/>"
+    )
+
+    # Build the internal docs
+    docs(session, nightly=True, internal=True)
+    PYO3_DOCS_TARGET.rename("netlify_build/internal")
+
+
+def _build_netlify_redirects(preview: bool) -> None:
+    current_version = os.environ.get("PYO3_VERSION")
+
+    with ExitStack() as stack:
+        redirects_file = stack.enter_context(open("netlify_build/_redirects", "w"))
+        headers_file = stack.enter_context(open("netlify_build/_headers", "w"))
+        for d in glob("netlify_build/v*"):
+            version = d.removeprefix("netlify_build/v")
+            full_directory = d + "/"
+            redirects_file.write(
+                f"/v{version}/doc/* https://docs.rs/pyo3/{version}/:splat\n"
+            )
+            if version != current_version:
+                # for old versions, mark the files in the latest version as the canonical URL
+                for file in glob(f"{d}/**", recursive=True):
+                    file_path = file.removeprefix(full_directory)
+                    # remove index.html and/or .html suffix to match the page URL on the
+                    # final netlfiy site
+                    url_path = file_path
+                    if file_path == "index.html":
+                        url_path = ""
+
+                    url_path = url_path.removesuffix(".html")
+
+                    # if the file exists in the latest version, add a canonical
+                    # URL as a header
+                    for url in (
+                        f"/v{version}/{url_path}",
+                        *(
+                            (f"/v{version}/{file_path}",)
+                            if file_path != url_path
+                            else ()
+                        ),
+                    ):
+                        headers_file.write(url + "\n")
+                        if os.path.exists(
+                            f"netlify_build/v{current_version}/{file_path}"
+                        ):
+                            headers_file.write(
+                                f'  Link: <https://pyo3.rs/v{current_version}/{url_path}>; rel="canonical"\n'
+                            )
+                        else:
+                            # this file doesn't exist in the latest guide, don't
+                            # index it
+                            headers_file.write("  X-Robots-Tag: noindex\n")
+
+        # Add latest redirect
+        if current_version is not None:
+            redirects_file.write(f"/latest/* /v{current_version}/:splat 302\n")
+
+        # some backwards compatbiility redirects
+        redirects_file.write(
+            """\
+/latest/building_and_distribution/* /latest/building-and-distribution/:splat 302
+/latest/building_and_distribution/multiple_python_versions/* /latest/building-and-distribution/multiple-python-versions:splat 302
+/latest/function/error_handling/* /latest/function/error-handling/:splat 302
+/latest/getting_started/* /latest/getting-started/:splat 302
+/latest/python_from_rust/* /latest/python-from-rust/:splat 302
+/latest/python_typing_hints/* /latest/python-typing-hints/:splat 302
+/latest/trait_bounds/* /latest/trait-bounds/:splat 302
+"""
+        )
+
+        # Add landing page redirect
+        if preview:
+            redirects_file.write("/ /main/ 302\n")
+        else:
+            redirects_file.write(f"/ /v{current_version}/ 302\n")
+
+
+@nox.session(name="check-guide")
+def check_guide(session: nox.Session):
+    # reuse other sessions, but with default args
+    posargs = [*session.posargs]
+    del session.posargs[:]
+    build_guide(session)
+    docs(session)
+    session.posargs.extend(posargs)
+
+    if toml is None:
+        session.error("requires Python 3.11 or `toml` to be installed")
+    pyo3_version = toml.loads((PYO3_DIR / "Cargo.toml").read_text())["package"][
+        "version"
+    ]
+
+    remaps = {
+        f"file://{PYO3_GUIDE_SRC}/([^/]*/)*?%7B%7B#PYO3_DOCS_URL}}}}": f"file://{PYO3_DOCS_TARGET}",
+        f"https://pyo3.rs/v%7Bpyo3_version%7D": f"file://{PYO3_GUIDE_TARGET}",
+        "https://pyo3.rs/main/": f"file://{PYO3_GUIDE_TARGET}/",
+        "https://pyo3.rs/latest/": f"file://{PYO3_GUIDE_TARGET}/",
+        "%7B%7B#PYO3_DOCS_VERSION}}": "latest",
+        # bypass fragments for edge cases
+        # blob links
+        "(https://github.com/[^/]+/[^/]+/blob/[^#]+)#[a-zA-Z0-9._-]*": "$1",
+        # issue comments
+        "(https://github.com/[^/]+/[^/]+/issues/[0-9]+)#issuecomment-[0-9]*": "$1",
+        # rust docs
+        "(https://docs.rs/[^#]+)#[a-zA-Z0-9._-]*": "$1",
+    }
+    remap_args = []
+    for key, value in remaps.items():
+        remap_args.extend(("--remap", f"{key} {value}"))
+
+    # check all links in the guide
+    _run(
+        session,
+        "lychee",
+        "--include-fragments",
+        str(PYO3_GUIDE_SRC),
+        *remap_args,
+        "--accept=200,429",
+        *session.posargs,
+        external=True,
+    )
+    # check external links in the docs
+    # (intra-doc links are checked by rustdoc)
+    _run(
+        session,
+        "lychee",
+        str(PYO3_DOCS_TARGET),
+        *remap_args,
+        f"--exclude=file://{PYO3_DOCS_TARGET}",
+        # exclude some old http links from copyright notices, known to fail
+        "--exclude=http://www.adobe.com/",
+        "--exclude=http://www.nhncorp.com/",
+        "--accept=200,429",
+        # reduce the concurrency to avoid rate-limit from `pyo3.rs`
+        "--max-concurrency=32",
+        *session.posargs,
+        external=True,
+    )
 
 
 @nox.session(name="format-guide", venv_backend="none")
@@ -429,15 +831,17 @@ def address_sanitizer(session: nox.Session):
 _IGNORE_CHANGELOG_PR_CATEGORIES = (
     "release",
     "docs",
+    "ci",
 )
 
 
 @nox.session(name="check-changelog")
 def check_changelog(session: nox.Session):
-    event_path = os.environ.get("GITHUB_EVENT_PATH")
-    if event_path is None:
+    if not _is_github_actions():
         session.error("Can only check changelog on github actions")
 
+    event_path = os.environ["GITHUB_EVENT_PATH"]
+
     with open(event_path) as event_file:
         event = json.load(event_file)
 
@@ -475,51 +879,29 @@ def check_changelog(session: nox.Session):
         print(fragment.name)
 
 
-@nox.session(name="set-minimal-package-versions", venv_backend="none")
-def set_minimal_package_versions(session: nox.Session):
+@nox.session(name="set-msrv-package-versions", venv_backend="none")
+def set_msrv_package_versions(session: nox.Session):
     from collections import defaultdict
 
-    try:
-        import tomllib as toml
-    except ImportError:
-        import toml
-
     projects = (
-        None,
-        "examples/decorator",
-        "examples/maturin-starter",
-        "examples/setuptools-rust-starter",
-        "examples/word-count",
+        PYO3_DIR,
+        *(Path(p).parent for p in glob("examples/*/Cargo.toml")),
+        *(Path(p).parent for p in glob("pyo3-ffi/examples/*/Cargo.toml")),
     )
-    min_pkg_versions = {
-        "rust_decimal": "1.26.1",
-        "csv": "1.1.6",
-        "indexmap": "1.6.2",
-        "hashbrown": "0.9.1",
-        "log": "0.4.17",
-        "once_cell": "1.17.2",
-        "rayon": "1.6.1",
-        "rayon-core": "1.10.2",
-        "regex": "1.7.3",
-        "proptest": "1.0.0",
-        "chrono": "0.4.25",
-        "byteorder": "1.4.3",
-        "crossbeam-channel": "0.5.8",
-        "crossbeam-deque": "0.8.3",
-        "crossbeam-epoch": "0.9.15",
-        "crossbeam-utils": "0.8.16",
-    }
+    min_pkg_versions = {}
 
     # run cargo update first to ensure that everything is at highest
     # possible version, so that this matches what CI will resolve to.
     for project in projects:
-        if project is None:
-            _run_cargo(session, "update")
-        else:
-            _run_cargo(session, "update", f"--manifest-path={project}/Cargo.toml")
+        _run_cargo(
+            session,
+            "+stable",
+            "update",
+            f"--manifest-path={project}/Cargo.toml",
+            env=os.environ | {"CARGO_RESOLVER_INCOMPATIBLE_RUST_VERSIONS": "fallback"},
+        )
 
-    for project in projects:
-        lock_file = Path(project or "") / "Cargo.lock"
+        lock_file = project / "Cargo.lock"
 
         def load_pkg_versions():
             cargo_lock = toml.loads(lock_file.read_text())
@@ -545,19 +927,15 @@ def load_pkg_versions():
                     # and re-read `Cargo.lock`
                     pkg_versions = load_pkg_versions()
 
-    # As a smoke test, cargo metadata solves all dependencies, so
-    # will break if any crates rely on cargo features not
-    # supported on MSRV
-    for project in projects:
-        if project is None:
-            _run_cargo(session, "metadata", silent=True)
-        else:
-            _run_cargo(
-                session,
-                "metadata",
-                f"--manifest-path={project}/Cargo.toml",
-                silent=True,
-            )
+        # As a smoke test, cargo metadata solves all dependencies, so
+        # will break if any crates rely on cargo features not
+        # supported on MSRV
+        _run_cargo(
+            session,
+            "metadata",
+            f"--manifest-path={project}/Cargo.toml",
+            silent=True,
+        )
 
 
 @nox.session(name="ffi-check")
@@ -576,26 +954,187 @@ def test_version_limits(session: nox.Session):
         config_file.set("CPython", "3.6")
         _run_cargo(session, "check", env=env, expect_error=True)
 
-        assert "3.13" not in PY_VERSIONS
-        config_file.set("CPython", "3.13")
+        assert "3.15" not in PY_VERSIONS
+        config_file.set("CPython", "3.15")
         _run_cargo(session, "check", env=env, expect_error=True)
 
-        # 3.13 CPython should build with forward compatibility
+        # 3.15 CPython should build if abi3 is explicitly requested
+        _run_cargo(session, "check", "--features=pyo3/abi3", env=env)
+
+        # 3.15 CPython should build with forward compatibility
         env["PYO3_USE_ABI3_FORWARD_COMPATIBILITY"] = "1"
         _run_cargo(session, "check", env=env)
 
-        assert "3.6" not in PYPY_VERSIONS
-        config_file.set("PyPy", "3.6")
+        assert "3.10" not in PYPY_VERSIONS
+        config_file.set("PyPy", "3.10")
         _run_cargo(session, "check", env=env, expect_error=True)
 
-        assert "3.11" not in PYPY_VERSIONS
-        config_file.set("PyPy", "3.11")
-        _run_cargo(session, "check", env=env, expect_error=True)
+    # attempt to build with latest version and check that abi3 version
+    # configured matches the feature
+    max_minor_version = max(int(v.split(".")[1]) for v in PY_VERSIONS if "t" not in v)
+    with tempfile.TemporaryFile() as stderr:
+        env = os.environ.copy()
+        env["PYO3_PRINT_CONFIG"] = "1"  # get diagnostics from the build
+        env["PYO3_NO_PYTHON"] = "1"  # isolate the build from local Python
+        _run_cargo(
+            session,
+            "check",
+            f"--features=pyo3/abi3-py3{max_minor_version}",
+            env=env,
+            stderr=stderr,
+            expect_error=True,
+        )
+        stderr.seek(0)
+        stderr = stderr.read().decode()
+    # NB if this assertion fails with something like
+    # "An abi3-py3* feature must be specified when compiling without a Python
+    # interpreter."
+    #
+    # then `ABI3_MAX_MINOR` in `pyo3-build-config/src/impl_.rs` is probably outdated.
+    assert f"version=3.{max_minor_version}" in stderr, (
+        f"Expected to see version=3.{max_minor_version}, got: \n\n{stderr}"
+    )
+
+
+@nox.session(name="check-feature-powerset", venv_backend="none")
+def check_feature_powerset(session: nox.Session):
+    if toml is None:
+        session.error("requires Python 3.11 or `toml` to be installed")
+
+    cargo_toml = toml.loads((PYO3_DIR / "Cargo.toml").read_text())
+
+    # free-threaded builds do not support ABI3 (yet)
+    EXPECTED_ABI3_FEATURES = {
+        f"abi3-py3{ver.split('.')[1]}" for ver in PY_VERSIONS if not ver.endswith("t")
+    }
+
+    EXCLUDED_FROM_FULL = {
+        "nightly",
+        "extension-module",
+        "full",
+        "default",
+        "auto-initialize",
+        "generate-import-lib",
+        "multiple-pymethods",  # Because it's not supported on wasm
+    }
+
+    features = cargo_toml["features"]
+
+    full_feature = set(features["full"])
+    abi3_features = {feature for feature in features if feature.startswith("abi3")}
+    abi3_version_features = abi3_features - {"abi3"}
+
+    unexpected_abi3_features = abi3_version_features - EXPECTED_ABI3_FEATURES
+    if unexpected_abi3_features:
+        session.error(
+            f"unexpected `abi3` features found in Cargo.toml: {unexpected_abi3_features}"
+        )
+
+    missing_abi3_features = EXPECTED_ABI3_FEATURES - abi3_version_features
+    if missing_abi3_features:
+        session.error(f"missing `abi3` features in Cargo.toml: {missing_abi3_features}")
+
+    expected_full_feature = features.keys() - EXCLUDED_FROM_FULL - abi3_features
+
+    uncovered_features = expected_full_feature - full_feature
+    if uncovered_features:
+        session.error(
+            f"some features missing from `full` meta feature: {uncovered_features}"
+        )
+
+    experimental_features = {
+        feature for feature in features if feature.startswith("experimental-")
+    }
+    full_without_experimental = full_feature - experimental_features
+
+    if len(experimental_features) >= 2:
+        # justification: we always assume that feature within these groups are
+        # mutually exclusive to simplify CI
+        features_to_group = [
+            full_without_experimental,
+            experimental_features,
+        ]
+    elif len(experimental_features) == 1:
+        # no need to make an experimental features group
+        features_to_group = [full_without_experimental]
+    else:
+        session.error("no experimental features exist; please simplify the noxfile")
+
+    features_to_skip = [
+        *(EXCLUDED_FROM_FULL),
+        *abi3_version_features,
+    ]
+
+    # deny warnings
+    env = os.environ.copy()
+    rust_flags = env.get("RUSTFLAGS", "")
+    env["RUSTFLAGS"] = f"{rust_flags} -Dwarnings"
+
+    subcommand = "hack"
+    if "minimal-versions" in session.posargs:
+        subcommand = "minimal-versions"
+
+    comma_join = ",".join
+    _run_cargo(
+        session,
+        subcommand,
+        "--feature-powerset",
+        '--optional-deps=""',
+        f'--skip="{comma_join(features_to_skip)}"',
+        *(f"--group-features={comma_join(group)}" for group in features_to_group),
+        "check",
+        "--all-targets",
+        env=env,
+    )
+
+
+@nox.session(name="update-ui-tests", venv_backend="none")
+def update_ui_tests(session: nox.Session):
+    env = os.environ.copy()
+    env["TRYBUILD"] = "overwrite"
+    command = ["test", "--test", "test_compile_error"]
+    _run_cargo(session, *command, env=env)
+    _run_cargo(session, *command, "--features=full", env=env)
+    _run_cargo(session, *command, "--features=abi3,full", env=env)
+
+
+@nox.session(name="test-introspection")
+def test_introspection(session: nox.Session):
+    session.install("maturin")
+    session.install("ruff")
+    options = []
+    target = os.environ.get("CARGO_BUILD_TARGET")
+    if target is not None:
+        options += ("--target", target)
+    profile = os.environ.get("CARGO_BUILD_PROFILE")
+    if profile == "release":
+        options.append("--release")
+    session.run_always(
+        "maturin",
+        "develop",
+        "-m",
+        "./pytests/Cargo.toml",
+        "--features",
+        "experimental-inspect",
+        *options,
+    )
+    # We look for the built library
+    lib_file = None
+    for file in Path(session.virtualenv.location).rglob("pyo3_pytests.*"):
+        if file.is_file():
+            lib_file = str(file.resolve())
+    _run_cargo_test(
+        session,
+        package="pyo3-introspection",
+        env={"PYO3_PYTEST_LIB_PATH": lib_file},
+    )
 
 
 def _build_docs_for_ffi_check(session: nox.Session) -> None:
     # pyo3-ffi-check needs to scrape docs of pyo3-ffi
-    _run_cargo(session, "doc", _FFI_CHECK, "-p", "pyo3-ffi", "--no-deps")
+    env = os.environ.copy()
+    env["PYO3_PYTHON"] = sys.executable
+    _run_cargo(session, "doc", _FFI_CHECK, "-p", "pyo3-ffi", "--no-deps", env=env)
 
 
 @lru_cache()
@@ -605,7 +1144,7 @@ def _get_rust_info() -> Tuple[str, ...]:
     return tuple(output.splitlines())
 
 
-def _get_rust_version() -> Tuple[int, int, int, List[str]]:
+def get_rust_version() -> Tuple[int, int, int, List[str]]:
     for line in _get_rust_info():
         if line.startswith(_RELEASE_LINE_START):
             version = line[len(_RELEASE_LINE_START) :].strip()
@@ -614,6 +1153,13 @@ def _get_rust_version() -> Tuple[int, int, int, List[str]]:
             return (*map(int, version_number.split(".")), extra)
 
 
+def is_rust_nightly() -> bool:
+    for line in _get_rust_info():
+        if line.startswith(_RELEASE_LINE_START):
+            return line.strip().endswith("-nightly")
+    return False
+
+
 def _get_rust_default_target() -> str:
     for line in _get_rust_info():
         if line.startswith(_HOST_LINE_START):
@@ -621,31 +1167,20 @@ def _get_rust_default_target() -> str:
 
 
 @lru_cache()
-def _get_feature_sets() -> Tuple[Tuple[str, ...], ...]:
-    """Returns feature sets to use for clippy job"""
-    rust_version = _get_rust_version()
+def _get_feature_sets() -> Tuple[Optional[str], ...]:
+    """Returns feature sets to use for Rust jobs"""
     cargo_target = os.getenv("CARGO_BUILD_TARGET", "")
-    if rust_version[:2] >= (1, 62) and "wasm32-wasi" not in cargo_target:
-        # multiple-pymethods feature not supported before 1.62 or on WASI
-        return (
-            ("--no-default-features",),
-            (
-                "--no-default-features",
-                "--features=abi3",
-            ),
-            ("--features=full multiple-pymethods",),
-            ("--features=abi3 full multiple-pymethods",),
-        )
-    else:
-        return (
-            ("--no-default-features",),
-            (
-                "--no-default-features",
-                "--features=abi3",
-            ),
-            ("--features=full",),
-            ("--features=abi3 full",),
-        )
+
+    features = "full"
+
+    if "wasm32-wasip1" not in cargo_target:
+        # multiple-pymethods not supported on wasm
+        features += ",multiple-pymethods"
+
+    if is_rust_nightly():
+        features += ",nightly"
+
+    return (None, "abi3", features, f"abi3,{features}")
 
 
 _RELEASE_LINE_START = "release: "
@@ -673,12 +1208,24 @@ def _get_coverage_env() -> Dict[str, str]:
 
 def _run(session: nox.Session, *args: str, **kwargs: Any) -> None:
     """Wrapper for _run(session, which creates nice groups on GitHub Actions."""
-    if "GITHUB_ACTIONS" in os.environ:
+    is_github_actions = _is_github_actions()
+    failed = False
+    if is_github_actions:
         # Insert ::group:: at the start of nox's command line output
         print("::group::", end="", flush=True, file=sys.stderr)
-    session.run(*args, **kwargs)
-    if "GITHUB_ACTIONS" in os.environ:
-        print("::endgroup::", file=sys.stderr)
+    try:
+        session.run(*args, **kwargs)
+    except nox.command.CommandFailed:
+        failed = True
+        raise
+    finally:
+        if is_github_actions:
+            print("::endgroup::", file=sys.stderr)
+            # Defer the error message until after the group to make them easier
+            # to find in the log
+            if failed:
+                command = " ".join(args)
+                print(f"::error::`{command}` failed", file=sys.stderr)
 
 
 def _run_cargo(
@@ -696,19 +1243,27 @@ def _run_cargo_test(
     *,
     package: Optional[str] = None,
     features: Optional[str] = None,
+    env: Optional[Dict[str, str]] = None,
+    extra_flags: Optional[List[str]] = None,
 ) -> None:
     command = ["cargo"]
     if "careful" in session.posargs:
+        # do explicit setup so failures in setup can be seen
+        _run_cargo(session, "careful", "setup")
         command.append("careful")
+
     command.extend(("test", "--no-fail-fast"))
+
     if "release" in session.posargs:
         command.append("--release")
     if package:
         command.append(f"--package={package}")
     if features:
         command.append(f"--features={features}")
+    if extra_flags:
+        command.extend(extra_flags)
 
-    _run(session, *command, external=True)
+    _run(session, *command, external=True, env=env or {})
 
 
 def _run_cargo_publish(session: nox.Session, *, package: str) -> None:
@@ -728,10 +1283,6 @@ def _run_cargo_set_package_version(
     _run(session, *command, external=True)
 
 
-def _get_output(*args: str) -> str:
-    return subprocess.run(args, capture_output=True, text=True, check=True).stdout
-
-
 def _for_all_version_configs(
     session: nox.Session, job: Callable[[Dict[str, str]], None]
 ) -> None:
@@ -755,14 +1306,22 @@ class _ConfigFile:
     def __init__(self, config_file) -> None:
         self._config_file = config_file
 
-    def set(self, implementation: str, version: str) -> None:
+    def set(
+        self, implementation: str, version: str, build_flags: Iterable[str] = ()
+    ) -> None:
         """Set the contents of this config file to the given implementation and version."""
+        if version.endswith("t"):
+            # Free threaded versions pass the support in config file through a flag
+            version = version[:-1]
+            build_flags = (*build_flags, "Py_GIL_DISABLED")
+
         self._config_file.seek(0)
         self._config_file.truncate(0)
         self._config_file.write(
             f"""\
 implementation={implementation}
 version={version}
+build_flags={",".join(build_flags)}
 suppress_build_script_link_lines=true
 """
         )
@@ -780,5 +1339,9 @@ def _config_file() -> Iterator[_ConfigFile]:
         yield _ConfigFile(config)
 
 
+def _is_github_actions() -> bool:
+    return "GITHUB_ACTIONS" in os.environ
+
+
 _BENCHES = "--manifest-path=pyo3-benches/Cargo.toml"
 _FFI_CHECK = "--manifest-path=pyo3-ffi-check/Cargo.toml"
diff --git a/pyo3-benches/Cargo.toml b/pyo3-benches/Cargo.toml
index e99ef09e19c..6927bfa237d 100644
--- a/pyo3-benches/Cargo.toml
+++ b/pyo3-benches/Cargo.toml
@@ -9,16 +9,24 @@ publish = false
 [dependencies]
 pyo3 = { path = "../", features = ["auto-initialize", "full"] }
 
+[build-dependencies]
+pyo3-build-config = { path = "../pyo3-build-config" }
+
 [dev-dependencies]
-codspeed-criterion-compat = "2.3"
-criterion = "0.5.1"
+codspeed-criterion-compat = "4.0"
+criterion = "0.7.0"
 num-bigint = "0.4.3"
 rust_decimal = { version = "1.0.0", default-features = false }
+hashbrown = "0.16"
 
 [[bench]]
 name = "bench_any"
 harness = false
 
+[[bench]]
+name = "bench_attach"
+harness = false
+
 [[bench]]
 name = "bench_call"
 harness = false
@@ -44,7 +52,7 @@ name = "bench_frompyobject"
 harness = false
 
 [[bench]]
-name = "bench_gil"
+name = "bench_intopyobject"
 harness = false
 
 [[bench]]
@@ -52,11 +60,11 @@ name = "bench_list"
 harness = false
 
 [[bench]]
-name = "bench_pyclass"
+name = "bench_py"
 harness = false
 
 [[bench]]
-name = "bench_pyobject"
+name = "bench_pyclass"
 harness = false
 
 [[bench]]
diff --git a/pyo3-benches/benches/bench_any.rs b/pyo3-benches/benches/bench_any.rs
index b77ab9567a6..827f4713990 100644
--- a/pyo3-benches/benches/bench_any.rs
+++ b/pyo3-benches/benches/bench_any.rs
@@ -52,9 +52,9 @@ fn find_object_type(obj: &Bound<'_, PyAny>) -> ObjectType {
         ObjectType::Str
     } else if obj.is_instance_of::<PyTuple>() {
         ObjectType::Tuple
-    } else if obj.downcast::<PySequence>().is_ok() {
+    } else if obj.cast::<PySequence>().is_ok() {
         ObjectType::Sequence
-    } else if obj.downcast::<PyMapping>().is_ok() {
+    } else if obj.cast::<PyMapping>().is_ok() {
         ObjectType::Mapping
     } else {
         ObjectType::Unknown
@@ -62,8 +62,8 @@ fn find_object_type(obj: &Bound<'_, PyAny>) -> ObjectType {
 }
 
 fn bench_identify_object_type(b: &mut Bencher<'_>) {
-    Python::with_gil(|py| {
-        let obj = py.eval_bound("object()", None, None).unwrap();
+    Python::attach(|py| {
+        let obj = py.eval(c"object()", None, None).unwrap();
 
         b.iter(|| find_object_type(&obj));
 
@@ -72,12 +72,12 @@ fn bench_identify_object_type(b: &mut Bencher<'_>) {
 }
 
 fn bench_collect_generic_iterator(b: &mut Bencher<'_>) {
-    Python::with_gil(|py| {
-        let collection = py.eval_bound("list(range(1 << 20))", None, None).unwrap();
+    Python::attach(|py| {
+        let collection = py.eval(c"list(range(1 << 20))", None, None).unwrap();
 
         b.iter(|| {
             collection
-                .iter()
+                .try_iter()
                 .unwrap()
                 .collect::<PyResult<Vec<_>>>()
                 .unwrap()
diff --git a/pyo3-benches/benches/bench_attach.rs b/pyo3-benches/benches/bench_attach.rs
new file mode 100644
index 00000000000..745a7555b89
--- /dev/null
+++ b/pyo3-benches/benches/bench_attach.rs
@@ -0,0 +1,22 @@
+use codspeed_criterion_compat::{criterion_group, criterion_main, Bencher, Criterion};
+
+use pyo3::prelude::*;
+
+fn bench_clean_attach(b: &mut Bencher<'_>) {
+    // Acquiring first GIL will also create a "clean" GILPool, so this measures the Python overhead.
+    b.iter(|| Python::attach(|_| {}));
+}
+
+fn bench_dirty_attach(b: &mut Bencher<'_>) {
+    let obj = Python::attach(|py| py.None());
+    // Drop the returned clone of the object so that the reference pool has work to do.
+    b.iter(|| Python::attach(|py| obj.clone_ref(py)));
+}
+
+fn criterion_benchmark(c: &mut Criterion) {
+    c.bench_function("clean_attach", bench_clean_attach);
+    c.bench_function("dirty_attach", bench_dirty_attach);
+}
+
+criterion_group!(benches, criterion_benchmark);
+criterion_main!(benches);
diff --git a/pyo3-benches/benches/bench_bigint.rs b/pyo3-benches/benches/bench_bigint.rs
index 4a50b437d95..6227e95e496 100644
--- a/pyo3-benches/benches/bench_bigint.rs
+++ b/pyo3-benches/benches/bench_bigint.rs
@@ -1,73 +1,59 @@
-use codspeed_criterion_compat::{black_box, criterion_group, criterion_main, Bencher, Criterion};
+use std::hint::black_box;
+
+use codspeed_criterion_compat::{criterion_group, criterion_main, Bencher, Criterion};
+use num_bigint::BigInt;
 
 use pyo3::prelude::*;
 use pyo3::types::PyDict;
 
-use num_bigint::BigInt;
-
 fn extract_bigint_extract_fail(bench: &mut Bencher<'_>) {
-    Python::with_gil(|py| {
-        let d = PyDict::new_bound(py).into_any();
+    Python::attach(|py| {
+        let d = PyDict::new(py).into_any();
 
         bench.iter(|| match black_box(&d).extract::<BigInt>() {
             Ok(v) => panic!("should err {}", v),
-            Err(e) => black_box(e),
+            Err(e) => e,
         });
     });
 }
 
 fn extract_bigint_small(bench: &mut Bencher<'_>) {
-    Python::with_gil(|py| {
-        let int = py.eval_bound("-42", None, None).unwrap();
+    Python::attach(|py| {
+        let int = py.eval(c"-42", None, None).unwrap();
 
-        bench.iter(|| {
-            let v = black_box(&int).extract::<BigInt>().unwrap();
-            black_box(v);
-        });
+        bench.iter_with_large_drop(|| black_box(&int).extract::<BigInt>().unwrap());
     });
 }
 
 fn extract_bigint_big_negative(bench: &mut Bencher<'_>) {
-    Python::with_gil(|py| {
-        let int = py.eval_bound("-10**300", None, None).unwrap();
+    Python::attach(|py| {
+        let int = py.eval(c"-10**300", None, None).unwrap();
 
-        bench.iter(|| {
-            let v = black_box(&int).extract::<BigInt>().unwrap();
-            black_box(v);
-        });
+        bench.iter_with_large_drop(|| black_box(&int).extract::<BigInt>().unwrap());
     });
 }
 
 fn extract_bigint_big_positive(bench: &mut Bencher<'_>) {
-    Python::with_gil(|py| {
-        let int = py.eval_bound("10**300", None, None).unwrap();
+    Python::attach(|py| {
+        let int = py.eval(c"10**300", None, None).unwrap();
 
-        bench.iter(|| {
-            let v = black_box(&int).extract::<BigInt>().unwrap();
-            black_box(v);
-        });
+        bench.iter_with_large_drop(|| black_box(&int).extract::<BigInt>().unwrap());
     });
 }
 
 fn extract_bigint_huge_negative(bench: &mut Bencher<'_>) {
-    Python::with_gil(|py| {
-        let int = py.eval_bound("-10**3000", None, None).unwrap();
+    Python::attach(|py| {
+        let int = py.eval(c"-10**3000", None, None).unwrap();
 
-        bench.iter(|| {
-            let v = black_box(&int).extract::<BigInt>().unwrap();
-            black_box(v);
-        });
+        bench.iter_with_large_drop(|| black_box(&int).extract::<BigInt>().unwrap());
     });
 }
 
 fn extract_bigint_huge_positive(bench: &mut Bencher<'_>) {
-    Python::with_gil(|py| {
-        let int = py.eval_bound("10**3000", None, None).unwrap();
+    Python::attach(|py| {
+        let int = py.eval(c"10**3000", None, None).unwrap();
 
-        bench.iter(|| {
-            let v = black_box(&int).extract::<BigInt>().unwrap();
-            black_box(v);
-        });
+        bench.iter_with_large_drop(|| black_box(&int).extract::<BigInt>().unwrap());
     });
 }
 
diff --git a/pyo3-benches/benches/bench_call.rs b/pyo3-benches/benches/bench_call.rs
index 50772097961..909e5761149 100644
--- a/pyo3-benches/benches/bench_call.rs
+++ b/pyo3-benches/benches/bench_call.rs
@@ -1,29 +1,90 @@
+use std::hint::black_box;
+
 use codspeed_criterion_compat::{criterion_group, criterion_main, Bencher, Criterion};
 
+use pyo3::ffi::c_str;
 use pyo3::prelude::*;
+use pyo3::types::IntoPyDict;
 
 macro_rules! test_module {
     ($py:ident, $code:literal) => {
-        PyModule::from_code($py, $code, file!(), "test_module").expect("module creation failed")
+        PyModule::from_code($py, c_str!($code), c_str!(file!()), c"test_module")
+            .expect("module creation failed")
     };
 }
 
 fn bench_call_0(b: &mut Bencher<'_>) {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let module = test_module!(py, "def foo(): pass");
 
-        let foo_module = module.getattr("foo").unwrap();
+        let foo_module = &module.getattr("foo").unwrap();
+
+        b.iter(|| {
+            for _ in 0..1000 {
+                black_box(foo_module).call0().unwrap();
+            }
+        });
+    })
+}
+
+fn bench_call_1(b: &mut Bencher<'_>) {
+    Python::attach(|py| {
+        let module = test_module!(py, "def foo(a, b, c): pass");
+
+        let foo_module = &module.getattr("foo").unwrap();
+        let args = (
+            1.into_pyobject(py).unwrap(),
+            "s".into_pyobject(py).unwrap(),
+            1.23.into_pyobject(py).unwrap(),
+        );
+
+        b.iter(|| {
+            for _ in 0..1000 {
+                black_box(foo_module).call1(args.clone()).unwrap();
+            }
+        });
+    })
+}
+
+fn bench_call(b: &mut Bencher<'_>) {
+    Python::attach(|py| {
+        let module = test_module!(py, "def foo(a, b, c, d, e): pass");
+
+        let foo_module = &module.getattr("foo").unwrap();
+        let args = (
+            1.into_pyobject(py).unwrap(),
+            "s".into_pyobject(py).unwrap(),
+            1.23.into_pyobject(py).unwrap(),
+        );
+        let kwargs = [("d", 1), ("e", 42)].into_py_dict(py).unwrap();
+
+        b.iter(|| {
+            for _ in 0..1000 {
+                black_box(foo_module)
+                    .call(args.clone(), Some(&kwargs))
+                    .unwrap();
+            }
+        });
+    })
+}
+
+fn bench_call_one_arg(b: &mut Bencher<'_>) {
+    Python::attach(|py| {
+        let module = test_module!(py, "def foo(a): pass");
+
+        let foo_module = &module.getattr("foo").unwrap();
+        let arg = 1i32.into_pyobject(py).unwrap();
 
         b.iter(|| {
             for _ in 0..1000 {
-                foo_module.call0().unwrap();
+                black_box(foo_module).call1((arg.clone(),)).unwrap();
             }
         });
     })
 }
 
 fn bench_call_method_0(b: &mut Bencher<'_>) {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let module = test_module!(
             py,
             "
@@ -33,11 +94,92 @@ class Foo:
 "
         );
 
-        let foo_module = module.getattr("Foo").unwrap().call0().unwrap();
+        let foo_module = &module.getattr("Foo").unwrap().call0().unwrap();
+
+        b.iter(|| {
+            for _ in 0..1000 {
+                black_box(foo_module).call_method0("foo").unwrap();
+            }
+        });
+    })
+}
+
+fn bench_call_method_1(b: &mut Bencher<'_>) {
+    Python::attach(|py| {
+        let module = test_module!(
+            py,
+            "
+class Foo:
+    def foo(self, a, b, c):
+        pass
+"
+        );
+
+        let foo_module = &module.getattr("Foo").unwrap().call0().unwrap();
+        let args = (
+            1.into_pyobject(py).unwrap(),
+            "s".into_pyobject(py).unwrap(),
+            1.23.into_pyobject(py).unwrap(),
+        );
+
+        b.iter(|| {
+            for _ in 0..1000 {
+                black_box(foo_module)
+                    .call_method1("foo", args.clone())
+                    .unwrap();
+            }
+        });
+    })
+}
+
+fn bench_call_method(b: &mut Bencher<'_>) {
+    Python::attach(|py| {
+        let module = test_module!(
+            py,
+            "
+class Foo:
+    def foo(self, a, b, c, d, e):
+        pass
+"
+        );
+
+        let foo_module = &module.getattr("Foo").unwrap().call0().unwrap();
+        let args = (
+            1.into_pyobject(py).unwrap(),
+            "s".into_pyobject(py).unwrap(),
+            1.23.into_pyobject(py).unwrap(),
+        );
+        let kwargs = [("d", 1), ("e", 42)].into_py_dict(py).unwrap();
+
+        b.iter(|| {
+            for _ in 0..1000 {
+                black_box(foo_module)
+                    .call_method("foo", args.clone(), Some(&kwargs))
+                    .unwrap();
+            }
+        });
+    })
+}
+
+fn bench_call_method_one_arg(b: &mut Bencher<'_>) {
+    Python::attach(|py| {
+        let module = test_module!(
+            py,
+            "
+class Foo:
+    def foo(self, a):
+        pass
+"
+        );
+
+        let foo_module = &module.getattr("Foo").unwrap().call0().unwrap();
+        let arg = 1i32.into_pyobject(py).unwrap();
 
         b.iter(|| {
             for _ in 0..1000 {
-                foo_module.call_method0("foo").unwrap();
+                black_box(foo_module)
+                    .call_method1("foo", (arg.clone(),))
+                    .unwrap();
             }
         });
     })
@@ -45,7 +187,13 @@ class Foo:
 
 fn criterion_benchmark(c: &mut Criterion) {
     c.bench_function("call_0", bench_call_0);
+    c.bench_function("call_1", bench_call_1);
+    c.bench_function("call", bench_call);
+    c.bench_function("call_one_arg", bench_call_one_arg);
     c.bench_function("call_method_0", bench_call_method_0);
+    c.bench_function("call_method_1", bench_call_method_1);
+    c.bench_function("call_method", bench_call_method);
+    c.bench_function("call_method_one_arg", bench_call_method_one_arg);
 }
 
 criterion_group!(benches, criterion_benchmark);
diff --git a/pyo3-benches/benches/bench_comparisons.rs b/pyo3-benches/benches/bench_comparisons.rs
index ffd4c1a452f..581e9738b75 100644
--- a/pyo3-benches/benches/bench_comparisons.rs
+++ b/pyo3-benches/benches/bench_comparisons.rs
@@ -44,18 +44,18 @@ impl OrderedRichcmp {
 }
 
 fn bench_ordered_dunder_methods(b: &mut Bencher<'_>) {
-    Python::with_gil(|py| {
-        let obj1 = Py::new(py, OrderedDunderMethods(0)).unwrap().into_ref(py);
-        let obj2 = Py::new(py, OrderedDunderMethods(1)).unwrap().into_ref(py);
+    Python::attach(|py| {
+        let obj1 = &Bound::new(py, OrderedDunderMethods(0)).unwrap().into_any();
+        let obj2 = &Bound::new(py, OrderedDunderMethods(1)).unwrap().into_any();
 
         b.iter(|| obj2.gt(obj1).unwrap());
     });
 }
 
 fn bench_ordered_richcmp(b: &mut Bencher<'_>) {
-    Python::with_gil(|py| {
-        let obj1 = Py::new(py, OrderedRichcmp(0)).unwrap().into_ref(py);
-        let obj2 = Py::new(py, OrderedRichcmp(1)).unwrap().into_ref(py);
+    Python::attach(|py| {
+        let obj1 = &Bound::new(py, OrderedRichcmp(0)).unwrap().into_any();
+        let obj2 = &Bound::new(py, OrderedRichcmp(1)).unwrap().into_any();
 
         b.iter(|| obj2.gt(obj1).unwrap());
     });
diff --git a/pyo3-benches/benches/bench_decimal.rs b/pyo3-benches/benches/bench_decimal.rs
index 6db6704bf8e..6a288253a82 100644
--- a/pyo3-benches/benches/bench_decimal.rs
+++ b/pyo3-benches/benches/bench_decimal.rs
@@ -1,14 +1,16 @@
-use codspeed_criterion_compat::{black_box, criterion_group, criterion_main, Bencher, Criterion};
+use std::hint::black_box;
+
+use codspeed_criterion_compat::{criterion_group, criterion_main, Bencher, Criterion};
+use rust_decimal::Decimal;
 
 use pyo3::prelude::*;
 use pyo3::types::PyDict;
-use rust_decimal::Decimal;
 
 fn decimal_via_extract(b: &mut Bencher<'_>) {
-    Python::with_gil(|py| {
-        let locals = PyDict::new_bound(py);
-        py.run_bound(
-            r#"
+    Python::attach(|py| {
+        let locals = PyDict::new(py);
+        py.run(
+            cr#"
 import decimal
 py_dec = decimal.Decimal("0.0")
 "#,
@@ -18,9 +20,7 @@ py_dec = decimal.Decimal("0.0")
         .unwrap();
         let py_dec = locals.get_item("py_dec").unwrap().unwrap();
 
-        b.iter(|| {
-            let _: Decimal = black_box(&py_dec).extract().unwrap();
-        });
+        b.iter(|| black_box(&py_dec).extract::<Decimal>().unwrap());
     })
 }
 
diff --git a/pyo3-benches/benches/bench_dict.rs b/pyo3-benches/benches/bench_dict.rs
index 072dd9408ce..8ea38b7f67e 100644
--- a/pyo3-benches/benches/bench_dict.rs
+++ b/pyo3-benches/benches/bench_dict.rs
@@ -1,17 +1,21 @@
+use std::collections::{BTreeMap, HashMap};
+use std::hint::black_box;
+
 use codspeed_criterion_compat::{criterion_group, criterion_main, Bencher, Criterion};
 
 use pyo3::types::IntoPyDict;
 use pyo3::{prelude::*, types::PyMapping};
-use std::collections::{BTreeMap, HashMap};
-use std::hint::black_box;
 
 fn iter_dict(b: &mut Bencher<'_>) {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         const LEN: usize = 100_000;
-        let dict = (0..LEN as u64).map(|i| (i, i * 2)).into_py_dict_bound(py);
+        let dict = (0..LEN as u64)
+            .map(|i| (i, i * 2))
+            .into_py_dict(py)
+            .unwrap();
         let mut sum = 0;
         b.iter(|| {
-            for (k, _v) in dict.iter() {
+            for (k, _v) in &dict {
                 let i: u64 = k.extract().unwrap();
                 sum += i;
             }
@@ -20,16 +24,24 @@ fn iter_dict(b: &mut Bencher<'_>) {
 }
 
 fn dict_new(b: &mut Bencher<'_>) {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         const LEN: usize = 50_000;
-        b.iter_with_large_drop(|| (0..LEN as u64).map(|i| (i, i * 2)).into_py_dict_bound(py));
+        b.iter_with_large_drop(|| {
+            (0..LEN as u64)
+                .map(|i| (i, i * 2))
+                .into_py_dict(py)
+                .unwrap()
+        });
     });
 }
 
 fn dict_get_item(b: &mut Bencher<'_>) {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         const LEN: usize = 50_000;
-        let dict = (0..LEN as u64).map(|i| (i, i * 2)).into_py_dict_bound(py);
+        let dict = (0..LEN as u64)
+            .map(|i| (i, i * 2))
+            .into_py_dict(py)
+            .unwrap();
         let mut sum = 0;
         b.iter(|| {
             for i in 0..LEN {
@@ -45,35 +57,49 @@ fn dict_get_item(b: &mut Bencher<'_>) {
 }
 
 fn extract_hashmap(b: &mut Bencher<'_>) {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         const LEN: usize = 100_000;
-        let dict = (0..LEN as u64).map(|i| (i, i * 2)).into_py_dict_bound(py);
-        b.iter(|| HashMap::<u64, u64>::extract_bound(&dict));
+        let dict = (0..LEN as u64)
+            .map(|i| (i, i * 2))
+            .into_py_dict(py)
+            .unwrap()
+            .into_any();
+        b.iter(|| HashMap::<u64, u64>::extract(dict.as_borrowed()));
     });
 }
 
 fn extract_btreemap(b: &mut Bencher<'_>) {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         const LEN: usize = 100_000;
-        let dict = (0..LEN as u64).map(|i| (i, i * 2)).into_py_dict_bound(py);
-        b.iter(|| BTreeMap::<u64, u64>::extract_bound(&dict));
+        let dict = (0..LEN as u64)
+            .map(|i| (i, i * 2))
+            .into_py_dict(py)
+            .unwrap()
+            .into_any();
+        b.iter(|| BTreeMap::<u64, u64>::extract(dict.as_borrowed()));
     });
 }
 
-#[cfg(feature = "hashbrown")]
 fn extract_hashbrown_map(b: &mut Bencher<'_>) {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         const LEN: usize = 100_000;
-        let dict = (0..LEN as u64).map(|i| (i, i * 2)).into_py_dict_bound(py);
-        b.iter(|| hashbrown::HashMap::<u64, u64>::extract_bound(&dict));
+        let dict = (0..LEN as u64)
+            .map(|i| (i, i * 2))
+            .into_py_dict(py)
+            .unwrap()
+            .into_any();
+        b.iter(|| hashbrown::HashMap::<u64, u64>::extract(dict.as_borrowed()));
     });
 }
 
 fn mapping_from_dict(b: &mut Bencher<'_>) {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         const LEN: usize = 100_000;
-        let dict = &(0..LEN as u64).map(|i| (i, i * 2)).into_py_dict_bound(py);
-        b.iter(|| black_box(dict).downcast::<PyMapping>().unwrap());
+        let dict = &(0..LEN as u64)
+            .map(|i| (i, i * 2))
+            .into_py_dict(py)
+            .unwrap();
+        b.iter(|| black_box(dict).cast::<PyMapping>().unwrap());
     });
 }
 
@@ -83,11 +109,8 @@ fn criterion_benchmark(c: &mut Criterion) {
     c.bench_function("dict_get_item", dict_get_item);
     c.bench_function("extract_hashmap", extract_hashmap);
     c.bench_function("extract_btreemap", extract_btreemap);
-
-    #[cfg(feature = "hashbrown")]
-    c.bench_function("extract_hashbrown_map", extract_hashbrown_map);
-
     c.bench_function("mapping_from_dict", mapping_from_dict);
+    c.bench_function("extract_hashbrown_map", extract_hashbrown_map);
 }
 
 criterion_group!(benches, criterion_benchmark);
diff --git a/pyo3-benches/benches/bench_err.rs b/pyo3-benches/benches/bench_err.rs
index 998ed6975b0..543df090d48 100644
--- a/pyo3-benches/benches/bench_err.rs
+++ b/pyo3-benches/benches/bench_err.rs
@@ -3,7 +3,7 @@ use codspeed_criterion_compat::{criterion_group, criterion_main, Bencher, Criter
 use pyo3::{exceptions::PyValueError, prelude::*};
 
 fn err_new_restore_and_fetch(b: &mut Bencher<'_>) {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         b.iter(|| {
             PyValueError::new_err("some exception message").restore(py);
             PyErr::fetch(py)
diff --git a/pyo3-benches/benches/bench_extract.rs b/pyo3-benches/benches/bench_extract.rs
index 1c783c3b706..1364185bcdd 100644
--- a/pyo3-benches/benches/bench_extract.rs
+++ b/pyo3-benches/benches/bench_extract.rs
@@ -1,4 +1,6 @@
-use codspeed_criterion_compat::{black_box, criterion_group, criterion_main, Bencher, Criterion};
+use std::hint::black_box;
+
+use codspeed_criterion_compat::{criterion_group, criterion_main, Bencher, Criterion};
 
 use pyo3::{
     prelude::*,
@@ -6,88 +8,82 @@ use pyo3::{
 };
 
 fn extract_str_extract_success(bench: &mut Bencher<'_>) {
-    Python::with_gil(|py| {
-        let s = &PyString::new_bound(py, "Hello, World!");
+    Python::attach(|py| {
+        let s = PyString::new(py, "Hello, World!").into_any();
 
-        bench.iter(|| black_box(s).extract::<&str>().unwrap());
+        bench.iter(|| black_box(&s).extract::<&str>().unwrap());
     });
 }
 
 fn extract_str_extract_fail(bench: &mut Bencher<'_>) {
-    Python::with_gil(|py| {
-        let d = PyDict::new_bound(py).into_any();
+    Python::attach(|py| {
+        let d = PyDict::new(py).into_any();
 
         bench.iter(|| match black_box(&d).extract::<&str>() {
             Ok(v) => panic!("should err {}", v),
-            Err(e) => black_box(e),
+            Err(e) => e,
         });
     });
 }
 
-#[cfg(any(Py_3_10, not(Py_LIMITED_API)))]
-fn extract_str_downcast_success(bench: &mut Bencher<'_>) {
-    Python::with_gil(|py| {
-        let s = &PyString::new_bound(py, "Hello, World!");
+#[cfg(Py_3_10)]
+fn extract_str_cast_success(bench: &mut Bencher<'_>) {
+    Python::attach(|py| {
+        let s = PyString::new(py, "Hello, World!").into_any();
 
         bench.iter(|| {
-            let py_str = black_box(s).downcast::<PyString>().unwrap();
+            let py_str = black_box(&s).cast::<PyString>().unwrap();
             py_str.to_str().unwrap()
         });
     });
 }
 
-fn extract_str_downcast_fail(bench: &mut Bencher<'_>) {
-    Python::with_gil(|py| {
-        let d = PyDict::new_bound(py).into_any();
+fn extract_str_cast_fail(bench: &mut Bencher<'_>) {
+    Python::attach(|py| {
+        let d = PyDict::new(py).into_any();
 
-        bench.iter(|| match black_box(&d).downcast::<PyString>() {
+        bench.iter(|| match black_box(&d).cast::<PyString>() {
             Ok(v) => panic!("should err {}", v),
-            Err(e) => black_box(e),
+            Err(e) => e,
         });
     });
 }
 
 fn extract_int_extract_success(bench: &mut Bencher<'_>) {
-    Python::with_gil(|py| {
-        let int_obj: PyObject = 123.into_py(py);
-        let int = int_obj.as_ref(py);
+    Python::attach(|py| {
+        let int = 123i32.into_pyobject(py).unwrap();
 
-        bench.iter(|| {
-            let v = black_box(int).extract::<i64>().unwrap();
-            black_box(v);
-        });
+        bench.iter(|| black_box(&int).extract::<i64>().unwrap());
     });
 }
 
 fn extract_int_extract_fail(bench: &mut Bencher<'_>) {
-    Python::with_gil(|py| {
-        let d = PyDict::new_bound(py).into_any();
+    Python::attach(|py| {
+        let d = PyDict::new(py).into_any();
 
         bench.iter(|| match black_box(&d).extract::<i64>() {
             Ok(v) => panic!("should err {}", v),
-            Err(e) => black_box(e),
+            Err(e) => e,
         });
     });
 }
 
-fn extract_int_downcast_success(bench: &mut Bencher<'_>) {
-    Python::with_gil(|py| {
-        let int_obj: PyObject = 123.into_py(py);
-        let int = int_obj.as_ref(py);
+fn extract_int_cast_success(bench: &mut Bencher<'_>) {
+    Python::attach(|py| {
+        let int = 123i32.into_pyobject(py).unwrap();
 
         bench.iter(|| {
-            let py_int = black_box(int).downcast::<PyInt>().unwrap();
-            let v = py_int.extract::<i64>().unwrap();
-            black_box(v);
+            let py_int = black_box(&int).cast::<PyInt>().unwrap();
+            py_int.extract::<i64>().unwrap()
         });
     });
 }
 
-fn extract_int_downcast_fail(bench: &mut Bencher<'_>) {
-    Python::with_gil(|py| {
-        let d = PyDict::new_bound(py).into_any();
+fn extract_int_cast_fail(bench: &mut Bencher<'_>) {
+    Python::attach(|py| {
+        let d = PyDict::new(py).into_any();
 
-        bench.iter(|| match black_box(&d).downcast::<PyInt>() {
+        bench.iter(|| match black_box(&d).cast::<PyInt>() {
             Ok(v) => panic!("should err {}", v),
             Err(e) => black_box(e),
         });
@@ -95,48 +91,42 @@ fn extract_int_downcast_fail(bench: &mut Bencher<'_>) {
 }
 
 fn extract_float_extract_success(bench: &mut Bencher<'_>) {
-    Python::with_gil(|py| {
-        let float_obj: PyObject = 23.42.into_py(py);
-        let float = float_obj.as_ref(py);
+    Python::attach(|py| {
+        let float = 23.42f64.into_pyobject(py).unwrap();
 
-        bench.iter(|| {
-            let v = black_box(float).extract::<f64>().unwrap();
-            black_box(v);
-        });
+        bench.iter(|| black_box(&float).extract::<f64>().unwrap());
     });
 }
 
 fn extract_float_extract_fail(bench: &mut Bencher<'_>) {
-    Python::with_gil(|py| {
-        let d = PyDict::new_bound(py).into_any();
+    Python::attach(|py| {
+        let d = PyDict::new(py).into_any();
 
         bench.iter(|| match black_box(&d).extract::<f64>() {
             Ok(v) => panic!("should err {}", v),
-            Err(e) => black_box(e),
+            Err(e) => e,
         });
     });
 }
 
-fn extract_float_downcast_success(bench: &mut Bencher<'_>) {
-    Python::with_gil(|py| {
-        let float_obj: PyObject = 23.42.into_py(py);
-        let float = float_obj.as_ref(py);
+fn extract_float_cast_success(bench: &mut Bencher<'_>) {
+    Python::attach(|py| {
+        let float = 23.42f64.into_pyobject(py).unwrap();
 
         bench.iter(|| {
-            let py_int = black_box(float).downcast::<PyFloat>().unwrap();
-            let v = py_int.extract::<f64>().unwrap();
-            black_box(v);
+            let py_float = black_box(&float).cast::<PyFloat>().unwrap();
+            py_float.value()
         });
     });
 }
 
-fn extract_float_downcast_fail(bench: &mut Bencher<'_>) {
-    Python::with_gil(|py| {
-        let d = PyDict::new_bound(py).into_any();
+fn extract_float_cast_fail(bench: &mut Bencher<'_>) {
+    Python::attach(|py| {
+        let d = PyDict::new(py).into_any();
 
-        bench.iter(|| match black_box(&d).downcast::<PyFloat>() {
+        bench.iter(|| match black_box(&d).cast::<PyFloat>() {
             Ok(v) => panic!("should err {}", v),
-            Err(e) => black_box(e),
+            Err(e) => e,
         });
     });
 }
@@ -145,22 +135,22 @@ fn criterion_benchmark(c: &mut Criterion) {
     c.bench_function("extract_str_extract_success", extract_str_extract_success);
     c.bench_function("extract_str_extract_fail", extract_str_extract_fail);
     #[cfg(any(Py_3_10, not(Py_LIMITED_API)))]
-    c.bench_function("extract_str_downcast_success", extract_str_downcast_success);
-    c.bench_function("extract_str_downcast_fail", extract_str_downcast_fail);
+    c.bench_function("extract_str_cast_success", extract_str_cast_success);
+    c.bench_function("extract_str_cast_fail", extract_str_cast_fail);
     c.bench_function("extract_int_extract_success", extract_int_extract_success);
     c.bench_function("extract_int_extract_fail", extract_int_extract_fail);
-    c.bench_function("extract_int_downcast_success", extract_int_downcast_success);
-    c.bench_function("extract_int_downcast_fail", extract_int_downcast_fail);
+    c.bench_function("extract_int_cast_success", extract_int_cast_success);
+    c.bench_function("extract_int_cast_fail", extract_int_cast_fail);
     c.bench_function(
         "extract_float_extract_success",
         extract_float_extract_success,
     );
     c.bench_function("extract_float_extract_fail", extract_float_extract_fail);
     c.bench_function(
-        "extract_float_downcast_success",
-        extract_float_downcast_success,
+        "extract_float_cast_success",
+        extract_float_cast_success,
     );
-    c.bench_function("extract_float_downcast_fail", extract_float_downcast_fail);
+    c.bench_function("extract_float_cast_fail", extract_float_cast_fail);
 }
 
 criterion_group!(benches, criterion_benchmark);
diff --git a/pyo3-benches/benches/bench_frompyobject.rs b/pyo3-benches/benches/bench_frompyobject.rs
index 8114ee5a802..43e128b62ec 100644
--- a/pyo3-benches/benches/bench_frompyobject.rs
+++ b/pyo3-benches/benches/bench_frompyobject.rs
@@ -1,11 +1,14 @@
-use codspeed_criterion_compat::{black_box, criterion_group, criterion_main, Bencher, Criterion};
+use std::hint::black_box;
+
+use codspeed_criterion_compat::{criterion_group, criterion_main, Bencher, Criterion};
 
 use pyo3::{
     prelude::*,
-    types::{PyFloat, PyList, PyString},
+    types::{PyByteArray, PyBytes, PyList, PyString},
 };
 
 #[derive(FromPyObject)]
+#[allow(dead_code)]
 enum ManyTypes {
     Int(i32),
     Bytes(Vec<u8>),
@@ -13,42 +16,42 @@ enum ManyTypes {
 }
 
 fn enum_from_pyobject(b: &mut Bencher<'_>) {
-    Python::with_gil(|py| {
-        let any: &Bound<'_, PyAny> = &PyString::new_bound(py, "hello world");
+    Python::attach(|py| {
+        let any = PyString::new(py, "hello world").into_any();
 
-        b.iter(|| any.extract::<ManyTypes>().unwrap());
+        b.iter(|| black_box(&any).extract::<ManyTypes>().unwrap());
     })
 }
 
-fn list_via_downcast(b: &mut Bencher<'_>) {
-    Python::with_gil(|py| {
-        let any: &Bound<'_, PyAny> = &PyList::empty_bound(py);
+fn list_via_cast(b: &mut Bencher<'_>) {
+    Python::attach(|py| {
+        let any = PyList::empty(py).into_any();
 
-        b.iter(|| black_box(any).downcast::<PyList>().unwrap());
+        b.iter(|| black_box(&any).cast::<PyList>().unwrap());
     })
 }
 
 fn list_via_extract(b: &mut Bencher<'_>) {
-    Python::with_gil(|py| {
-        let any: &Bound<'_, PyAny> = &PyList::empty_bound(py);
+    Python::attach(|py| {
+        let any = PyList::empty(py).into_any();
 
-        b.iter(|| black_box(any).extract::<Bound<'_, PyList>>().unwrap());
+        b.iter(|| black_box(&any).extract::<Bound<'_, PyList>>().unwrap());
     })
 }
 
-fn not_a_list_via_downcast(b: &mut Bencher<'_>) {
-    Python::with_gil(|py| {
-        let any: &Bound<'_, PyAny> = &PyString::new_bound(py, "foobar");
+fn not_a_list_via_cast(b: &mut Bencher<'_>) {
+    Python::attach(|py| {
+        let any = PyString::new(py, "foobar").into_any();
 
-        b.iter(|| black_box(any).downcast::<PyList>().unwrap_err());
+        b.iter(|| black_box(&any).cast::<PyList>().unwrap_err());
     })
 }
 
 fn not_a_list_via_extract(b: &mut Bencher<'_>) {
-    Python::with_gil(|py| {
-        let any: &Bound<'_, PyAny> = &PyString::new_bound(py, "foobar");
+    Python::attach(|py| {
+        let any = PyString::new(py, "foobar").into_any();
 
-        b.iter(|| black_box(any).extract::<Bound<'_, PyList>>().unwrap_err());
+        b.iter(|| black_box(&any).extract::<Bound<'_, PyList>>().unwrap_err());
     })
 }
 
@@ -59,10 +62,10 @@ enum ListOrNotList<'a> {
 }
 
 fn not_a_list_via_extract_enum(b: &mut Bencher<'_>) {
-    Python::with_gil(|py| {
-        let any: &Bound<'_, PyAny> = &PyString::new_bound(py, "foobar");
+    Python::attach(|py| {
+        let any = PyString::new(py, "foobar").into_any();
 
-        b.iter(|| match black_box(any).extract::<ListOrNotList<'_>>() {
+        b.iter(|| match black_box(&any).extract::<ListOrNotList<'_>>() {
             Ok(ListOrNotList::List(_list)) => panic!(),
             Ok(ListOrNotList::NotList(any)) => any,
             Err(_) => panic!(),
@@ -70,21 +73,86 @@ fn not_a_list_via_extract_enum(b: &mut Bencher<'_>) {
     })
 }
 
-fn f64_from_pyobject(b: &mut Bencher<'_>) {
-    Python::with_gil(|py| {
-        let obj = &PyFloat::new_bound(py, 1.234);
-        b.iter(|| black_box(obj).extract::<f64>().unwrap());
+fn bench_vec_from_py_bytes(b: &mut Bencher<'_>, data: &[u8]) {
+    Python::attach(|py| {
+        let any = PyBytes::new(py, data).into_any();
+
+        b.iter(|| black_box(&any).extract::<Vec<u8>>().unwrap());
+    })
+}
+
+fn vec_bytes_from_py_bytes_small(b: &mut Bencher<'_>) {
+    bench_vec_from_py_bytes(b, &[]);
+}
+
+fn vec_bytes_from_py_bytes_medium(b: &mut Bencher<'_>) {
+    let data = (0..u8::MAX).collect::<Vec<u8>>();
+    bench_vec_from_py_bytes(b, &data);
+}
+
+fn vec_bytes_from_py_bytes_large(b: &mut Bencher<'_>) {
+    let data = vec![10u8; 100_000];
+    bench_vec_from_py_bytes(b, &data);
+}
+
+fn bench_vec_from_py_bytearray(b: &mut Bencher<'_>, data: &[u8]) {
+    Python::attach(|py| {
+        let any = PyByteArray::new(py, data).into_any();
+
+        b.iter(|| black_box(&any).extract::<Vec<u8>>().unwrap());
     })
 }
 
+fn vec_bytes_from_py_bytearray_small(b: &mut Bencher<'_>) {
+    bench_vec_from_py_bytearray(b, &[]);
+}
+
+fn vec_bytes_from_py_bytearray_medium(b: &mut Bencher<'_>) {
+    let data = (0..u8::MAX).collect::<Vec<u8>>();
+    bench_vec_from_py_bytearray(b, &data);
+}
+
+fn vec_bytes_from_py_bytearray_large(b: &mut Bencher<'_>) {
+    let data = vec![10u8; 100_000];
+    bench_vec_from_py_bytearray(b, &data);
+}
+
 fn criterion_benchmark(c: &mut Criterion) {
     c.bench_function("enum_from_pyobject", enum_from_pyobject);
-    c.bench_function("list_via_downcast", list_via_downcast);
+
+    c.bench_function("list_via_cast", list_via_cast);
+
     c.bench_function("list_via_extract", list_via_extract);
-    c.bench_function("not_a_list_via_downcast", not_a_list_via_downcast);
+
+    c.bench_function("not_a_list_via_cast", not_a_list_via_cast);
     c.bench_function("not_a_list_via_extract", not_a_list_via_extract);
     c.bench_function("not_a_list_via_extract_enum", not_a_list_via_extract_enum);
-    c.bench_function("f64_from_pyobject", f64_from_pyobject);
+
+    c.bench_function(
+        "vec_bytes_from_py_bytes_small",
+        vec_bytes_from_py_bytes_small,
+    );
+    c.bench_function(
+        "vec_bytes_from_py_bytes_medium",
+        vec_bytes_from_py_bytes_medium,
+    );
+    c.bench_function(
+        "vec_bytes_from_py_bytes_large",
+        vec_bytes_from_py_bytes_large,
+    );
+
+    c.bench_function(
+        "vec_bytes_from_py_bytearray_small",
+        vec_bytes_from_py_bytearray_small,
+    );
+    c.bench_function(
+        "vec_bytes_from_py_bytearray_medium",
+        vec_bytes_from_py_bytearray_medium,
+    );
+    c.bench_function(
+        "vec_bytes_from_py_bytearray_large",
+        vec_bytes_from_py_bytearray_large,
+    );
 }
 
 criterion_group!(benches, criterion_benchmark);
diff --git a/pyo3-benches/benches/bench_gil.rs b/pyo3-benches/benches/bench_gil.rs
deleted file mode 100644
index 59b9ff9686f..00000000000
--- a/pyo3-benches/benches/bench_gil.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-use codspeed_criterion_compat::{criterion_group, criterion_main, BatchSize, Bencher, Criterion};
-
-use pyo3::prelude::*;
-
-fn bench_clean_acquire_gil(b: &mut Bencher<'_>) {
-    // Acquiring first GIL will also create a "clean" GILPool, so this measures the Python overhead.
-    b.iter(|| Python::with_gil(|_| {}));
-}
-
-fn bench_dirty_acquire_gil(b: &mut Bencher<'_>) {
-    let obj = Python::with_gil(|py| py.None());
-    b.iter_batched(
-        || {
-            // Clone and drop an object so that the GILPool has work to do.
-            let _ = obj.clone();
-        },
-        |_| Python::with_gil(|_| {}),
-        BatchSize::NumBatches(1),
-    );
-}
-
-fn criterion_benchmark(c: &mut Criterion) {
-    c.bench_function("clean_acquire_gil", bench_clean_acquire_gil);
-    c.bench_function("dirty_acquire_gil", bench_dirty_acquire_gil);
-}
-
-criterion_group!(benches, criterion_benchmark);
-criterion_main!(benches);
diff --git a/pyo3-benches/benches/bench_intern.rs b/pyo3-benches/benches/bench_intern.rs
index d8dd1b8fd30..a135fe13278 100644
--- a/pyo3-benches/benches/bench_intern.rs
+++ b/pyo3-benches/benches/bench_intern.rs
@@ -1,3 +1,5 @@
+use std::hint::black_box;
+
 use codspeed_criterion_compat::{criterion_group, criterion_main, Bencher, Criterion};
 
 use pyo3::prelude::*;
@@ -5,18 +7,18 @@ use pyo3::prelude::*;
 use pyo3::intern;
 
 fn getattr_direct(b: &mut Bencher<'_>) {
-    Python::with_gil(|py| {
-        let sys = py.import("sys").unwrap();
+    Python::attach(|py| {
+        let sys = &py.import("sys").unwrap();
 
-        b.iter(|| sys.getattr("version").unwrap());
+        b.iter(|| black_box(sys).getattr("version").unwrap());
     });
 }
 
 fn getattr_intern(b: &mut Bencher<'_>) {
-    Python::with_gil(|py| {
-        let sys = py.import("sys").unwrap();
+    Python::attach(|py| {
+        let sys = &py.import("sys").unwrap();
 
-        b.iter(|| sys.getattr(intern!(py, "version")).unwrap());
+        b.iter(|| black_box(sys).getattr(intern!(py, "version")).unwrap());
     });
 }
 
diff --git a/pyo3-benches/benches/bench_intopyobject.rs b/pyo3-benches/benches/bench_intopyobject.rs
new file mode 100644
index 00000000000..1ec88501bb2
--- /dev/null
+++ b/pyo3-benches/benches/bench_intopyobject.rs
@@ -0,0 +1,76 @@
+use std::hint::black_box;
+
+use codspeed_criterion_compat::{criterion_group, criterion_main, Bencher, Criterion};
+
+use pyo3::conversion::IntoPyObject;
+use pyo3::prelude::*;
+use pyo3::types::PyBytes;
+
+fn bench_bytes_new(b: &mut Bencher<'_>, data: &[u8]) {
+    Python::attach(|py| {
+        b.iter_with_large_drop(|| PyBytes::new(py, black_box(data)));
+    });
+}
+
+fn bytes_new_small(b: &mut Bencher<'_>) {
+    bench_bytes_new(b, &[]);
+}
+
+fn bytes_new_medium(b: &mut Bencher<'_>) {
+    let data = (0..u8::MAX).collect::<Vec<u8>>();
+    bench_bytes_new(b, &data);
+}
+
+fn bytes_new_large(b: &mut Bencher<'_>) {
+    let data = vec![10u8; 100_000];
+    bench_bytes_new(b, &data);
+}
+
+fn bench_bytes_into_pyobject(b: &mut Bencher<'_>, data: &[u8]) {
+    Python::attach(|py| {
+        b.iter_with_large_drop(|| black_box(data).into_pyobject(py));
+    });
+}
+
+fn byte_slice_into_pyobject_small(b: &mut Bencher<'_>) {
+    bench_bytes_into_pyobject(b, &[]);
+}
+
+fn byte_slice_into_pyobject_medium(b: &mut Bencher<'_>) {
+    let data = (0..u8::MAX).collect::<Vec<u8>>();
+    bench_bytes_into_pyobject(b, &data);
+}
+
+fn byte_slice_into_pyobject_large(b: &mut Bencher<'_>) {
+    let data = vec![10u8; 100_000];
+    bench_bytes_into_pyobject(b, &data);
+}
+
+fn vec_into_pyobject(b: &mut Bencher<'_>) {
+    Python::attach(|py| {
+        let bytes = (0..u8::MAX).collect::<Vec<u8>>();
+        b.iter_with_large_drop(|| black_box(&bytes).clone().into_pyobject(py));
+    });
+}
+
+fn criterion_benchmark(c: &mut Criterion) {
+    c.bench_function("bytes_new_small", bytes_new_small);
+    c.bench_function("bytes_new_medium", bytes_new_medium);
+    c.bench_function("bytes_new_large", bytes_new_large);
+    c.bench_function(
+        "byte_slice_into_pyobject_small",
+        byte_slice_into_pyobject_small,
+    );
+    c.bench_function(
+        "byte_slice_into_pyobject_medium",
+        byte_slice_into_pyobject_medium,
+    );
+    c.bench_function(
+        "byte_slice_into_pyobject_large",
+        byte_slice_into_pyobject_large,
+    );
+    c.bench_function("vec_into_pyobject", vec_into_pyobject);
+}
+
+criterion_group!(benches, criterion_benchmark);
+criterion_main!(benches);
diff --git a/pyo3-benches/benches/bench_list.rs b/pyo3-benches/benches/bench_list.rs
index e0f238c5599..5f83ff442f9 100644
--- a/pyo3-benches/benches/bench_list.rs
+++ b/pyo3-benches/benches/bench_list.rs
@@ -6,12 +6,12 @@ use pyo3::prelude::*;
 use pyo3::types::{PyList, PySequence};
 
 fn iter_list(b: &mut Bencher<'_>) {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         const LEN: usize = 100_000;
-        let list = PyList::new_bound(py, 0..LEN);
+        let list = PyList::new(py, 0..LEN).unwrap();
         let mut sum = 0;
         b.iter(|| {
-            for x in list.iter() {
+            for x in &list {
                 let i: u64 = x.extract().unwrap();
                 sum += i;
             }
@@ -20,16 +20,16 @@ fn iter_list(b: &mut Bencher<'_>) {
 }
 
 fn list_new(b: &mut Bencher<'_>) {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         const LEN: usize = 50_000;
-        b.iter_with_large_drop(|| PyList::new_bound(py, 0..LEN));
+        b.iter_with_large_drop(|| PyList::new(py, 0..LEN));
     });
 }
 
 fn list_get_item(b: &mut Bencher<'_>) {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         const LEN: usize = 50_000;
-        let list = PyList::new_bound(py, 0..LEN);
+        let list = PyList::new(py, 0..LEN).unwrap();
         let mut sum = 0;
         b.iter(|| {
             for i in 0..LEN {
@@ -39,11 +39,37 @@ fn list_get_item(b: &mut Bencher<'_>) {
     });
 }
 
-#[cfg(not(Py_LIMITED_API))]
+fn list_nth(b: &mut Bencher<'_>) {
+    Python::attach(|py| {
+        const LEN: usize = 50;
+        let list = PyList::new(py, 0..LEN).unwrap();
+        let mut sum = 0;
+        b.iter(|| {
+            for i in 0..LEN {
+                sum += list.iter().nth(i).unwrap().extract::<usize>().unwrap();
+            }
+        });
+    });
+}
+
+fn list_nth_back(b: &mut Bencher<'_>) {
+    Python::attach(|py| {
+        const LEN: usize = 50;
+        let list = PyList::new(py, 0..LEN).unwrap();
+        let mut sum = 0;
+        b.iter(|| {
+            for i in 0..LEN {
+                sum += list.iter().nth_back(i).unwrap().extract::<usize>().unwrap();
+            }
+        });
+    });
+}
+
+#[cfg(not(any(Py_LIMITED_API, Py_GIL_DISABLED)))]
 fn list_get_item_unchecked(b: &mut Bencher<'_>) {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         const LEN: usize = 50_000;
-        let list = PyList::new_bound(py, 0..LEN);
+        let list = PyList::new(py, 0..LEN).unwrap();
         let mut sum = 0;
         b.iter(|| {
             for i in 0..LEN {
@@ -56,18 +82,20 @@ fn list_get_item_unchecked(b: &mut Bencher<'_>) {
 }
 
 fn sequence_from_list(b: &mut Bencher<'_>) {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         const LEN: usize = 50_000;
-        let list = &PyList::new_bound(py, 0..LEN);
-        b.iter(|| black_box(list).downcast::<PySequence>().unwrap());
+        let list = &PyList::new(py, 0..LEN).unwrap();
+        b.iter(|| black_box(list).cast::<PySequence>().unwrap());
     });
 }
 
 fn criterion_benchmark(c: &mut Criterion) {
     c.bench_function("iter_list", iter_list);
     c.bench_function("list_new", list_new);
+    c.bench_function("list_nth", list_nth);
+    c.bench_function("list_nth_back", list_nth_back);
     c.bench_function("list_get_item", list_get_item);
-    #[cfg(not(Py_LIMITED_API))]
+    #[cfg(not(any(Py_LIMITED_API, Py_GIL_DISABLED)))]
     c.bench_function("list_get_item_unchecked", list_get_item_unchecked);
     c.bench_function("sequence_from_list", sequence_from_list);
 }
diff --git a/pyo3-benches/benches/bench_py.rs b/pyo3-benches/benches/bench_py.rs
new file mode 100644
index 00000000000..fa022a6186d
--- /dev/null
+++ b/pyo3-benches/benches/bench_py.rs
@@ -0,0 +1,116 @@
+use codspeed_criterion_compat::{criterion_group, criterion_main, BatchSize, Bencher, Criterion};
+
+use std::sync::{
+    atomic::{AtomicUsize, Ordering},
+    mpsc::channel,
+    Arc, Barrier,
+};
+use std::thread::spawn;
+use std::time::{Duration, Instant};
+
+use pyo3::prelude::*;
+
+fn drop_many_objects(b: &mut Bencher<'_>) {
+    Python::attach(|py| {
+        b.iter(|| {
+            for _ in 0..1000 {
+                drop(py.None());
+            }
+        });
+    });
+}
+
+fn drop_many_objects_without_gil(b: &mut Bencher<'_>) {
+    b.iter_batched(
+        || Python::attach(|py| (0..1000).map(|_| py.None()).collect::<Vec<Py<PyAny>>>()),
+        |objs| {
+            drop(objs);
+
+            Python::attach(|_py| ());
+        },
+        BatchSize::SmallInput,
+    );
+}
+
+fn drop_many_objects_multiple_threads(b: &mut Bencher<'_>) {
+    const THREADS: usize = 5;
+
+    let barrier = Arc::new(Barrier::new(1 + THREADS));
+
+    let done = Arc::new(AtomicUsize::new(0));
+
+    let sender = (0..THREADS)
+        .map(|_| {
+            let (sender, receiver) = channel();
+
+            let barrier = barrier.clone();
+
+            let done = done.clone();
+
+            spawn(move || {
+                for objs in receiver {
+                    barrier.wait();
+
+                    drop(objs);
+
+                    done.fetch_add(1, Ordering::AcqRel);
+                }
+            });
+
+            sender
+        })
+        .collect::<Vec<_>>();
+
+    b.iter_custom(|iters| {
+        let mut duration = Duration::ZERO;
+
+        let mut last_done = done.load(Ordering::Acquire);
+
+        for _ in 0..iters {
+            for sender in &sender {
+                let objs = Python::attach(|py| {
+                    (0..1000 / THREADS)
+                        .map(|_| py.None())
+                        .collect::<Vec<Py<PyAny>>>()
+                });
+
+                sender.send(objs).unwrap();
+            }
+
+            barrier.wait();
+
+            let start = Instant::now();
+
+            loop {
+                Python::attach(|_py| ());
+
+                let done = done.load(Ordering::Acquire);
+                if done - last_done == THREADS {
+                    last_done = done;
+                    break;
+                }
+            }
+
+            Python::attach(|_py| ());
+
+            duration += start.elapsed();
+        }
+
+        duration
+    });
+}
+
+fn criterion_benchmark(c: &mut Criterion) {
+    c.bench_function("drop_many_objects", drop_many_objects);
+    c.bench_function(
+        "drop_many_objects_without_gil",
+        drop_many_objects_without_gil,
+    );
+    c.bench_function(
+        "drop_many_objects_multiple_threads",
+        drop_many_objects_multiple_threads,
+    );
+}
+
+criterion_group!(benches, criterion_benchmark);
+criterion_main!(benches);
diff --git a/pyo3-benches/benches/bench_pyclass.rs b/pyo3-benches/benches/bench_pyclass.rs
index b917a4acc08..0967a897649 100644
--- a/pyo3-benches/benches/bench_pyclass.rs
+++ b/pyo3-benches/benches/bench_pyclass.rs
@@ -27,12 +27,12 @@ impl MyClass {
 }
 
 pub fn first_time_init(b: &mut Bencher<'_>) {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         b.iter(|| {
             // This is using an undocumented internal PyO3 API to measure pyclass performance; please
             // don't use this in your own code!
             let ty = LazyTypeObject::<MyClass>::new();
-            ty.get_or_init(py);
+            ty.get_or_try_init(py).unwrap();
         });
     });
 }
diff --git a/pyo3-benches/benches/bench_pyobject.rs b/pyo3-benches/benches/bench_pyobject.rs
deleted file mode 100644
index af25d61ce6a..00000000000
--- a/pyo3-benches/benches/bench_pyobject.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-use codspeed_criterion_compat::{criterion_group, criterion_main, Bencher, Criterion};
-
-use pyo3::prelude::*;
-
-fn drop_many_objects(b: &mut Bencher<'_>) {
-    Python::with_gil(|py| {
-        b.iter(|| {
-            for _ in 0..1000 {
-                std::mem::drop(py.None());
-            }
-        });
-    });
-}
-
-fn criterion_benchmark(c: &mut Criterion) {
-    c.bench_function("drop_many_objects", drop_many_objects);
-}
-
-criterion_group!(benches, criterion_benchmark);
-criterion_main!(benches);
diff --git a/pyo3-benches/benches/bench_set.rs b/pyo3-benches/benches/bench_set.rs
index 49243a63fd4..0c9fedba687 100644
--- a/pyo3-benches/benches/bench_set.rs
+++ b/pyo3-benches/benches/bench_set.rs
@@ -1,26 +1,29 @@
 use codspeed_criterion_compat::{criterion_group, criterion_main, Bencher, Criterion};
 
-use pyo3::prelude::*;
 use pyo3::types::PySet;
-use std::collections::{BTreeSet, HashSet};
+use pyo3::{prelude::*, IntoPyObjectExt};
+use std::{
+    collections::{BTreeSet, HashSet},
+    hint::black_box,
+};
 
 fn set_new(b: &mut Bencher<'_>) {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         const LEN: usize = 100_000;
         // Create Python objects up-front, so that the benchmark doesn't need to include
         // the cost of allocating LEN Python integers
-        let elements: Vec<PyObject> = (0..LEN).map(|i| i.into_py(py)).collect();
-        b.iter_with_large_drop(|| PySet::new_bound(py, &elements).unwrap());
+        let elements: Vec<Py<PyAny>> = (0..LEN).map(|i| i.into_py_any(py).unwrap()).collect();
+        b.iter_with_large_drop(|| PySet::new(py, &elements).unwrap());
     });
 }
 
 fn iter_set(b: &mut Bencher<'_>) {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         const LEN: usize = 100_000;
-        let set = PySet::new_bound(py, &(0..LEN).collect::<Vec<_>>()).unwrap();
+        let set = PySet::new(py, 0..LEN).unwrap();
         let mut sum = 0;
         b.iter(|| {
-            for x in set.iter() {
+            for x in &set {
                 let i: u64 = x.extract().unwrap();
                 sum += i;
             }
@@ -29,27 +32,26 @@ fn iter_set(b: &mut Bencher<'_>) {
 }
 
 fn extract_hashset(b: &mut Bencher<'_>) {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         const LEN: usize = 100_000;
-        let set = PySet::new_bound(py, &(0..LEN).collect::<Vec<_>>()).unwrap();
-        b.iter_with_large_drop(|| HashSet::<u64>::extract(set.as_gil_ref()));
+        let any = PySet::new(py, 0..LEN).unwrap().into_any();
+        b.iter_with_large_drop(|| black_box(&any).extract::<HashSet<u64>>());
     });
 }
 
 fn extract_btreeset(b: &mut Bencher<'_>) {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         const LEN: usize = 100_000;
-        let set = PySet::new_bound(py, &(0..LEN).collect::<Vec<_>>()).unwrap();
-        b.iter_with_large_drop(|| BTreeSet::<u64>::extract(set.as_gil_ref()));
+        let any = PySet::new(py, 0..LEN).unwrap().into_any();
+        b.iter_with_large_drop(|| black_box(&any).extract::<BTreeSet<u64>>());
     });
 }
 
-#[cfg(feature = "hashbrown")]
 fn extract_hashbrown_set(b: &mut Bencher<'_>) {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         const LEN: usize = 100_000;
-        let set = PySet::new_bound(py, &(0..LEN).collect::<Vec<_>>()).unwrap();
-        b.iter_with_large_drop(|| hashbrown::HashSet::<u64>::extract(set.as_gil_ref()));
+        let any = PySet::new(py, 0..LEN).unwrap().into_any();
+        b.iter_with_large_drop(|| black_box(&any).extract::<hashbrown::HashSet<u64>>());
     });
 }
 
@@ -58,8 +60,6 @@ fn criterion_benchmark(c: &mut Criterion) {
     c.bench_function("iter_set", iter_set);
     c.bench_function("extract_hashset", extract_hashset);
     c.bench_function("extract_btreeset", extract_btreeset);
-
-    #[cfg(feature = "hashbrown")]
     c.bench_function("extract_hashbrown_set", extract_hashbrown_set);
 }
 
diff --git a/pyo3-benches/benches/bench_tuple.rs b/pyo3-benches/benches/bench_tuple.rs
index 24f32fac364..77c829945d6 100644
--- a/pyo3-benches/benches/bench_tuple.rs
+++ b/pyo3-benches/benches/bench_tuple.rs
@@ -1,12 +1,14 @@
+use std::hint::black_box;
+
 use codspeed_criterion_compat::{criterion_group, criterion_main, Bencher, Criterion};
 
 use pyo3::prelude::*;
 use pyo3::types::{PyList, PySequence, PyTuple};
 
 fn iter_tuple(b: &mut Bencher<'_>) {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         const LEN: usize = 100_000;
-        let tuple = PyTuple::new_bound(py, 0..LEN);
+        let tuple = PyTuple::new(py, 0..LEN).unwrap();
         let mut sum = 0;
         b.iter(|| {
             for x in tuple.iter_borrowed() {
@@ -18,16 +20,16 @@ fn iter_tuple(b: &mut Bencher<'_>) {
 }
 
 fn tuple_new(b: &mut Bencher<'_>) {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         const LEN: usize = 50_000;
-        b.iter_with_large_drop(|| PyTuple::new_bound(py, 0..LEN));
+        b.iter_with_large_drop(|| PyTuple::new(py, 0..LEN).unwrap());
     });
 }
 
 fn tuple_get_item(b: &mut Bencher<'_>) {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         const LEN: usize = 50_000;
-        let tuple = PyTuple::new_bound(py, 0..LEN);
+        let tuple = PyTuple::new(py, 0..LEN).unwrap();
         let mut sum = 0;
         b.iter(|| {
             for i in 0..LEN {
@@ -39,9 +41,9 @@ fn tuple_get_item(b: &mut Bencher<'_>) {
 
 #[cfg(not(any(Py_LIMITED_API, PyPy)))]
 fn tuple_get_item_unchecked(b: &mut Bencher<'_>) {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         const LEN: usize = 50_000;
-        let tuple = PyTuple::new_bound(py, 0..LEN);
+        let tuple = PyTuple::new(py, 0..LEN).unwrap();
         let mut sum = 0;
         b.iter(|| {
             for i in 0..LEN {
@@ -54,9 +56,9 @@ fn tuple_get_item_unchecked(b: &mut Bencher<'_>) {
 }
 
 fn tuple_get_borrowed_item(b: &mut Bencher<'_>) {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         const LEN: usize = 50_000;
-        let tuple = PyTuple::new_bound(py, 0..LEN);
+        let tuple = PyTuple::new(py, 0..LEN).unwrap();
         let mut sum = 0;
         b.iter(|| {
             for i in 0..LEN {
@@ -72,9 +74,9 @@ fn tuple_get_borrowed_item(b: &mut Bencher<'_>) {
 
 #[cfg(not(any(Py_LIMITED_API, PyPy)))]
 fn tuple_get_borrowed_item_unchecked(b: &mut Bencher<'_>) {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         const LEN: usize = 50_000;
-        let tuple = PyTuple::new_bound(py, 0..LEN);
+        let tuple = PyTuple::new(py, 0..LEN).unwrap();
         let mut sum = 0;
         b.iter(|| {
             for i in 0..LEN {
@@ -90,32 +92,62 @@ fn tuple_get_borrowed_item_unchecked(b: &mut Bencher<'_>) {
 }
 
 fn sequence_from_tuple(b: &mut Bencher<'_>) {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         const LEN: usize = 50_000;
-        let tuple = PyTuple::new_bound(py, 0..LEN).to_object(py);
-        b.iter(|| tuple.downcast::<PySequence>(py).unwrap());
+        let tuple = PyTuple::new(py, 0..LEN).unwrap().into_any();
+        b.iter(|| black_box(&tuple).cast::<PySequence>().unwrap());
     });
 }
 
 fn tuple_new_list(b: &mut Bencher<'_>) {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         const LEN: usize = 50_000;
-        let tuple = PyTuple::new_bound(py, 0..LEN);
-        b.iter_with_large_drop(|| PyList::new_bound(py, tuple.iter_borrowed()));
+        let tuple = PyTuple::new(py, 0..LEN).unwrap();
+        b.iter_with_large_drop(|| PyList::new(py, tuple.iter_borrowed()));
     });
 }
 
 fn tuple_to_list(b: &mut Bencher<'_>) {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         const LEN: usize = 50_000;
-        let tuple = PyTuple::new_bound(py, 0..LEN);
+        let tuple = PyTuple::new(py, 0..LEN).unwrap();
         b.iter_with_large_drop(|| tuple.to_list());
     });
 }
 
-fn tuple_into_py(b: &mut Bencher<'_>) {
-    Python::with_gil(|py| {
-        b.iter(|| -> PyObject { (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12).into_py(py) });
+fn tuple_into_pyobject(b: &mut Bencher<'_>) {
+    Python::attach(|py| {
+        b.iter(|| {
+            (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)
+                .into_pyobject(py)
+                .unwrap()
+        });
+    });
+}
+
+fn tuple_nth(b: &mut Bencher<'_>) {
+    Python::attach(|py| {
+        const LEN: usize = 50;
+        let list = PyTuple::new(py, 0..LEN).unwrap();
+        let mut sum = 0;
+        b.iter(|| {
+            for i in 0..LEN {
+                sum += list.iter().nth(i).unwrap().extract::<usize>().unwrap();
+            }
+        });
+    });
+}
+
+fn tuple_nth_back(b: &mut Bencher<'_>) {
+    Python::attach(|py| {
+        const LEN: usize = 50;
+        let list = PyTuple::new(py, 0..LEN).unwrap();
+        let mut sum = 0;
+        b.iter(|| {
+            for i in 0..LEN {
+                sum += list.iter().nth_back(i).unwrap().extract::<usize>().unwrap();
+            }
+        });
     });
 }
 
@@ -123,6 +155,8 @@ fn criterion_benchmark(c: &mut Criterion) {
     c.bench_function("iter_tuple", iter_tuple);
     c.bench_function("tuple_new", tuple_new);
     c.bench_function("tuple_get_item", tuple_get_item);
+    c.bench_function("tuple_nth", tuple_nth);
+    c.bench_function("tuple_nth_back", tuple_nth_back);
     #[cfg(not(any(Py_LIMITED_API, PyPy)))]
     c.bench_function("tuple_get_item_unchecked", tuple_get_item_unchecked);
     c.bench_function("tuple_get_borrowed_item", tuple_get_borrowed_item);
@@ -134,7 +168,7 @@ fn criterion_benchmark(c: &mut Criterion) {
     c.bench_function("sequence_from_tuple", sequence_from_tuple);
     c.bench_function("tuple_new_list", tuple_new_list);
     c.bench_function("tuple_to_list", tuple_to_list);
-    c.bench_function("tuple_into_py", tuple_into_py);
+    c.bench_function("tuple_into_pyobject", tuple_into_pyobject);
 }
 
 criterion_group!(benches, criterion_benchmark);
diff --git a/pyo3-benches/build.rs b/pyo3-benches/build.rs
new file mode 100644
index 00000000000..0475124bb4e
--- /dev/null
+++ b/pyo3-benches/build.rs
@@ -0,0 +1,3 @@
+fn main() {
+    pyo3_build_config::use_pyo3_cfgs();
+}
diff --git a/pyo3-build-config/Cargo.toml b/pyo3-build-config/Cargo.toml
index 702e99a4aac..cd7cd52b73f 100644
--- a/pyo3-build-config/Cargo.toml
+++ b/pyo3-build-config/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "pyo3-build-config"
-version = "0.21.0-dev"
+version = "0.27.0"
 description = "Build configuration for the PyO3 ecosystem"
 authors = ["PyO3 Project and Contributors <https://github.com/PyO3>"]
 keywords = ["pyo3", "python", "cpython", "ffi"]
@@ -9,15 +9,15 @@ repository = "https://github.com/pyo3/pyo3"
 categories = ["api-bindings", "development-tools::ffi"]
 license = "MIT OR Apache-2.0"
 edition = "2021"
+rust-version.workspace = true
 
 [dependencies]
-once_cell = "1"
-python3-dll-a = { version = "0.2.6", optional = true }
-target-lexicon = "0.12"
+python3-dll-a = { version = "0.2.12", optional = true }
+target-lexicon = "0.13"
 
 [build-dependencies]
-python3-dll-a = { version = "0.2.6", optional = true }
-target-lexicon = "0.12"
+python3-dll-a = { version = "0.2.12", optional = true }
+target-lexicon = "0.13"
 
 [features]
 default = []
@@ -29,6 +29,9 @@ resolve-config = []
 # This feature is enabled by pyo3 when building an extension module.
 extension-module = []
 
+# Automatically generates `python3.dll` import libraries for Windows targets.
+generate-import-lib = ["dep:python3-dll-a"]
+
 # These features are enabled by pyo3 when building Stable ABI extension modules.
 abi3 = []
 abi3-py37 = ["abi3-py38"]
@@ -36,7 +39,9 @@ abi3-py38 = ["abi3-py39"]
 abi3-py39 = ["abi3-py310"]
 abi3-py310 = ["abi3-py311"]
 abi3-py311 = ["abi3-py312"]
-abi3-py312 = ["abi3"]
+abi3-py312 = ["abi3-py313"]
+abi3-py313 = ["abi3-py314"]
+abi3-py314 = ["abi3"]
 
 [package.metadata.docs.rs]
 features = ["resolve-config"]
diff --git a/pyo3-build-config/build.rs b/pyo3-build-config/build.rs
index 309a78c87da..a6e767edcf0 100644
--- a/pyo3-build-config/build.rs
+++ b/pyo3-build-config/build.rs
@@ -12,7 +12,7 @@ mod errors;
 use std::{env, path::Path};
 
 use errors::{Context, Result};
-use impl_::{env_var, make_interpreter_config, InterpreterConfig};
+use impl_::{make_interpreter_config, InterpreterConfig};
 
 fn configure(interpreter_config: Option<InterpreterConfig>, name: &str) -> Result<bool> {
     let target = Path::new(&env::var_os("OUT_DIR").unwrap()).join(name);
@@ -29,28 +29,12 @@ fn configure(interpreter_config: Option<InterpreterConfig>, name: &str) -> Resul
     }
 }
 
-/// If PYO3_CONFIG_FILE is set, copy it into the crate.
-fn config_file() -> Result<Option<InterpreterConfig>> {
-    if let Some(path) = env_var("PYO3_CONFIG_FILE") {
-        let path = Path::new(&path);
-        println!("cargo:rerun-if-changed={}", path.display());
-        // Absolute path is necessary because this build script is run with a cwd different to the
-        // original `cargo build` instruction.
-        ensure!(
-            path.is_absolute(),
-            "PYO3_CONFIG_FILE must be an absolute path"
-        );
-
-        let interpreter_config = InterpreterConfig::from_path(path)
-            .context("failed to parse contents of PYO3_CONFIG_FILE")?;
-        Ok(Some(interpreter_config))
-    } else {
-        Ok(None)
-    }
-}
-
 fn generate_build_configs() -> Result<()> {
-    let configured = configure(config_file()?, "pyo3-build-config-file.txt")?;
+    // If PYO3_CONFIG_FILE is set, copy it into the crate.
+    let configured = configure(
+        InterpreterConfig::from_pyo3_config_file_env().transpose()?,
+        "pyo3-build-config-file.txt",
+    )?;
 
     if configured {
         // Don't bother trying to find an interpreter on the host system
diff --git a/pyo3-build-config/src/errors.rs b/pyo3-build-config/src/errors.rs
index 87c59a998b4..b11d02fd581 100644
--- a/pyo3-build-config/src/errors.rs
+++ b/pyo3-build-config/src/errors.rs
@@ -68,7 +68,7 @@ impl std::fmt::Display for ErrorReport<'_> {
             writeln!(f, "\ncaused by:")?;
             let mut index = 0;
             while let Some(some_source) = source {
-                writeln!(f, "  - {}: {}", index, some_source)?;
+                writeln!(f, "  - {index}: {some_source}")?;
                 source = some_source.source();
                 index += 1;
             }
diff --git a/pyo3-build-config/src/impl_.rs b/pyo3-build-config/src/impl_.rs
index fd467b72e0a..cca9393d873 100644
--- a/pyo3-build-config/src/impl_.rs
+++ b/pyo3-build-config/src/impl_.rs
@@ -2,13 +2,14 @@
 //! and its build script.
 
 // Optional python3.dll import library generator for Windows
-#[cfg(feature = "python3-dll-a")]
+#[cfg(feature = "generate-import-lib")]
 #[path = "import_lib.rs"]
 mod import_lib;
 
+#[cfg(test)]
+use std::cell::RefCell;
 use std::{
     collections::{HashMap, HashSet},
-    convert::AsRef,
     env,
     ffi::{OsStr, OsString},
     fmt::Display,
@@ -16,25 +17,35 @@ use std::{
     io::{BufRead, BufReader, Read, Write},
     path::{Path, PathBuf},
     process::{Command, Stdio},
-    str,
-    str::FromStr,
+    str::{self, FromStr},
 };
 
 pub use target_lexicon::Triple;
 
-use target_lexicon::{Environment, OperatingSystem};
+use target_lexicon::{Architecture, Environment, OperatingSystem, Vendor};
 
 use crate::{
     bail, ensure,
     errors::{Context, Error, Result},
-    format_warn, warn,
+    warn,
 };
 
 /// Minimum Python version PyO3 supports.
-const MINIMUM_SUPPORTED_VERSION: PythonVersion = PythonVersion { major: 3, minor: 7 };
+pub(crate) const MINIMUM_SUPPORTED_VERSION: PythonVersion = PythonVersion { major: 3, minor: 7 };
+
+/// GraalPy may implement the same CPython version over multiple releases.
+const MINIMUM_SUPPORTED_VERSION_GRAALPY: PythonVersion = PythonVersion {
+    major: 25,
+    minor: 0,
+};
 
 /// Maximum Python version that can be used as minimum required Python version with abi3.
-const ABI3_MAX_MINOR: u8 = 12;
+pub(crate) const ABI3_MAX_MINOR: u8 = 14;
+
+#[cfg(test)]
+thread_local! {
+    static READ_ENV_VARS: RefCell<Vec<String>> = const { RefCell::new(Vec::new()) };
+}
 
 /// Gets an environment variable owned by cargo.
 ///
@@ -47,7 +58,13 @@ pub fn cargo_env_var(var: &str) -> Option<String> {
 /// the variable changes.
 pub fn env_var(var: &str) -> Option<OsString> {
     if cfg!(feature = "resolve-config") {
-        println!("cargo:rerun-if-env-changed={}", var);
+        println!("cargo:rerun-if-env-changed={var}");
+    }
+    #[cfg(test)]
+    {
+        READ_ENV_VARS.with(|env_vars| {
+            env_vars.borrow_mut().push(var.to_owned());
+        });
     }
     env::var_os(var)
 }
@@ -150,6 +167,8 @@ pub struct InterpreterConfig {
     ///
     /// Serialized to multiple `extra_build_script_line` values.
     pub extra_build_script_lines: Vec<String>,
+    /// macOS Python3.framework requires special rpath handling
+    pub python_framework_prefix: Option<String>,
 }
 
 impl InterpreterConfig {
@@ -160,26 +179,28 @@ impl InterpreterConfig {
 
         let mut out = vec![];
 
-        // pyo3-build-config was released when Python 3.6 was supported, so minimum flag to emit is
-        // Py_3_6 (to avoid silently breaking users who depend on this cfg).
-        for i in 6..=self.version.minor {
-            out.push(format!("cargo:rustc-cfg=Py_3_{}", i));
+        for i in MINIMUM_SUPPORTED_VERSION.minor..=self.version.minor {
+            out.push(format!("cargo:rustc-cfg=Py_3_{i}"));
         }
 
-        if self.implementation.is_pypy() {
-            out.push("cargo:rustc-cfg=PyPy".to_owned());
-            if self.abi3 {
-                out.push(format_warn!(
-                    "PyPy does not yet support abi3 so the build artifacts will be version-specific. \
-                    See https://foss.heptapod.net/pypy/pypy/-/issues/3397 for more information."
-                ));
-            }
-        } else if self.abi3 {
+        match self.implementation {
+            PythonImplementation::CPython => {}
+            PythonImplementation::PyPy => out.push("cargo:rustc-cfg=PyPy".to_owned()),
+            PythonImplementation::GraalPy => out.push("cargo:rustc-cfg=GraalPy".to_owned()),
+        }
+
+        // If Py_GIL_DISABLED is set, do not build with limited API support
+        if self.abi3 && !self.is_free_threaded() {
             out.push("cargo:rustc-cfg=Py_LIMITED_API".to_owned());
         }
 
         for flag in &self.build_flags.0 {
-            out.push(format!("cargo:rustc-cfg=py_sys_config=\"{}\"", flag));
+            match flag {
+                BuildFlag::Py_GIL_DISABLED => {
+                    out.push("cargo:rustc-cfg=Py_GIL_DISABLED".to_owned())
+                }
+                flag => out.push(format!("cargo:rustc-cfg=py_sys_config=\"{flag}\"")),
+            }
         }
 
         out
@@ -198,6 +219,12 @@ import sys
 from sysconfig import get_config_var, get_platform
 
 PYPY = platform.python_implementation() == "PyPy"
+GRAALPY = platform.python_implementation() == "GraalVM"
+
+if GRAALPY:
+    graalpy_ver = map(int, __graalpython__.get_graalvm_version().split('.'));
+    print("graalpy_major", next(graalpy_ver))
+    print("graalpy_minor", next(graalpy_ver))
 
 # sys.base_prefix is missing on Python versions older than 3.3; this allows the script to continue
 # so that the version mismatch can be reported in a nicer way later.
@@ -220,6 +247,7 @@ WINDOWS = platform.system() == "Windows"
 
 # macOS framework packages use shared linking
 FRAMEWORK = bool(get_config_var("PYTHONFRAMEWORK"))
+FRAMEWORK_PREFIX = get_config_var("PYTHONFRAMEWORKPREFIX")
 
 # unix-style shared library enabled
 SHARED = bool(get_config_var("Py_ENABLE_SHARED"))
@@ -227,7 +255,8 @@ SHARED = bool(get_config_var("Py_ENABLE_SHARED"))
 print("implementation", platform.python_implementation())
 print("version_major", sys.version_info[0])
 print("version_minor", sys.version_info[1])
-print("shared", PYPY or ANACONDA or WINDOWS or FRAMEWORK or SHARED)
+print("shared", PYPY or GRAALPY or ANACONDA or WINDOWS or FRAMEWORK or SHARED)
+print("python_framework_prefix", FRAMEWORK_PREFIX)
 print_if_set("ld_version", get_config_var("LDVERSION"))
 print_if_set("libdir", get_config_var("LIBDIR"))
 print_if_set("base_prefix", base_prefix)
@@ -235,6 +264,7 @@ print("executable", sys.executable)
 print("calcsize_pointer", struct.calcsize("P"))
 print("mingw", get_platform().startswith("mingw"))
 print("ext_suffix", get_config_var("EXT_SUFFIX"))
+print("gil_disabled", get_config_var("Py_GIL_DISABLED"))
 "#;
         let output = run_python_script(interpreter.as_ref(), SCRIPT)?;
         let map: HashMap<String, String> = parse_script_output(&output);
@@ -245,7 +275,25 @@ print("ext_suffix", get_config_var("EXT_SUFFIX"))
             interpreter.as_ref().display()
         );
 
+        if let Some(value) = map.get("graalpy_major") {
+            let graalpy_version = PythonVersion {
+                major: value
+                    .parse()
+                    .context("failed to parse GraalPy major version")?,
+                minor: map["graalpy_minor"]
+                    .parse()
+                    .context("failed to parse GraalPy minor version")?,
+            };
+            ensure!(
+                graalpy_version >= MINIMUM_SUPPORTED_VERSION_GRAALPY,
+                "At least GraalPy version {} needed, got {}",
+                MINIMUM_SUPPORTED_VERSION_GRAALPY,
+                graalpy_version
+            );
+        };
+
         let shared = map["shared"].as_str() == "True";
+        let python_framework_prefix = map.get("python_framework_prefix").cloned();
 
         let version = PythonVersion {
             major: map["version_major"]
@@ -260,6 +308,13 @@ print("ext_suffix", get_config_var("EXT_SUFFIX"))
 
         let implementation = map["implementation"].parse()?;
 
+        let gil_disabled = match map["gil_disabled"].as_str() {
+            "1" => true,
+            "0" => false,
+            "None" => false,
+            _ => panic!("Unknown Py_GIL_DISABLED value"),
+        };
+
         let lib_name = if cfg!(windows) {
             default_lib_name_windows(
                 version,
@@ -270,18 +325,20 @@ print("ext_suffix", get_config_var("EXT_SUFFIX"))
                 // on Windows from sysconfig - e.g. ext_suffix may be
                 // `_d.cp312-win_amd64.pyd` for 3.12 debug build
                 map["ext_suffix"].starts_with("_d."),
-            )
+                gil_disabled,
+            )?
         } else {
             default_lib_name_unix(
                 version,
                 implementation,
                 map.get("ld_version").map(String::as_str),
-            )
+                gil_disabled,
+            )?
         };
 
         let lib_dir = if cfg!(windows) {
             map.get("base_prefix")
-                .map(|base_prefix| format!("{}\\libs", base_prefix))
+                .map(|base_prefix| format!("{base_prefix}\\libs"))
         } else {
             map.get("libdir").cloned()
         };
@@ -307,6 +364,7 @@ print("ext_suffix", get_config_var("EXT_SUFFIX"))
             build_flags: BuildFlags::from_interpreter(interpreter)?,
             suppress_build_script_link_lines: false,
             extra_build_script_lines: vec![],
+            python_framework_prefix,
         })
     }
 
@@ -344,12 +402,20 @@ print("ext_suffix", get_config_var("EXT_SUFFIX"))
             Some(s) => !s.is_empty(),
             _ => false,
         };
+        let python_framework_prefix = sysconfigdata
+            .get_value("PYTHONFRAMEWORKPREFIX")
+            .map(str::to_string);
         let lib_dir = get_key!(sysconfigdata, "LIBDIR").ok().map(str::to_string);
+        let gil_disabled = match sysconfigdata.get_value("Py_GIL_DISABLED") {
+            Some(value) => value == "1",
+            None => false,
+        };
         let lib_name = Some(default_lib_name_unix(
             version,
             implementation,
             sysconfigdata.get_value("LDVERSION"),
-        ));
+            gil_disabled,
+        )?);
         let pointer_width = parse_key!(sysconfigdata, "SIZEOF_VOID_P")
             .map(|bytes_width: u32| bytes_width * 8)
             .ok();
@@ -367,6 +433,36 @@ print("ext_suffix", get_config_var("EXT_SUFFIX"))
             build_flags,
             suppress_build_script_link_lines: false,
             extra_build_script_lines: vec![],
+            python_framework_prefix,
+        })
+    }
+
+    /// Import an externally-provided config file.
+    ///
+    /// The `abi3` features, if set, may apply an `abi3` constraint to the Python version.
+    #[allow(dead_code)] // only used in build.rs
+    pub(super) fn from_pyo3_config_file_env() -> Option<Result<Self>> {
+        env_var("PYO3_CONFIG_FILE").map(|path| {
+            let path = Path::new(&path);
+            println!("cargo:rerun-if-changed={}", path.display());
+            // Absolute path is necessary because this build script is run with a cwd different to the
+            // original `cargo build` instruction.
+            ensure!(
+                path.is_absolute(),
+                "PYO3_CONFIG_FILE must be an absolute path"
+            );
+
+            let mut config = InterpreterConfig::from_path(path)
+                .context("failed to parse contents of PYO3_CONFIG_FILE")?;
+            // If the abi3 feature is enabled, the minimum Python version is constrained by the abi3
+            // feature.
+            //
+            // TODO: abi3 is a property of the build mode, not the interpreter. Should this be
+            // removed from `InterpreterConfig`?
+            config.abi3 |= is_abi3();
+            config.fixup_for_abi3_version(get_abi3_version())?;
+
+            Ok(config)
         })
     }
 
@@ -411,9 +507,10 @@ print("ext_suffix", get_config_var("EXT_SUFFIX"))
         let mut lib_dir = None;
         let mut executable = None;
         let mut pointer_width = None;
-        let mut build_flags = None;
+        let mut build_flags: Option<BuildFlags> = None;
         let mut suppress_build_script_link_lines = None;
         let mut extra_build_script_lines = vec![];
+        let mut python_framework_prefix = None;
 
         for (i, line) in lines.enumerate() {
             let line = line.context("failed to read line from config")?;
@@ -442,6 +539,7 @@ print("ext_suffix", get_config_var("EXT_SUFFIX"))
                 "extra_build_script_line" => {
                     extra_build_script_lines.push(value.to_string());
                 }
+                "python_framework_prefix" => parse_value!(python_framework_prefix, value),
                 unknown => warn!("unknown config key `{}`", unknown),
             }
         }
@@ -449,14 +547,7 @@ print("ext_suffix", get_config_var("EXT_SUFFIX"))
         let version = version.ok_or("missing value for version")?;
         let implementation = implementation.unwrap_or(PythonImplementation::CPython);
         let abi3 = abi3.unwrap_or(false);
-        // Fixup lib_name if it's not set
-        let lib_name = lib_name.or_else(|| {
-            if let Ok(Ok(target)) = env::var("TARGET").map(|target| target.parse::<Triple>()) {
-                default_lib_name_for_target(version, implementation, abi3, &target)
-            } else {
-                None
-            }
-        });
+        let build_flags = build_flags.unwrap_or_default();
 
         Ok(InterpreterConfig {
             implementation,
@@ -467,26 +558,61 @@ print("ext_suffix", get_config_var("EXT_SUFFIX"))
             lib_dir,
             executable,
             pointer_width,
-            build_flags: build_flags.unwrap_or_default(),
+            build_flags,
             suppress_build_script_link_lines: suppress_build_script_link_lines.unwrap_or(false),
             extra_build_script_lines,
+            python_framework_prefix,
         })
     }
 
-    #[cfg(feature = "python3-dll-a")]
+    /// Helper function to apply a default lib_name if none is set in `PYO3_CONFIG_FILE`.
+    ///
+    /// This requires knowledge of the final target, so cannot be done when the config file is
+    /// inlined into `pyo3-build-config` at build time and instead needs to be done when
+    /// resolving the build config for linking.
+    #[cfg(any(test, feature = "resolve-config"))]
+    pub(crate) fn apply_default_lib_name_to_config_file(&mut self, target: &Triple) {
+        if self.lib_name.is_none() {
+            self.lib_name = Some(default_lib_name_for_target(
+                self.version,
+                self.implementation,
+                self.abi3,
+                self.is_free_threaded(),
+                target,
+            ));
+        }
+    }
+
+    #[cfg(feature = "generate-import-lib")]
     #[allow(clippy::unnecessary_wraps)]
     pub fn generate_import_libs(&mut self) -> Result<()> {
         // Auto generate python3.dll import libraries for Windows targets.
         if self.lib_dir.is_none() {
             let target = target_triple_from_env();
-            let py_version = if self.abi3 { None } else { Some(self.version) };
-            self.lib_dir =
-                import_lib::generate_import_lib(&target, self.implementation, py_version)?;
+            let py_version = if self.implementation == PythonImplementation::CPython
+                && self.abi3
+                && !self.is_free_threaded()
+            {
+                None
+            } else {
+                Some(self.version)
+            };
+            let abiflags = if self.is_free_threaded() {
+                Some("t")
+            } else {
+                None
+            };
+            self.lib_dir = import_lib::generate_import_lib(
+                &target,
+                self.implementation,
+                py_version,
+                abiflags,
+            )?;
         }
         Ok(())
     }
 
-    #[cfg(not(feature = "python3-dll-a"))]
+    #[cfg(not(feature = "generate-import-lib"))]
     #[allow(clippy::unnecessary_wraps)]
     pub fn generate_import_libs(&mut self) -> Result<()> {
         Ok(())
@@ -546,9 +672,10 @@ print("ext_suffix", get_config_var("EXT_SUFFIX"))
         write_option_line!(executable)?;
         write_option_line!(pointer_width)?;
         write_line!(build_flags)?;
+        write_option_line!(python_framework_prefix)?;
         write_line!(suppress_build_script_link_lines)?;
         for line in &self.extra_build_script_lines {
-            writeln!(writer, "extra_build_script_line={}", line)
+            writeln!(writer, "extra_build_script_line={line}")
                 .context("failed to write extra_build_script_line")?;
         }
         Ok(())
@@ -586,10 +713,18 @@ print("ext_suffix", get_config_var("EXT_SUFFIX"))
         )
     }
 
-    /// Lowers the configured version to the abi3 version, if set.
+    pub fn is_free_threaded(&self) -> bool {
+        self.build_flags.0.contains(&BuildFlag::Py_GIL_DISABLED)
+    }
+
+    /// Updates configured ABI to build for to the requested abi3 version
+    /// This is a no-op for platforms where abi3 is not supported
     fn fixup_for_abi3_version(&mut self, abi3_version: Option<PythonVersion>) -> Result<()> {
-        // PyPy doesn't support abi3; don't adjust the version
-        if self.implementation.is_pypy() {
+        // PyPy, GraalPy, and the free-threaded build don't support abi3; don't adjust the version
+        if self.implementation.is_pypy()
+            || self.implementation.is_graalpy()
+            || self.is_free_threaded()
+        {
             return Ok(());
         }
 
@@ -604,6 +739,9 @@ print("ext_suffix", get_config_var("EXT_SUFFIX"))
             );
 
             self.version = version;
+        } else if is_abi3() && self.version.minor > ABI3_MAX_MINOR {
+            warn!("Automatically falling back to abi3-py3{ABI3_MAX_MINOR} because current Python is higher than the maximum supported");
+            self.version.minor = ABI3_MAX_MINOR;
         }
 
         Ok(())
@@ -617,6 +755,14 @@ pub struct PythonVersion {
 }
 
 impl PythonVersion {
+    pub const PY313: Self = PythonVersion {
+        major: 3,
+        minor: 13,
+    };
+    const PY310: Self = PythonVersion {
+        major: 3,
+        minor: 10,
+    };
     const PY37: Self = PythonVersion { major: 3, minor: 7 };
 }
 
@@ -648,6 +794,7 @@ impl FromStr for PythonVersion {
 pub enum PythonImplementation {
     CPython,
     PyPy,
+    GraalPy,
 }
 
 impl PythonImplementation {
@@ -656,12 +803,19 @@ impl PythonImplementation {
         self == PythonImplementation::PyPy
     }
 
+    #[doc(hidden)]
+    pub fn is_graalpy(self) -> bool {
+        self == PythonImplementation::GraalPy
+    }
+
     #[doc(hidden)]
     pub fn from_soabi(soabi: &str) -> Result<Self> {
         if soabi.starts_with("pypy") {
             Ok(PythonImplementation::PyPy)
         } else if soabi.starts_with("cpython") {
             Ok(PythonImplementation::CPython)
+        } else if soabi.starts_with("graalpy") {
+            Ok(PythonImplementation::GraalPy)
         } else {
             bail!("unsupported Python interpreter");
         }
@@ -673,6 +827,7 @@ impl Display for PythonImplementation {
         match self {
             PythonImplementation::CPython => write!(f, "CPython"),
             PythonImplementation::PyPy => write!(f, "PyPy"),
+            PythonImplementation::GraalPy => write!(f, "GraalVM"),
         }
     }
 }
@@ -683,6 +838,7 @@ impl FromStr for PythonImplementation {
         match s {
             "CPython" => Ok(PythonImplementation::CPython),
             "PyPy" => Ok(PythonImplementation::PyPy),
+            "GraalVM" => Ok(PythonImplementation::GraalPy),
             _ => bail!("unknown interpreter: {}", s),
         }
     }
@@ -701,7 +857,7 @@ fn have_python_interpreter() -> bool {
 /// Must be called from a PyO3 crate build script.
 fn is_abi3() -> bool {
     cargo_env_var("CARGO_FEATURE_ABI3").is_some()
-        || env_var("PYO3_USE_ABI3_FORWARD_COMPATIBILITY").map_or(false, |os_str| os_str == "1")
+        || env_var("PYO3_USE_ABI3_FORWARD_COMPATIBILITY").is_some_and(|os_str| os_str == "1")
 }
 
 /// Gets the minimum supported Python version from PyO3 `abi3-py*` features.
@@ -709,29 +865,29 @@ fn is_abi3() -> bool {
 /// Must be called from a PyO3 crate build script.
 pub fn get_abi3_version() -> Option<PythonVersion> {
     let minor_version = (MINIMUM_SUPPORTED_VERSION.minor..=ABI3_MAX_MINOR)
-        .find(|i| cargo_env_var(&format!("CARGO_FEATURE_ABI3_PY3{}", i)).is_some());
+        .find(|i| cargo_env_var(&format!("CARGO_FEATURE_ABI3_PY3{i}")).is_some());
     minor_version.map(|minor| PythonVersion { major: 3, minor })
 }
 
 /// Checks if the `extension-module` feature is enabled for the PyO3 crate.
 ///
+/// This can be triggered either by:
+/// - The `extension-module` Cargo feature
+/// - Setting the `PYO3_BUILD_EXTENSION_MODULE` environment variable
+///
 /// Must be called from a PyO3 crate build script.
 pub fn is_extension_module() -> bool {
     cargo_env_var("CARGO_FEATURE_EXTENSION_MODULE").is_some()
-}
-
-/// Checks if we need to link to `libpython` for the current build target.
-///
-/// Must be called from a PyO3 crate build script.
-pub fn is_linking_libpython() -> bool {
-    is_linking_libpython_for_target(&target_triple_from_env())
+        || env_var("PYO3_BUILD_EXTENSION_MODULE").is_some()
 }
 
 /// Checks if we need to link to `libpython` for the target.
 ///
 /// Must be called from a PyO3 crate build script.
-fn is_linking_libpython_for_target(target: &Triple) -> bool {
+pub fn is_linking_libpython_for_target(target: &Triple) -> bool {
     target.operating_system == OperatingSystem::Windows
+        // See https://github.com/PyO3/pyo3/issues/4068#issuecomment-2051159852
+        || target.operating_system == OperatingSystem::Aix
         || target.environment == Environment::Android
         || target.environment == Environment::Androideabi
         || !is_extension_module()
@@ -742,7 +898,7 @@ fn is_linking_libpython_for_target(target: &Triple) -> bool {
 ///
 /// Must be called from a PyO3 crate build script.
 fn require_libdir_for_target(target: &Triple) -> bool {
-    let is_generating_libpython = cfg!(feature = "python3-dll-a")
+    let is_generating_libpython = cfg!(feature = "generate-import-lib")
         && target.operating_system == OperatingSystem::Windows
         && is_abi3();
 
@@ -761,11 +917,14 @@ pub struct CrossCompileConfig {
     /// The version of the Python library to link against.
     version: Option<PythonVersion>,
 
-    /// The target Python implementation hint (CPython or PyPy)
+    /// The target Python implementation hint (CPython, PyPy, GraalPy, ...)
     implementation: Option<PythonImplementation>,
 
     /// The compile target triple (e.g. aarch64-unknown-linux-gnu)
     target: Triple,
+
+    /// Python ABI flags, used to detect free-threaded Python builds.
+    abiflags: Option<String>,
 }
 
 impl CrossCompileConfig {
@@ -780,7 +939,7 @@ impl CrossCompileConfig {
     ) -> Result<Option<Self>> {
         if env_vars.any() || Self::is_cross_compiling_from_to(host, target) {
             let lib_dir = env_vars.lib_dir_path()?;
-            let version = env_vars.parse_version()?;
+            let (version, abiflags) = env_vars.parse_version()?;
             let implementation = env_vars.parse_implementation()?;
             let target = target.clone();
 
@@ -789,6 +948,7 @@ impl CrossCompileConfig {
                 version,
                 implementation,
                 target,
+                abiflags,
             }))
         } else {
             Ok(None)
@@ -803,16 +963,20 @@ impl CrossCompileConfig {
         // e.g. x86_64-unknown-linux-musl on x86_64-unknown-linux-gnu host
         //      x86_64-pc-windows-gnu on x86_64-pc-windows-msvc host
         let mut compatible = host.architecture == target.architecture
-            && host.vendor == target.vendor
+            && (host.vendor == target.vendor
+                // Don't treat `-pc-` to `-win7-` as cross-compiling
+                || (host.vendor == Vendor::Pc && target.vendor.as_str() == "win7"))
             && host.operating_system == target.operating_system;
 
         // Not cross-compiling to compile for 32-bit Python from windows 64-bit
         compatible |= target.operating_system == OperatingSystem::Windows
-            && host.operating_system == OperatingSystem::Windows;
+            && host.operating_system == OperatingSystem::Windows
+            && matches!(target.architecture, Architecture::X86_32(_))
+            && host.architecture == Architecture::X86_64;
 
         // Not cross-compiling to compile for x86-64 Python from macOS arm64 and vice versa
-        compatible |= target.operating_system == OperatingSystem::Darwin
-            && host.operating_system == OperatingSystem::Darwin;
+        compatible |= matches!(target.operating_system, OperatingSystem::Darwin(_))
+            && matches!(host.operating_system, OperatingSystem::Darwin(_));
 
         !compatible
     }
@@ -821,6 +985,7 @@ impl CrossCompileConfig {
     ///
     /// The conversion can not fail because `PYO3_CROSS_LIB_DIR` variable
     /// is ensured contain a valid UTF-8 string.
+    #[allow(dead_code)]
     fn lib_dir_string(&self) -> Option<String> {
         self.lib_dir
             .as_ref()
@@ -862,22 +1027,25 @@ impl CrossCompileEnvVars {
     }
 
     /// Parses `PYO3_CROSS_PYTHON_VERSION` environment variable value
-    /// into `PythonVersion`.
-    fn parse_version(&self) -> Result<Option<PythonVersion>> {
-        let version = self
-            .pyo3_cross_python_version
-            .as_ref()
-            .map(|os_string| {
+    /// into `PythonVersion` and ABI flags.
+    fn parse_version(&self) -> Result<(Option<PythonVersion>, Option<String>)> {
+        match self.pyo3_cross_python_version.as_ref() {
+            Some(os_string) => {
                 let utf8_str = os_string
                     .to_str()
                     .ok_or("PYO3_CROSS_PYTHON_VERSION is not valid a UTF-8 string")?;
-                utf8_str
+                let (utf8_str, abiflags) = if let Some(version) = utf8_str.strip_suffix('t') {
+                    (version, Some("t".to_string()))
+                } else {
+                    (utf8_str, None)
+                };
+                let version = utf8_str
                     .parse()
-                    .context("failed to parse PYO3_CROSS_PYTHON_VERSION")
-            })
-            .transpose()?;
-
-        Ok(version)
+                    .context("failed to parse PYO3_CROSS_PYTHON_VERSION")?;
+                Ok((Some(version), abiflags))
+            }
+            None => Ok((None, None)),
+        }
     }
 
     /// Parses `PYO3_CROSS_PYTHON_IMPLEMENTATION` environment variable value
@@ -921,12 +1089,12 @@ impl CrossCompileEnvVars {
 ///
 /// This function relies on PyO3 cross-compiling environment variables:
 ///
-///   * `PYO3_CROSS`: If present, forces PyO3 to configure as a cross-compilation.
-///   * `PYO3_CROSS_LIB_DIR`: If present, must be set to the directory containing
+/// * `PYO3_CROSS`: If present, forces PyO3 to configure as a cross-compilation.
+/// * `PYO3_CROSS_LIB_DIR`: If present, must be set to the directory containing
 ///   the target's libpython DSO and the associated `_sysconfigdata*.py` file for
 ///   Unix-like targets, or the Python DLL import libraries for the Windows target.
-///   * `PYO3_CROSS_PYTHON_VERSION`: Major and minor version (e.g. 3.9) of the target Python
-///   installation. This variable is only needed if PyO3 cannnot determine the version to target
+/// * `PYO3_CROSS_PYTHON_VERSION`: Major and minor version (e.g. 3.9) of the target Python
+///   installation. This variable is only needed if PyO3 cannot determine the version to target
 ///   from `abi3-py3*` features, or if there are multiple versions of Python present in
 ///   `PYO3_CROSS_LIB_DIR`.
 ///
@@ -944,6 +1112,7 @@ pub fn cross_compiling_from_to(
 ///
 /// This must be called from PyO3's build script, because it relies on environment
 /// variables such as `CARGO_CFG_TARGET_OS` which aren't available at any other time.
+#[allow(dead_code)]
 pub fn cross_compiling_from_cargo_env() -> Result<Option<CrossCompileConfig>> {
     let env_vars = CrossCompileEnvVars::from_env();
     let host = Triple::host();
@@ -958,6 +1127,7 @@ pub enum BuildFlag {
     Py_DEBUG,
     Py_REF_DEBUG,
     Py_TRACE_REFS,
+    Py_GIL_DISABLED,
     COUNT_ALLOCS,
     Other(String),
 }
@@ -965,8 +1135,8 @@ pub enum BuildFlag {
 impl Display for BuildFlag {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            BuildFlag::Other(flag) => write!(f, "{}", flag),
-            _ => write!(f, "{:?}", self),
+            BuildFlag::Other(flag) => write!(f, "{flag}"),
+            _ => write!(f, "{self:?}"),
         }
     }
 }
@@ -978,17 +1148,19 @@ impl FromStr for BuildFlag {
             "Py_DEBUG" => Ok(BuildFlag::Py_DEBUG),
             "Py_REF_DEBUG" => Ok(BuildFlag::Py_REF_DEBUG),
             "Py_TRACE_REFS" => Ok(BuildFlag::Py_TRACE_REFS),
+            "Py_GIL_DISABLED" => Ok(BuildFlag::Py_GIL_DISABLED),
             "COUNT_ALLOCS" => Ok(BuildFlag::COUNT_ALLOCS),
             other => Ok(BuildFlag::Other(other.to_owned())),
         }
     }
 }
 
-/// A list of python interpreter compile-time preprocessor defines that
-/// we will pick up and pass to rustc via `--cfg=py_sys_config={varname}`;
+/// A list of python interpreter compile-time preprocessor defines.
+///
+/// PyO3 will pick these up and pass to rustc via `--cfg=py_sys_config={varname}`;
 /// this allows using them conditional cfg attributes in the .rs files, so
 ///
-/// ```rust
+/// ```rust,no_run
 /// #[cfg(py_sys_config="{varname}")]
 /// # struct Foo;
 /// ```
@@ -1001,10 +1173,11 @@ impl FromStr for BuildFlag {
 pub struct BuildFlags(pub HashSet<BuildFlag>);
 
 impl BuildFlags {
-    const ALL: [BuildFlag; 4] = [
+    const ALL: [BuildFlag; 5] = [
         BuildFlag::Py_DEBUG,
         BuildFlag::Py_REF_DEBUG,
         BuildFlag::Py_TRACE_REFS,
+        BuildFlag::Py_GIL_DISABLED,
         BuildFlag::COUNT_ALLOCS,
     ];
 
@@ -1016,11 +1189,7 @@ impl BuildFlags {
         Self(
             BuildFlags::ALL
                 .iter()
-                .filter(|flag| {
-                    config_map
-                        .get_value(&flag.to_string())
-                        .map_or(false, |value| value == "1")
-                })
+                .filter(|flag| config_map.get_value(flag.to_string()) == Some("1"))
                 .cloned()
                 .collect(),
         )
@@ -1031,10 +1200,15 @@ impl BuildFlags {
     /// the interpreter and printing variables of interest from
     /// sysconfig.get_config_vars.
     fn from_interpreter(interpreter: impl AsRef<Path>) -> Result<Self> {
-        // sysconfig is missing all the flags on windows, so we can't actually
-        // query the interpreter directly for its build flags.
+        // sysconfig is missing all the flags on windows for Python 3.12 and
+        // older, so we can't actually query the interpreter directly for its
+        // build flags on those versions.
         if cfg!(windows) {
-            return Ok(Self::new());
+            let script = String::from("import sys;print(sys.version_info < (3, 13))");
+            let stdout = run_python_script(interpreter.as_ref(), &script)?;
+            if stdout.trim_end() == "True" {
+                return Ok(Self::new());
+            }
         }
 
         let mut script = String::from("import sysconfig\n");
@@ -1042,7 +1216,7 @@ impl BuildFlags {
 
         for k in &BuildFlags::ALL {
             use std::fmt::Write;
-            writeln!(&mut script, "print(config.get('{}', '0'))", k).unwrap();
+            writeln!(&mut script, "print(config.get('{k}', '0'))").unwrap();
         }
 
         let stdout = run_python_script(interpreter.as_ref(), &script)?;
@@ -1080,7 +1254,7 @@ impl Display for BuildFlags {
             } else {
                 write!(f, ",")?;
             }
-            write!(f, "{}", flag)?;
+            write!(f, "{flag}")?;
         }
         Ok(())
     }
@@ -1146,6 +1320,10 @@ pub fn parse_sysconfigdata(sysconfigdata_path: impl AsRef<Path>) -> Result<Sysco
     })?;
     script += r#"
 for key, val in build_time_vars.items():
+    # (ana)conda(-forge) built Pythons are statically linked but ship the shared library with them.
+    # We detect them based on the magic prefix directory they have encoded in their builds.
+    if key == "Py_ENABLE_SHARED" and "_h_env_placehold" in build_time_vars.get("prefix"):
+        val = 1
     print(key, val)
 "#;
 
@@ -1167,8 +1345,9 @@ fn ends_with(entry: &DirEntry, pat: &str) -> bool {
 ///
 /// Returns `None` if the library directory is not available, and a runtime error
 /// when no or multiple sysconfigdata files are found.
+#[allow(dead_code)]
 fn find_sysconfigdata(cross: &CrossCompileConfig) -> Result<Option<PathBuf>> {
-    let mut sysconfig_paths = find_all_sysconfigdata(cross);
+    let mut sysconfig_paths = find_all_sysconfigdata(cross)?;
     if sysconfig_paths.is_empty() {
         if let Some(lib_dir) = cross.lib_dir.as_ref() {
             bail!("Could not find _sysconfigdata*.py in {}", lib_dir.display());
@@ -1231,11 +1410,16 @@ fn find_sysconfigdata(cross: &CrossCompileConfig) -> Result<Option<PathBuf>> {
 ///
 /// Returns an empty vector when the target Python library directory
 /// is not set via `PYO3_CROSS_LIB_DIR`.
-pub fn find_all_sysconfigdata(cross: &CrossCompileConfig) -> Vec<PathBuf> {
+pub fn find_all_sysconfigdata(cross: &CrossCompileConfig) -> Result<Vec<PathBuf>> {
     let sysconfig_paths = if let Some(lib_dir) = cross.lib_dir.as_ref() {
-        search_lib_dir(lib_dir, cross)
+        search_lib_dir(lib_dir, cross).with_context(|| {
+            format!(
+                "failed to search the lib dir at 'PYO3_CROSS_LIB_DIR={}'",
+                lib_dir.display()
+            )
+        })?
     } else {
-        return Vec::new();
+        return Ok(Vec::new());
     };
 
     let sysconfig_name = env_var("_PYTHON_SYSCONFIGDATA_NAME");
@@ -1253,21 +1437,30 @@ pub fn find_all_sysconfigdata(cross: &CrossCompileConfig) -> Vec<PathBuf> {
     sysconfig_paths.sort();
     sysconfig_paths.dedup();
 
-    sysconfig_paths
+    Ok(sysconfig_paths)
 }
 
 fn is_pypy_lib_dir(path: &str, v: &Option<PythonVersion>) -> bool {
     let pypy_version_pat = if let Some(v) = v {
-        format!("pypy{}", v)
+        format!("pypy{v}")
     } else {
         "pypy3.".into()
     };
     path == "lib_pypy" || path.starts_with(&pypy_version_pat)
 }
 
+fn is_graalpy_lib_dir(path: &str, v: &Option<PythonVersion>) -> bool {
+    let graalpy_version_pat = if let Some(v) = v {
+        format!("graalpy{v}")
+    } else {
+        "graalpy2".into()
+    };
+    path == "lib_graalpython" || path.starts_with(&graalpy_version_pat)
+}
+
 fn is_cpython_lib_dir(path: &str, v: &Option<PythonVersion>) -> bool {
     let cpython_version_pat = if let Some(v) = v {
-        format!("python{}", v)
+        format!("python{v}")
     } else {
         "python3.".into()
     };
@@ -1275,17 +1468,22 @@ fn is_cpython_lib_dir(path: &str, v: &Option<PythonVersion>) -> bool {
 }
 
 /// recursive search for _sysconfigdata, returns all possibilities of sysconfigdata paths
-fn search_lib_dir(path: impl AsRef<Path>, cross: &CrossCompileConfig) -> Vec<PathBuf> {
+fn search_lib_dir(path: impl AsRef<Path>, cross: &CrossCompileConfig) -> Result<Vec<PathBuf>> {
     let mut sysconfig_paths = vec![];
-    for f in fs::read_dir(path).expect("Path does not exist") {
+    for f in fs::read_dir(path.as_ref()).with_context(|| {
+        format!(
+            "failed to list the entries in '{}'",
+            path.as_ref().display()
+        )
+    })? {
         sysconfig_paths.extend(match &f {
             // Python 3.7+ sysconfigdata with platform specifics
             Ok(f) if starts_with(f, "_sysconfigdata_") && ends_with(f, "py") => vec![f.path()],
-            Ok(f) if f.metadata().map_or(false, |metadata| metadata.is_dir()) => {
+            Ok(f) if f.metadata().is_ok_and(|metadata| metadata.is_dir()) => {
                 let file_name = f.file_name();
                 let file_name = file_name.to_string_lossy();
                 if file_name == "build" || file_name == "lib" {
-                    search_lib_dir(f.path(), cross)
+                    search_lib_dir(f.path(), cross)?
                 } else if file_name.starts_with("lib.") {
                     // check if right target os
                     if !file_name.contains(&cross.target.operating_system.to_string()) {
@@ -1295,11 +1493,12 @@ fn search_lib_dir(path: impl AsRef<Path>, cross: &CrossCompileConfig) -> Vec<Pat
                     if !file_name.contains(&cross.target.architecture.to_string()) {
                         continue;
                     }
-                    search_lib_dir(f.path(), cross)
+                    search_lib_dir(f.path(), cross)?
                 } else if is_cpython_lib_dir(&file_name, &cross.version)
                     || is_pypy_lib_dir(&file_name, &cross.version)
+                    || is_graalpy_lib_dir(&file_name, &cross.version)
                 {
-                    search_lib_dir(f.path(), cross)
+                    search_lib_dir(f.path(), cross)?
                 } else {
                     continue;
                 }
@@ -1328,7 +1527,7 @@ fn search_lib_dir(path: impl AsRef<Path>, cross: &CrossCompileConfig) -> Vec<Pat
         }
     }
 
-    sysconfig_paths
+    Ok(sysconfig_paths)
 }
 
 /// Find cross compilation information from sysconfigdata file
@@ -1338,12 +1537,16 @@ fn search_lib_dir(path: impl AsRef<Path>, cross: &CrossCompileConfig) -> Vec<Pat
 /// [1]: https://github.com/python/cpython/blob/3.8/Lib/sysconfig.py#L348
 ///
 /// Returns `None` when the target Python library directory is not set.
+#[allow(dead_code)]
 fn cross_compile_from_sysconfigdata(
     cross_compile_config: &CrossCompileConfig,
 ) -> Result<Option<InterpreterConfig>> {
     if let Some(path) = find_sysconfigdata(cross_compile_config)? {
         let data = parse_sysconfigdata(path)?;
-        let config = InterpreterConfig::from_sysconfigdata(&data)?;
+        let mut config = InterpreterConfig::from_sysconfigdata(&data)?;
+        if let Some(cross_lib_dir) = cross_compile_config.lib_dir_string() {
+            config.lib_dir = Some(cross_lib_dir)
+        }
 
         Ok(Some(config))
     } else {
@@ -1357,7 +1560,7 @@ fn cross_compile_from_sysconfigdata(
 /// Windows, macOS and Linux.
 ///
 /// Must be called from a PyO3 crate build script.
-#[allow(unused_mut)]
+#[allow(unused_mut, dead_code)]
 fn default_cross_compile(cross_compile_config: &CrossCompileConfig) -> Result<InterpreterConfig> {
     let version = cross_compile_config
         .version
@@ -1366,7 +1569,7 @@ fn default_cross_compile(cross_compile_config: &CrossCompileConfig) -> Result<In
             format!(
                 "PYO3_CROSS_PYTHON_VERSION or an abi3-py3* feature must be specified \
                 when cross-compiling and PYO3_CROSS_LIB_DIR is not set.\n\
-                = help: see the PyO3 user guide for more information: https://pyo3.rs/v{}/building_and_distribution.html#cross-compiling",
+                = help: see the PyO3 user guide for more information: https://pyo3.rs/v{}/building-and-distribution.html#cross-compiling",
                 env!("CARGO_PKG_VERSION")
             )
         )?;
@@ -1375,22 +1578,34 @@ fn default_cross_compile(cross_compile_config: &CrossCompileConfig) -> Result<In
     let implementation = cross_compile_config
         .implementation
         .unwrap_or(PythonImplementation::CPython);
+    let gil_disabled: bool = cross_compile_config.abiflags.as_deref() == Some("t");
 
-    let lib_name =
-        default_lib_name_for_target(version, implementation, abi3, &cross_compile_config.target);
+    let lib_name = default_lib_name_for_target(
+        version,
+        implementation,
+        abi3,
+        gil_disabled,
+        &cross_compile_config.target,
+    );
 
     let mut lib_dir = cross_compile_config.lib_dir_string();
 
     // Auto generate python3.dll import libraries for Windows targets.
-    #[cfg(feature = "python3-dll-a")]
+    #[cfg(feature = "generate-import-lib")]
     if lib_dir.is_none() {
-        let py_version = if abi3 { None } else { Some(version) };
+        let py_version = if implementation == PythonImplementation::CPython && abi3 && !gil_disabled
+        {
+            None
+        } else {
+            Some(version)
+        };
         lib_dir = self::import_lib::generate_import_lib(
             &cross_compile_config.target,
             cross_compile_config
                 .implementation
                 .unwrap_or(PythonImplementation::CPython),
             py_version,
+            None,
         )?;
     }
 
@@ -1399,13 +1614,14 @@ fn default_cross_compile(cross_compile_config: &CrossCompileConfig) -> Result<In
         version,
         shared: true,
         abi3,
-        lib_name,
+        lib_name: Some(lib_name),
         lib_dir,
         executable: None,
         pointer_width: None,
         build_flags: BuildFlags::default(),
         suppress_build_script_link_lines: false,
         extra_build_script_lines: vec![],
+        python_framework_prefix: None,
     })
 }
 
@@ -1418,8 +1634,8 @@ fn default_cross_compile(cross_compile_config: &CrossCompileConfig) -> Result<In
 /// Windows, macOS and Linux.
 ///
 /// Must be called from a PyO3 crate build script.
-fn default_abi3_config(host: &Triple, version: PythonVersion) -> InterpreterConfig {
-    // FIXME: PyPy does not support the Stable ABI yet.
+fn default_abi3_config(host: &Triple, version: PythonVersion) -> Result<InterpreterConfig> {
+    // FIXME: PyPy & GraalPy do not support the Stable ABI.
     let implementation = PythonImplementation::CPython;
     let abi3 = true;
 
@@ -1430,12 +1646,13 @@ fn default_abi3_config(host: &Triple, version: PythonVersion) -> InterpreterConf
             abi3,
             false,
             false,
-        ))
+            false,
+        )?)
     } else {
         None
     };
 
-    InterpreterConfig {
+    Ok(InterpreterConfig {
         implementation,
         version,
         shared: true,
@@ -1447,7 +1664,8 @@ fn default_abi3_config(host: &Triple, version: PythonVersion) -> InterpreterConf
         build_flags: BuildFlags::default(),
         suppress_build_script_link_lines: false,
         extra_build_script_lines: vec![],
-    }
+        python_framework_prefix: None,
+    })
 }
 
 /// Detects the cross compilation target interpreter configuration from all
@@ -1457,6 +1675,7 @@ fn default_abi3_config(host: &Triple, version: PythonVersion) -> InterpreterConf
 /// when no target Python interpreter is found.
 ///
 /// Must be called from a PyO3 crate build script.
+#[allow(dead_code)]
 fn load_cross_compile_config(
     cross_compile_config: CrossCompileConfig,
 ) -> Result<InterpreterConfig> {
@@ -1475,42 +1694,26 @@ fn load_cross_compile_config(
         default_cross_compile(&cross_compile_config)?
     };
 
-    if config.lib_name.is_some() && config.lib_dir.is_none() {
-        warn!(
-            "The output binary will link to libpython, \
-            but PYO3_CROSS_LIB_DIR environment variable is not set. \
-            Ensure that the target Python library directory is \
-            in the rustc native library search path."
-        );
-    }
-
     Ok(config)
 }
 
-// Link against python3.lib for the stable ABI on Windows.
-// See https://www.python.org/dev/peps/pep-0384/#linkage
-//
-// This contains only the limited ABI symbols.
+// These contains only the limited ABI symbols.
 const WINDOWS_ABI3_LIB_NAME: &str = "python3";
+const WINDOWS_ABI3_DEBUG_LIB_NAME: &str = "python3_d";
 
+/// Generates the default library name for the target platform.
+#[allow(dead_code)]
 fn default_lib_name_for_target(
     version: PythonVersion,
     implementation: PythonImplementation,
     abi3: bool,
+    gil_disabled: bool,
     target: &Triple,
-) -> Option<String> {
+) -> String {
     if target.operating_system == OperatingSystem::Windows {
-        Some(default_lib_name_windows(
-            version,
-            implementation,
-            abi3,
-            false,
-            false,
-        ))
-    } else if is_linking_libpython_for_target(target) {
-        Some(default_lib_name_unix(version, implementation, None))
+        default_lib_name_windows(version, implementation, abi3, false, false, gil_disabled).unwrap()
     } else {
-        None
+        default_lib_name_unix(version, implementation, None, gil_disabled).unwrap()
     }
 }
 
@@ -1520,18 +1723,36 @@ fn default_lib_name_windows(
     abi3: bool,
     mingw: bool,
     debug: bool,
-) -> String {
-    if debug {
+    gil_disabled: bool,
+) -> Result<String> {
+    if debug && version < PythonVersion::PY310 {
         // CPython bug: linking against python3_d.dll raises error
         // https://github.com/python/cpython/issues/101614
-        format!("python{}{}_d", version.major, version.minor)
-    } else if abi3 && !implementation.is_pypy() {
-        WINDOWS_ABI3_LIB_NAME.to_owned()
+        Ok(format!("python{}{}_d", version.major, version.minor))
+    } else if abi3 && !(gil_disabled || implementation.is_pypy() || implementation.is_graalpy()) {
+        if debug {
+            Ok(WINDOWS_ABI3_DEBUG_LIB_NAME.to_owned())
+        } else {
+            Ok(WINDOWS_ABI3_LIB_NAME.to_owned())
+        }
     } else if mingw {
+        ensure!(
+            !gil_disabled,
+            "MinGW free-threaded builds are not currently tested or supported"
+        );
         // https://packages.msys2.org/base/mingw-w64-python
-        format!("python{}.{}", version.major, version.minor)
+        Ok(format!("python{}.{}", version.major, version.minor))
+    } else if gil_disabled {
+        ensure!(version >= PythonVersion::PY313, "Cannot compile C extensions for the free-threaded build on Python versions earlier than 3.13, found {}.{}", version.major, version.minor);
+        if debug {
+            Ok(format!("python{}{}t_d", version.major, version.minor))
+        } else {
+            Ok(format!("python{}{}t", version.major, version.minor))
+        }
+    } else if debug {
+        Ok(format!("python{}{}_d", version.major, version.minor))
     } else {
-        format!("python{}{}", version.major, version.minor)
+        Ok(format!("python{}{}", version.major, version.minor))
     }
 }
 
@@ -1539,30 +1760,32 @@ fn default_lib_name_unix(
     version: PythonVersion,
     implementation: PythonImplementation,
     ld_version: Option<&str>,
-) -> String {
+    gil_disabled: bool,
+) -> Result<String> {
     match implementation {
         PythonImplementation::CPython => match ld_version {
-            Some(ld_version) => format!("python{}", ld_version),
+            Some(ld_version) => Ok(format!("python{ld_version}")),
             None => {
                 if version > PythonVersion::PY37 {
                     // PEP 3149 ABI version tags are finally gone
-                    format!("python{}.{}", version.major, version.minor)
+                    if gil_disabled {
+                        ensure!(version >= PythonVersion::PY313, "Cannot compile C extensions for the free-threaded build on Python versions earlier than 3.13, found {}.{}", version.major, version.minor);
+                        Ok(format!("python{}.{}t", version.major, version.minor))
+                    } else {
+                        Ok(format!("python{}.{}", version.major, version.minor))
+                    }
                 } else {
                     // Work around https://bugs.python.org/issue36707
-                    format!("python{}.{}m", version.major, version.minor)
+                    Ok(format!("python{}.{}m", version.major, version.minor))
                 }
             }
         },
-        PythonImplementation::PyPy => {
-            if version >= (PythonVersion { major: 3, minor: 9 }) {
-                match ld_version {
-                    Some(ld_version) => format!("pypy{}-c", ld_version),
-                    None => format!("pypy{}.{}-c", version.major, version.minor),
-                }
-            } else {
-                format!("pypy{}-c", version.major)
-            }
-        }
+        PythonImplementation::PyPy => match ld_version {
+            Some(ld_version) => Ok(format!("pypy{ld_version}-c")),
+            None => Ok(format!("pypy{}.{}-c", version.major, version.minor)),
+        },
+
+        PythonImplementation::GraalPy => Ok("python-native".to_string()),
     }
 }
 
@@ -1663,7 +1886,9 @@ pub fn find_interpreter() -> Result<PathBuf> {
             .find(|bin| {
                 if let Ok(out) = Command::new(bin).arg("--version").output() {
                     // begin with `Python 3.X.X :: additional info`
-                    out.stdout.starts_with(b"Python 3") || out.stderr.starts_with(b"Python 3")
+                    out.stdout.starts_with(b"Python 3")
+                        || out.stderr.starts_with(b"Python 3")
+                        || out.stdout.starts_with(b"GraalPy 3")
                 } else {
                     false
                 }
@@ -1689,6 +1914,7 @@ fn get_host_interpreter(abi3_version: Option<PythonVersion>) -> Result<Interpret
 ///
 /// This must be called from PyO3's build script, because it relies on environment variables such as
 /// CARGO_CFG_TARGET_OS which aren't available at any other time.
+#[allow(dead_code)]
 pub fn make_cross_compile_config() -> Result<Option<InterpreterConfig>> {
     let interpreter_config = if let Some(cross_config) = cross_compiling_from_cargo_env()? {
         let mut interpreter_config = load_cross_compile_config(cross_config)?;
@@ -1730,12 +1956,19 @@ pub fn make_interpreter_config() -> Result<InterpreterConfig> {
         );
     };
 
-    let mut interpreter_config = default_abi3_config(&host, abi3_version.unwrap());
+    let mut interpreter_config = default_abi3_config(&host, abi3_version.unwrap())?;
 
     // Auto generate python3.dll import libraries for Windows targets.
-    #[cfg(feature = "python3-dll-a")]
+    #[cfg(feature = "generate-import-lib")]
     {
-        let py_version = if interpreter_config.abi3 {
+        let gil_disabled = interpreter_config
+            .build_flags
+            .0
+            .contains(&BuildFlag::Py_GIL_DISABLED);
+        let py_version = if interpreter_config.implementation == PythonImplementation::CPython
+            && interpreter_config.abi3
+            && !gil_disabled
+        {
             None
         } else {
             Some(interpreter_config.version)
@@ -1744,6 +1977,7 @@ pub fn make_interpreter_config() -> Result<InterpreterConfig> {
             &host,
             interpreter_config.implementation,
             py_version,
+            None,
         )?;
     }
 
@@ -1764,7 +1998,7 @@ fn escape(bytes: &[u8]) -> String {
 }
 
 fn unescape(escaped: &str) -> Vec<u8> {
-    assert!(escaped.len() % 2 == 0, "invalid hex encoding");
+    assert_eq!(escaped.len() % 2, 0, "invalid hex encoding");
 
     let mut bytes = Vec::with_capacity(escaped.len() / 2);
 
@@ -1777,7 +2011,7 @@ fn unescape(escaped: &str) -> Vec<u8> {
             }
         }
 
-        bytes.push(unhex(chunk[0]) << 4 | unhex(chunk[1]));
+        bytes.push((unhex(chunk[0]) << 4) | unhex(chunk[1]));
     }
 
     bytes
@@ -1785,7 +2019,6 @@ fn unescape(escaped: &str) -> Vec<u8> {
 
 #[cfg(test)]
 mod tests {
-    use std::iter::FromIterator;
     use target_lexicon::triple;
 
     use super::*;
@@ -1804,6 +2037,7 @@ mod tests {
             version: MINIMUM_SUPPORTED_VERSION,
             suppress_build_script_link_lines: true,
             extra_build_script_lines: vec!["cargo:test1".to_string(), "cargo:test2".to_string()],
+            python_framework_prefix: None,
         };
         let mut buf: Vec<u8> = Vec::new();
         config.to_writer(&mut buf).unwrap();
@@ -1832,6 +2066,7 @@ mod tests {
             },
             suppress_build_script_link_lines: false,
             extra_build_script_lines: vec![],
+            python_framework_prefix: None,
         };
         let mut buf: Vec<u8> = Vec::new();
         config.to_writer(&mut buf).unwrap();
@@ -1853,6 +2088,7 @@ mod tests {
             version: MINIMUM_SUPPORTED_VERSION,
             suppress_build_script_link_lines: true,
             extra_build_script_lines: vec!["cargo:test1".to_string(), "cargo:test2".to_string()],
+            python_framework_prefix: None,
         };
         let mut buf: Vec<u8> = Vec::new();
         config.to_writer(&mut buf).unwrap();
@@ -1879,6 +2115,7 @@ mod tests {
                 build_flags: BuildFlags::default(),
                 suppress_build_script_link_lines: false,
                 extra_build_script_lines: vec![],
+                python_framework_prefix: None,
             }
         )
     }
@@ -1901,6 +2138,7 @@ mod tests {
                 build_flags: BuildFlags::default(),
                 suppress_build_script_link_lines: false,
                 extra_build_script_lines: vec![],
+                python_framework_prefix: None,
             }
         )
     }
@@ -2003,6 +2241,7 @@ mod tests {
                 version: PythonVersion::PY37,
                 suppress_build_script_link_lines: false,
                 extra_build_script_lines: vec![],
+                python_framework_prefix: None,
             }
         );
     }
@@ -2032,6 +2271,7 @@ mod tests {
                 version: PythonVersion::PY37,
                 suppress_build_script_link_lines: false,
                 extra_build_script_lines: vec![],
+                python_framework_prefix: None,
             }
         );
 
@@ -2058,6 +2298,7 @@ mod tests {
                 version: PythonVersion::PY37,
                 suppress_build_script_link_lines: false,
                 extra_build_script_lines: vec![],
+                python_framework_prefix: None,
             }
         );
     }
@@ -2068,7 +2309,7 @@ mod tests {
         let min_version = "3.7".parse().unwrap();
 
         assert_eq!(
-            default_abi3_config(&host, min_version),
+            default_abi3_config(&host, min_version).unwrap(),
             InterpreterConfig {
                 implementation: PythonImplementation::CPython,
                 version: PythonVersion { major: 3, minor: 7 },
@@ -2081,6 +2322,7 @@ mod tests {
                 build_flags: BuildFlags::default(),
                 suppress_build_script_link_lines: false,
                 extra_build_script_lines: vec![],
+                python_framework_prefix: None,
             }
         );
     }
@@ -2091,7 +2333,7 @@ mod tests {
         let min_version = "3.9".parse().unwrap();
 
         assert_eq!(
-            default_abi3_config(&host, min_version),
+            default_abi3_config(&host, min_version).unwrap(),
             InterpreterConfig {
                 implementation: PythonImplementation::CPython,
                 version: PythonVersion { major: 3, minor: 9 },
@@ -2104,6 +2346,7 @@ mod tests {
                 build_flags: BuildFlags::default(),
                 suppress_build_script_link_lines: false,
                 extra_build_script_lines: vec![],
+                python_framework_prefix: None,
             }
         );
     }
@@ -2138,6 +2381,7 @@ mod tests {
                 build_flags: BuildFlags::default(),
                 suppress_build_script_link_lines: false,
                 extra_build_script_lines: vec![],
+                python_framework_prefix: None,
             }
         );
     }
@@ -2172,6 +2416,7 @@ mod tests {
                 build_flags: BuildFlags::default(),
                 suppress_build_script_link_lines: false,
                 extra_build_script_lines: vec![],
+                python_framework_prefix: None,
             }
         );
     }
@@ -2206,6 +2451,7 @@ mod tests {
                 build_flags: BuildFlags::default(),
                 suppress_build_script_link_lines: false,
                 extra_build_script_lines: vec![],
+                python_framework_prefix: None,
             }
         );
     }
@@ -2216,7 +2462,7 @@ mod tests {
             pyo3_cross: None,
             pyo3_cross_lib_dir: None,
             pyo3_cross_python_implementation: Some("PyPy".into()),
-            pyo3_cross_python_version: Some("3.10".into()),
+            pyo3_cross_python_version: Some("3.11".into()),
         };
 
         let triple = triple!("x86_64-unknown-linux-gnu");
@@ -2231,17 +2477,18 @@ mod tests {
                 implementation: PythonImplementation::PyPy,
                 version: PythonVersion {
                     major: 3,
-                    minor: 10
+                    minor: 11
                 },
                 shared: true,
                 abi3: false,
-                lib_name: Some("pypy3.10-c".into()),
+                lib_name: Some("pypy3.11-c".into()),
                 lib_dir: None,
                 executable: None,
                 pointer_width: None,
                 build_flags: BuildFlags::default(),
                 suppress_build_script_link_lines: false,
                 extra_build_script_lines: vec![],
+                python_framework_prefix: None,
             }
         );
     }
@@ -2251,75 +2498,184 @@ mod tests {
         use PythonImplementation::*;
         assert_eq!(
             super::default_lib_name_windows(
-                PythonVersion { major: 3, minor: 7 },
+                PythonVersion { major: 3, minor: 9 },
                 CPython,
                 false,
                 false,
                 false,
-            ),
-            "python37",
+                false,
+            )
+            .unwrap(),
+            "python39",
         );
+        assert!(super::default_lib_name_windows(
+            PythonVersion { major: 3, minor: 9 },
+            CPython,
+            false,
+            false,
+            false,
+            true,
+        )
+        .is_err());
         assert_eq!(
             super::default_lib_name_windows(
-                PythonVersion { major: 3, minor: 7 },
+                PythonVersion { major: 3, minor: 9 },
                 CPython,
                 true,
                 false,
                 false,
-            ),
+                false,
+            )
+            .unwrap(),
             "python3",
         );
         assert_eq!(
             super::default_lib_name_windows(
-                PythonVersion { major: 3, minor: 7 },
+                PythonVersion { major: 3, minor: 9 },
                 CPython,
                 false,
                 true,
                 false,
-            ),
-            "python3.7",
+                false,
+            )
+            .unwrap(),
+            "python3.9",
         );
         assert_eq!(
             super::default_lib_name_windows(
-                PythonVersion { major: 3, minor: 7 },
+                PythonVersion { major: 3, minor: 9 },
                 CPython,
                 true,
                 true,
                 false,
-            ),
+                false,
+            )
+            .unwrap(),
             "python3",
         );
         assert_eq!(
             super::default_lib_name_windows(
-                PythonVersion { major: 3, minor: 7 },
+                PythonVersion { major: 3, minor: 9 },
                 PyPy,
                 true,
                 false,
                 false,
-            ),
-            "python37",
+                false,
+            )
+            .unwrap(),
+            "python39",
         );
         assert_eq!(
             super::default_lib_name_windows(
-                PythonVersion { major: 3, minor: 7 },
+                PythonVersion { major: 3, minor: 9 },
                 CPython,
                 false,
                 false,
                 true,
-            ),
-            "python37_d",
+                false,
+            )
+            .unwrap(),
+            "python39_d",
         );
-        // abi3 debug builds on windows use version-specific lib
+        // abi3 debug builds on windows use version-specific lib on 3.9 and older
         // to workaround https://github.com/python/cpython/issues/101614
         assert_eq!(
             super::default_lib_name_windows(
-                PythonVersion { major: 3, minor: 7 },
+                PythonVersion { major: 3, minor: 9 },
                 CPython,
                 true,
                 false,
                 true,
-            ),
-            "python37_d",
+                false,
+            )
+            .unwrap(),
+            "python39_d",
+        );
+        assert_eq!(
+            super::default_lib_name_windows(
+                PythonVersion {
+                    major: 3,
+                    minor: 10
+                },
+                CPython,
+                true,
+                false,
+                true,
+                false,
+            )
+            .unwrap(),
+            "python3_d",
+        );
+        // Python versions older than 3.13 don't support gil_disabled
+        assert!(super::default_lib_name_windows(
+            PythonVersion {
+                major: 3,
+                minor: 12,
+            },
+            CPython,
+            false,
+            false,
+            false,
+            true,
+        )
+        .is_err());
+        // mingw and free-threading are incompatible (until someone adds support)
+        assert!(super::default_lib_name_windows(
+            PythonVersion {
+                major: 3,
+                minor: 12,
+            },
+            CPython,
+            false,
+            true,
+            false,
+            true,
+        )
+        .is_err());
+        assert_eq!(
+            super::default_lib_name_windows(
+                PythonVersion {
+                    major: 3,
+                    minor: 13
+                },
+                CPython,
+                false,
+                false,
+                false,
+                true,
+            )
+            .unwrap(),
+            "python313t",
+        );
+        assert_eq!(
+            super::default_lib_name_windows(
+                PythonVersion {
+                    major: 3,
+                    minor: 13
+                },
+                CPython,
+                true, // abi3 true should not affect the free-threaded lib name
+                false,
+                false,
+                true,
+            )
+            .unwrap(),
+            "python313t",
+        );
+        assert_eq!(
+            super::default_lib_name_windows(
+                PythonVersion {
+                    major: 3,
+                    minor: 13
+                },
+                CPython,
+                false,
+                false,
+                true,
+                true,
+            )
+            .unwrap(),
+            "python313t_d",
         );
     }
 
@@ -2328,16 +2684,34 @@ mod tests {
         use PythonImplementation::*;
         // Defaults to python3.7m for CPython 3.7
         assert_eq!(
-            super::default_lib_name_unix(PythonVersion { major: 3, minor: 7 }, CPython, None),
+            super::default_lib_name_unix(
+                PythonVersion { major: 3, minor: 7 },
+                CPython,
+                None,
+                false
+            )
+            .unwrap(),
             "python3.7m",
         );
         // Defaults to pythonX.Y for CPython 3.8+
         assert_eq!(
-            super::default_lib_name_unix(PythonVersion { major: 3, minor: 8 }, CPython, None),
+            super::default_lib_name_unix(
+                PythonVersion { major: 3, minor: 8 },
+                CPython,
+                None,
+                false
+            )
+            .unwrap(),
             "python3.8",
         );
         assert_eq!(
-            super::default_lib_name_unix(PythonVersion { major: 3, minor: 9 }, CPython, None),
+            super::default_lib_name_unix(
+                PythonVersion { major: 3, minor: 9 },
+                CPython,
+                None,
+                false
+            )
+            .unwrap(),
             "python3.9",
         );
         // Can use ldversion to override for CPython
@@ -2345,22 +2719,64 @@ mod tests {
             super::default_lib_name_unix(
                 PythonVersion { major: 3, minor: 9 },
                 CPython,
-                Some("3.7md")
-            ),
+                Some("3.7md"),
+                false
+            )
+            .unwrap(),
             "python3.7md",
         );
 
-        // PyPy 3.7 ignores ldversion
+        // PyPy 3.11 includes ldversion
         assert_eq!(
-            super::default_lib_name_unix(PythonVersion { major: 3, minor: 7 }, PyPy, Some("3.7md")),
-            "pypy3-c",
+            super::default_lib_name_unix(
+                PythonVersion {
+                    major: 3,
+                    minor: 11
+                },
+                PyPy,
+                None,
+                false
+            )
+            .unwrap(),
+            "pypy3.11-c",
+        );
+
+        assert_eq!(
+            super::default_lib_name_unix(
+                PythonVersion { major: 3, minor: 9 },
+                PyPy,
+                Some("3.11d"),
+                false
+            )
+            .unwrap(),
+            "pypy3.11d-c",
         );
 
-        // PyPy 3.9 includes ldversion
+        // free-threading adds a t suffix
         assert_eq!(
-            super::default_lib_name_unix(PythonVersion { major: 3, minor: 9 }, PyPy, Some("3.9d")),
-            "pypy3.9d-c",
+            super::default_lib_name_unix(
+                PythonVersion {
+                    major: 3,
+                    minor: 13
+                },
+                CPython,
+                None,
+                true
+            )
+            .unwrap(),
+            "python3.13t",
         );
+        // 3.12 and older are incompatible with gil_disabled
+        assert!(super::default_lib_name_unix(
+            PythonVersion {
+                major: 3,
+                minor: 12,
+            },
+            CPython,
+            None,
+            true,
+        )
+        .is_err());
     }
 
     #[test]
@@ -2374,7 +2790,7 @@ mod tests {
 
         assert_eq!(
             env_vars.parse_version().unwrap(),
-            Some(PythonVersion { major: 3, minor: 9 })
+            (Some(PythonVersion { major: 3, minor: 9 }), None),
         );
 
         let env_vars = CrossCompileEnvVars {
@@ -2384,7 +2800,25 @@ mod tests {
             pyo3_cross_python_implementation: None,
         };
 
-        assert_eq!(env_vars.parse_version().unwrap(), None);
+        assert_eq!(env_vars.parse_version().unwrap(), (None, None));
+
+        let env_vars = CrossCompileEnvVars {
+            pyo3_cross: None,
+            pyo3_cross_lib_dir: None,
+            pyo3_cross_python_version: Some("3.13t".into()),
+            pyo3_cross_python_implementation: None,
+        };
+
+        assert_eq!(
+            env_vars.parse_version().unwrap(),
+            (
+                Some(PythonVersion {
+                    major: 3,
+                    minor: 13
+                }),
+                Some("t".into())
+            ),
+        );
 
         let env_vars = CrossCompileEnvVars {
             pyo3_cross: None,
@@ -2410,6 +2844,7 @@ mod tests {
             version: PythonVersion { major: 3, minor: 7 },
             suppress_build_script_link_lines: false,
             extra_build_script_lines: vec![],
+            python_framework_prefix: None,
         };
 
         config
@@ -2432,6 +2867,7 @@ mod tests {
             version: PythonVersion { major: 3, minor: 7 },
             suppress_build_script_link_lines: false,
             extra_build_script_lines: vec![],
+            python_framework_prefix: None,
         };
 
         assert!(config
@@ -2467,6 +2903,11 @@ mod tests {
             version: Some(interpreter_config.version),
             implementation: Some(interpreter_config.implementation),
             target: triple!("x86_64-unknown-linux-gnu"),
+            abiflags: if interpreter_config.is_free_threaded() {
+                Some("t".into())
+            } else {
+                None
+            },
         };
 
         let sysconfigdata_path = match find_sysconfigdata(&cross) {
@@ -2491,6 +2932,7 @@ mod tests {
                 version: interpreter_config.version,
                 suppress_build_script_link_lines: false,
                 extra_build_script_lines: vec![],
+                python_framework_prefix: None,
             }
         )
     }
@@ -2564,6 +3006,23 @@ mod tests {
         )
         .unwrap()
         .is_none());
+
+        assert!(cross_compiling_from_to(
+            &triple!("x86_64-pc-windows-msvc"),
+            &triple!("x86_64-win7-windows-msvc"),
+        )
+        .unwrap()
+        .is_none());
+    }
+
+    #[test]
+    fn test_is_cross_compiling_from_to() {
+        assert!(cross_compiling_from_to(
+            &triple!("x86_64-pc-windows-msvc"),
+            &triple!("aarch64-pc-windows-msvc")
+        )
+        .unwrap()
+        .is_some());
     }
 
     #[test]
@@ -2595,7 +3054,10 @@ mod tests {
     fn test_build_script_outputs_base() {
         let interpreter_config = InterpreterConfig {
             implementation: PythonImplementation::CPython,
-            version: PythonVersion { major: 3, minor: 8 },
+            version: PythonVersion {
+                major: 3,
+                minor: 11,
+            },
             shared: true,
             abi3: false,
             lib_name: Some("python3".into()),
@@ -2605,13 +3067,16 @@ mod tests {
             build_flags: BuildFlags::default(),
             suppress_build_script_link_lines: false,
             extra_build_script_lines: vec![],
+            python_framework_prefix: None,
         };
         assert_eq!(
             interpreter_config.build_script_outputs(),
             [
-                "cargo:rustc-cfg=Py_3_6".to_owned(),
                 "cargo:rustc-cfg=Py_3_7".to_owned(),
                 "cargo:rustc-cfg=Py_3_8".to_owned(),
+                "cargo:rustc-cfg=Py_3_9".to_owned(),
+                "cargo:rustc-cfg=Py_3_10".to_owned(),
+                "cargo:rustc-cfg=Py_3_11".to_owned(),
             ]
         );
 
@@ -2622,9 +3087,11 @@ mod tests {
         assert_eq!(
             interpreter_config.build_script_outputs(),
             [
-                "cargo:rustc-cfg=Py_3_6".to_owned(),
                 "cargo:rustc-cfg=Py_3_7".to_owned(),
                 "cargo:rustc-cfg=Py_3_8".to_owned(),
+                "cargo:rustc-cfg=Py_3_9".to_owned(),
+                "cargo:rustc-cfg=Py_3_10".to_owned(),
+                "cargo:rustc-cfg=Py_3_11".to_owned(),
                 "cargo:rustc-cfg=PyPy".to_owned(),
             ]
         );
@@ -2634,7 +3101,7 @@ mod tests {
     fn test_build_script_outputs_abi3() {
         let interpreter_config = InterpreterConfig {
             implementation: PythonImplementation::CPython,
-            version: PythonVersion { major: 3, minor: 7 },
+            version: PythonVersion { major: 3, minor: 9 },
             shared: true,
             abi3: true,
             lib_name: Some("python3".into()),
@@ -2644,13 +3111,15 @@ mod tests {
             build_flags: BuildFlags::default(),
             suppress_build_script_link_lines: false,
             extra_build_script_lines: vec![],
+            python_framework_prefix: None,
         };
 
         assert_eq!(
             interpreter_config.build_script_outputs(),
             [
-                "cargo:rustc-cfg=Py_3_6".to_owned(),
                 "cargo:rustc-cfg=Py_3_7".to_owned(),
+                "cargo:rustc-cfg=Py_3_8".to_owned(),
+                "cargo:rustc-cfg=Py_3_9".to_owned(),
                 "cargo:rustc-cfg=Py_LIMITED_API".to_owned(),
             ]
         );
@@ -2662,13 +3131,48 @@ mod tests {
         assert_eq!(
             interpreter_config.build_script_outputs(),
             [
-                "cargo:rustc-cfg=Py_3_6".to_owned(),
                 "cargo:rustc-cfg=Py_3_7".to_owned(),
+                "cargo:rustc-cfg=Py_3_8".to_owned(),
+                "cargo:rustc-cfg=Py_3_9".to_owned(),
                 "cargo:rustc-cfg=PyPy".to_owned(),
-                "cargo:warning=PyPy does not yet support abi3 so the build artifacts \
-            will be version-specific. See https://foss.heptapod.net/pypy/pypy/-/issues/3397 \
-            for more information."
-                    .to_owned(),
+                "cargo:rustc-cfg=Py_LIMITED_API".to_owned(),
+            ]
+        );
+    }
+
+    #[test]
+    fn test_build_script_outputs_gil_disabled() {
+        let mut build_flags = BuildFlags::default();
+        build_flags.0.insert(BuildFlag::Py_GIL_DISABLED);
+        let interpreter_config = InterpreterConfig {
+            implementation: PythonImplementation::CPython,
+            version: PythonVersion {
+                major: 3,
+                minor: 13,
+            },
+            shared: true,
+            abi3: false,
+            lib_name: Some("python3".into()),
+            lib_dir: None,
+            executable: None,
+            pointer_width: None,
+            build_flags,
+            suppress_build_script_link_lines: false,
+            extra_build_script_lines: vec![],
+            python_framework_prefix: None,
+        };
+
+        assert_eq!(
+            interpreter_config.build_script_outputs(),
+            [
+                "cargo:rustc-cfg=Py_3_7".to_owned(),
+                "cargo:rustc-cfg=Py_3_8".to_owned(),
+                "cargo:rustc-cfg=Py_3_9".to_owned(),
+                "cargo:rustc-cfg=Py_3_10".to_owned(),
+                "cargo:rustc-cfg=Py_3_11".to_owned(),
+                "cargo:rustc-cfg=Py_3_12".to_owned(),
+                "cargo:rustc-cfg=Py_3_13".to_owned(),
+                "cargo:rustc-cfg=Py_GIL_DISABLED".to_owned(),
             ]
         );
     }
@@ -2689,15 +3193,123 @@ mod tests {
             build_flags,
             suppress_build_script_link_lines: false,
             extra_build_script_lines: vec![],
+            python_framework_prefix: None,
         };
 
         assert_eq!(
             interpreter_config.build_script_outputs(),
             [
-                "cargo:rustc-cfg=Py_3_6".to_owned(),
                 "cargo:rustc-cfg=Py_3_7".to_owned(),
                 "cargo:rustc-cfg=py_sys_config=\"Py_DEBUG\"".to_owned(),
             ]
         );
     }
+
+    #[test]
+    fn test_find_sysconfigdata_in_invalid_lib_dir() {
+        let e = find_all_sysconfigdata(&CrossCompileConfig {
+            lib_dir: Some(PathBuf::from("/abc/123/not/a/real/path")),
+            version: None,
+            implementation: None,
+            target: triple!("x86_64-unknown-linux-gnu"),
+            abiflags: None,
+        })
+        .unwrap_err();
+
+        // actual error message is platform-dependent, so just check the context we add
+        assert!(e.report().to_string().starts_with(
+            "failed to search the lib dir at 'PYO3_CROSS_LIB_DIR=/abc/123/not/a/real/path'\n\
+            caused by:\n  \
+              - 0: failed to list the entries in '/abc/123/not/a/real/path'\n  \
+              - 1: \
+            "
+        ));
+    }
+
+    #[test]
+    fn test_from_pyo3_config_file_env_rebuild() {
+        READ_ENV_VARS.with(|vars| vars.borrow_mut().clear());
+        let _ = InterpreterConfig::from_pyo3_config_file_env();
+        // it's possible that other env vars were also read, hence just checking for contains
+        READ_ENV_VARS.with(|vars| assert!(vars.borrow().contains(&"PYO3_CONFIG_FILE".to_string())));
+    }
+
+    #[test]
+    fn test_apply_default_lib_name_to_config_file() {
+        let mut config = InterpreterConfig {
+            implementation: PythonImplementation::CPython,
+            version: PythonVersion { major: 3, minor: 9 },
+            shared: true,
+            abi3: false,
+            lib_name: None,
+            lib_dir: None,
+            executable: None,
+            pointer_width: None,
+            build_flags: BuildFlags::default(),
+            suppress_build_script_link_lines: false,
+            extra_build_script_lines: vec![],
+            python_framework_prefix: None,
+        };
+
+        let unix = Triple::from_str("x86_64-unknown-linux-gnu").unwrap();
+        let win_x64 = Triple::from_str("x86_64-pc-windows-msvc").unwrap();
+        let win_arm64 = Triple::from_str("aarch64-pc-windows-msvc").unwrap();
+
+        config.apply_default_lib_name_to_config_file(&unix);
+        assert_eq!(config.lib_name, Some("python3.9".into()));
+
+        config.lib_name = None;
+        config.apply_default_lib_name_to_config_file(&win_x64);
+        assert_eq!(config.lib_name, Some("python39".into()));
+
+        config.lib_name = None;
+        config.apply_default_lib_name_to_config_file(&win_arm64);
+        assert_eq!(config.lib_name, Some("python39".into()));
+
+        // PyPy
+        config.implementation = PythonImplementation::PyPy;
+        config.version = PythonVersion {
+            major: 3,
+            minor: 11,
+        };
+        config.lib_name = None;
+        config.apply_default_lib_name_to_config_file(&unix);
+        assert_eq!(config.lib_name, Some("pypy3.11-c".into()));
+
+        config.implementation = PythonImplementation::CPython;
+
+        // Free-threaded
+        config.build_flags.0.insert(BuildFlag::Py_GIL_DISABLED);
+        config.version = PythonVersion {
+            major: 3,
+            minor: 13,
+        };
+        config.lib_name = None;
+        config.apply_default_lib_name_to_config_file(&unix);
+        assert_eq!(config.lib_name, Some("python3.13t".into()));
+
+        config.lib_name = None;
+        config.apply_default_lib_name_to_config_file(&win_x64);
+        assert_eq!(config.lib_name, Some("python313t".into()));
+
+        config.lib_name = None;
+        config.apply_default_lib_name_to_config_file(&win_arm64);
+        assert_eq!(config.lib_name, Some("python313t".into()));
+
+        config.build_flags.0.remove(&BuildFlag::Py_GIL_DISABLED);
+
+        // abi3
+        config.abi3 = true;
+        config.lib_name = None;
+        config.apply_default_lib_name_to_config_file(&unix);
+        assert_eq!(config.lib_name, Some("python3.13".into()));
+
+        config.lib_name = None;
+        config.apply_default_lib_name_to_config_file(&win_x64);
+        assert_eq!(config.lib_name, Some("python3".into()));
+
+        config.lib_name = None;
+        config.apply_default_lib_name_to_config_file(&win_arm64);
+        assert_eq!(config.lib_name, Some("python3".into()));
+    }
 }
diff --git a/pyo3-build-config/src/import_lib.rs b/pyo3-build-config/src/import_lib.rs
index dc21638c3db..ee934441f77 100644
--- a/pyo3-build-config/src/import_lib.rs
+++ b/pyo3-build-config/src/import_lib.rs
@@ -7,7 +7,7 @@ use python3_dll_a::ImportLibraryGenerator;
 use target_lexicon::{Architecture, OperatingSystem, Triple};
 
 use super::{PythonImplementation, PythonVersion};
-use crate::errors::{Context, Result};
+use crate::errors::{Context, Error, Result};
 
 /// Generates the `python3.dll` or `pythonXY.dll` import library for Windows targets.
 ///
@@ -19,6 +19,7 @@ pub(super) fn generate_import_lib(
     target: &Triple,
     py_impl: PythonImplementation,
     py_version: Option<PythonVersion>,
+    abiflags: Option<&str>,
 ) -> Result<Option<String>> {
     if target.operating_system != OperatingSystem::Windows {
         return Ok(None);
@@ -42,11 +43,15 @@ pub(super) fn generate_import_lib(
     let implementation = match py_impl {
         PythonImplementation::CPython => python3_dll_a::PythonImplementation::CPython,
         PythonImplementation::PyPy => python3_dll_a::PythonImplementation::PyPy,
+        PythonImplementation::GraalPy => {
+            return Err(Error::from("No support for GraalPy on Windows"))
+        }
     };
 
     ImportLibraryGenerator::new(&arch, &env)
         .version(py_version.map(|v| (v.major, v.minor)))
         .implementation(implementation)
+        .abiflags(abiflags)
         .generate(&out_lib_dir)
         .context("failed to generate python3.dll import library")?;
 
diff --git a/pyo3-build-config/src/lib.rs b/pyo3-build-config/src/lib.rs
index 576dd37024b..267d3eb6b8c 100644
--- a/pyo3-build-config/src/lib.rs
+++ b/pyo3-build-config/src/lib.rs
@@ -16,15 +16,13 @@ use std::{
     path::{Path, PathBuf},
 };
 
-use std::{env, process::Command, str::FromStr};
-
-#[cfg(feature = "resolve-config")]
-use once_cell::sync::OnceCell;
+use std::{env, process::Command, str::FromStr, sync::OnceLock};
 
 pub use impl_::{
     cross_compiling_from_to, find_all_sysconfigdata, parse_sysconfigdata, BuildFlag, BuildFlags,
     CrossCompileConfig, InterpreterConfig, PythonImplementation, PythonVersion, Triple,
 };
+
 use target_lexicon::OperatingSystem;
 
 /// Adds all the [`#[cfg]` flags](index.html) to the current compilation.
@@ -38,12 +36,16 @@ use target_lexicon::OperatingSystem;
 /// | `#[cfg(Py_3_7)]`, `#[cfg(Py_3_8)]`, `#[cfg(Py_3_9)]`, `#[cfg(Py_3_10)]` | These attributes mark code only for a given Python version and up. For example, `#[cfg(Py_3_7)]` marks code which can run on Python 3.7 **and newer**. |
 /// | `#[cfg(Py_LIMITED_API)]` | This marks code which is run when compiling with PyO3's `abi3` feature enabled. |
 /// | `#[cfg(PyPy)]` | This marks code which is run when compiling for PyPy. |
+/// | `#[cfg(GraalPy)]` | This marks code which is run when compiling for GraalPy. |
 ///
-/// For examples of how to use these attributes, [see PyO3's guide](https://pyo3.rs/latest/building_and_distribution/multiple_python_versions.html).
+/// For examples of how to use these attributes,
+#[doc = concat!("[see PyO3's guide](https://pyo3.rs/v", env!("CARGO_PKG_VERSION"), "/building-and-distribution/multiple_python_versions.html)")]
+/// .
 #[cfg(feature = "resolve-config")]
 pub fn use_pyo3_cfgs() {
+    print_expected_cfgs();
     for cargo_command in get().build_script_outputs() {
-        println!("{}", cargo_command)
+        println!("{cargo_command}")
     }
 }
 
@@ -62,7 +64,7 @@ pub fn add_extension_module_link_args() {
 }
 
 fn _add_extension_module_link_args(triple: &Triple, mut writer: impl std::io::Write) {
-    if triple.operating_system == OperatingSystem::Darwin {
+    if matches!(triple.operating_system, OperatingSystem::Darwin(_)) {
         writeln!(writer, "cargo:rustc-cdylib-link-arg=-undefined").unwrap();
         writeln!(writer, "cargo:rustc-cdylib-link-arg=dynamic_lookup").unwrap();
     } else if triple == &Triple::from_str("wasm32-unknown-emscripten").unwrap() {
@@ -71,12 +73,45 @@ fn _add_extension_module_link_args(triple: &Triple, mut writer: impl std::io::Wr
     }
 }
 
+/// Adds linker arguments suitable for linking against the Python framework on macOS.
+///
+/// This should be called from a build script.
+///
+/// The following link flags are added:
+/// - macOS: `-Wl,-rpath,<framework_prefix>`
+///
+/// All other platforms currently are no-ops.
+#[cfg(feature = "resolve-config")]
+pub fn add_python_framework_link_args() {
+    let target = impl_::target_triple_from_env();
+    _add_python_framework_link_args(
+        get(),
+        &target,
+        impl_::is_linking_libpython_for_target(&target),
+        std::io::stdout(),
+    )
+}
+
+#[cfg(feature = "resolve-config")]
+fn _add_python_framework_link_args(
+    interpreter_config: &InterpreterConfig,
+    triple: &Triple,
+    link_libpython: bool,
+    mut writer: impl std::io::Write,
+) {
+    if matches!(triple.operating_system, OperatingSystem::Darwin(_)) && link_libpython {
+        if let Some(framework_prefix) = interpreter_config.python_framework_prefix.as_ref() {
+            writeln!(writer, "cargo:rustc-link-arg=-Wl,-rpath,{framework_prefix}").unwrap();
+        }
+    }
+}
+
 /// Loads the configuration determined from the build environment.
 ///
-/// Because this will never change in a given compilation run, this is cached in a `once_cell`.
+/// Because this will never change in a given compilation run, this is cached in a `OnceLock`.
 #[cfg(feature = "resolve-config")]
 pub fn get() -> &'static InterpreterConfig {
-    static CONFIG: OnceCell<InterpreterConfig> = OnceCell::new();
+    static CONFIG: OnceLock<InterpreterConfig> = OnceLock::new();
     CONFIG.get_or_init(|| {
         // Check if we are in a build script and cross compiling to a different target.
         let cross_compile_config_path = resolve_cross_compile_config_path();
@@ -85,10 +120,12 @@ pub fn get() -> &'static InterpreterConfig {
             .map(|path| path.exists())
             .unwrap_or(false);
 
+        // CONFIG_FILE is generated in build.rs, so its content can vary
+        #[allow(unknown_lints, clippy::const_is_empty)]
         if let Some(interpreter_config) = InterpreterConfig::from_cargo_dep_env() {
             interpreter_config
-        } else if !CONFIG_FILE.is_empty() {
-            InterpreterConfig::from_reader(Cursor::new(CONFIG_FILE))
+        } else if let Some(interpreter_config) = config_from_pyo3_config_file_env() {
+            Ok(interpreter_config)
         } else if cross_compiling {
             InterpreterConfig::from_path(cross_compile_config_path.as_ref().unwrap())
         } else {
@@ -98,13 +135,25 @@ pub fn get() -> &'static InterpreterConfig {
     })
 }
 
-/// Build configuration provided by `PYO3_CONFIG_FILE`. May be empty if env var not set.
-#[doc(hidden)]
+/// Build configuration provided by `PYO3_CONFIG_FILE`, inlined into the `pyo3-build-config` binary.
 #[cfg(feature = "resolve-config")]
-const CONFIG_FILE: &str = include_str!(concat!(env!("OUT_DIR"), "/pyo3-build-config-file.txt"));
+fn config_from_pyo3_config_file_env() -> Option<InterpreterConfig> {
+    #[doc(hidden)]
+    const CONFIG_FILE: &str = include_str!(concat!(env!("OUT_DIR"), "/pyo3-build-config-file.txt"));
+
+    // CONFIG_FILE is generated in build.rs, so its content can vary
+    #[allow(clippy::const_is_empty)]
+    if !CONFIG_FILE.is_empty() {
+        let config = InterpreterConfig::from_reader(Cursor::new(CONFIG_FILE))
+            .expect("contents of CONFIG_FILE should always be valid (generated by pyo3-build-config's build.rs)");
+        Some(config)
+    } else {
+        None
+    }
+}
 
 /// Build configuration discovered by `pyo3-build-config` build script. Not aware of
-/// cross-compilation settings.
+/// cross-compilation settings. Not generated if `PYO3_CONFIG_FILE` is set.
 #[doc(hidden)]
 #[cfg(feature = "resolve-config")]
 const HOST_CONFIG: &str = include_str!(concat!(env!("OUT_DIR"), "/pyo3-build-config.txt"));
@@ -125,33 +174,53 @@ fn resolve_cross_compile_config_path() -> Option<PathBuf> {
     })
 }
 
+/// Helper to print a feature cfg with a minimum rust version required.
+fn print_feature_cfg(minor_version_required: u32, cfg: &str) {
+    let minor_version = rustc_minor_version().unwrap_or(0);
+
+    if minor_version >= minor_version_required {
+        println!("cargo:rustc-cfg={cfg}");
+    }
+
+    // rustc 1.80.0 stabilized `rustc-check-cfg` feature, don't emit before
+    if minor_version >= 80 {
+        println!("cargo:rustc-check-cfg=cfg({cfg})");
+    }
+}
+
 /// Use certain features if we detect the compiler being used supports them.
 ///
 /// Features may be removed or added as MSRV gets bumped or new features become available,
 /// so this function is unstable.
 #[doc(hidden)]
 pub fn print_feature_cfgs() {
-    fn rustc_minor_version() -> Option<u32> {
-        let rustc = env::var_os("RUSTC")?;
-        let output = Command::new(rustc).arg("--version").output().ok()?;
-        let version = core::str::from_utf8(&output.stdout).ok()?;
-        let mut pieces = version.split('.');
-        if pieces.next() != Some("rustc 1") {
-            return None;
-        }
-        pieces.next()?.parse().ok()
-    }
-
-    let rustc_minor_version = rustc_minor_version().unwrap_or(0);
+    print_feature_cfg(85, "fn_ptr_eq");
+    print_feature_cfg(86, "from_bytes_with_nul_error");
+}
 
-    // Enable use of const initializer for thread_local! on Rust 1.59 and greater
-    if rustc_minor_version >= 59 {
-        println!("cargo:rustc-cfg=thread_local_const_init");
+/// Registers `pyo3`s config names as reachable cfg expressions
+///
+/// - <https://github.com/rust-lang/cargo/pull/13571>
+/// - <https://doc.rust-lang.org/nightly/cargo/reference/build-scripts.html#rustc-check-cfg>
+#[doc(hidden)]
+pub fn print_expected_cfgs() {
+    if rustc_minor_version().is_some_and(|version| version < 80) {
+        // rustc 1.80.0 stabilized `rustc-check-cfg` feature, don't emit before
+        return;
     }
 
-    // invalid_from_utf8 lint was added in Rust 1.74
-    if rustc_minor_version >= 74 {
-        println!("cargo:rustc-cfg=invalid_from_utf8_lint");
+    println!("cargo:rustc-check-cfg=cfg(Py_LIMITED_API)");
+    println!("cargo:rustc-check-cfg=cfg(Py_GIL_DISABLED)");
+    println!("cargo:rustc-check-cfg=cfg(PyPy)");
+    println!("cargo:rustc-check-cfg=cfg(GraalPy)");
+    println!("cargo:rustc-check-cfg=cfg(py_sys_config, values(\"Py_DEBUG\", \"Py_REF_DEBUG\", \"Py_TRACE_REFS\", \"COUNT_ALLOCS\"))");
+    println!("cargo:rustc-check-cfg=cfg(pyo3_disable_reference_pool)");
+    println!("cargo:rustc-check-cfg=cfg(pyo3_leak_on_drop_without_reference_pool)");
+
+    // allow `Py_3_*` cfgs from the minimum supported version up to the
+    // maximum minor version (+1 for development for the next)
+    for i in impl_::MINIMUM_SUPPORTED_VERSION.minor..=impl_::ABI3_MAX_MINOR + 1 {
+        println!("cargo:rustc-check-cfg=cfg(Py_3_{i})");
     }
 }
 
@@ -159,36 +228,56 @@ pub fn print_feature_cfgs() {
 ///
 /// Please don't use these - they could change at any time.
 #[doc(hidden)]
+#[cfg(feature = "resolve-config")]
 pub mod pyo3_build_script_impl {
-    #[cfg(feature = "resolve-config")]
     use crate::errors::{Context, Result};
 
-    #[cfg(feature = "resolve-config")]
     use super::*;
 
     pub mod errors {
         pub use crate::errors::*;
     }
     pub use crate::impl_::{
-        cargo_env_var, env_var, is_linking_libpython, make_cross_compile_config, InterpreterConfig,
-        PythonVersion,
+        cargo_env_var, env_var, is_linking_libpython_for_target, make_cross_compile_config,
+        target_triple_from_env, InterpreterConfig, PythonVersion,
     };
+    pub enum BuildConfigSource {
+        /// Config was provided by `PYO3_CONFIG_FILE`.
+        ConfigFile,
+        /// Config was found by an interpreter on the host system.
+        Host,
+        /// Config was configured by cross-compilation settings.
+        CrossCompile,
+    }
 
-    /// Gets the configuration for use from PyO3's build script.
+    pub struct BuildConfig {
+        pub interpreter_config: InterpreterConfig,
+        pub source: BuildConfigSource,
+    }
+
+    /// Gets the configuration for use from `pyo3-ffi`'s build script.
     ///
-    /// Differs from .get() above only in the cross-compile case, where PyO3's build script is
-    /// required to generate a new config (as it's the first build script which has access to the
-    /// correct value for CARGO_CFG_TARGET_OS).
-    #[cfg(feature = "resolve-config")]
-    pub fn resolve_interpreter_config() -> Result<InterpreterConfig> {
-        if !CONFIG_FILE.is_empty() {
-            let mut interperter_config = InterpreterConfig::from_reader(Cursor::new(CONFIG_FILE))?;
-            interperter_config.generate_import_libs()?;
-            Ok(interperter_config)
+    /// Differs from `.get()` in three ways:
+    /// 1. The cargo_dep_env config is not yet available (exported by `pyo3-ffi`'s build script).
+    /// 1. If `PYO3_CONFIG_FILE` is set, lib name is fixed up and the windows import libs might be generated.
+    /// 2. The cross-compile config file is generated if necessary.
+    ///
+    /// Steps 2 and 3 are necessary because `pyo3-ffi`'s build script is the first code run which knows
+    /// the correct target triple.
+    pub fn resolve_build_config(target: &Triple) -> Result<BuildConfig> {
+        // CONFIG_FILE is generated in build.rs, so it's content can vary
+        #[allow(unknown_lints, clippy::const_is_empty)]
+        if let Some(mut interpreter_config) = config_from_pyo3_config_file_env() {
+            interpreter_config.apply_default_lib_name_to_config_file(target);
+            interpreter_config.generate_import_libs()?;
+            Ok(BuildConfig {
+                interpreter_config,
+                source: BuildConfigSource::ConfigFile,
+            })
         } else if let Some(interpreter_config) = make_cross_compile_config()? {
             // This is a cross compile and need to write the config file.
             let path = resolve_cross_compile_config_path()
-                .expect("resolve_interpreter_config() must be called from a build script");
+                .expect("resolve_build_config() must be called from a build script");
             let parent_dir = path.parent().ok_or_else(|| {
                 format!(
                     "failed to resolve parent directory of config file {}",
@@ -204,13 +293,71 @@ pub mod pyo3_build_script_impl {
             interpreter_config.to_writer(&mut std::fs::File::create(&path).with_context(
                 || format!("failed to create config file at {}", path.display()),
             )?)?;
-            Ok(interpreter_config)
+            Ok(BuildConfig {
+                interpreter_config,
+                source: BuildConfigSource::CrossCompile,
+            })
         } else {
-            InterpreterConfig::from_reader(Cursor::new(HOST_CONFIG))
+            let interpreter_config = InterpreterConfig::from_reader(Cursor::new(HOST_CONFIG))?;
+            Ok(BuildConfig {
+                interpreter_config,
+                source: BuildConfigSource::Host,
+            })
+        }
+    }
+
+    /// Helper to generate an error message when the configured Python version is newer
+    /// than PyO3's current supported version.
+    pub struct MaximumVersionExceeded {
+        message: String,
+    }
+
+    impl MaximumVersionExceeded {
+        pub fn new(
+            interpreter_config: &InterpreterConfig,
+            supported_version: PythonVersion,
+        ) -> Self {
+            let implementation = match interpreter_config.implementation {
+                PythonImplementation::CPython => "Python",
+                PythonImplementation::PyPy => "PyPy",
+                PythonImplementation::GraalPy => "GraalPy",
+            };
+            let version = &interpreter_config.version;
+            let message = format!(
+                "the configured {implementation} version ({version}) is newer than PyO3's maximum supported version ({supported_version})\n\
+                = help: this package is being built with PyO3 version {current_version}\n\
+                = help: check https://crates.io/crates/pyo3 for the latest PyO3 version available\n\
+                = help: updating this package to the latest version of PyO3 may provide compatibility with this {implementation} version",
+                current_version = env!("CARGO_PKG_VERSION")
+            );
+            Self { message }
+        }
+
+        pub fn add_help(&mut self, help: &str) {
+            self.message.push_str("\n= help: ");
+            self.message.push_str(help);
+        }
+
+        pub fn finish(self) -> String {
+            self.message
         }
     }
 }
 
+fn rustc_minor_version() -> Option<u32> {
+    static RUSTC_MINOR_VERSION: OnceLock<Option<u32>> = OnceLock::new();
+    *RUSTC_MINOR_VERSION.get_or_init(|| {
+        let rustc = env::var_os("RUSTC")?;
+        let output = Command::new(rustc).arg("--version").output().ok()?;
+        let version = core::str::from_utf8(&output.stdout).ok()?;
+        let mut pieces = version.split('.');
+        if pieces.next() != Some("rustc 1") {
+            return None;
+        }
+        pieces.next()?.parse().ok()
+    })
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -247,4 +394,88 @@ mod tests {
              cargo:rustc-cdylib-link-arg=-sWASM_BIGINT\n"
         );
     }
+
+    #[cfg(feature = "resolve-config")]
+    #[test]
+    fn python_framework_link_args() {
+        let mut buf = Vec::new();
+
+        let interpreter_config = InterpreterConfig {
+            implementation: PythonImplementation::CPython,
+            version: PythonVersion {
+                major: 3,
+                minor: 13,
+            },
+            shared: true,
+            abi3: false,
+            lib_name: None,
+            lib_dir: None,
+            executable: None,
+            pointer_width: None,
+            build_flags: BuildFlags::default(),
+            suppress_build_script_link_lines: false,
+            extra_build_script_lines: vec![],
+            python_framework_prefix: Some(
+                "/Applications/Xcode.app/Contents/Developer/Library/Frameworks".to_string(),
+            ),
+        };
+        // Does nothing on non-mac
+        _add_python_framework_link_args(
+            &interpreter_config,
+            &Triple::from_str("x86_64-pc-windows-msvc").unwrap(),
+            true,
+            &mut buf,
+        );
+        assert_eq!(buf, Vec::new());
+
+        _add_python_framework_link_args(
+            &interpreter_config,
+            &Triple::from_str("x86_64-apple-darwin").unwrap(),
+            true,
+            &mut buf,
+        );
+        assert_eq!(
+            std::str::from_utf8(&buf).unwrap(),
+            "cargo:rustc-link-arg=-Wl,-rpath,/Applications/Xcode.app/Contents/Developer/Library/Frameworks\n"
+        );
+    }
+
+    #[test]
+    #[cfg(feature = "resolve-config")]
+    fn test_maximum_version_exceeded_formatting() {
+        let interpreter_config = InterpreterConfig {
+            implementation: PythonImplementation::CPython,
+            version: PythonVersion {
+                major: 3,
+                minor: 13,
+            },
+            shared: true,
+            abi3: false,
+            lib_name: None,
+            lib_dir: None,
+            executable: None,
+            pointer_width: None,
+            build_flags: BuildFlags::default(),
+            suppress_build_script_link_lines: false,
+            extra_build_script_lines: vec![],
+            python_framework_prefix: None,
+        };
+        let mut error = pyo3_build_script_impl::MaximumVersionExceeded::new(
+            &interpreter_config,
+            PythonVersion {
+                major: 3,
+                minor: 12,
+            },
+        );
+        error.add_help("this is a help message");
+        let error = error.finish();
+        let expected = concat!("\
+            the configured Python version (3.13) is newer than PyO3's maximum supported version (3.12)\n\
+            = help: this package is being built with PyO3 version ", env!("CARGO_PKG_VERSION"), "\n\
+            = help: check https://crates.io/crates/pyo3 for the latest PyO3 version available\n\
+            = help: updating this package to the latest version of PyO3 may provide compatibility with this Python version\n\
+            = help: this is a help message"
+        );
+        assert_eq!(error, expected);
+    }
 }
diff --git a/pyo3-ffi-check/Cargo.toml b/pyo3-ffi-check/Cargo.toml
index 776add0c910..874da3d2bef 100644
--- a/pyo3-ffi-check/Cargo.toml
+++ b/pyo3-ffi-check/Cargo.toml
@@ -13,7 +13,7 @@ path = "../pyo3-ffi"
 features = ["extension-module"]  # A lazy way of skipping linking in most cases (as we don't use any runtime symbols)
 
 [build-dependencies]
-bindgen = "0.66.1"
+bindgen = "0.69.4"
 pyo3-build-config = { path = "../pyo3-build-config" }
 
 [workspace]
diff --git a/pyo3-ffi-check/build.rs b/pyo3-ffi-check/build.rs
index ca4a17b6a61..e7cfbe40df3 100644
--- a/pyo3-ffi-check/build.rs
+++ b/pyo3-ffi-check/build.rs
@@ -1,6 +1,24 @@
 use std::env;
 use std::path::PathBuf;
 
+#[derive(Debug)]
+struct ParseCallbacks;
+
+impl bindgen::callbacks::ParseCallbacks for ParseCallbacks {
+    // these are anonymous fields and structs in CPython that we needed to
+    // invent names for. Bindgen seems to generate stable names, so we remap the
+    // automatically generated names to the names we invented in the FFI
+    fn item_name(&self, _original_item_name: &str) -> Option<String> {
+        if _original_item_name == "_object__bindgen_ty_1__bindgen_ty_1" {
+            Some("PyObjectObFlagsAndRefcnt".into())
+        } else if _original_item_name == "_object__bindgen_ty_1" {
+            Some("PyObjectObRefcnt".into())
+        } else {
+            None
+        }
+    }
+}
+
 fn main() {
     let config = pyo3_build_config::get();
     let python_include_dir = config
@@ -8,13 +26,28 @@ fn main() {
             "import sysconfig; print(sysconfig.get_config_var('INCLUDEPY'), end='');",
         )
         .expect("failed to get lib dir");
+    let gil_disabled_on_windows = config
+        .run_python_script(
+            "import sysconfig; import platform; print(sysconfig.get_config_var('Py_GIL_DISABLED') == 1 and platform.system() == 'Windows');",
+        )
+        .expect("failed to get Py_GIL_DISABLED").trim_end() == "True";
+
+    let clang_args = if gil_disabled_on_windows {
+        vec![
+            format!("-I{python_include_dir}"),
+            "-DPy_GIL_DISABLED".to_string(),
+        ]
+    } else {
+        vec![format!("-I{python_include_dir}")]
+    };
 
     println!("cargo:rerun-if-changed=wrapper.h");
 
     let bindings = bindgen::Builder::default()
         .header("wrapper.h")
-        .clang_arg(format!("-I{python_include_dir}"))
-        .parse_callbacks(Box::new(bindgen::CargoCallbacks))
+        .clang_args(clang_args)
+        .parse_callbacks(Box::new(bindgen::CargoCallbacks::new()))
+        .parse_callbacks(Box::new(ParseCallbacks))
         // blocklist some values which apparently have conflicting definitions on unix
         .blocklist_item("FP_NORMAL")
         .blocklist_item("FP_SUBNORMAL")
diff --git a/pyo3-ffi-check/macro/Cargo.toml b/pyo3-ffi-check/macro/Cargo.toml
index 46395fc8a8c..dfefcd2c1e1 100644
--- a/pyo3-ffi-check/macro/Cargo.toml
+++ b/pyo3-ffi-check/macro/Cargo.toml
@@ -10,6 +10,6 @@ proc-macro = true
 [dependencies]
 glob = "0.3"
 quote = "1"
-proc-macro2 = "1"
+proc-macro2 = "1.0.60"
 scraper = "0.17"
 pyo3-build-config = { path = "../../pyo3-build-config" }
diff --git a/pyo3-ffi-check/macro/src/lib.rs b/pyo3-ffi-check/macro/src/lib.rs
index e3d442c3703..41092b9020e 100644
--- a/pyo3-ffi-check/macro/src/lib.rs
+++ b/pyo3-ffi-check/macro/src/lib.rs
@@ -49,6 +49,7 @@ pub fn for_all_structs(input: proc_macro::TokenStream) -> proc_macro::TokenStrea
             .unwrap()
             .strip_suffix(".html")
             .unwrap();
+
         let struct_ident = Ident::new(struct_name, Span::call_site());
         output.extend(quote!(#macro_name!(#struct_ident);));
     }
diff --git a/pyo3-ffi-check/src/main.rs b/pyo3-ffi-check/src/main.rs
index 99713524702..0407a2ffa39 100644
--- a/pyo3-ffi-check/src/main.rs
+++ b/pyo3-ffi-check/src/main.rs
@@ -48,7 +48,8 @@ fn main() {
 
     macro_rules! check_field {
         ($struct_name:ident, $field:ident, $bindgen_field:ident) => {{
-            #[allow(clippy::used_underscore_binding)]
+            // some struct fields are deprecated but still present in the ABI
+            #[allow(clippy::used_underscore_binding, deprecated)]
             let pyo3_ffi_offset = memoffset::offset_of!(pyo3_ffi::$struct_name, $field);
             #[allow(clippy::used_underscore_binding)]
             let bindgen_offset = memoffset::offset_of!(bindings::$struct_name, $bindgen_field);
diff --git a/pyo3-ffi/ACKNOWLEDGEMENTS b/pyo3-ffi/ACKNOWLEDGEMENTS
index 4502d7774e0..8b20727dece 100644
--- a/pyo3-ffi/ACKNOWLEDGEMENTS
+++ b/pyo3-ffi/ACKNOWLEDGEMENTS
@@ -3,4 +3,4 @@ for binary compatibility, with additional metadata to support PyPy.
 
 For original implementations please see:
  - https://github.com/python/cpython
- - https://foss.heptapod.net/pypy/pypy
+ - https://github.com/pypy/pypy
diff --git a/pyo3-ffi/Cargo.toml b/pyo3-ffi/Cargo.toml
index 8021dc72b69..03de6584643 100644
--- a/pyo3-ffi/Cargo.toml
+++ b/pyo3-ffi/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "pyo3-ffi"
-version = "0.21.0-dev"
+version = "0.27.0"
 description = "Python-API bindings for the PyO3 ecosystem"
 authors = ["PyO3 Project and Contributors <https://github.com/PyO3>"]
 keywords = ["pyo3", "python", "cpython", "ffi"]
@@ -10,6 +10,7 @@ categories = ["api-bindings", "development-tools::ffi"]
 license = "MIT OR Apache-2.0"
 edition = "2021"
 links = "python"
+rust-version.workspace = true
 
 [dependencies]
 libc = "0.2.62"
@@ -32,13 +33,26 @@ abi3-py38 = ["abi3-py39", "pyo3-build-config/abi3-py38"]
 abi3-py39 = ["abi3-py310", "pyo3-build-config/abi3-py39"]
 abi3-py310 = ["abi3-py311", "pyo3-build-config/abi3-py310"]
 abi3-py311 = ["abi3-py312", "pyo3-build-config/abi3-py311"]
-abi3-py312 = ["abi3", "pyo3-build-config/abi3-py312"]
+abi3-py312 = ["abi3-py313", "pyo3-build-config/abi3-py312"]
+abi3-py313 = ["abi3-py314", "pyo3-build-config/abi3-py313"]
+abi3-py314 = ["abi3", "pyo3-build-config/abi3-py314"]
 
 # Automatically generates `python3.dll` import libraries for Windows targets.
-generate-import-lib = ["pyo3-build-config/python3-dll-a"]
+generate-import-lib = ["pyo3-build-config/generate-import-lib"]
+
+[dev-dependencies]
+paste = "1"
 
 [build-dependencies]
-pyo3-build-config = { path = "../pyo3-build-config", version = "=0.21.0-dev", features = ["resolve-config"] }
+pyo3-build-config = { path = "../pyo3-build-config", version = "=0.27.0", features = ["resolve-config"] }
 
 [lints]
 workspace = true
+
+[package.metadata.cpython]
+min-version = "3.7"
+max-version = "3.14" # inclusive
+
+[package.metadata.pypy]
+min-version = "3.11"
+max-version = "3.11" # inclusive
diff --git a/pyo3-ffi/README.md b/pyo3-ffi/README.md
index 030c59d449c..41b9546ac50 100644
--- a/pyo3-ffi/README.md
+++ b/pyo3-ffi/README.md
@@ -12,9 +12,12 @@ Manual][capi] for up-to-date documentation.
 
 # Minimum supported Rust and Python versions
 
-PyO3 supports the following software versions:
-  - Python 3.7 and up (CPython and PyPy)
-  - Rust 1.56 and up
+Requires Rust 1.63 or greater.
+
+`pyo3-ffi` supports the following Python distributions:
+  - CPython 3.7 or greater
+  - PyPy 7.3 (Python 3.9+)
+  - GraalPy 24.0 or greater (Python 3.10+)
 
 # Example: Building Python Native modules
 
@@ -38,26 +41,43 @@ name = "string_sum"
 crate-type = ["cdylib"]
 
 [dependencies.pyo3-ffi]
-version = "*"
+version = "0.27.0"
 features = ["extension-module"]
+
+[build-dependencies]
+# This is only necessary if you need to configure your build based on
+# the Python version or the compile-time configuration for the interpreter.
+pyo3_build_config = "0.27.0"
+```
+
+If you need to use conditional compilation based on Python version or how
+Python was compiled, you need to add `pyo3-build-config` as a
+`build-dependency` in your `Cargo.toml` as in the example above and either
+create a new `build.rs` file or modify an existing one so that
+`pyo3_build_config::use_pyo3_cfgs()` gets called at build time:
+
+**`build.rs`**
+
+```rust,ignore
+fn main() {
+    pyo3_build_config::use_pyo3_cfgs()
+}
 ```
 
 **`src/lib.rs`**
-```rust
-use std::os::raw::c_char;
+```rust,no_run
+use std::ffi::{c_char, c_long};
 use std::ptr;
 
 use pyo3_ffi::*;
 
 static mut MODULE_DEF: PyModuleDef = PyModuleDef {
     m_base: PyModuleDef_HEAD_INIT,
-    m_name: "string_sum\0".as_ptr().cast::<c_char>(),
-    m_doc: "A Python module written in Rust.\0"
-        .as_ptr()
-        .cast::<c_char>(),
+    m_name: c"string_sum".as_ptr(),
+    m_doc: c"A Python module written in Rust.".as_ptr(),
     m_size: 0,
-    m_methods: unsafe { METHODS.as_mut_ptr().cast() },
-    m_slots: std::ptr::null_mut(),
+    m_methods: std::ptr::addr_of_mut!(METHODS).cast(),
+    m_slots: unsafe { SLOTS as *const [PyModuleDef_Slot] as *mut PyModuleDef_Slot },
     m_traverse: None,
     m_clear: None,
     m_free: None,
@@ -65,74 +85,116 @@ static mut MODULE_DEF: PyModuleDef = PyModuleDef {
 
 static mut METHODS: [PyMethodDef; 2] = [
     PyMethodDef {
-        ml_name: "sum_as_string\0".as_ptr().cast::<c_char>(),
+        ml_name: c"sum_as_string".as_ptr(),
         ml_meth: PyMethodDefPointer {
-            _PyCFunctionFast: sum_as_string,
+            PyCFunctionFast: sum_as_string,
         },
         ml_flags: METH_FASTCALL,
-        ml_doc: "returns the sum of two integers as a string\0"
-            .as_ptr()
-            .cast::<c_char>(),
+        ml_doc: c"returns the sum of two integers as a string".as_ptr(),
     },
     // A zeroed PyMethodDef to mark the end of the array.
-    PyMethodDef::zeroed()
+    PyMethodDef::zeroed(),
+];
+
+static mut SLOTS: &[PyModuleDef_Slot] = &[
+    // NB: only include this slot if the module does not store any global state in `static` variables
+    // or other data which could cross between subinterpreters
+    #[cfg(Py_3_12)]
+    PyModuleDef_Slot {
+        slot: Py_mod_multiple_interpreters,
+        value: Py_MOD_PER_INTERPRETER_GIL_SUPPORTED,
+    },
+    // NB: only include this slot if the module does not depend on the GIL for thread safety
+    #[cfg(Py_GIL_DISABLED)]
+    PyModuleDef_Slot {
+        slot: Py_mod_gil,
+        value: Py_MOD_GIL_NOT_USED,
+    },
+    PyModuleDef_Slot {
+        slot: 0,
+        value: ptr::null_mut(),
+    },
 ];
 
 // The module initialization function, which must be named `PyInit_<your_module>`.
 #[allow(non_snake_case)]
 #[no_mangle]
 pub unsafe extern "C" fn PyInit_string_sum() -> *mut PyObject {
-    PyModule_Create(ptr::addr_of_mut!(MODULE_DEF))
+    PyModuleDef_Init(ptr::addr_of_mut!(MODULE_DEF))
 }
 
-pub unsafe extern "C" fn sum_as_string(
-    _self: *mut PyObject,
-    args: *mut *mut PyObject,
-    nargs: Py_ssize_t,
-) -> *mut PyObject {
-    if nargs != 2 {
-        PyErr_SetString(
-            PyExc_TypeError,
-            "sum_as_string() expected 2 positional arguments\0"
-                .as_ptr()
-                .cast::<c_char>(),
+/// A helper to parse function arguments
+/// If we used PyO3's proc macros they'd handle all of this boilerplate for us :)
+unsafe fn parse_arg_as_i32(obj: *mut PyObject, n_arg: usize) -> Option<i32> {
+    if PyLong_Check(obj) == 0 {
+        let msg = format!(
+            "sum_as_string expected an int for positional argument {}\0",
+            n_arg
         );
-        return std::ptr::null_mut();
+        PyErr_SetString(PyExc_TypeError, msg.as_ptr().cast::<c_char>());
+        return None;
     }
 
-    let arg1 = *args;
-    if PyLong_Check(arg1) == 0 {
-        PyErr_SetString(
-            PyExc_TypeError,
-            "sum_as_string() expected an int for positional argument 1\0"
-                .as_ptr()
-                .cast::<c_char>(),
-        );
-        return std::ptr::null_mut();
+    // Let's keep the behaviour consistent on platforms where `c_long` is bigger than 32 bits.
+    // In particular, it is an i32 on Windows but i64 on most Linux systems
+    let mut overflow = 0;
+    let i_long: c_long = PyLong_AsLongAndOverflow(obj, &mut overflow);
+
+    #[allow(irrefutable_let_patterns)] // some platforms have c_long equal to i32
+    if overflow != 0 {
+        raise_overflowerror(obj);
+        None
+    } else if let Ok(i) = i_long.try_into() {
+        Some(i)
+    } else {
+        raise_overflowerror(obj);
+        None
     }
+}
 
-    let arg1 = PyLong_AsLong(arg1);
-    if !PyErr_Occurred().is_null() {
-        return ptr::null_mut();
+unsafe fn raise_overflowerror(obj: *mut PyObject) {
+    let obj_repr = PyObject_Str(obj);
+    if !obj_repr.is_null() {
+        let mut size = 0;
+        let p = PyUnicode_AsUTF8AndSize(obj_repr, &mut size);
+        if !p.is_null() {
+            let s = std::str::from_utf8_unchecked(std::slice::from_raw_parts(
+                p.cast::<u8>(),
+                size as usize,
+            ));
+            let msg = format!("cannot fit {} in 32 bits\0", s);
+
+            PyErr_SetString(PyExc_OverflowError, msg.as_ptr().cast::<c_char>());
+        }
+        Py_DECREF(obj_repr);
     }
+}
 
-    let arg2 = *args.add(1);
-    if PyLong_Check(arg2) == 0 {
+pub unsafe extern "C" fn sum_as_string(
+    _self: *mut PyObject,
+    args: *mut *mut PyObject,
+    nargs: Py_ssize_t,
+) -> *mut PyObject {
+    if nargs != 2 {
         PyErr_SetString(
             PyExc_TypeError,
-            "sum_as_string() expected an int for positional argument 2\0"
-                .as_ptr()
-                .cast::<c_char>(),
+            c"sum_as_string expected 2 positional arguments".as_ptr(),
         );
         return std::ptr::null_mut();
     }
 
-    let arg2 = PyLong_AsLong(arg2);
-    if !PyErr_Occurred().is_null() {
-        return ptr::null_mut();
-    }
+    let (first, second) = (*args, *args.add(1));
+
+    let first = match parse_arg_as_i32(first, 1) {
+        Some(x) => x,
+        None => return std::ptr::null_mut(),
+    };
+    let second = match parse_arg_as_i32(second, 2) {
+        Some(x) => x,
+        None => return std::ptr::null_mut(),
+    };
 
-    match arg1.checked_add(arg2) {
+    match first.checked_add(second) {
         Some(sum) => {
             let string = sum.to_string();
             PyUnicode_FromStringAndSize(string.as_ptr().cast::<c_char>(), string.len() as isize)
@@ -140,7 +202,7 @@ pub unsafe extern "C" fn sum_as_string(
         None => {
             PyErr_SetString(
                 PyExc_OverflowError,
-                "arguments too large to add\0".as_ptr().cast::<c_char>(),
+                c"arguments too large to add".as_ptr(),
             );
             std::ptr::null_mut()
         }
@@ -184,7 +246,7 @@ can be easily converted to rust as well.
 [`maturin`]: https://github.com/PyO3/maturin "Build and publish crates with pyo3, rust-cpython and cffi bindings as well as rust binaries as python packages"
 [`pyo3-build-config`]: https://docs.rs/pyo3-build-config
 [feature flags]: https://doc.rust-lang.org/cargo/reference/features.html "Features - The Cargo Book"
-[manual_builds]: https://pyo3.rs/latest/building_and_distribution.html#manual-builds "Manual builds - Building and Distribution - PyO3 user guide"
+[manual_builds]: https://pyo3.rs/latest/building-and-distribution.html#manual-builds "Manual builds - Building and Distribution - PyO3 user guide"
 [setuptools-rust]: https://github.com/PyO3/setuptools-rust "Setuptools plugin for Rust extensions"
 [PEP 384]: https://www.python.org/dev/peps/pep-0384 "PEP 384 -- Defining a Stable ABI"
 [Features chapter of the guide]: https://pyo3.rs/latest/features.html#features-reference "Features Reference - PyO3 user guide"
diff --git a/pyo3-ffi/build.rs b/pyo3-ffi/build.rs
index 286767d8f25..3e2354f2d38 100644
--- a/pyo3-ffi/build.rs
+++ b/pyo3-ffi/build.rs
@@ -1,10 +1,11 @@
 use pyo3_build_config::{
     bail, ensure, print_feature_cfgs,
     pyo3_build_script_impl::{
-        cargo_env_var, env_var, errors::Result, is_linking_libpython, resolve_interpreter_config,
-        InterpreterConfig, PythonVersion,
+        cargo_env_var, env_var, errors::Result, is_linking_libpython_for_target,
+        resolve_build_config, target_triple_from_env, BuildConfig, BuildConfigSource,
+        InterpreterConfig, MaximumVersionExceeded, PythonVersion,
     },
-    PythonImplementation,
+    warn, PythonImplementation,
 };
 
 /// Minimum Python version PyO3 supports.
@@ -17,16 +18,24 @@ const SUPPORTED_VERSIONS_CPYTHON: SupportedVersions = SupportedVersions {
     min: PythonVersion { major: 3, minor: 7 },
     max: PythonVersion {
         major: 3,
-        minor: 12,
+        minor: 14,
     },
 };
 
 const SUPPORTED_VERSIONS_PYPY: SupportedVersions = SupportedVersions {
-    min: PythonVersion { major: 3, minor: 7 },
-    max: PythonVersion {
+    min: PythonVersion {
+        major: 3,
+        minor: 11,
+    },
+    max: SUPPORTED_VERSIONS_CPYTHON.max,
+};
+
+const SUPPORTED_VERSIONS_GRAALPY: SupportedVersions = SupportedVersions {
+    min: PythonVersion {
         major: 3,
         minor: 10,
     },
+    max: SUPPORTED_VERSIONS_CPYTHON.max,
 };
 
 fn ensure_python_version(interpreter_config: &InterpreterConfig) -> Result<()> {
@@ -45,15 +54,21 @@ fn ensure_python_version(interpreter_config: &InterpreterConfig) -> Result<()> {
                 interpreter_config.version,
                 versions.min,
             );
-            ensure!(
-                interpreter_config.version <= versions.max || env_var("PYO3_USE_ABI3_FORWARD_COMPATIBILITY").map_or(false, |os_str| os_str == "1"),
-                "the configured Python interpreter version ({}) is newer than PyO3's maximum supported version ({})\n\
-                 = help: please check if an updated version of PyO3 is available. Current version: {}\n\
-                 = help: set PYO3_USE_ABI3_FORWARD_COMPATIBILITY=1 to suppress this check and build anyway using the stable ABI",
-                interpreter_config.version,
-                versions.max,
-                std::env::var("CARGO_PKG_VERSION").unwrap(),
-            );
+            if interpreter_config.version > versions.max {
+                let mut error = MaximumVersionExceeded::new(interpreter_config, versions.max);
+                if interpreter_config.is_free_threaded() {
+                    error.add_help(
+                        "the free-threaded build of CPython does not support the limited API so this check cannot be suppressed.",
+                    );
+                    return Err(error.finish().into());
+                }
+
+                if env_var("PYO3_USE_ABI3_FORWARD_COMPATIBILITY").is_none_or(|os_str| os_str != "1")
+                {
+                    error.add_help("set PYO3_USE_ABI3_FORWARD_COMPATIBILITY=1 to suppress this check and build anyway using the stable ABI");
+                    return Err(error.finish().into());
+                }
+            }
         }
         PythonImplementation::PyPy => {
             let versions = SUPPORTED_VERSIONS_PYPY;
@@ -64,14 +79,43 @@ fn ensure_python_version(interpreter_config: &InterpreterConfig) -> Result<()> {
                 versions.min,
             );
             // PyO3 does not support abi3, so we cannot offer forward compatibility
+            if interpreter_config.version > versions.max {
+                let error = MaximumVersionExceeded::new(interpreter_config, versions.max);
+                return Err(error.finish().into());
+            }
+        }
+        PythonImplementation::GraalPy => {
+            let versions = SUPPORTED_VERSIONS_GRAALPY;
             ensure!(
-                interpreter_config.version <= versions.max,
-                "the configured PyPy interpreter version ({}) is newer than PyO3's maximum supported version ({})\n\
-                 = help: please check if an updated version of PyO3 is available. Current version: {}",
+                interpreter_config.version >= versions.min,
+                "the configured GraalPy interpreter version ({}) is lower than PyO3's minimum supported version ({})",
                 interpreter_config.version,
-                versions.max,
-                std::env::var("CARGO_PKG_VERSION").unwrap()
+                versions.min,
             );
+            // GraalPy does not support abi3, so we cannot offer forward compatibility
+            if interpreter_config.version > versions.max {
+                let error = MaximumVersionExceeded::new(interpreter_config, versions.max);
+                return Err(error.finish().into());
+            }
+        }
+    }
+
+    if interpreter_config.abi3 {
+        match interpreter_config.implementation {
+            PythonImplementation::CPython => {
+                if interpreter_config.is_free_threaded() {
+                    warn!(
+                            "The free-threaded build of CPython does not yet support abi3 so the build artifacts will be version-specific."
+                    )
+                }
+            }
+            PythonImplementation::PyPy => warn!(
+                "PyPy does not yet support abi3 so the build artifacts will be version-specific. \
+                See https://github.com/pypy/pypy/issues/3397 for more information."
+            ),
+            PythonImplementation::GraalPy => warn!(
+                "GraalPy does not support abi3 so the build artifacts will be version-specific."
+            ),
         }
     }
 
@@ -100,7 +144,8 @@ fn ensure_target_pointer_width(interpreter_config: &InterpreterConfig) -> Result
     Ok(())
 }
 
-fn emit_link_config(interpreter_config: &InterpreterConfig) -> Result<()> {
+fn emit_link_config(build_config: &BuildConfig) -> Result<()> {
+    let interpreter_config = &build_config.interpreter_config;
     let target_os = cargo_env_var("CARGO_CFG_TARGET_OS").unwrap();
 
     println!(
@@ -121,7 +166,14 @@ fn emit_link_config(interpreter_config: &InterpreterConfig) -> Result<()> {
     );
 
     if let Some(lib_dir) = &interpreter_config.lib_dir {
-        println!("cargo:rustc-link-search=native={}", lib_dir);
+        println!("cargo:rustc-link-search=native={lib_dir}");
+    } else if matches!(build_config.source, BuildConfigSource::CrossCompile) {
+        warn!(
+            "The output binary will link to libpython, \
+            but PYO3_CROSS_LIB_DIR environment variable is not set. \
+            Ensure that the target Python library directory is \
+            in the rustc native library search path."
+        );
     }
 
     Ok(())
@@ -135,32 +187,35 @@ fn emit_link_config(interpreter_config: &InterpreterConfig) -> Result<()> {
 /// Emits the cargo configuration based on this config as well as a few checks of the Rust compiler
 /// version to enable features which aren't supported on MSRV.
 fn configure_pyo3() -> Result<()> {
-    let interpreter_config = resolve_interpreter_config()?;
+    let target = target_triple_from_env();
+    let build_config = resolve_build_config(&target)?;
+    let interpreter_config = &build_config.interpreter_config;
 
-    if env_var("PYO3_PRINT_CONFIG").map_or(false, |os_str| os_str == "1") {
-        print_config_and_exit(&interpreter_config);
+    if env_var("PYO3_PRINT_CONFIG").is_some_and(|os_str| os_str == "1") {
+        print_config_and_exit(interpreter_config);
     }
 
-    ensure_python_version(&interpreter_config)?;
-    ensure_target_pointer_width(&interpreter_config)?;
+    ensure_python_version(interpreter_config)?;
+    ensure_target_pointer_width(interpreter_config)?;
 
     // Serialize the whole interpreter config into DEP_PYTHON_PYO3_CONFIG env var.
     interpreter_config.to_cargo_dep_env()?;
 
-    if is_linking_libpython() && !interpreter_config.suppress_build_script_link_lines {
-        emit_link_config(&interpreter_config)?;
+    if is_linking_libpython_for_target(&target)
+        && !interpreter_config.suppress_build_script_link_lines
+    {
+        emit_link_config(&build_config)?;
     }
 
     for cfg in interpreter_config.build_script_outputs() {
-        println!("{}", cfg)
+        println!("{cfg}")
     }
 
     // Extra lines come last, to support last write wins.
     for line in &interpreter_config.extra_build_script_lines {
-        println!("{}", line);
+        println!("{line}");
     }
 
-    // Emit cfgs like `thread_local_const_init`
     print_feature_cfgs();
 
     Ok(())
@@ -176,6 +231,7 @@ fn print_config_and_exit(config: &InterpreterConfig) {
 }
 
 fn main() {
+    pyo3_build_config::print_expected_cfgs();
     if let Err(e) = configure_pyo3() {
         eprintln!("error: {}", e.report());
         std::process::exit(1)
diff --git a/pyo3-ffi/examples/README.md b/pyo3-ffi/examples/README.md
new file mode 100644
index 00000000000..f02ae4ba6b4
--- /dev/null
+++ b/pyo3-ffi/examples/README.md
@@ -0,0 +1,21 @@
+# `pyo3-ffi` Examples
+
+These example crates are a collection of toy extension modules built with
+`pyo3-ffi`. They are all tested using `nox` in PyO3's CI.
+
+Below is a brief description of each of these:
+
+| Example | Description |
+| `word-count` | Illustrates how to use pyo3-ffi to write a static rust extension |
+| `sequential` | Illustrates how to use pyo3-ffi to write subinterpreter-safe modules using multi-phase module initialization |
+
+## Creating new projects from these examples
+
+To copy an example, use [`cargo-generate`](https://crates.io/crates/cargo-generate). Follow the commands below, replacing `<example>` with the example to start from:
+
+```bash
+$ cargo install cargo-generate
+$ cargo generate --git https://github.com/PyO3/pyo3 examples/<example>
+```
+
+(`cargo generate` will take a little while to clone the PyO3 repo first; be patient when waiting for the command to run.)
diff --git a/examples/sequential/.template/Cargo.toml b/pyo3-ffi/examples/sequential/.template/Cargo.toml
similarity index 100%
rename from examples/sequential/.template/Cargo.toml
rename to pyo3-ffi/examples/sequential/.template/Cargo.toml
diff --git a/examples/sequential/.template/pre-script.rhai b/pyo3-ffi/examples/sequential/.template/pre-script.rhai
similarity index 100%
rename from examples/sequential/.template/pre-script.rhai
rename to pyo3-ffi/examples/sequential/.template/pre-script.rhai
diff --git a/examples/sequential/.template/pyproject.toml b/pyo3-ffi/examples/sequential/.template/pyproject.toml
similarity index 100%
rename from examples/sequential/.template/pyproject.toml
rename to pyo3-ffi/examples/sequential/.template/pyproject.toml
diff --git a/pyo3-ffi/examples/sequential/Cargo.toml b/pyo3-ffi/examples/sequential/Cargo.toml
new file mode 100644
index 00000000000..21e87c09496
--- /dev/null
+++ b/pyo3-ffi/examples/sequential/Cargo.toml
@@ -0,0 +1,17 @@
+[package]
+name = "sequential"
+version = "0.1.0"
+edition = "2021"
+rust-version = "1.83"
+
+[lib]
+name = "sequential"
+crate-type = ["cdylib", "lib"]
+
+[dependencies]
+pyo3-ffi = { path = "../../", features = ["extension-module"] }
+
+[build-dependencies]
+pyo3-build-config = { path = "../../../pyo3-build-config" }
+
+[workspace]
diff --git a/examples/sequential/MANIFEST.in b/pyo3-ffi/examples/sequential/MANIFEST.in
similarity index 100%
rename from examples/sequential/MANIFEST.in
rename to pyo3-ffi/examples/sequential/MANIFEST.in
diff --git a/examples/sequential/README.md b/pyo3-ffi/examples/sequential/README.md
similarity index 91%
rename from examples/sequential/README.md
rename to pyo3-ffi/examples/sequential/README.md
index e3c0078241d..6eb718d9d98 100644
--- a/examples/sequential/README.md
+++ b/pyo3-ffi/examples/sequential/README.md
@@ -1,6 +1,6 @@
 # sequential
 
-A project built using only `pyo3_ffi`, without any of PyO3's safe api. It can be executed by subinterpreters that have their own GIL.
+A project built using only `pyo3_ffi`, without any of PyO3's safe api. It supports both subinterpreters and free-threaded Python.
 
 ## Building and Testing
 
diff --git a/pyo3-ffi/examples/sequential/build.rs b/pyo3-ffi/examples/sequential/build.rs
new file mode 100644
index 00000000000..0475124bb4e
--- /dev/null
+++ b/pyo3-ffi/examples/sequential/build.rs
@@ -0,0 +1,3 @@
+fn main() {
+    pyo3_build_config::use_pyo3_cfgs();
+}
diff --git a/examples/sequential/cargo-generate.toml b/pyo3-ffi/examples/sequential/cargo-generate.toml
similarity index 100%
rename from examples/sequential/cargo-generate.toml
rename to pyo3-ffi/examples/sequential/cargo-generate.toml
diff --git a/examples/sequential/noxfile.py b/pyo3-ffi/examples/sequential/noxfile.py
similarity index 100%
rename from examples/sequential/noxfile.py
rename to pyo3-ffi/examples/sequential/noxfile.py
diff --git a/examples/sequential/pyproject.toml b/pyo3-ffi/examples/sequential/pyproject.toml
similarity index 100%
rename from examples/sequential/pyproject.toml
rename to pyo3-ffi/examples/sequential/pyproject.toml
diff --git a/examples/sequential/src/id.rs b/pyo3-ffi/examples/sequential/src/id.rs
similarity index 77%
rename from examples/sequential/src/id.rs
rename to pyo3-ffi/examples/sequential/src/id.rs
index d80e84b4eab..21c667242de 100644
--- a/examples/sequential/src/id.rs
+++ b/pyo3-ffi/examples/sequential/src/id.rs
@@ -1,6 +1,7 @@
 use core::sync::atomic::{AtomicU64, Ordering};
 use core::{mem, ptr};
-use std::os::raw::{c_char, c_int, c_uint, c_ulonglong, c_void};
+use std::ffi::CString;
+use std::ffi::{c_char, c_int, c_uint, c_ulonglong, c_void};
 
 use pyo3_ffi::*;
 
@@ -27,10 +28,10 @@ unsafe extern "C" fn id_new(
     kwds: *mut PyObject,
 ) -> *mut PyObject {
     if PyTuple_Size(args) != 0 || !kwds.is_null() {
-        PyErr_SetString(
-            PyExc_TypeError,
-            "Id() takes no arguments\0".as_ptr().cast::<c_char>(),
-        );
+        // We use pyo3-ffi's `c_str!` macro to create null-terminated literals because
+        // Rust's string literals are not null-terminated
+        // On Rust 1.77 or newer you can use `c"text"` instead.
+        PyErr_SetString(PyExc_TypeError, c"Id() takes no arguments".as_ptr());
         return ptr::null_mut();
     }
 
@@ -81,8 +82,12 @@ unsafe extern "C" fn id_richcompare(
         pyo3_ffi::Py_GT => slf > other,
         pyo3_ffi::Py_GE => slf >= other,
         unrecognized => {
-            let msg = format!("unrecognized richcompare opcode {}\0", unrecognized);
-            PyErr_SetString(PyExc_SystemError, msg.as_ptr().cast::<c_char>());
+            let msg = CString::new(&*format!(
+                "unrecognized richcompare opcode {}",
+                unrecognized
+            ))
+            .unwrap();
+            PyErr_SetString(PyExc_SystemError, msg.as_ptr());
             return ptr::null_mut();
         }
     };
@@ -94,15 +99,14 @@ unsafe extern "C" fn id_richcompare(
     }
 }
 
-static mut SLOTS: &[PyType_Slot] = &[
+static mut SLOTS: [PyType_Slot; 6] = [
     PyType_Slot {
         slot: Py_tp_new,
         pfunc: id_new as *mut c_void,
     },
     PyType_Slot {
         slot: Py_tp_doc,
-        pfunc: "An id that is increased every time an instance is created\0".as_ptr()
-            as *mut c_void,
+        pfunc: c"An id that is increased every time an instance is created".as_ptr() as *mut c_void,
     },
     PyType_Slot {
         slot: Py_tp_repr,
@@ -123,9 +127,9 @@ static mut SLOTS: &[PyType_Slot] = &[
 ];
 
 pub static mut ID_SPEC: PyType_Spec = PyType_Spec {
-    name: "sequential.Id\0".as_ptr().cast::<c_char>(),
+    name: c"sequential.Id".as_ptr(),
     basicsize: mem::size_of::<PyId>() as c_int,
     itemsize: 0,
     flags: (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_IMMUTABLETYPE) as c_uint,
-    slots: unsafe { SLOTS as *const [PyType_Slot] as *mut PyType_Slot },
+    slots: ptr::addr_of_mut!(SLOTS).cast(),
 };
diff --git a/examples/sequential/src/lib.rs b/pyo3-ffi/examples/sequential/src/lib.rs
similarity index 100%
rename from examples/sequential/src/lib.rs
rename to pyo3-ffi/examples/sequential/src/lib.rs
diff --git a/examples/sequential/src/module.rs b/pyo3-ffi/examples/sequential/src/module.rs
similarity index 73%
rename from examples/sequential/src/module.rs
rename to pyo3-ffi/examples/sequential/src/module.rs
index 5552baf3368..c8d506c5568 100644
--- a/examples/sequential/src/module.rs
+++ b/pyo3-ffi/examples/sequential/src/module.rs
@@ -1,30 +1,35 @@
 use core::{mem, ptr};
 use pyo3_ffi::*;
-use std::os::raw::{c_char, c_int, c_void};
+use std::ffi::{c_int, c_void};
 
 pub static mut MODULE_DEF: PyModuleDef = PyModuleDef {
     m_base: PyModuleDef_HEAD_INIT,
-    m_name: "sequential\0".as_ptr().cast::<c_char>(),
-    m_doc: "A library for generating sequential ids, written in Rust.\0"
-        .as_ptr()
-        .cast::<c_char>(),
+    m_name: c"sequential".as_ptr(),
+    m_doc: c"A library for generating sequential ids, written in Rust.".as_ptr(),
     m_size: mem::size_of::<sequential_state>() as Py_ssize_t,
     m_methods: std::ptr::null_mut(),
-    m_slots: unsafe { SEQUENTIAL_SLOTS as *const [PyModuleDef_Slot] as *mut PyModuleDef_Slot },
+    m_slots: std::ptr::addr_of_mut!(SEQUENTIAL_SLOTS).cast(),
     m_traverse: Some(sequential_traverse),
     m_clear: Some(sequential_clear),
     m_free: Some(sequential_free),
 };
 
-static mut SEQUENTIAL_SLOTS: &[PyModuleDef_Slot] = &[
+const SEQUENTIAL_SLOTS_LEN: usize = 3 + if cfg!(Py_GIL_DISABLED) { 1 } else { 0 };
+static mut SEQUENTIAL_SLOTS: [PyModuleDef_Slot; SEQUENTIAL_SLOTS_LEN] = [
     PyModuleDef_Slot {
         slot: Py_mod_exec,
         value: sequential_exec as *mut c_void,
     },
+    #[cfg(Py_3_12)]
     PyModuleDef_Slot {
         slot: Py_mod_multiple_interpreters,
         value: Py_MOD_PER_INTERPRETER_GIL_SUPPORTED,
     },
+    #[cfg(Py_GIL_DISABLED)]
+    PyModuleDef_Slot {
+        slot: Py_mod_gil,
+        value: Py_MOD_GIL_NOT_USED,
+    },
     PyModuleDef_Slot {
         slot: 0,
         value: ptr::null_mut(),
@@ -40,15 +45,12 @@ unsafe extern "C" fn sequential_exec(module: *mut PyObject) -> c_int {
         ptr::null_mut(),
     );
     if id_type.is_null() {
-        PyErr_SetString(
-            PyExc_SystemError,
-            "cannot locate type object\0".as_ptr().cast::<c_char>(),
-        );
+        PyErr_SetString(PyExc_SystemError, c"cannot locate type object".as_ptr());
         return -1;
     }
     (*state).id_type = id_type.cast::<PyTypeObject>();
 
-    PyModule_AddObjectRef(module, "Id\0".as_ptr().cast::<c_char>(), id_type)
+    PyModule_AddObjectRef(module, c"Id".as_ptr(), id_type)
 }
 
 unsafe extern "C" fn sequential_traverse(
diff --git a/examples/sequential/tests/test.rs b/pyo3-ffi/examples/sequential/tests/test.rs
similarity index 88%
rename from examples/sequential/tests/test.rs
rename to pyo3-ffi/examples/sequential/tests/test.rs
index 6076edd4974..f4b68092e1d 100644
--- a/examples/sequential/tests/test.rs
+++ b/pyo3-ffi/examples/sequential/tests/test.rs
@@ -5,11 +5,11 @@ use std::thread;
 use pyo3_ffi::*;
 use sequential::PyInit_sequential;
 
-static COMMAND: &'static str = "
+static COMMAND: &'static CStr= c"
 from sequential import Id
 
 s = sum(int(Id()) for _ in range(12))
-\0";
+";
 
 // Newtype to be able to pass it to another thread.
 struct State(*mut PyThreadState);
@@ -19,10 +19,7 @@ unsafe impl Send for State {}
 #[test]
 fn lets_go_fast() -> Result<(), String> {
     unsafe {
-        let ret = PyImport_AppendInittab(
-            "sequential\0".as_ptr().cast::<c_char>(),
-            Some(PyInit_sequential),
-        );
+        let ret = PyImport_AppendInittab(c"sequential".as_ptr(), Some(PyInit_sequential));
         if ret == -1 {
             return Err("could not add module to inittab".into());
         }
@@ -122,11 +119,7 @@ unsafe fn fetch() -> String {
 
 fn run_code() -> Result<u64, String> {
     unsafe {
-        let code_obj = Py_CompileString(
-            COMMAND.as_ptr().cast::<c_char>(),
-            "program\0".as_ptr().cast::<c_char>(),
-            Py_file_input,
-        );
+        let code_obj = Py_CompileString(COMMAND.as_ptr(), c"program".as_ptr(), Py_file_input);
         if code_obj.is_null() {
             return Err(fetch());
         }
@@ -138,7 +131,7 @@ fn run_code() -> Result<u64, String> {
         } else {
             Py_DECREF(res_ptr);
         }
-        let sum = PyDict_GetItemString(globals, "s\0".as_ptr().cast::<c_char>()); /* borrowed reference */
+        let sum = PyDict_GetItemString(globals, c"s".as_ptr()); /* borrowed reference */
         if sum.is_null() {
             Py_DECREF(globals);
             return Err("globals did not have `s`".into());
diff --git a/examples/sequential/tests/test_.py b/pyo3-ffi/examples/sequential/tests/test_.py
similarity index 100%
rename from examples/sequential/tests/test_.py
rename to pyo3-ffi/examples/sequential/tests/test_.py
diff --git a/examples/string-sum/.template/Cargo.toml b/pyo3-ffi/examples/string-sum/.template/Cargo.toml
similarity index 100%
rename from examples/string-sum/.template/Cargo.toml
rename to pyo3-ffi/examples/string-sum/.template/Cargo.toml
diff --git a/examples/string-sum/.template/pre-script.rhai b/pyo3-ffi/examples/string-sum/.template/pre-script.rhai
similarity index 100%
rename from examples/string-sum/.template/pre-script.rhai
rename to pyo3-ffi/examples/string-sum/.template/pre-script.rhai
diff --git a/examples/string-sum/.template/pyproject.toml b/pyo3-ffi/examples/string-sum/.template/pyproject.toml
similarity index 100%
rename from examples/string-sum/.template/pyproject.toml
rename to pyo3-ffi/examples/string-sum/.template/pyproject.toml
diff --git a/pyo3-ffi/examples/string-sum/Cargo.toml b/pyo3-ffi/examples/string-sum/Cargo.toml
new file mode 100644
index 00000000000..173521eaab5
--- /dev/null
+++ b/pyo3-ffi/examples/string-sum/Cargo.toml
@@ -0,0 +1,17 @@
+[package]
+name = "string_sum"
+version = "0.1.0"
+edition = "2021"
+rust-version = "1.83"
+
+[lib]
+name = "string_sum"
+crate-type = ["cdylib"]
+
+[dependencies]
+pyo3-ffi = { path = "../../", features = ["extension-module"] }
+
+[build-dependencies]
+pyo3-build-config = { path = "../../../pyo3-build-config" }
+
+[workspace]
diff --git a/examples/string-sum/MANIFEST.in b/pyo3-ffi/examples/string-sum/MANIFEST.in
similarity index 100%
rename from examples/string-sum/MANIFEST.in
rename to pyo3-ffi/examples/string-sum/MANIFEST.in
diff --git a/examples/string-sum/README.md b/pyo3-ffi/examples/string-sum/README.md
similarity index 100%
rename from examples/string-sum/README.md
rename to pyo3-ffi/examples/string-sum/README.md
diff --git a/pyo3-ffi/examples/string-sum/build.rs b/pyo3-ffi/examples/string-sum/build.rs
new file mode 100644
index 00000000000..0475124bb4e
--- /dev/null
+++ b/pyo3-ffi/examples/string-sum/build.rs
@@ -0,0 +1,3 @@
+fn main() {
+    pyo3_build_config::use_pyo3_cfgs();
+}
diff --git a/examples/string-sum/cargo-generate.toml b/pyo3-ffi/examples/string-sum/cargo-generate.toml
similarity index 100%
rename from examples/string-sum/cargo-generate.toml
rename to pyo3-ffi/examples/string-sum/cargo-generate.toml
diff --git a/examples/string-sum/noxfile.py b/pyo3-ffi/examples/string-sum/noxfile.py
similarity index 100%
rename from examples/string-sum/noxfile.py
rename to pyo3-ffi/examples/string-sum/noxfile.py
diff --git a/examples/string-sum/pyproject.toml b/pyo3-ffi/examples/string-sum/pyproject.toml
similarity index 100%
rename from examples/string-sum/pyproject.toml
rename to pyo3-ffi/examples/string-sum/pyproject.toml
diff --git a/examples/string-sum/src/lib.rs b/pyo3-ffi/examples/string-sum/src/lib.rs
similarity index 71%
rename from examples/string-sum/src/lib.rs
rename to pyo3-ffi/examples/string-sum/src/lib.rs
index 91072418038..a0e53765481 100644
--- a/examples/string-sum/src/lib.rs
+++ b/pyo3-ffi/examples/string-sum/src/lib.rs
@@ -1,42 +1,55 @@
-use std::os::raw::{c_char, c_long};
+use std::ffi::{c_char, c_long};
 use std::ptr;
 
 use pyo3_ffi::*;
 
 static mut MODULE_DEF: PyModuleDef = PyModuleDef {
     m_base: PyModuleDef_HEAD_INIT,
-    m_name: "string_sum\0".as_ptr().cast::<c_char>(),
-    m_doc: "A Python module written in Rust.\0"
-        .as_ptr()
-        .cast::<c_char>(),
+    m_name: c"string_sum".as_ptr(),
+    m_doc: c"A Python module written in Rust.".as_ptr(),
     m_size: 0,
-    m_methods: unsafe { METHODS as *const [PyMethodDef] as *mut PyMethodDef },
-    m_slots: std::ptr::null_mut(),
+    m_methods: std::ptr::addr_of_mut!(METHODS).cast(),
+    m_slots: unsafe { SLOTS as *const [PyModuleDef_Slot] as *mut PyModuleDef_Slot },
     m_traverse: None,
     m_clear: None,
     m_free: None,
 };
 
-static mut METHODS: &[PyMethodDef] = &[
+static mut METHODS: [PyMethodDef; 2] = [
     PyMethodDef {
-        ml_name: "sum_as_string\0".as_ptr().cast::<c_char>(),
+        ml_name: c"sum_as_string".as_ptr(),
         ml_meth: PyMethodDefPointer {
-            _PyCFunctionFast: sum_as_string,
+            PyCFunctionFast: sum_as_string,
         },
         ml_flags: METH_FASTCALL,
-        ml_doc: "returns the sum of two integers as a string\0"
-            .as_ptr()
-            .cast::<c_char>(),
+        ml_doc: c"returns the sum of two integers as a string".as_ptr(),
     },
     // A zeroed PyMethodDef to mark the end of the array.
     PyMethodDef::zeroed(),
 ];
 
+static mut SLOTS: &[PyModuleDef_Slot] = &[
+    #[cfg(Py_3_12)]
+    PyModuleDef_Slot {
+        slot: Py_mod_multiple_interpreters,
+        value: Py_MOD_PER_INTERPRETER_GIL_SUPPORTED,
+    },
+    #[cfg(Py_GIL_DISABLED)]
+    PyModuleDef_Slot {
+        slot: Py_mod_gil,
+        value: Py_MOD_GIL_NOT_USED,
+    },
+    PyModuleDef_Slot {
+        slot: 0,
+        value: ptr::null_mut(),
+    },
+];
+
 // The module initialization function, which must be named `PyInit_<your_module>`.
 #[allow(non_snake_case)]
 #[no_mangle]
 pub unsafe extern "C" fn PyInit_string_sum() -> *mut PyObject {
-    PyModule_Create(ptr::addr_of_mut!(MODULE_DEF))
+    PyModuleDef_Init(ptr::addr_of_mut!(MODULE_DEF))
 }
 
 /// A helper to parse function arguments
@@ -56,6 +69,7 @@ unsafe fn parse_arg_as_i32(obj: *mut PyObject, n_arg: usize) -> Option<i32> {
     let mut overflow = 0;
     let i_long: c_long = PyLong_AsLongAndOverflow(obj, &mut overflow);
 
+    #[allow(irrefutable_let_patterns)] // some platforms have c_long equal to i32
     if overflow != 0 {
         raise_overflowerror(obj);
         None
@@ -93,9 +107,7 @@ pub unsafe extern "C" fn sum_as_string(
     if nargs != 2 {
         PyErr_SetString(
             PyExc_TypeError,
-            "sum_as_string expected 2 positional arguments\0"
-                .as_ptr()
-                .cast::<c_char>(),
+            c"sum_as_string expected 2 positional arguments".as_ptr(),
         );
         return std::ptr::null_mut();
     }
@@ -117,10 +129,7 @@ pub unsafe extern "C" fn sum_as_string(
             PyUnicode_FromStringAndSize(string.as_ptr().cast::<c_char>(), string.len() as isize)
         }
         None => {
-            PyErr_SetString(
-                PyExc_OverflowError,
-                "arguments too large to add\0".as_ptr().cast::<c_char>(),
-            );
+            PyErr_SetString(PyExc_OverflowError, c"arguments too large to add".as_ptr());
             std::ptr::null_mut()
         }
     }
diff --git a/examples/string-sum/tests/test_.py b/pyo3-ffi/examples/string-sum/tests/test_.py
similarity index 100%
rename from examples/string-sum/tests/test_.py
rename to pyo3-ffi/examples/string-sum/tests/test_.py
diff --git a/pyo3-ffi/src/abstract_.rs b/pyo3-ffi/src/abstract_.rs
index 0b3b7dbb3c2..712a0739b43 100644
--- a/pyo3-ffi/src/abstract_.rs
+++ b/pyo3-ffi/src/abstract_.rs
@@ -1,23 +1,25 @@
 use crate::object::*;
 use crate::pyport::Py_ssize_t;
-use std::os::raw::{c_char, c_int};
-use std::ptr;
-
-extern "C" {
-    #[cfg(PyPy)]
-    #[link_name = "PyPyObject_DelAttrString"]
-    pub fn PyObject_DelAttrString(o: *mut PyObject, attr_name: *const c_char) -> c_int;
-}
+#[cfg(any(Py_3_12, all(Py_3_8, not(Py_LIMITED_API))))]
+use libc::size_t;
+use std::ffi::{c_char, c_int};
 
 #[inline]
-#[cfg(not(PyPy))]
+#[cfg(all(
+    not(Py_3_13), // CPython exposed as a function in 3.13, in object.h
+    not(all(PyPy, not(Py_3_11))) // PyPy exposed as a function until PyPy 3.10, macro in 3.11+
+))]
 pub unsafe fn PyObject_DelAttrString(o: *mut PyObject, attr_name: *const c_char) -> c_int {
-    PyObject_SetAttrString(o, attr_name, ptr::null_mut())
+    PyObject_SetAttrString(o, attr_name, std::ptr::null_mut())
 }
 
 #[inline]
+#[cfg(all(
+    not(Py_3_13), // CPython exposed as a function in 3.13, in object.h
+    not(all(PyPy, not(Py_3_11))) // PyPy exposed as a function until PyPy 3.10, macro in 3.11+
+))]
 pub unsafe fn PyObject_DelAttr(o: *mut PyObject, attr_name: *mut PyObject) -> c_int {
-    PyObject_SetAttr(o, attr_name, ptr::null_mut())
+    PyObject_SetAttr(o, attr_name, std::ptr::null_mut())
 }
 
 extern "C" {
@@ -76,6 +78,28 @@ extern "C" {
         method: *mut PyObject,
         ...
     ) -> *mut PyObject;
+}
+#[cfg(any(Py_3_12, all(Py_3_8, not(Py_LIMITED_API))))]
+pub const PY_VECTORCALL_ARGUMENTS_OFFSET: size_t =
+    1 << (8 * std::mem::size_of::<size_t>() as size_t - 1);
+
+extern "C" {
+    #[cfg_attr(PyPy, link_name = "PyPyObject_Vectorcall")]
+    #[cfg(any(Py_3_12, all(Py_3_11, not(Py_LIMITED_API))))]
+    pub fn PyObject_Vectorcall(
+        callable: *mut PyObject,
+        args: *const *mut PyObject,
+        nargsf: size_t,
+        kwnames: *mut PyObject,
+    ) -> *mut PyObject;
+
+    #[cfg(any(Py_3_12, all(Py_3_9, not(any(Py_LIMITED_API, PyPy)))))]
+    pub fn PyObject_VectorcallMethod(
+        name: *mut PyObject,
+        args: *const *mut PyObject,
+        nargsf: size_t,
+        kwnames: *mut PyObject,
+    ) -> *mut PyObject;
     #[cfg_attr(PyPy, link_name = "PyPyObject_Type")]
     pub fn PyObject_Type(o: *mut PyObject) -> *mut PyObject;
     #[cfg_attr(PyPy, link_name = "PyPyObject_Size")]
@@ -113,10 +137,7 @@ extern "C" {
 #[cfg(not(any(Py_3_8, PyPy)))]
 #[inline]
 pub unsafe fn PyIter_Check(o: *mut PyObject) -> c_int {
-    crate::PyObject_HasAttrString(
-        crate::Py_TYPE(o).cast(),
-        "__next__\0".as_ptr() as *const c_char,
-    )
+    crate::PyObject_HasAttrString(crate::Py_TYPE(o).cast(), c"__next__".as_ptr())
 }
 
 extern "C" {
@@ -128,7 +149,11 @@ extern "C" {
     pub fn PyIter_Next(arg1: *mut PyObject) -> *mut PyObject;
     #[cfg(all(not(PyPy), Py_3_10))]
     #[cfg_attr(PyPy, link_name = "PyPyIter_Send")]
-    pub fn PyIter_Send(iter: *mut PyObject, arg: *mut PyObject, presult: *mut *mut PyObject);
+    pub fn PyIter_Send(
+        iter: *mut PyObject,
+        arg: *mut PyObject,
+        presult: *mut *mut PyObject,
+    ) -> PySendResult;
 
     #[cfg_attr(PyPy, link_name = "PyPyNumber_Check")]
     pub fn PyNumber_Check(o: *mut PyObject) -> c_int;
diff --git a/pyo3-ffi/src/boolobject.rs b/pyo3-ffi/src/boolobject.rs
index 78972ff0835..4d2ce70a600 100644
--- a/pyo3-ffi/src/boolobject.rs
+++ b/pyo3-ffi/src/boolobject.rs
@@ -1,14 +1,9 @@
+#[cfg(not(GraalPy))]
 use crate::longobject::PyLongObject;
 use crate::object::*;
-use std::os::raw::{c_int, c_long};
+use std::ffi::{c_int, c_long};
 use std::ptr::addr_of_mut;
 
-#[cfg_attr(windows, link(name = "pythonXY"))]
-extern "C" {
-    #[cfg_attr(PyPy, link_name = "PyPyBool_Type")]
-    pub static mut PyBool_Type: PyTypeObject;
-}
-
 #[inline]
 pub unsafe fn PyBool_Check(op: *mut PyObject) -> c_int {
     (Py_TYPE(op) == addr_of_mut!(PyBool_Type)) as c_int
@@ -16,20 +11,33 @@ pub unsafe fn PyBool_Check(op: *mut PyObject) -> c_int {
 
 #[cfg_attr(windows, link(name = "pythonXY"))]
 extern "C" {
+    #[cfg(not(GraalPy))]
     #[cfg_attr(PyPy, link_name = "_PyPy_FalseStruct")]
     static mut _Py_FalseStruct: PyLongObject;
+    #[cfg(not(GraalPy))]
     #[cfg_attr(PyPy, link_name = "_PyPy_TrueStruct")]
     static mut _Py_TrueStruct: PyLongObject;
+
+    #[cfg(GraalPy)]
+    static mut _Py_FalseStructReference: *mut PyObject;
+    #[cfg(GraalPy)]
+    static mut _Py_TrueStructReference: *mut PyObject;
 }
 
 #[inline]
 pub unsafe fn Py_False() -> *mut PyObject {
-    addr_of_mut!(_Py_FalseStruct) as *mut PyObject
+    #[cfg(not(GraalPy))]
+    return addr_of_mut!(_Py_FalseStruct) as *mut PyObject;
+    #[cfg(GraalPy)]
+    return _Py_FalseStructReference;
 }
 
 #[inline]
 pub unsafe fn Py_True() -> *mut PyObject {
-    addr_of_mut!(_Py_TrueStruct) as *mut PyObject
+    #[cfg(not(GraalPy))]
+    return addr_of_mut!(_Py_TrueStruct) as *mut PyObject;
+    #[cfg(GraalPy)]
+    return _Py_TrueStructReference;
 }
 
 #[inline]
diff --git a/pyo3-ffi/src/bytearrayobject.rs b/pyo3-ffi/src/bytearrayobject.rs
index a37deb410f7..6729f6167c6 100644
--- a/pyo3-ffi/src/bytearrayobject.rs
+++ b/pyo3-ffi/src/bytearrayobject.rs
@@ -1,11 +1,10 @@
 use crate::object::*;
 use crate::pyport::Py_ssize_t;
-use std::os::raw::{c_char, c_int};
+use std::ffi::{c_char, c_int};
 use std::ptr::addr_of_mut;
 
-#[cfg(not(any(PyPy, Py_LIMITED_API)))]
+#[cfg(not(any(PyPy, GraalPy, Py_LIMITED_API)))]
 #[repr(C)]
-#[derive(Copy, Clone)]
 pub struct PyByteArrayObject {
     pub ob_base: PyVarObject,
     pub ob_alloc: Py_ssize_t,
@@ -17,8 +16,8 @@ pub struct PyByteArrayObject {
     pub ob_exports: c_int,
 }
 
-#[cfg(any(PyPy, Py_LIMITED_API))]
-opaque_struct!(PyByteArrayObject);
+#[cfg(any(PyPy, GraalPy, Py_LIMITED_API))]
+opaque_struct!(pub PyByteArrayObject);
 
 #[cfg_attr(windows, link(name = "pythonXY"))]
 extern "C" {
diff --git a/pyo3-ffi/src/bytesobject.rs b/pyo3-ffi/src/bytesobject.rs
index 0fd327b6fca..08351d18daa 100644
--- a/pyo3-ffi/src/bytesobject.rs
+++ b/pyo3-ffi/src/bytesobject.rs
@@ -1,6 +1,6 @@
 use crate::object::*;
 use crate::pyport::Py_ssize_t;
-use std::os::raw::{c_char, c_int};
+use std::ffi::{c_char, c_int};
 use std::ptr::addr_of_mut;
 
 #[cfg_attr(windows, link(name = "pythonXY"))]
diff --git a/pyo3-ffi/src/ceval.rs b/pyo3-ffi/src/ceval.rs
index 7aae25f8c3e..5746d574346 100644
--- a/pyo3-ffi/src/ceval.rs
+++ b/pyo3-ffi/src/ceval.rs
@@ -1,6 +1,6 @@
 use crate::object::PyObject;
 use crate::pystate::PyThreadState;
-use std::os::raw::{c_char, c_int, c_void};
+use std::ffi::{c_char, c_int, c_void};
 
 extern "C" {
     #[cfg_attr(PyPy, link_name = "PyPyEval_EvalCode")]
@@ -24,6 +24,7 @@ extern "C" {
         closure: *mut PyObject,
     ) -> *mut PyObject;
 
+    #[cfg(not(Py_3_13))]
     #[cfg_attr(Py_3_9, deprecated(note = "Python 3.9"))]
     #[cfg_attr(PyPy, link_name = "PyPyEval_CallObjectWithKeywords")]
     pub fn PyEval_CallObjectWithKeywords(
@@ -33,6 +34,7 @@ extern "C" {
     ) -> *mut PyObject;
 }
 
+#[cfg(not(Py_3_13))]
 #[cfg_attr(Py_3_9, deprecated(note = "Python 3.9"))]
 #[inline]
 pub unsafe fn PyEval_CallObject(func: *mut PyObject, arg: *mut PyObject) -> *mut PyObject {
@@ -41,9 +43,11 @@ pub unsafe fn PyEval_CallObject(func: *mut PyObject, arg: *mut PyObject) -> *mut
 }
 
 extern "C" {
+    #[cfg(not(Py_3_13))]
     #[cfg_attr(Py_3_9, deprecated(note = "Python 3.9"))]
     #[cfg_attr(PyPy, link_name = "PyPyEval_CallFunction")]
     pub fn PyEval_CallFunction(obj: *mut PyObject, format: *const c_char, ...) -> *mut PyObject;
+    #[cfg(not(Py_3_13))]
     #[cfg_attr(Py_3_9, deprecated(note = "Python 3.9"))]
     #[cfg_attr(PyPy, link_name = "PyPyEval_CallMethod")]
     pub fn PyEval_CallMethod(
@@ -95,9 +99,22 @@ extern "C" {
 }
 
 extern "C" {
+    #[cfg(not(Py_3_13))]
     #[cfg_attr(PyPy, link_name = "PyPyEval_ThreadsInitialized")]
+    #[cfg_attr(
+        Py_3_9,
+        deprecated(
+            note = "Deprecated in Python 3.9, this function always returns true in Python 3.7 or newer."
+        )
+    )]
     pub fn PyEval_ThreadsInitialized() -> c_int;
     #[cfg_attr(PyPy, link_name = "PyPyEval_InitThreads")]
+    #[cfg_attr(
+        Py_3_9,
+        deprecated(
+            note = "Deprecated in Python 3.9, this function does nothing in Python 3.7 or newer."
+        )
+    )]
     pub fn PyEval_InitThreads();
     pub fn PyEval_AcquireLock();
     pub fn PyEval_ReleaseLock();
diff --git a/pyo3-ffi/src/code.rs b/pyo3-ffi/src/code.rs
index d28f68cded7..296b17f6aa4 100644
--- a/pyo3-ffi/src/code.rs
+++ b/pyo3-ffi/src/code.rs
@@ -1,4 +1,4 @@
 // This header doesn't exist in CPython, but Include/cpython/code.h does. We add
 // this here so that PyCodeObject has a definition under the limited API.
 
-opaque_struct!(PyCodeObject);
+opaque_struct!(pub PyCodeObject);
diff --git a/pyo3-ffi/src/codecs.rs b/pyo3-ffi/src/codecs.rs
index 2fd214cbbfe..9e4c52c9348 100644
--- a/pyo3-ffi/src/codecs.rs
+++ b/pyo3-ffi/src/codecs.rs
@@ -1,5 +1,5 @@
 use crate::object::PyObject;
-use std::os::raw::{c_char, c_int};
+use std::ffi::{c_char, c_int};
 
 extern "C" {
     pub fn PyCodec_Register(search_function: *mut PyObject) -> c_int;
diff --git a/pyo3-ffi/src/compat/mod.rs b/pyo3-ffi/src/compat/mod.rs
new file mode 100644
index 00000000000..044ea46762b
--- /dev/null
+++ b/pyo3-ffi/src/compat/mod.rs
@@ -0,0 +1,61 @@
+//! C API Compatibility Shims
+//!
+//! Some CPython C API functions added in recent versions of Python are
+//! inherently safer to use than older C API constructs. This module
+//! exposes functions available on all Python versions that wrap the
+//! old C API on old Python versions and wrap the function directly
+//! on newer Python versions.
+
+// Unless otherwise noted, the compatibility shims are adapted from
+// the pythoncapi-compat project: https://github.com/python/pythoncapi-compat
+
+/// Internal helper macro which defines compatibility shims for C API functions, deferring to a
+/// re-export when that's available.
+macro_rules! compat_function {
+    (
+        originally_defined_for($cfg:meta);
+
+        $(#[$attrs:meta])*
+        pub unsafe fn $name:ident($($arg_names:ident: $arg_types:ty),* $(,)?) -> $ret:ty $body:block
+    ) => {
+        // Define as a standalone function under docsrs cfg so that this shows as a unique function in the docs,
+        // not a re-export (the re-export has the wrong visibility)
+        #[cfg(any(docsrs, not($cfg)))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
+        $(#[$attrs])*
+        pub unsafe fn $name(
+            $($arg_names: $arg_types,)*
+        ) -> $ret $body
+
+        #[cfg(all($cfg, not(docsrs)))]
+        pub use $crate::$name;
+
+        #[cfg(test)]
+        paste::paste! {
+            // Test that the compat function does not overlap with the original function. If the
+            // cfgs line up, then the the two glob imports will resolve to the same item via the
+            // re-export. If the cfgs mismatch, then the use of $name will be ambiguous in cases
+            // where the function is defined twice, and the test will fail to compile.
+            #[allow(unused_imports)]
+            mod [<test_ $name _export>] {
+                use $crate::*;
+                use $crate::compat::*;
+
+                #[test]
+                fn test_export() {
+                    let _ = $name;
+                }
+            }
+        }
+    };
+}
+
+mod py_3_10;
+mod py_3_13;
+mod py_3_14;
+mod py_3_9;
+
+pub use self::py_3_10::*;
+pub use self::py_3_13::*;
+pub use self::py_3_14::*;
+pub use self::py_3_9::*;
diff --git a/pyo3-ffi/src/compat/py_3_10.rs b/pyo3-ffi/src/compat/py_3_10.rs
new file mode 100644
index 00000000000..2d4daa194c6
--- /dev/null
+++ b/pyo3-ffi/src/compat/py_3_10.rs
@@ -0,0 +1,45 @@
+compat_function!(
+    originally_defined_for(Py_3_10);
+
+    #[inline]
+    pub unsafe fn Py_NewRef(obj: *mut crate::PyObject) -> *mut crate::PyObject {
+        crate::Py_INCREF(obj);
+        obj
+    }
+);
+
+compat_function!(
+    originally_defined_for(Py_3_10);
+
+    #[inline]
+    pub unsafe fn Py_XNewRef(obj: *mut crate::PyObject) -> *mut crate::PyObject {
+        crate::Py_XINCREF(obj);
+        obj
+    }
+);
+
+compat_function!(
+    originally_defined_for(Py_3_10);
+
+    #[inline]
+    pub unsafe fn PyModule_AddObjectRef(
+        module: *mut crate::PyObject,
+        name: *const std::ffi::c_char,
+        value: *mut crate::PyObject,
+    ) -> std::ffi::c_int {
+        if value.is_null() && crate::PyErr_Occurred().is_null() {
+            crate::PyErr_SetString(
+                crate::PyExc_SystemError,
+                c"PyModule_AddObjectRef() must be called with an exception raised if value is NULL".as_ptr(),
+            );
+            return -1;
+        }
+
+        crate::Py_XINCREF(value);
+        let result = crate::PyModule_AddObject(module, name, value);
+        if result < 0 {
+            crate::Py_XDECREF(value);
+        }
+        result
+    }
+);
diff --git a/pyo3-ffi/src/compat/py_3_13.rs b/pyo3-ffi/src/compat/py_3_13.rs
new file mode 100644
index 00000000000..a433f7ac334
--- /dev/null
+++ b/pyo3-ffi/src/compat/py_3_13.rs
@@ -0,0 +1,121 @@
+compat_function!(
+    originally_defined_for(Py_3_13);
+
+    #[inline]
+    pub unsafe fn PyDict_GetItemRef(
+        dp: *mut crate::PyObject,
+        key: *mut crate::PyObject,
+        result: *mut *mut crate::PyObject,
+    ) -> std::ffi::c_int {
+        use crate::{compat::Py_NewRef, PyDict_GetItemWithError, PyErr_Occurred};
+
+        let item = PyDict_GetItemWithError(dp, key);
+        if !item.is_null() {
+            *result = Py_NewRef(item);
+            return 1; // found
+        }
+        *result = std::ptr::null_mut();
+        if PyErr_Occurred().is_null() {
+            return 0; // not found
+        }
+        -1
+    }
+);
+
+compat_function!(
+    originally_defined_for(Py_3_13);
+
+    #[inline]
+    pub unsafe fn PyList_GetItemRef(
+        arg1: *mut crate::PyObject,
+        arg2: crate::Py_ssize_t,
+    ) -> *mut crate::PyObject {
+        use crate::{PyList_GetItem, Py_XINCREF};
+
+        let item = PyList_GetItem(arg1, arg2);
+        Py_XINCREF(item);
+        item
+    }
+);
+
+compat_function!(
+    originally_defined_for(Py_3_13);
+
+    #[inline]
+    pub unsafe fn PyImport_AddModuleRef(
+        name: *const std::ffi::c_char,
+    ) -> *mut crate::PyObject {
+        use crate::{compat::Py_XNewRef, PyImport_AddModule};
+
+        Py_XNewRef(PyImport_AddModule(name))
+    }
+);
+
+compat_function!(
+    originally_defined_for(Py_3_13);
+
+    #[inline]
+    pub unsafe fn PyWeakref_GetRef(
+        reference: *mut crate::PyObject,
+        pobj: *mut *mut crate::PyObject,
+    ) -> std::ffi::c_int {
+        use crate::{
+            compat::Py_NewRef, PyErr_SetString, PyExc_TypeError, PyWeakref_Check,
+            PyWeakref_GetObject, Py_None,
+        };
+
+        if !reference.is_null() && PyWeakref_Check(reference) == 0 {
+            *pobj = std::ptr::null_mut();
+            PyErr_SetString(PyExc_TypeError, c"expected a weakref".as_ptr());
+            return -1;
+        }
+        let obj = PyWeakref_GetObject(reference);
+        if obj.is_null() {
+            // SystemError if reference is NULL
+            *pobj = std::ptr::null_mut();
+            return -1;
+        }
+        if obj == Py_None() {
+            *pobj = std::ptr::null_mut();
+            return 0;
+        }
+        *pobj = Py_NewRef(obj);
+        1
+    }
+);
+
+compat_function!(
+    originally_defined_for(Py_3_13);
+
+    #[inline]
+    pub unsafe fn PyList_Extend(
+        list: *mut crate::PyObject,
+        iterable: *mut crate::PyObject,
+    ) -> std::ffi::c_int {
+        crate::PyList_SetSlice(list, crate::PY_SSIZE_T_MAX, crate::PY_SSIZE_T_MAX, iterable)
+    }
+);
+
+compat_function!(
+    originally_defined_for(Py_3_13);
+
+    #[inline]
+    pub unsafe fn PyList_Clear(list: *mut crate::PyObject) -> std::ffi::c_int {
+        crate::PyList_SetSlice(list, 0, crate::PY_SSIZE_T_MAX, std::ptr::null_mut())
+    }
+);
+
+compat_function!(
+    originally_defined_for(Py_3_13);
+
+    #[inline]
+    pub unsafe fn PyModule_Add(
+        module: *mut crate::PyObject,
+        name: *const std::ffi::c_char,
+        value: *mut crate::PyObject,
+    ) -> std::ffi::c_int {
+        let result = crate::compat::PyModule_AddObjectRef(module, name, value);
+        crate::Py_XDECREF(value);
+        result
+    }
+);
diff --git a/pyo3-ffi/src/compat/py_3_14.rs b/pyo3-ffi/src/compat/py_3_14.rs
new file mode 100644
index 00000000000..859d26ea777
--- /dev/null
+++ b/pyo3-ffi/src/compat/py_3_14.rs
@@ -0,0 +1,26 @@
+compat_function!(
+    originally_defined_for(all(Py_3_14, not(Py_LIMITED_API)));
+
+    #[inline]
+    pub unsafe fn Py_HashBuffer(
+        ptr: *const std::ffi::c_void,
+        len: crate::Py_ssize_t,
+    ) -> crate::Py_hash_t {
+        #[cfg(not(any(Py_LIMITED_API, PyPy)))]
+        {
+            crate::_Py_HashBytes(ptr, len)
+        }
+
+        #[cfg(any(Py_LIMITED_API, PyPy))]
+        {
+            let bytes = crate::PyBytes_FromStringAndSize(ptr as *const std::ffi::c_char, len);
+            if bytes.is_null() {
+                -1
+            } else {
+                let result = crate::PyObject_Hash(bytes);
+                crate::Py_DECREF(bytes);
+                result
+            }
+        }
+    }
+);
diff --git a/pyo3-ffi/src/compat/py_3_9.rs b/pyo3-ffi/src/compat/py_3_9.rs
new file mode 100644
index 00000000000..6b3521cc167
--- /dev/null
+++ b/pyo3-ffi/src/compat/py_3_9.rs
@@ -0,0 +1,20 @@
+compat_function!(
+    originally_defined_for(all(
+        not(PyPy),
+        any(Py_3_10, all(not(Py_LIMITED_API), Py_3_9)) // Added to python in 3.9 but to limited API in 3.10
+    ));
+
+    #[inline]
+    pub unsafe fn PyObject_CallNoArgs(obj: *mut crate::PyObject) -> *mut crate::PyObject {
+        crate::PyObject_CallObject(obj, std::ptr::null_mut())
+    }
+);
+
+compat_function!(
+    originally_defined_for(all(Py_3_9, not(any(Py_LIMITED_API, PyPy))));
+
+    #[inline]
+    pub unsafe fn PyObject_CallMethodNoArgs(obj: *mut crate::PyObject, name: *mut crate::PyObject) -> *mut crate::PyObject {
+        crate::PyObject_CallMethodObjArgs(obj, name, std::ptr::null_mut::<crate::PyObject>())
+    }
+);
diff --git a/pyo3-ffi/src/compile.rs b/pyo3-ffi/src/compile.rs
index 189a1a8b8a4..50128a815d0 100644
--- a/pyo3-ffi/src/compile.rs
+++ b/pyo3-ffi/src/compile.rs
@@ -1,4 +1,4 @@
-use std::os::raw::c_int;
+use std::ffi::c_int;
 
 pub const Py_single_input: c_int = 256;
 pub const Py_file_input: c_int = 257;
diff --git a/pyo3-ffi/src/complexobject.rs b/pyo3-ffi/src/complexobject.rs
index 339f5d8c81a..a8920765424 100644
--- a/pyo3-ffi/src/complexobject.rs
+++ b/pyo3-ffi/src/complexobject.rs
@@ -1,38 +1,7 @@
 use crate::object::*;
-use std::os::raw::{c_double, c_int};
+use std::ffi::{c_double, c_int};
 use std::ptr::addr_of_mut;
 
-#[repr(C)]
-#[derive(Copy, Clone)]
-// non-limited
-pub struct Py_complex {
-    pub real: c_double,
-    pub imag: c_double,
-}
-
-#[cfg(not(Py_LIMITED_API))]
-extern "C" {
-    pub fn _Py_c_sum(left: Py_complex, right: Py_complex) -> Py_complex;
-    pub fn _Py_c_diff(left: Py_complex, right: Py_complex) -> Py_complex;
-    pub fn _Py_c_neg(complex: Py_complex) -> Py_complex;
-    pub fn _Py_c_prod(left: Py_complex, right: Py_complex) -> Py_complex;
-    pub fn _Py_c_quot(dividend: Py_complex, divisor: Py_complex) -> Py_complex;
-    pub fn _Py_c_pow(num: Py_complex, exp: Py_complex) -> Py_complex;
-    pub fn _Py_c_abs(arg: Py_complex) -> c_double;
-    #[cfg_attr(PyPy, link_name = "PyPyComplex_FromCComplex")]
-    pub fn PyComplex_FromCComplex(v: Py_complex) -> *mut PyObject;
-    #[cfg_attr(PyPy, link_name = "PyPyComplex_AsCComplex")]
-    pub fn PyComplex_AsCComplex(op: *mut PyObject) -> Py_complex;
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-// non-limited
-pub struct PyComplexObject {
-    pub ob_base: PyObject,
-    pub cval: Py_complex,
-}
-
 #[cfg_attr(windows, link(name = "pythonXY"))]
 extern "C" {
     #[cfg_attr(PyPy, link_name = "PyPyComplex_Type")]
@@ -46,17 +15,16 @@ pub unsafe fn PyComplex_Check(op: *mut PyObject) -> c_int {
 
 #[inline]
 pub unsafe fn PyComplex_CheckExact(op: *mut PyObject) -> c_int {
-    (Py_TYPE(op) == addr_of_mut!(PyComplex_Type)) as c_int
+    Py_IS_TYPE(op, addr_of_mut!(PyComplex_Type))
 }
 
 extern "C" {
     // skipped non-limited PyComplex_FromCComplex
     #[cfg_attr(PyPy, link_name = "PyPyComplex_FromDoubles")]
     pub fn PyComplex_FromDoubles(real: c_double, imag: c_double) -> *mut PyObject;
+
     #[cfg_attr(PyPy, link_name = "PyPyComplex_RealAsDouble")]
     pub fn PyComplex_RealAsDouble(op: *mut PyObject) -> c_double;
     #[cfg_attr(PyPy, link_name = "PyPyComplex_ImagAsDouble")]
     pub fn PyComplex_ImagAsDouble(op: *mut PyObject) -> c_double;
-    // skipped non-limited PyComplex_AsCComplex
-    // skipped non-limited _PyComplex_FormatAdvancedWriter
 }
diff --git a/pyo3-ffi/src/context.rs b/pyo3-ffi/src/context.rs
index 210d6e21f04..8f2f1576bb1 100644
--- a/pyo3-ffi/src/context.rs
+++ b/pyo3-ffi/src/context.rs
@@ -1,5 +1,5 @@
 use crate::object::{PyObject, PyTypeObject, Py_TYPE};
-use std::os::raw::{c_char, c_int};
+use std::ffi::{c_char, c_int};
 use std::ptr::addr_of_mut;
 
 extern "C" {
diff --git a/pyo3-ffi/src/cpython/abstract_.rs b/pyo3-ffi/src/cpython/abstract_.rs
index d2e3ca9d67a..53ef71e0710 100644
--- a/pyo3-ffi/src/cpython/abstract_.rs
+++ b/pyo3-ffi/src/cpython/abstract_.rs
@@ -1,11 +1,11 @@
 use crate::{PyObject, Py_ssize_t};
-use std::os::raw::{c_char, c_int};
+#[cfg(any(all(Py_3_8, not(PyPy)), not(Py_3_11)))]
+use std::ffi::c_char;
+use std::ffi::c_int;
 
 #[cfg(not(Py_3_11))]
 use crate::Py_buffer;
 
-#[cfg(Py_3_8)]
-use crate::pyport::PY_SSIZE_T_MAX;
 #[cfg(all(Py_3_8, not(PyPy)))]
 use crate::{
     vectorcallfunc, PyCallable_Check, PyThreadState, PyThreadState_GET, PyTuple_Check,
@@ -15,11 +15,11 @@ use crate::{
 use libc::size_t;
 
 extern "C" {
-    #[cfg(all(Py_3_8, not(PyPy)))]
+    #[cfg(all(Py_3_8, not(any(PyPy, GraalPy))))]
     pub fn _PyStack_AsDict(values: *const *mut PyObject, kwnames: *mut PyObject) -> *mut PyObject;
 }
 
-#[cfg(all(Py_3_8, not(PyPy)))]
+#[cfg(all(Py_3_8, not(any(PyPy, GraalPy))))]
 const _PY_FASTCALL_SMALL_STACK: size_t = 5;
 
 extern "C" {
@@ -41,15 +41,15 @@ extern "C" {
     ) -> *mut PyObject;
 }
 
-#[cfg(Py_3_8)]
-const PY_VECTORCALL_ARGUMENTS_OFFSET: Py_ssize_t =
-    1 << (8 * std::mem::size_of::<Py_ssize_t>() as Py_ssize_t - 1);
+#[cfg(Py_3_8)] // NB exported as public in abstract.rs from 3.12
+const PY_VECTORCALL_ARGUMENTS_OFFSET: size_t =
+    1 << (8 * std::mem::size_of::<size_t>() as size_t - 1);
 
 #[cfg(Py_3_8)]
 #[inline(always)]
 pub unsafe fn PyVectorcall_NARGS(n: size_t) -> Py_ssize_t {
-    assert!(n <= (PY_SSIZE_T_MAX as size_t));
-    (n as Py_ssize_t) & !PY_VECTORCALL_ARGUMENTS_OFFSET
+    let n = n & !PY_VECTORCALL_ARGUMENTS_OFFSET;
+    n.try_into().expect("cannot fail due to mask")
 }
 
 #[cfg(all(Py_3_8, not(PyPy)))]
@@ -63,7 +63,7 @@ pub unsafe fn PyVectorcall_Function(callable: *mut PyObject) -> Option<vectorcal
     assert!(PyCallable_Check(callable) > 0);
     let offset = (*tp).tp_vectorcall_offset;
     assert!(offset > 0);
-    let ptr = (callable as *const c_char).offset(offset) as *const Option<vectorcallfunc>;
+    let ptr = callable.cast::<c_char>().offset(offset).cast();
     *ptr
 }
 
@@ -91,7 +91,7 @@ pub unsafe fn _PyObject_VectorcallTstate(
     }
 }
 
-#[cfg(all(Py_3_8, not(PyPy)))]
+#[cfg(all(Py_3_8, not(any(PyPy, GraalPy, Py_3_11))))] // exported as a function from 3.11, see abstract.rs
 #[inline(always)]
 pub unsafe fn PyObject_Vectorcall(
     callable: *mut PyObject,
@@ -103,18 +103,11 @@ pub unsafe fn PyObject_Vectorcall(
 }
 
 extern "C" {
-    #[cfg(all(PyPy, Py_3_8))]
-    #[cfg_attr(not(Py_3_9), link_name = "_PyPyObject_Vectorcall")]
-    #[cfg_attr(Py_3_9, link_name = "PyPyObject_Vectorcall")]
-    pub fn PyObject_Vectorcall(
-        callable: *mut PyObject,
-        args: *const *mut PyObject,
-        nargsf: size_t,
-        kwnames: *mut PyObject,
-    ) -> *mut PyObject;
-
     #[cfg(Py_3_8)]
-    #[cfg_attr(all(not(PyPy), not(Py_3_9)), link_name = "_PyObject_VectorcallDict")]
+    #[cfg_attr(
+        all(not(any(PyPy, GraalPy)), not(Py_3_9)),
+        link_name = "_PyObject_VectorcallDict"
+    )]
     #[cfg_attr(all(PyPy, not(Py_3_9)), link_name = "_PyPyObject_VectorcallDict")]
     #[cfg_attr(all(PyPy, Py_3_9), link_name = "PyPyObject_VectorcallDict")]
     pub fn PyObject_VectorcallDict(
@@ -134,7 +127,7 @@ extern "C" {
     ) -> *mut PyObject;
 }
 
-#[cfg(all(Py_3_8, not(PyPy)))]
+#[cfg(all(Py_3_8, not(any(PyPy, GraalPy))))]
 #[inline(always)]
 pub unsafe fn _PyObject_FastCallTstate(
     tstate: *mut PyThreadState,
@@ -145,7 +138,7 @@ pub unsafe fn _PyObject_FastCallTstate(
     _PyObject_VectorcallTstate(tstate, func, args, nargs as size_t, std::ptr::null_mut())
 }
 
-#[cfg(all(Py_3_8, not(PyPy)))]
+#[cfg(all(Py_3_8, not(any(PyPy, GraalPy))))]
 #[inline(always)]
 pub unsafe fn _PyObject_FastCall(
     func: *mut PyObject,
@@ -181,17 +174,7 @@ pub unsafe fn PyObject_CallOneArg(func: *mut PyObject, arg: *mut PyObject) -> *m
     let args = args_array.as_ptr().offset(1); // For PY_VECTORCALL_ARGUMENTS_OFFSET
     let tstate = PyThreadState_GET();
     let nargsf = 1 | PY_VECTORCALL_ARGUMENTS_OFFSET;
-    _PyObject_VectorcallTstate(tstate, func, args, nargsf as size_t, std::ptr::null_mut())
-}
-
-extern "C" {
-    #[cfg(all(Py_3_9, not(PyPy)))]
-    pub fn PyObject_VectorcallMethod(
-        name: *mut PyObject,
-        args: *const *mut PyObject,
-        nargsf: size_t,
-        kwnames: *mut PyObject,
-    ) -> *mut PyObject;
+    _PyObject_VectorcallTstate(tstate, func, args, nargsf, std::ptr::null_mut())
 }
 
 #[cfg(all(Py_3_9, not(PyPy)))]
@@ -200,10 +183,10 @@ pub unsafe fn PyObject_CallMethodNoArgs(
     self_: *mut PyObject,
     name: *mut PyObject,
 ) -> *mut PyObject {
-    PyObject_VectorcallMethod(
+    crate::PyObject_VectorcallMethod(
         name,
         &self_,
-        1 | PY_VECTORCALL_ARGUMENTS_OFFSET as size_t,
+        1 | PY_VECTORCALL_ARGUMENTS_OFFSET,
         std::ptr::null_mut(),
     )
 }
@@ -217,10 +200,10 @@ pub unsafe fn PyObject_CallMethodOneArg(
 ) -> *mut PyObject {
     let args = [self_, arg];
     assert!(!arg.is_null());
-    PyObject_VectorcallMethod(
+    crate::PyObject_VectorcallMethod(
         name,
         args.as_ptr(),
-        2 | PY_VECTORCALL_ARGUMENTS_OFFSET as size_t,
+        2 | PY_VECTORCALL_ARGUMENTS_OFFSET,
         std::ptr::null_mut(),
     )
 }
@@ -255,12 +238,12 @@ extern "C" {
     pub fn PyBuffer_GetPointer(
         view: *mut Py_buffer,
         indices: *mut Py_ssize_t,
-    ) -> *mut std::os::raw::c_void;
+    ) -> *mut std::ffi::c_void;
     #[cfg_attr(PyPy, link_name = "PyPyBuffer_SizeFromFormat")]
     pub fn PyBuffer_SizeFromFormat(format: *const c_char) -> Py_ssize_t;
     #[cfg_attr(PyPy, link_name = "PyPyBuffer_ToContiguous")]
     pub fn PyBuffer_ToContiguous(
-        buf: *mut std::os::raw::c_void,
+        buf: *mut std::ffi::c_void,
         view: *mut Py_buffer,
         len: Py_ssize_t,
         order: c_char,
@@ -268,7 +251,7 @@ extern "C" {
     #[cfg_attr(PyPy, link_name = "PyPyBuffer_FromContiguous")]
     pub fn PyBuffer_FromContiguous(
         view: *mut Py_buffer,
-        buf: *mut std::os::raw::c_void,
+        buf: *mut std::ffi::c_void,
         len: Py_ssize_t,
         order: c_char,
     ) -> c_int;
@@ -286,7 +269,7 @@ extern "C" {
     pub fn PyBuffer_FillInfo(
         view: *mut Py_buffer,
         o: *mut PyObject,
-        buf: *mut std::os::raw::c_void,
+        buf: *mut std::ffi::c_void,
         len: Py_ssize_t,
         readonly: c_int,
         flags: c_int,
@@ -308,7 +291,7 @@ pub const PY_ITERSEARCH_INDEX: c_int = 2;
 pub const PY_ITERSEARCH_CONTAINS: c_int = 3;
 
 extern "C" {
-    #[cfg(not(PyPy))]
+    #[cfg(not(any(PyPy, GraalPy)))]
     pub fn _PySequence_IterSearch(
         seq: *mut PyObject,
         obj: *mut PyObject,
diff --git a/pyo3-ffi/src/cpython/bytesobject.rs b/pyo3-ffi/src/cpython/bytesobject.rs
index 912fc0ac427..56344d35dd9 100644
--- a/pyo3-ffi/src/cpython/bytesobject.rs
+++ b/pyo3-ffi/src/cpython/bytesobject.rs
@@ -1,22 +1,34 @@
 use crate::object::*;
 use crate::Py_ssize_t;
-#[cfg(not(any(PyPy, Py_LIMITED_API)))]
-use std::os::raw::c_char;
-use std::os::raw::c_int;
+#[cfg(not(Py_LIMITED_API))]
+use std::ffi::c_char;
+use std::ffi::c_int;
 
-#[cfg(not(any(PyPy, Py_LIMITED_API)))]
+#[cfg(not(any(PyPy, GraalPy, Py_LIMITED_API)))]
 #[repr(C)]
-#[derive(Copy, Clone)]
 pub struct PyBytesObject {
     pub ob_base: PyVarObject,
+    #[cfg_attr(
+        Py_3_11,
+        deprecated(note = "Deprecated in Python 3.11 and will be removed in a future version.")
+    )]
     pub ob_shash: crate::Py_hash_t,
     pub ob_sval: [c_char; 1],
 }
 
-#[cfg(any(PyPy, Py_LIMITED_API))]
-opaque_struct!(PyBytesObject);
+#[cfg(any(PyPy, GraalPy, Py_LIMITED_API))]
+opaque_struct!(pub PyBytesObject);
 
 extern "C" {
     #[cfg_attr(PyPy, link_name = "_PyPyBytes_Resize")]
     pub fn _PyBytes_Resize(bytes: *mut *mut PyObject, newsize: Py_ssize_t) -> c_int;
 }
+
+#[cfg(not(Py_LIMITED_API))]
+#[inline]
+pub unsafe fn PyBytes_AS_STRING(op: *mut PyObject) -> *const c_char {
+    #[cfg(not(any(PyPy, GraalPy)))]
+    return &(*op.cast::<PyBytesObject>()).ob_sval as *const c_char;
+    #[cfg(any(PyPy, GraalPy))]
+    return crate::PyBytes_AsString(op);
+}
diff --git a/pyo3-ffi/src/cpython/ceval.rs b/pyo3-ffi/src/cpython/ceval.rs
index 6df10627d2e..cbec47195ec 100644
--- a/pyo3-ffi/src/cpython/ceval.rs
+++ b/pyo3-ffi/src/cpython/ceval.rs
@@ -1,6 +1,6 @@
 use crate::cpython::pystate::Py_tracefunc;
 use crate::object::{freefunc, PyObject};
-use std::os::raw::c_int;
+use std::ffi::c_int;
 
 extern "C" {
     // skipped non-limited _PyEval_CallTracing
diff --git a/pyo3-ffi/src/cpython/code.rs b/pyo3-ffi/src/cpython/code.rs
index 05f21a137b5..aa02a80adb9 100644
--- a/pyo3-ffi/src/cpython/code.rs
+++ b/pyo3-ffi/src/cpython/code.rs
@@ -1,202 +1,43 @@
 use crate::object::*;
 use crate::pyport::Py_ssize_t;
 
-#[allow(unused_imports)]
-use std::os::raw::{c_char, c_int, c_short, c_uchar, c_void};
+#[cfg(not(GraalPy))]
+use std::ffi::c_char;
+use std::ffi::{c_int, c_void};
 #[cfg(not(PyPy))]
 use std::ptr::addr_of_mut;
 
-#[cfg(all(Py_3_8, not(PyPy), not(Py_3_11)))]
-opaque_struct!(_PyOpcache);
+// skipped private _PY_MONITORING_LOCAL_EVENTS
+// skipped private _PY_MONITORING_UNGROUPED_EVENTS
+// skipped private _PY_MONITORING_EVENTS
 
-#[cfg(Py_3_12)]
-pub const _PY_MONITORING_LOCAL_EVENTS: usize = 10;
-#[cfg(Py_3_12)]
-pub const _PY_MONITORING_UNGROUPED_EVENTS: usize = 15;
-#[cfg(Py_3_12)]
-pub const _PY_MONITORING_EVENTS: usize = 17;
+// skipped private _PyLocalMonitors
+// skipped private _Py_GlobalMonitors
 
-#[cfg(Py_3_12)]
-#[repr(C)]
-#[derive(Clone, Copy)]
-pub struct _Py_LocalMonitors {
-    pub tools: [u8; _PY_MONITORING_UNGROUPED_EVENTS],
-}
-
-#[cfg(Py_3_12)]
-#[repr(C)]
-#[derive(Clone, Copy)]
-pub struct _Py_GlobalMonitors {
-    pub tools: [u8; _PY_MONITORING_UNGROUPED_EVENTS],
-}
-
-// skipped _Py_CODEUNIT
+// skipped private _Py_CODEUNIT
 
-// skipped _Py_OPCODE
-// skipped _Py_OPARG
+// skipped private _Py_OPCODE
+// skipped private _Py_OPARG
 
-// skipped _py_make_codeunit
+// skipped private _py_make_codeunit
 
-// skipped _py_set_opcode
+// skipped private _py_set_opcode
 
-// skipped _Py_MAKE_CODEUNIT
-// skipped _Py_SET_OPCODE
-
-#[cfg(Py_3_12)]
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct _PyCoCached {
-    pub _co_code: *mut PyObject,
-    pub _co_varnames: *mut PyObject,
-    pub _co_cellvars: *mut PyObject,
-    pub _co_freevars: *mut PyObject,
-}
-
-#[cfg(Py_3_12)]
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct _PyCoLineInstrumentationData {
-    pub original_opcode: u8,
-    pub line_delta: i8,
-}
-
-#[cfg(Py_3_12)]
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct _PyCoMonitoringData {
-    pub local_monitors: _Py_LocalMonitors,
-    pub active_monitors: _Py_LocalMonitors,
-    pub tools: *mut u8,
-    pub lines: *mut _PyCoLineInstrumentationData,
-    pub line_tools: *mut u8,
-    pub per_instruction_opcodes: *mut u8,
-    pub per_instruction_tools: *mut u8,
-}
-
-#[cfg(all(not(PyPy), not(Py_3_7)))]
-opaque_struct!(PyCodeObject);
-
-#[cfg(all(not(PyPy), Py_3_7, not(Py_3_8)))]
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct PyCodeObject {
-    pub ob_base: PyObject,
-    pub co_argcount: c_int,
-    pub co_kwonlyargcount: c_int,
-    pub co_nlocals: c_int,
-    pub co_stacksize: c_int,
-    pub co_flags: c_int,
-    pub co_firstlineno: c_int,
-    pub co_code: *mut PyObject,
-    pub co_consts: *mut PyObject,
-    pub co_names: *mut PyObject,
-    pub co_varnames: *mut PyObject,
-    pub co_freevars: *mut PyObject,
-    pub co_cellvars: *mut PyObject,
-    pub co_cell2arg: *mut Py_ssize_t,
-    pub co_filename: *mut PyObject,
-    pub co_name: *mut PyObject,
-    pub co_lnotab: *mut PyObject,
-    pub co_zombieframe: *mut c_void,
-    pub co_weakreflist: *mut PyObject,
-    pub co_extra: *mut c_void,
-}
-
-#[cfg(all(not(PyPy), Py_3_8, not(Py_3_11)))]
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct PyCodeObject {
-    pub ob_base: PyObject,
-    pub co_argcount: c_int,
-    pub co_posonlyargcount: c_int,
-    pub co_kwonlyargcount: c_int,
-    pub co_nlocals: c_int,
-    pub co_stacksize: c_int,
-    pub co_flags: c_int,
-    pub co_firstlineno: c_int,
-    pub co_code: *mut PyObject,
-    pub co_consts: *mut PyObject,
-    pub co_names: *mut PyObject,
-    pub co_varnames: *mut PyObject,
-    pub co_freevars: *mut PyObject,
-    pub co_cellvars: *mut PyObject,
-    pub co_cell2arg: *mut Py_ssize_t,
-    pub co_filename: *mut PyObject,
-    pub co_name: *mut PyObject,
-    #[cfg(not(Py_3_10))]
-    pub co_lnotab: *mut PyObject,
-    #[cfg(Py_3_10)]
-    pub co_linetable: *mut PyObject,
-    pub co_zombieframe: *mut c_void,
-    pub co_weakreflist: *mut PyObject,
-    pub co_extra: *mut c_void,
-    pub co_opcache_map: *mut c_uchar,
-    pub co_opcache: *mut _PyOpcache,
-    pub co_opcache_flag: c_int,
-    pub co_opcache_size: c_uchar,
-}
+// skipped private _Py_MAKE_CODEUNIT
+// skipped private _Py_SET_OPCODE
 
-#[cfg(all(not(PyPy), Py_3_11))]
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct PyCodeObject {
-    pub ob_base: PyVarObject,
-    pub co_consts: *mut PyObject,
-    pub co_names: *mut PyObject,
-    pub co_exceptiontable: *mut PyObject,
-    pub co_flags: c_int,
-    #[cfg(not(Py_3_12))]
-    pub co_warmup: c_int,
+// skipped private _PyCoCached
+// skipped private _PyCoLineInstrumentationData
+// skipped private _PyCoMontoringData
 
-    pub co_argcount: c_int,
-    pub co_posonlyargcount: c_int,
-    pub co_kwonlyargcount: c_int,
-    pub co_stacksize: c_int,
-    pub co_firstlineno: c_int,
+// skipped private _PyExecutorArray
 
-    pub co_nlocalsplus: c_int,
-    #[cfg(Py_3_12)]
-    pub co_framesize: c_int,
-    pub co_nlocals: c_int,
-    #[cfg(not(Py_3_12))]
-    pub co_nplaincellvars: c_int,
-    pub co_ncellvars: c_int,
-    pub co_nfreevars: c_int,
-    #[cfg(Py_3_12)]
-    pub co_version: u32,
-
-    pub co_localsplusnames: *mut PyObject,
-    pub co_localspluskinds: *mut PyObject,
-    pub co_filename: *mut PyObject,
-    pub co_name: *mut PyObject,
-    pub co_qualname: *mut PyObject,
-    pub co_linetable: *mut PyObject,
-    pub co_weakreflist: *mut PyObject,
-    #[cfg(not(Py_3_12))]
-    pub _co_code: *mut PyObject,
-    #[cfg(not(Py_3_12))]
-    pub _co_linearray: *mut c_char,
-    #[cfg(Py_3_12)]
-    pub _co_cached: *mut _PyCoCached,
-    #[cfg(Py_3_12)]
-    pub _co_instrumentation_version: u64,
-    #[cfg(Py_3_12)]
-    pub _co_monitoring: *mut _PyCoMonitoringData,
-    pub _co_firsttraceable: c_int,
-    pub co_extra: *mut c_void,
-    pub co_code_adaptive: [c_char; 1],
-}
-
-#[cfg(PyPy)]
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct PyCodeObject {
-    pub ob_base: PyObject,
-    pub co_name: *mut PyObject,
-    pub co_filename: *mut PyObject,
-    pub co_argcount: c_int,
-    pub co_flags: c_int,
-}
+opaque_struct!(
+    #[doc = "A Python code object.\n"]
+    #[doc = "\n"]
+    #[doc = "`pyo3-ffi` does not expose the contents of this struct, as it has no stability guarantees."]
+    pub PyCodeObject
+);
 
 /* Masks for co_flags */
 pub const CO_OPTIMIZED: c_int = 0x0001;
@@ -230,6 +71,7 @@ pub const CO_FUTURE_GENERATOR_STOP: c_int = 0x8_0000;
 
 pub const CO_MAXBLOCKS: usize = 20;
 
+#[cfg(not(PyPy))]
 #[cfg_attr(windows, link(name = "pythonXY"))]
 extern "C" {
     pub static mut PyCode_Type: PyTypeObject;
@@ -241,29 +83,16 @@ pub unsafe fn PyCode_Check(op: *mut PyObject) -> c_int {
     (Py_TYPE(op) == addr_of_mut!(PyCode_Type)) as c_int
 }
 
-#[inline]
-#[cfg(all(not(PyPy), Py_3_10, not(Py_3_11)))]
-pub unsafe fn PyCode_GetNumFree(op: *mut PyCodeObject) -> Py_ssize_t {
-    crate::PyTuple_GET_SIZE((*op).co_freevars)
-}
-
-#[inline]
-#[cfg(all(not(Py_3_10), Py_3_11, not(PyPy)))]
-pub unsafe fn PyCode_GetNumFree(op: *mut PyCodeObject) -> c_int {
-    (*op).co_nfreevars
-}
-
 extern "C" {
     #[cfg(PyPy)]
     #[link_name = "PyPyCode_Check"]
     pub fn PyCode_Check(op: *mut PyObject) -> c_int;
-
-    #[cfg(PyPy)]
-    #[link_name = "PyPyCode_GetNumFree"]
-    pub fn PyCode_GetNumFree(op: *mut PyCodeObject) -> Py_ssize_t;
 }
 
+// skipped PyCode_GetNumFree (requires knowledge of code object layout)
+
 extern "C" {
+    #[cfg(not(GraalPy))]
     #[cfg_attr(PyPy, link_name = "PyPyCode_New")]
     pub fn PyCode_New(
         argcount: c_int,
@@ -282,6 +111,7 @@ extern "C" {
         firstlineno: c_int,
         lnotab: *mut PyObject,
     ) -> *mut PyCodeObject;
+    #[cfg(not(GraalPy))]
     #[cfg(Py_3_8)]
     pub fn PyCode_NewWithPosOnlyArgs(
         argcount: c_int,
@@ -301,12 +131,14 @@ extern "C" {
         firstlineno: c_int,
         lnotab: *mut PyObject,
     ) -> *mut PyCodeObject;
+    #[cfg(not(GraalPy))]
     #[cfg_attr(PyPy, link_name = "PyPyCode_NewEmpty")]
     pub fn PyCode_NewEmpty(
         filename: *const c_char,
         funcname: *const c_char,
         firstlineno: c_int,
     ) -> *mut PyCodeObject;
+    #[cfg(not(GraalPy))]
     pub fn PyCode_Addr2Line(arg1: *mut PyCodeObject, arg2: c_int) -> c_int;
     // skipped PyCodeAddressRange "for internal use only"
     // skipped _PyCode_CheckLineNumber
diff --git a/pyo3-ffi/src/cpython/compile.rs b/pyo3-ffi/src/cpython/compile.rs
index 71af81e83e5..df0b982b147 100644
--- a/pyo3-ffi/src/cpython/compile.rs
+++ b/pyo3-ffi/src/cpython/compile.rs
@@ -6,19 +6,21 @@ use crate::pyarena::*;
 use crate::pythonrun::*;
 #[cfg(not(any(PyPy, Py_3_10)))]
 use crate::PyCodeObject;
+use crate::INT_MAX;
 #[cfg(not(any(PyPy, Py_3_10)))]
-use std::os::raw::c_char;
-use std::os::raw::c_int;
-
-// skipped non-limited PyCF_MASK
-// skipped non-limited PyCF_MASK_OBSOLETE
-// skipped non-limited PyCF_SOURCE_IS_UTF8
-// skipped non-limited PyCF_DONT_IMPLY_DEDENT
-// skipped non-limited PyCF_ONLY_AST
-// skipped non-limited PyCF_IGNORE_COOKIE
-// skipped non-limited PyCF_TYPE_COMMENTS
-// skipped non-limited PyCF_ALLOW_TOP_LEVEL_AWAIT
-// skipped non-limited PyCF_COMPILE_MASK
+use std::ffi::c_char;
+use std::ffi::c_int;
+
+// skipped PyCF_MASK
+// skipped PyCF_MASK_OBSOLETE
+// skipped PyCF_SOURCE_IS_UTF8
+// skipped PyCF_DONT_IMPLY_DEDENT
+// skipped PyCF_ONLY_AST
+// skipped PyCF_IGNORE_COOKIE
+// skipped PyCF_TYPE_COMMENTS
+// skipped PyCF_ALLOW_TOP_LEVEL_AWAIT
+// skipped PyCF_OPTIMIZED_AST
+// skipped PyCF_COMPILE_MASK
 
 #[repr(C)]
 #[derive(Copy, Clone)]
@@ -28,31 +30,23 @@ pub struct PyCompilerFlags {
     pub cf_feature_version: c_int,
 }
 
-// skipped non-limited _PyCompilerFlags_INIT
-
-#[cfg(all(Py_3_12, not(PyPy)))]
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct _PyCompilerSrcLocation {
-    pub lineno: c_int,
-    pub end_lineno: c_int,
-    pub col_offset: c_int,
-    pub end_col_offset: c_int,
-}
-
-// skipped SRC_LOCATION_FROM_AST
+// skipped _PyCompilerFlags_INIT
 
-#[cfg(not(PyPy))]
+// NB this type technically existed in the header until 3.13, when it was
+// moved to the internal CPython headers.
+//
+// We choose not to expose it in the public API past 3.10, as it is
+// not used in the public API past that point.
+#[cfg(not(any(PyPy, GraalPy, Py_3_10)))]
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct PyFutureFeatures {
     pub ff_features: c_int,
-    #[cfg(not(Py_3_12))]
     pub ff_lineno: c_int,
-    #[cfg(Py_3_12)]
-    pub ff_location: _PyCompilerSrcLocation,
 }
 
+// FIXME: these constants should probably be &CStr, if they are used at all
+
 pub const FUTURE_NESTED_SCOPES: &str = "nested_scopes";
 pub const FUTURE_GENERATORS: &str = "generators";
 pub const FUTURE_DIVISION: &str = "division";
@@ -62,13 +56,12 @@ pub const FUTURE_PRINT_FUNCTION: &str = "print_function";
 pub const FUTURE_UNICODE_LITERALS: &str = "unicode_literals";
 pub const FUTURE_BARRY_AS_BDFL: &str = "barry_as_FLUFL";
 pub const FUTURE_GENERATOR_STOP: &str = "generator_stop";
-// skipped non-limited FUTURE_ANNOTATIONS
+pub const FUTURE_ANNOTATIONS: &str = "annotations";
 
+#[cfg(not(any(PyPy, GraalPy, Py_3_10)))]
 extern "C" {
-    #[cfg(not(any(PyPy, Py_3_10)))]
     pub fn PyNode_Compile(arg1: *mut _node, arg2: *const c_char) -> *mut PyCodeObject;
 
-    #[cfg(not(any(PyPy, Py_3_10)))]
     pub fn PyAST_CompileEx(
         _mod: *mut _mod,
         filename: *const c_char,
@@ -77,7 +70,6 @@ extern "C" {
         arena: *mut PyArena,
     ) -> *mut PyCodeObject;
 
-    #[cfg(not(any(PyPy, Py_3_10)))]
     pub fn PyAST_CompileObject(
         _mod: *mut _mod,
         filename: *mut PyObject,
@@ -86,23 +78,20 @@ extern "C" {
         arena: *mut PyArena,
     ) -> *mut PyCodeObject;
 
-    #[cfg(not(any(PyPy, Py_3_10)))]
     pub fn PyFuture_FromAST(_mod: *mut _mod, filename: *const c_char) -> *mut PyFutureFeatures;
 
-    #[cfg(not(any(PyPy, Py_3_10)))]
     pub fn PyFuture_FromASTObject(
         _mod: *mut _mod,
         filename: *mut PyObject,
     ) -> *mut PyFutureFeatures;
+}
 
-    // skipped non-limited _Py_Mangle
-    // skipped non-limited PY_INVALID_STACK_EFFECT
+pub const PY_INVALID_STACK_EFFECT: c_int = INT_MAX;
+
+extern "C" {
 
     pub fn PyCompile_OpcodeStackEffect(opcode: c_int, oparg: c_int) -> c_int;
 
     #[cfg(Py_3_8)]
     pub fn PyCompile_OpcodeStackEffectWithJump(opcode: c_int, oparg: c_int, jump: c_int) -> c_int;
-
-    // skipped non-limited _PyASTOptimizeState
-    // skipped non-limited _PyAST_Optimize
 }
diff --git a/pyo3-ffi/src/cpython/complexobject.rs b/pyo3-ffi/src/cpython/complexobject.rs
new file mode 100644
index 00000000000..3283fc4e52f
--- /dev/null
+++ b/pyo3-ffi/src/cpython/complexobject.rs
@@ -0,0 +1,30 @@
+use crate::PyObject;
+use std::ffi::c_double;
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct Py_complex {
+    pub real: c_double,
+    pub imag: c_double,
+}
+
+// skipped private function _Py_c_sum
+// skipped private function _Py_c_diff
+// skipped private function _Py_c_neg
+// skipped private function _Py_c_prod
+// skipped private function _Py_c_quot
+// skipped private function _Py_c_pow
+// skipped private function _Py_c_abs
+
+#[repr(C)]
+pub struct PyComplexObject {
+    pub ob_base: PyObject,
+    pub cval: Py_complex,
+}
+
+extern "C" {
+    #[cfg_attr(PyPy, link_name = "PyPyComplex_FromCComplex")]
+    pub fn PyComplex_FromCComplex(v: Py_complex) -> *mut PyObject;
+    #[cfg_attr(PyPy, link_name = "PyPyComplex_AsCComplex")]
+    pub fn PyComplex_AsCComplex(op: *mut PyObject) -> Py_complex;
+}
diff --git a/pyo3-ffi/src/cpython/critical_section.rs b/pyo3-ffi/src/cpython/critical_section.rs
new file mode 100644
index 00000000000..808dba870c6
--- /dev/null
+++ b/pyo3-ffi/src/cpython/critical_section.rs
@@ -0,0 +1,30 @@
+#[cfg(Py_GIL_DISABLED)]
+use crate::PyMutex;
+use crate::PyObject;
+
+#[repr(C)]
+#[cfg(Py_GIL_DISABLED)]
+pub struct PyCriticalSection {
+    _cs_prev: usize,
+    _cs_mutex: *mut PyMutex,
+}
+
+#[repr(C)]
+#[cfg(Py_GIL_DISABLED)]
+pub struct PyCriticalSection2 {
+    _cs_base: PyCriticalSection,
+    _cs_mutex2: *mut PyMutex,
+}
+
+#[cfg(not(Py_GIL_DISABLED))]
+opaque_struct!(pub PyCriticalSection);
+
+#[cfg(not(Py_GIL_DISABLED))]
+opaque_struct!(pub PyCriticalSection2);
+
+extern "C" {
+    pub fn PyCriticalSection_Begin(c: *mut PyCriticalSection, op: *mut PyObject);
+    pub fn PyCriticalSection_End(c: *mut PyCriticalSection);
+    pub fn PyCriticalSection2_Begin(c: *mut PyCriticalSection2, a: *mut PyObject, b: *mut PyObject);
+    pub fn PyCriticalSection2_End(c: *mut PyCriticalSection2);
+}
diff --git a/pyo3-ffi/src/cpython/descrobject.rs b/pyo3-ffi/src/cpython/descrobject.rs
index 1b5ee466c8e..03d64789fa7 100644
--- a/pyo3-ffi/src/cpython/descrobject.rs
+++ b/pyo3-ffi/src/cpython/descrobject.rs
@@ -1,5 +1,5 @@
 use crate::{PyGetSetDef, PyMethodDef, PyObject, PyTypeObject};
-use std::os::raw::{c_char, c_int, c_void};
+use std::ffi::{c_char, c_int, c_void};
 
 pub type wrapperfunc = Option<
     unsafe extern "C" fn(
@@ -69,10 +69,7 @@ pub struct PyWrapperDescrObject {
     pub d_wrapped: *mut c_void,
 }
 
-#[cfg_attr(windows, link(name = "pythonXY"))]
-extern "C" {
-    pub static mut _PyMethodWrapper_Type: PyTypeObject;
-}
+// skipped _PyMethodWrapper_Type
 
 // skipped non-limited PyDescr_NewWrapper
 // skipped non-limited PyDescr_IsData
diff --git a/pyo3-ffi/src/cpython/dictobject.rs b/pyo3-ffi/src/cpython/dictobject.rs
index 4af990a2d9a..0ee90b53fc6 100644
--- a/pyo3-ffi/src/cpython/dictobject.rs
+++ b/pyo3-ffi/src/cpython/dictobject.rs
@@ -1,18 +1,26 @@
 use crate::object::*;
 use crate::pyport::Py_ssize_t;
-use std::os::raw::c_int;
+use std::ffi::c_int;
 
-opaque_struct!(PyDictKeysObject);
+opaque_struct!(pub PyDictKeysObject);
 
 #[cfg(Py_3_11)]
-opaque_struct!(PyDictValues);
+opaque_struct!(pub PyDictValues);
 
+#[cfg(not(GraalPy))]
 #[repr(C)]
 #[derive(Debug)]
 pub struct PyDictObject {
     pub ob_base: PyObject,
     pub ma_used: Py_ssize_t,
+    #[cfg_attr(
+        Py_3_12,
+        deprecated(note = "Deprecated in Python 3.12 and will be removed in the future.")
+    )]
+    #[cfg(not(Py_3_14))]
     pub ma_version_tag: u64,
+    #[cfg(Py_3_14)]
+    _ma_watcher_tag: u64,
     pub ma_keys: *mut PyDictKeysObject,
     #[cfg(not(Py_3_11))]
     pub ma_values: *mut *mut PyObject,
diff --git a/pyo3-ffi/src/cpython/floatobject.rs b/pyo3-ffi/src/cpython/floatobject.rs
index e33da0b91b9..4b9ef1a2484 100644
--- a/pyo3-ffi/src/cpython/floatobject.rs
+++ b/pyo3-ffi/src/cpython/floatobject.rs
@@ -1,5 +1,7 @@
+#[cfg(GraalPy)]
+use crate::PyFloat_AsDouble;
 use crate::{PyFloat_Check, PyObject};
-use std::os::raw::c_double;
+use std::ffi::c_double;
 
 #[repr(C)]
 pub struct PyFloatObject {
@@ -15,7 +17,10 @@ pub unsafe fn _PyFloat_CAST(op: *mut PyObject) -> *mut PyFloatObject {
 
 #[inline]
 pub unsafe fn PyFloat_AS_DOUBLE(op: *mut PyObject) -> c_double {
-    (*_PyFloat_CAST(op)).ob_fval
+    #[cfg(not(GraalPy))]
+    return (*_PyFloat_CAST(op)).ob_fval;
+    #[cfg(GraalPy)]
+    return PyFloat_AsDouble(op);
 }
 
 // skipped PyFloat_Pack2
diff --git a/pyo3-ffi/src/cpython/frameobject.rs b/pyo3-ffi/src/cpython/frameobject.rs
index 7410000ef45..5bd9a620f19 100644
--- a/pyo3-ffi/src/cpython/frameobject.rs
+++ b/pyo3-ffi/src/cpython/frameobject.rs
@@ -1,74 +1,32 @@
+#[cfg(not(GraalPy))]
 use crate::cpython::code::PyCodeObject;
+#[cfg(not(GraalPy))]
 use crate::object::*;
+#[cfg(not(GraalPy))]
 use crate::pystate::PyThreadState;
-#[cfg(not(any(PyPy, Py_3_11)))]
-use std::os::raw::c_char;
-use std::os::raw::c_int;
-use std::ptr::addr_of_mut;
+use crate::PyFrameObject;
+#[cfg(not(any(PyPy, GraalPy, Py_3_11)))]
+use std::ffi::c_char;
+use std::ffi::c_int;
 
-#[cfg(not(any(PyPy, Py_3_11)))]
+#[cfg(not(any(PyPy, GraalPy, Py_3_11)))]
 pub type PyFrameState = c_char;
 
 #[repr(C)]
 #[derive(Copy, Clone)]
-#[cfg(not(any(PyPy, Py_3_11)))]
+#[cfg(not(any(PyPy, GraalPy, Py_3_11)))]
 pub struct PyTryBlock {
     pub b_type: c_int,
     pub b_handler: c_int,
     pub b_level: c_int,
 }
 
-#[repr(C)]
-#[derive(Copy, Clone)]
-#[cfg(not(any(PyPy, Py_3_11)))]
-pub struct PyFrameObject {
-    pub ob_base: PyVarObject,
-    pub f_back: *mut PyFrameObject,
-    pub f_code: *mut PyCodeObject,
-    pub f_builtins: *mut PyObject,
-    pub f_globals: *mut PyObject,
-    pub f_locals: *mut PyObject,
-    pub f_valuestack: *mut *mut PyObject,
-
-    #[cfg(not(Py_3_10))]
-    pub f_stacktop: *mut *mut PyObject,
-    pub f_trace: *mut PyObject,
-    #[cfg(Py_3_10)]
-    pub f_stackdepth: c_int,
-    pub f_trace_lines: c_char,
-    pub f_trace_opcodes: c_char,
-
-    pub f_gen: *mut PyObject,
-
-    pub f_lasti: c_int,
-    pub f_lineno: c_int,
-    pub f_iblock: c_int,
-    #[cfg(not(Py_3_10))]
-    pub f_executing: c_char,
-    #[cfg(Py_3_10)]
-    pub f_state: PyFrameState,
-    pub f_blockstack: [PyTryBlock; crate::CO_MAXBLOCKS],
-    pub f_localsplus: [*mut PyObject; 1],
-}
-
-#[cfg(any(PyPy, Py_3_11))]
-opaque_struct!(PyFrameObject);
-
 // skipped _PyFrame_IsRunnable
 // skipped _PyFrame_IsExecuting
 // skipped _PyFrameHasCompleted
 
-#[cfg_attr(windows, link(name = "pythonXY"))]
-extern "C" {
-    pub static mut PyFrame_Type: PyTypeObject;
-}
-
-#[inline]
-pub unsafe fn PyFrame_Check(op: *mut PyObject) -> c_int {
-    (Py_TYPE(op) == addr_of_mut!(PyFrame_Type)) as c_int
-}
-
 extern "C" {
+    #[cfg(not(GraalPy))]
     #[cfg_attr(PyPy, link_name = "PyPyFrame_New")]
     pub fn PyFrame_New(
         tstate: *mut PyThreadState,
@@ -79,7 +37,7 @@ extern "C" {
     // skipped _PyFrame_New_NoTrack
 
     pub fn PyFrame_BlockSetup(f: *mut PyFrameObject, _type: c_int, handler: c_int, level: c_int);
-    #[cfg(not(any(PyPy, Py_3_11)))]
+    #[cfg(not(any(PyPy, GraalPy, Py_3_11)))]
     pub fn PyFrame_BlockPop(f: *mut PyFrameObject) -> *mut PyTryBlock;
 
     pub fn PyFrame_LocalsToFast(f: *mut PyFrameObject, clear: c_int);
@@ -87,7 +45,6 @@ extern "C" {
     pub fn PyFrame_FastToLocals(f: *mut PyFrameObject);
 
     // skipped _PyFrame_DebugMallocStats
-    // skipped PyFrame_GetBack
 
     #[cfg(not(Py_3_9))]
     pub fn PyFrame_ClearFreeList() -> c_int;
diff --git a/pyo3-ffi/src/cpython/funcobject.rs b/pyo3-ffi/src/cpython/funcobject.rs
index 1e9ee0cc18c..7a242e85abd 100644
--- a/pyo3-ffi/src/cpython/funcobject.rs
+++ b/pyo3-ffi/src/cpython/funcobject.rs
@@ -1,10 +1,10 @@
-use std::os::raw::c_int;
+use std::ffi::c_int;
 #[cfg(not(all(PyPy, not(Py_3_8))))]
 use std::ptr::addr_of_mut;
 
 use crate::PyObject;
 
-#[cfg(all(not(PyPy), not(Py_3_10)))]
+#[cfg(all(not(any(PyPy, GraalPy)), not(Py_3_10)))]
 #[repr(C)]
 pub struct PyFunctionObject {
     pub ob_base: PyObject,
@@ -24,7 +24,7 @@ pub struct PyFunctionObject {
     pub vectorcall: Option<crate::vectorcallfunc>,
 }
 
-#[cfg(all(not(PyPy), Py_3_10))]
+#[cfg(all(not(any(PyPy, GraalPy)), Py_3_10))]
 #[repr(C)]
 pub struct PyFunctionObject {
     pub ob_base: PyObject,
@@ -41,6 +41,8 @@ pub struct PyFunctionObject {
     pub func_weakreflist: *mut PyObject,
     pub func_module: *mut PyObject,
     pub func_annotations: *mut PyObject,
+    #[cfg(Py_3_14)]
+    pub func_annotate: *mut PyObject,
     #[cfg(Py_3_12)]
     pub func_typeparams: *mut PyObject,
     pub vectorcall: Option<crate::vectorcallfunc>,
@@ -55,6 +57,11 @@ pub struct PyFunctionObject {
     pub func_name: *mut PyObject,
 }
 
+#[cfg(GraalPy)]
+pub struct PyFunctionObject {
+    pub ob_base: PyObject,
+}
+
 #[cfg_attr(windows, link(name = "pythonXY"))]
 extern "C" {
     #[cfg(not(all(PyPy, not(Py_3_8))))]
diff --git a/pyo3-ffi/src/cpython/genobject.rs b/pyo3-ffi/src/cpython/genobject.rs
index aaa03f82eef..680a261c0de 100644
--- a/pyo3-ffi/src/cpython/genobject.rs
+++ b/pyo3-ffi/src/cpython/genobject.rs
@@ -1,15 +1,12 @@
 use crate::object::*;
 use crate::PyFrameObject;
-#[cfg(not(PyPy))]
-use crate::_PyErr_StackItem;
-#[cfg(Py_3_11)]
-use std::os::raw::c_char;
-use std::os::raw::c_int;
+#[cfg(all(Py_3_11, not(any(PyPy, GraalPy, Py_3_14))))]
+use std::ffi::c_char;
+use std::ffi::c_int;
 use std::ptr::addr_of_mut;
 
-#[cfg(not(PyPy))]
+#[cfg(not(any(PyPy, GraalPy, Py_3_14)))]
 #[repr(C)]
-#[derive(Copy, Clone)]
 pub struct PyGenObject {
     pub ob_base: PyObject,
     #[cfg(not(Py_3_11))]
@@ -21,7 +18,8 @@ pub struct PyGenObject {
     pub gi_weakreflist: *mut PyObject,
     pub gi_name: *mut PyObject,
     pub gi_qualname: *mut PyObject,
-    pub gi_exc_state: _PyErr_StackItem,
+    #[allow(private_interfaces)]
+    pub gi_exc_state: crate::cpython::pystate::_PyErr_StackItem,
     #[cfg(Py_3_11)]
     pub gi_origin_or_finalizer: *mut PyObject,
     #[cfg(Py_3_11)]
@@ -36,6 +34,9 @@ pub struct PyGenObject {
     pub gi_iframe: [*mut PyObject; 1],
 }
 
+#[cfg(all(Py_3_14, not(any(PyPy, GraalPy))))]
+opaque_struct!(pub PyGenObject);
+
 #[cfg_attr(windows, link(name = "pythonXY"))]
 extern "C" {
     pub static mut PyGen_Type: PyTypeObject;
@@ -68,9 +69,10 @@ extern "C" {
 #[cfg_attr(windows, link(name = "pythonXY"))]
 extern "C" {
     pub static mut PyCoro_Type: PyTypeObject;
-    pub static mut _PyCoroWrapper_Type: PyTypeObject;
 }
 
+// skipped _PyCoroWrapper_Type
+
 #[inline]
 pub unsafe fn PyCoro_CheckExact(op: *mut PyObject) -> c_int {
     PyObject_TypeCheck(op, addr_of_mut!(PyCoro_Type))
diff --git a/pyo3-ffi/src/cpython/import.rs b/pyo3-ffi/src/cpython/import.rs
index aafd71a8355..3b9374f68e3 100644
--- a/pyo3-ffi/src/cpython/import.rs
+++ b/pyo3-ffi/src/cpython/import.rs
@@ -1,7 +1,7 @@
 use crate::{PyInterpreterState, PyObject};
 #[cfg(not(PyPy))]
-use std::os::raw::c_uchar;
-use std::os::raw::{c_char, c_int};
+use std::ffi::c_uchar;
+use std::ffi::{c_char, c_int};
 
 // skipped PyInit__imp
 
@@ -57,7 +57,7 @@ pub struct _frozen {
     pub size: c_int,
     #[cfg(Py_3_11)]
     pub is_package: c_int,
-    #[cfg(Py_3_11)]
+    #[cfg(all(Py_3_11, not(Py_3_13)))]
     pub get_code: Option<unsafe extern "C" fn() -> *mut PyObject>,
 }
 
@@ -65,10 +65,8 @@ pub struct _frozen {
 extern "C" {
     #[cfg(not(PyPy))]
     pub static mut PyImport_FrozenModules: *const _frozen;
-    #[cfg(all(not(PyPy), Py_3_11))]
-    pub static mut _PyImport_FrozenBootstrap: *const _frozen;
-    #[cfg(all(not(PyPy), Py_3_11))]
-    pub static mut _PyImport_FrozenStdlib: *const _frozen;
-    #[cfg(all(not(PyPy), Py_3_11))]
-    pub static mut _PyImport_FrozenTest: *const _frozen;
 }
+
+// skipped _PyImport_FrozenBootstrap
+// skipped _PyImport_FrozenStdlib
+// skipped _PyImport_FrozenTest
diff --git a/pyo3-ffi/src/cpython/initconfig.rs b/pyo3-ffi/src/cpython/initconfig.rs
index 17fe7559e1b..6b0ae2e5dec 100644
--- a/pyo3-ffi/src/cpython/initconfig.rs
+++ b/pyo3-ffi/src/cpython/initconfig.rs
@@ -2,7 +2,7 @@
 
 use crate::Py_ssize_t;
 use libc::wchar_t;
-use std::os::raw::{c_char, c_int, c_ulong};
+use std::ffi::{c_char, c_int, c_ulong};
 
 #[repr(C)]
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
@@ -93,6 +93,8 @@ pub struct PyConfig {
     pub tracemalloc: c_int,
     #[cfg(Py_3_12)]
     pub perf_profiling: c_int,
+    #[cfg(Py_3_14)]
+    pub remote_debug: c_int,
     pub import_time: c_int,
     #[cfg(Py_3_11)]
     pub code_debug_ranges: c_int,
@@ -141,6 +143,18 @@ pub struct PyConfig {
     pub safe_path: c_int,
     #[cfg(Py_3_12)]
     pub int_max_str_digits: c_int,
+    #[cfg(Py_3_14)]
+    pub thread_inherit_context: c_int,
+    #[cfg(Py_3_14)]
+    pub context_aware_warnings: c_int,
+    #[cfg(all(Py_3_14, target_os = "macos"))]
+    pub use_system_logger: c_int,
+    #[cfg(Py_3_13)]
+    pub cpu_count: c_int,
+    #[cfg(Py_GIL_DISABLED)]
+    pub enable_gil: c_int,
+    #[cfg(all(Py_3_14, Py_GIL_DISABLED))]
+    pub tlbc_enabled: c_int,
     pub pathconfig_warnings: c_int,
     #[cfg(Py_3_10)]
     pub program_name: *mut wchar_t,
@@ -165,6 +179,8 @@ pub struct PyConfig {
     pub run_command: *mut wchar_t,
     pub run_module: *mut wchar_t,
     pub run_filename: *mut wchar_t,
+    #[cfg(Py_3_13)]
+    pub sys_path_0: *mut wchar_t,
     pub _install_importlib: c_int,
     pub _init_main: c_int,
     #[cfg(all(Py_3_9, not(Py_3_12)))]
@@ -173,6 +189,8 @@ pub struct PyConfig {
     pub _is_python_build: c_int,
     #[cfg(all(Py_3_9, not(Py_3_10)))]
     pub _orig_argv: PyWideStringList,
+    #[cfg(all(Py_3_13, py_sys_config = "Py_DEBUG"))]
+    pub run_presite: *mut wchar_t,
 }
 
 extern "C" {
diff --git a/pyo3-ffi/src/cpython/listobject.rs b/pyo3-ffi/src/cpython/listobject.rs
index 7fb2228fadd..694e6bc4290 100644
--- a/pyo3-ffi/src/cpython/listobject.rs
+++ b/pyo3-ffi/src/cpython/listobject.rs
@@ -4,7 +4,6 @@ use crate::pyport::Py_ssize_t;
 
 #[cfg(not(PyPy))]
 #[repr(C)]
-#[derive(Copy, Clone)]
 pub struct PyListObject {
     pub ob_base: PyVarObject,
     pub ob_item: *mut *mut PyObject,
@@ -22,14 +21,14 @@ pub struct PyListObject {
 
 /// Macro, trading safety for speed
 #[inline]
-#[cfg(not(PyPy))]
+#[cfg(not(any(PyPy, GraalPy)))]
 pub unsafe fn PyList_GET_ITEM(op: *mut PyObject, i: Py_ssize_t) -> *mut PyObject {
     *(*(op as *mut PyListObject)).ob_item.offset(i)
 }
 
 /// Macro, *only* to be used to fill in brand new lists
 #[inline]
-#[cfg(not(PyPy))]
+#[cfg(not(any(PyPy, GraalPy)))]
 pub unsafe fn PyList_SET_ITEM(op: *mut PyObject, i: Py_ssize_t, v: *mut PyObject) {
     *(*(op as *mut PyListObject)).ob_item.offset(i) = v;
 }
diff --git a/pyo3-ffi/src/cpython/lock.rs b/pyo3-ffi/src/cpython/lock.rs
new file mode 100644
index 00000000000..487173f9afb
--- /dev/null
+++ b/pyo3-ffi/src/cpython/lock.rs
@@ -0,0 +1,26 @@
+#[cfg(Py_3_14)]
+use std::os::raw::c_int;
+use std::sync::atomic::AtomicU8;
+
+#[repr(transparent)]
+#[derive(Debug)]
+pub struct PyMutex {
+    pub(crate) _bits: AtomicU8,
+}
+
+// we don't impl Default because PyO3's safe wrappers don't need it
+#[allow(clippy::new_without_default)]
+impl PyMutex {
+    pub const fn new() -> PyMutex {
+        PyMutex {
+            _bits: AtomicU8::new(0),
+        }
+    }
+}
+
+extern "C" {
+    pub fn PyMutex_Lock(m: *mut PyMutex);
+    pub fn PyMutex_Unlock(m: *mut PyMutex);
+    #[cfg(Py_3_14)]
+    pub fn PyMutex_IsLocked(m: *mut PyMutex) -> c_int;
+}
diff --git a/pyo3-ffi/src/cpython/longobject.rs b/pyo3-ffi/src/cpython/longobject.rs
new file mode 100644
index 00000000000..a778d8c26d2
--- /dev/null
+++ b/pyo3-ffi/src/cpython/longobject.rs
@@ -0,0 +1,74 @@
+use crate::longobject::*;
+use crate::object::*;
+#[cfg(Py_3_13)]
+use crate::pyport::Py_ssize_t;
+use libc::size_t;
+#[cfg(Py_3_13)]
+use std::ffi::c_void;
+use std::ffi::{c_int, c_uchar};
+
+#[cfg(Py_3_13)]
+extern "C" {
+    pub fn PyLong_FromUnicodeObject(u: *mut PyObject, base: c_int) -> *mut PyObject;
+}
+
+#[cfg(Py_3_13)]
+pub const Py_ASNATIVEBYTES_DEFAULTS: c_int = -1;
+#[cfg(Py_3_13)]
+pub const Py_ASNATIVEBYTES_BIG_ENDIAN: c_int = 0;
+#[cfg(Py_3_13)]
+pub const Py_ASNATIVEBYTES_LITTLE_ENDIAN: c_int = 1;
+#[cfg(Py_3_13)]
+pub const Py_ASNATIVEBYTES_NATIVE_ENDIAN: c_int = 3;
+#[cfg(Py_3_13)]
+pub const Py_ASNATIVEBYTES_UNSIGNED_BUFFER: c_int = 4;
+#[cfg(Py_3_13)]
+pub const Py_ASNATIVEBYTES_REJECT_NEGATIVE: c_int = 8;
+
+extern "C" {
+    // skipped _PyLong_Sign
+
+    #[cfg(Py_3_13)]
+    pub fn PyLong_AsNativeBytes(
+        v: *mut PyObject,
+        buffer: *mut c_void,
+        n_bytes: Py_ssize_t,
+        flags: c_int,
+    ) -> Py_ssize_t;
+
+    #[cfg(Py_3_13)]
+    pub fn PyLong_FromNativeBytes(
+        buffer: *const c_void,
+        n_bytes: size_t,
+        flags: c_int,
+    ) -> *mut PyObject;
+
+    #[cfg(Py_3_13)]
+    pub fn PyLong_FromUnsignedNativeBytes(
+        buffer: *const c_void,
+        n_bytes: size_t,
+        flags: c_int,
+    ) -> *mut PyObject;
+
+    // skipped PyUnstable_Long_IsCompact
+    // skipped PyUnstable_Long_CompactValue
+
+    #[cfg_attr(PyPy, link_name = "_PyPyLong_FromByteArray")]
+    pub fn _PyLong_FromByteArray(
+        bytes: *const c_uchar,
+        n: size_t,
+        little_endian: c_int,
+        is_signed: c_int,
+    ) -> *mut PyObject;
+
+    #[cfg_attr(PyPy, link_name = "_PyPyLong_AsByteArrayO")]
+    pub fn _PyLong_AsByteArray(
+        v: *mut PyLongObject,
+        bytes: *mut c_uchar,
+        n: size_t,
+        little_endian: c_int,
+        is_signed: c_int,
+    ) -> c_int;
+
+    // skipped _PyLong_GCD
+}
diff --git a/pyo3-ffi/src/cpython/methodobject.rs b/pyo3-ffi/src/cpython/methodobject.rs
index 7d9659785ba..096bb02ae13 100644
--- a/pyo3-ffi/src/cpython/methodobject.rs
+++ b/pyo3-ffi/src/cpython/methodobject.rs
@@ -1,8 +1,10 @@
 use crate::object::*;
+#[cfg(not(GraalPy))]
 use crate::{PyCFunctionObject, PyMethodDefPointer, METH_METHOD, METH_STATIC};
-use std::os::raw::c_int;
+use std::ffi::c_int;
 use std::ptr::addr_of_mut;
 
+#[cfg(not(GraalPy))]
 pub struct PyCMethodObject {
     pub func: PyCFunctionObject,
     pub mm_class: *mut PyTypeObject,
@@ -23,6 +25,7 @@ pub unsafe fn PyCMethod_Check(op: *mut PyObject) -> c_int {
     PyObject_TypeCheck(op, addr_of_mut!(PyCMethod_Type))
 }
 
+#[cfg(not(GraalPy))]
 #[inline]
 pub unsafe fn PyCFunction_GET_FUNCTION(func: *mut PyObject) -> PyMethodDefPointer {
     debug_assert_eq!(PyCMethod_Check(func), 1);
@@ -31,6 +34,7 @@ pub unsafe fn PyCFunction_GET_FUNCTION(func: *mut PyObject) -> PyMethodDefPointe
     (*(*func).m_ml).ml_meth
 }
 
+#[cfg(not(GraalPy))]
 #[inline]
 pub unsafe fn PyCFunction_GET_SELF(func: *mut PyObject) -> *mut PyObject {
     debug_assert_eq!(PyCMethod_Check(func), 1);
@@ -43,6 +47,7 @@ pub unsafe fn PyCFunction_GET_SELF(func: *mut PyObject) -> *mut PyObject {
     }
 }
 
+#[cfg(not(GraalPy))]
 #[inline]
 pub unsafe fn PyCFunction_GET_FLAGS(func: *mut PyObject) -> c_int {
     debug_assert_eq!(PyCMethod_Check(func), 1);
@@ -51,6 +56,7 @@ pub unsafe fn PyCFunction_GET_FLAGS(func: *mut PyObject) -> c_int {
     (*(*func).m_ml).ml_flags
 }
 
+#[cfg(not(GraalPy))]
 #[inline]
 pub unsafe fn PyCFunction_GET_CLASS(func: *mut PyObject) -> *mut PyTypeObject {
     debug_assert_eq!(PyCMethod_Check(func), 1);
diff --git a/pyo3-ffi/src/cpython/mod.rs b/pyo3-ffi/src/cpython/mod.rs
index 738ba37652e..d2b2274628b 100644
--- a/pyo3-ffi/src/cpython/mod.rs
+++ b/pyo3-ffi/src/cpython/mod.rs
@@ -5,6 +5,9 @@ pub(crate) mod bytesobject;
 pub(crate) mod ceval;
 pub(crate) mod code;
 pub(crate) mod compile;
+pub(crate) mod complexobject;
+#[cfg(Py_3_13)]
+pub(crate) mod critical_section;
 pub(crate) mod descrobject;
 #[cfg(not(PyPy))]
 pub(crate) mod dictobject;
@@ -18,6 +21,9 @@ pub(crate) mod import;
 pub(crate) mod initconfig;
 // skipped interpreteridobject.h
 pub(crate) mod listobject;
+#[cfg(Py_3_13)]
+pub(crate) mod lock;
+pub(crate) mod longobject;
 #[cfg(all(Py_3_9, not(PyPy)))]
 pub(crate) mod methodobject;
 pub(crate) mod object;
@@ -32,6 +38,7 @@ pub(crate) mod pythonrun;
 // skipped sysmodule.h
 pub(crate) mod floatobject;
 pub(crate) mod pyframe;
+pub(crate) mod pyhash;
 pub(crate) mod tupleobject;
 pub(crate) mod unicodeobject;
 pub(crate) mod weakrefobject;
@@ -42,6 +49,9 @@ pub use self::bytesobject::*;
 pub use self::ceval::*;
 pub use self::code::*;
 pub use self::compile::*;
+pub use self::complexobject::*;
+#[cfg(Py_3_13)]
+pub use self::critical_section::*;
 pub use self::descrobject::*;
 #[cfg(not(PyPy))]
 pub use self::dictobject::*;
@@ -53,14 +63,18 @@ pub use self::import::*;
 #[cfg(all(Py_3_8, not(PyPy)))]
 pub use self::initconfig::*;
 pub use self::listobject::*;
+#[cfg(Py_3_13)]
+pub use self::lock::*;
+pub use self::longobject::*;
 #[cfg(all(Py_3_9, not(PyPy)))]
 pub use self::methodobject::*;
 pub use self::object::*;
 pub use self::objimpl::*;
 pub use self::pydebug::*;
 pub use self::pyerrors::*;
-#[cfg(Py_3_11)]
 pub use self::pyframe::*;
+#[cfg(any(not(PyPy), Py_3_13))]
+pub use self::pyhash::*;
 #[cfg(all(Py_3_8, not(PyPy)))]
 pub use self::pylifecycle::*;
 pub use self::pymem::*;
@@ -68,5 +82,5 @@ pub use self::pystate::*;
 pub use self::pythonrun::*;
 pub use self::tupleobject::*;
 pub use self::unicodeobject::*;
-#[cfg(not(PyPy))]
+#[cfg(not(any(PyPy, GraalPy)))]
 pub use self::weakrefobject::*;
diff --git a/pyo3-ffi/src/cpython/object.rs b/pyo3-ffi/src/cpython/object.rs
index 161fb50cf24..9230a1f65e8 100644
--- a/pyo3-ffi/src/cpython/object.rs
+++ b/pyo3-ffi/src/cpython/object.rs
@@ -1,25 +1,28 @@
 #[cfg(Py_3_8)]
 use crate::vectorcallfunc;
-#[cfg(Py_3_11)]
-use crate::PyModuleDef;
 use crate::{object, PyGetSetDef, PyMemberDef, PyMethodDef, PyObject, Py_ssize_t};
+use std::ffi::{c_char, c_int, c_uint, c_void};
 use std::mem;
-use std::os::raw::{c_char, c_int, c_uint, c_ulong, c_void};
 
-// skipped _Py_NewReference
-// skipped _Py_ForgetReference
-// skipped _Py_GetRefTotal
+// skipped private _Py_NewReference
+// skipped private _Py_NewReferenceNoTotal
+// skipped private _Py_ResurrectReference
+
+// skipped private _Py_GetGlobalRefTotal
+// skipped private _Py_GetRefTotal
+// skipped private _Py_GetLegacyRefTotal
+// skipped private _PyInterpreterState_GetRefTotal
 
-// skipped _Py_Identifier
+// skipped private _Py_Identifier
 
-// skipped _Py_static_string_init
-// skipped _Py_static_string
-// skipped _Py_IDENTIFIER
+// skipped private _Py_static_string_init
+// skipped private _Py_static_string
+// skipped private _Py_IDENTIFIER
 
 #[cfg(not(Py_3_11))] // moved to src/buffer.rs from Python
 mod bufferinfo {
     use crate::Py_ssize_t;
-    use std::os::raw::{c_char, c_int, c_void};
+    use std::ffi::{c_char, c_int, c_void};
     use std::ptr;
 
     #[repr(C)]
@@ -46,6 +49,7 @@ mod bufferinfo {
     }
 
     impl Py_buffer {
+        #[allow(clippy::new_without_default)]
         pub const fn new() -> Self {
             Py_buffer {
                 buf: ptr::null_mut(),
@@ -204,17 +208,8 @@ pub type printfunc =
     unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut ::libc::FILE, arg3: c_int) -> c_int;
 
 #[repr(C)]
-#[derive(Debug, Copy, Clone)]
+#[derive(Debug)]
 pub struct PyTypeObject {
-    #[cfg(all(PyPy, not(Py_3_9)))]
-    pub ob_refcnt: Py_ssize_t,
-    #[cfg(all(PyPy, not(Py_3_9)))]
-    pub ob_pypy_link: Py_ssize_t,
-    #[cfg(all(PyPy, not(Py_3_9)))]
-    pub ob_type: *mut PyTypeObject,
-    #[cfg(all(PyPy, not(Py_3_9)))]
-    pub ob_size: Py_ssize_t,
-    #[cfg(not(all(PyPy, not(Py_3_9))))]
     pub ob_base: object::PyVarObject,
     pub tp_name: *const c_char,
     pub tp_basicsize: Py_ssize_t,
@@ -237,7 +232,10 @@ pub struct PyTypeObject {
     pub tp_getattro: Option<object::getattrofunc>,
     pub tp_setattro: Option<object::setattrofunc>,
     pub tp_as_buffer: *mut PyBufferProcs,
-    pub tp_flags: c_ulong,
+    #[cfg(not(Py_GIL_DISABLED))]
+    pub tp_flags: std::ffi::c_ulong,
+    #[cfg(Py_GIL_DISABLED)]
+    pub tp_flags: crate::impl_::AtomicCULong,
     pub tp_doc: *const c_char,
     pub tp_traverse: Option<object::traverseproc>,
     pub tp_clear: Option<object::inquiry>,
@@ -270,10 +268,8 @@ pub struct PyTypeObject {
     pub tp_vectorcall: Option<vectorcallfunc>,
     #[cfg(Py_3_12)]
     pub tp_watched: c_char,
-    #[cfg(any(all(PyPy, Py_3_8, not(Py_3_10)), all(not(PyPy), Py_3_8, not(Py_3_9))))]
+    #[cfg(all(not(PyPy), Py_3_8, not(Py_3_9)))]
     pub tp_print: Option<printfunc>,
-    #[cfg(all(PyPy, not(Py_3_10)))]
-    pub tp_pypy_flags: std::os::raw::c_long,
     #[cfg(py_sys_config = "COUNT_ALLOCS")]
     pub tp_allocs: Py_ssize_t,
     #[cfg(py_sys_config = "COUNT_ALLOCS")]
@@ -289,14 +285,15 @@ pub struct PyTypeObject {
 #[cfg(Py_3_11)]
 #[repr(C)]
 #[derive(Clone)]
-pub struct _specialization_cache {
-    pub getitem: *mut PyObject,
+struct _specialization_cache {
+    getitem: *mut PyObject,
     #[cfg(Py_3_12)]
-    pub getitem_version: u32,
+    getitem_version: u32,
+    #[cfg(Py_3_13)]
+    init: *mut PyObject,
 }
 
 #[repr(C)]
-#[derive(Clone)]
 pub struct PyHeapTypeObject {
     pub ht_type: PyTypeObject,
     pub as_async: PyAsyncMethods,
@@ -311,10 +308,14 @@ pub struct PyHeapTypeObject {
     pub ht_cached_keys: *mut c_void,
     #[cfg(Py_3_9)]
     pub ht_module: *mut object::PyObject,
-    #[cfg(Py_3_11)]
-    pub _ht_tpname: *mut c_char,
-    #[cfg(Py_3_11)]
-    pub _spec_cache: _specialization_cache,
+    #[cfg(all(Py_3_11, not(PyPy)))]
+    _ht_tpname: *mut c_char,
+    #[cfg(Py_3_14)]
+    pub ht_token: *mut c_void,
+    #[cfg(all(Py_3_11, not(PyPy)))]
+    _spec_cache: _specialization_cache,
+    #[cfg(all(Py_GIL_DISABLED, Py_3_14))]
+    pub unique_id: Py_ssize_t,
 }
 
 impl Default for PyHeapTypeObject {
@@ -325,82 +326,75 @@ impl Default for PyHeapTypeObject {
 }
 
 #[inline]
+#[cfg(not(Py_3_11))]
 pub unsafe fn PyHeapType_GET_MEMBERS(etype: *mut PyHeapTypeObject) -> *mut PyMemberDef {
     let py_type = object::Py_TYPE(etype as *mut object::PyObject);
     let ptr = etype.offset((*py_type).tp_basicsize);
     ptr as *mut PyMemberDef
 }
 
-// skipped _PyType_Name
-// skipped _PyType_Lookup
-// skipped _PyType_LookupId
-// skipped _PyObject_LookupSpecial
-// skipped _PyType_CalculateMetaclass
-// skipped _PyType_GetDocFromInternalDoc
-// skipped _PyType_GetTextSignatureFromInternalDoc
+// skipped private _PyType_Name
+// skipped private _PyType_Lookup
+// skipped private _PyType_LookupRef
 
 extern "C" {
-    #[cfg(Py_3_11)]
-    #[cfg_attr(PyPy, link_name = "PyPyType_GetModuleByDef")]
-    pub fn PyType_GetModuleByDef(ty: *mut PyTypeObject, def: *mut PyModuleDef) -> *mut PyObject;
-
     #[cfg(Py_3_12)]
     pub fn PyType_GetDict(o: *mut PyTypeObject) -> *mut PyObject;
 
     #[cfg_attr(PyPy, link_name = "PyPyObject_Print")]
     pub fn PyObject_Print(o: *mut PyObject, fp: *mut ::libc::FILE, flags: c_int) -> c_int;
 
-    // skipped _Py_BreakPoint
-    // skipped _PyObject_Dump
-    // skipped _PyObject_IsFreed
-    // skipped _PyObject_IsAbstract
+    // skipped private _Py_BreakPoint
+    // skipped private _PyObject_Dump
+
     // skipped _PyObject_GetAttrId
-    // skipped _PyObject_SetAttrId
-    // skipped _PyObject_LookupAttr
-    // skipped _PyObject_LookupAttrId
-    // skipped _PyObject_GetMethod
 
-    #[cfg(not(PyPy))]
-    pub fn _PyObject_GetDictPtr(obj: *mut PyObject) -> *mut *mut PyObject;
-    #[cfg(not(PyPy))]
-    pub fn _PyObject_NextNotImplemented(arg1: *mut PyObject) -> *mut PyObject;
+    // skipped private _PyObject_GetDictPtr
     pub fn PyObject_CallFinalizer(arg1: *mut PyObject);
     #[cfg_attr(PyPy, link_name = "PyPyObject_CallFinalizerFromDealloc")]
     pub fn PyObject_CallFinalizerFromDealloc(arg1: *mut PyObject) -> c_int;
 
-    // skipped _PyObject_GenericGetAttrWithDict
-    // skipped _PyObject_GenericSetAttrWithDict
-    // skipped _PyObject_FunctionStr
+    // skipped private _PyObject_GenericGetAttrWithDict
+    // skipped private _PyObject_GenericSetAttrWithDict
+    // skipped private _PyObject_FunctionStr
 }
 
 // skipped Py_SETREF
 // skipped Py_XSETREF
 
-#[cfg_attr(windows, link(name = "pythonXY"))]
-extern "C" {
-    pub static mut _PyNone_Type: PyTypeObject;
-    pub static mut _PyNotImplemented_Type: PyTypeObject;
-}
-
-// skipped _Py_SwappedOp
+// skipped private _PyObject_ASSERT_FROM
+// skipped private _PyObject_ASSERT_WITH_MSG
+// skipped private _PyObject_ASSERT
+// skipped private _PyObject_ASSERT_FAILED_MSG
+// skipped private _PyObject_AssertFailed
 
-// skipped _PyDebugAllocatorStats
-// skipped _PyObject_DebugTypeStats
-// skipped _PyObject_ASSERT_FROM
-// skipped _PyObject_ASSERT_WITH_MSG
-// skipped _PyObject_ASSERT
-// skipped _PyObject_ASSERT_FAILED_MSG
-// skipped _PyObject_AssertFailed
-// skipped _PyObject_CheckConsistency
+// skipped private _PyTrash_begin
+// skipped private _PyTrash_end
 
 // skipped _PyTrash_thread_deposit_object
 // skipped _PyTrash_thread_destroy_chain
-// skipped _PyTrash_begin
-// skipped _PyTrash_end
-// skipped _PyTrash_cond
-// skipped PyTrash_UNWIND_LEVEL
-// skipped Py_TRASHCAN_BEGIN_CONDITION
-// skipped Py_TRASHCAN_END
+
 // skipped Py_TRASHCAN_BEGIN
-// skipped Py_TRASHCAN_SAFE_BEGIN
-// skipped Py_TRASHCAN_SAFE_END
+// skipped Py_TRASHCAN_END
+
+// skipped PyObject_GetItemData
+
+// skipped PyObject_VisitManagedDict
+// skipped _PyObject_SetManagedDict
+// skipped PyObject_ClearManagedDict
+
+// skipped TYPE_MAX_WATCHERS
+
+// skipped PyType_WatchCallback
+// skipped PyType_AddWatcher
+// skipped PyType_ClearWatcher
+// skipped PyType_Watch
+// skipped PyType_Unwatch
+
+// skipped PyUnstable_Type_AssignVersionTag
+
+// skipped PyRefTracerEvent
+
+// skipped PyRefTracer
+// skipped PyRefTracer_SetTracer
+// skipped PyRefTracer_GetTracer
diff --git a/pyo3-ffi/src/cpython/objimpl.rs b/pyo3-ffi/src/cpython/objimpl.rs
index 36a4380d122..71087d28d2c 100644
--- a/pyo3-ffi/src/cpython/objimpl.rs
+++ b/pyo3-ffi/src/cpython/objimpl.rs
@@ -1,8 +1,9 @@
+#[cfg(not(all(Py_3_11, any(PyPy, GraalPy))))]
 use libc::size_t;
-use std::os::raw::c_int;
+use std::ffi::c_int;
 
-#[cfg(not(PyPy))]
-use std::os::raw::c_void;
+#[cfg(not(any(PyPy, GraalPy)))]
+use std::ffi::c_void;
 
 use crate::object::*;
 
@@ -14,7 +15,7 @@ extern "C" {
     pub fn _Py_GetAllocatedBlocks() -> crate::Py_ssize_t;
 }
 
-#[cfg(not(PyPy))]
+#[cfg(not(any(PyPy, GraalPy)))]
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct PyObjectArenaAllocator {
@@ -23,7 +24,7 @@ pub struct PyObjectArenaAllocator {
     pub free: Option<extern "C" fn(ctx: *mut c_void, ptr: *mut c_void, size: size_t)>,
 }
 
-#[cfg(not(PyPy))]
+#[cfg(not(any(PyPy, GraalPy)))]
 impl Default for PyObjectArenaAllocator {
     #[inline]
     fn default() -> Self {
@@ -32,9 +33,9 @@ impl Default for PyObjectArenaAllocator {
 }
 
 extern "C" {
-    #[cfg(not(PyPy))]
+    #[cfg(not(any(PyPy, GraalPy)))]
     pub fn PyObject_GetArenaAllocator(allocator: *mut PyObjectArenaAllocator);
-    #[cfg(not(PyPy))]
+    #[cfg(not(any(PyPy, GraalPy)))]
     pub fn PyObject_SetArenaAllocator(allocator: *mut PyObjectArenaAllocator);
 
     #[cfg(Py_3_9)]
diff --git a/pyo3-ffi/src/cpython/pydebug.rs b/pyo3-ffi/src/cpython/pydebug.rs
index a42848e8fdb..6878554aead 100644
--- a/pyo3-ffi/src/cpython/pydebug.rs
+++ b/pyo3-ffi/src/cpython/pydebug.rs
@@ -1,4 +1,4 @@
-use std::os::raw::{c_char, c_int};
+use std::ffi::{c_char, c_int};
 
 #[cfg(not(Py_LIMITED_API))]
 #[cfg_attr(windows, link(name = "pythonXY"))]
diff --git a/pyo3-ffi/src/cpython/pyerrors.rs b/pyo3-ffi/src/cpython/pyerrors.rs
index fe7b4d4b045..c9831669ac7 100644
--- a/pyo3-ffi/src/cpython/pyerrors.rs
+++ b/pyo3-ffi/src/cpython/pyerrors.rs
@@ -1,5 +1,5 @@
 use crate::PyObject;
-#[cfg(not(PyPy))]
+#[cfg(not(any(PyPy, GraalPy)))]
 use crate::Py_ssize_t;
 
 #[repr(C)]
@@ -22,7 +22,7 @@ pub struct PyBaseExceptionObject {
     pub suppress_context: char,
 }
 
-#[cfg(not(PyPy))]
+#[cfg(not(any(PyPy, GraalPy)))]
 #[repr(C)]
 #[derive(Debug)]
 pub struct PySyntaxErrorObject {
@@ -46,9 +46,11 @@ pub struct PySyntaxErrorObject {
     pub end_offset: *mut PyObject,
     pub text: *mut PyObject,
     pub print_file_and_line: *mut PyObject,
+    #[cfg(Py_3_14)]
+    pub metadata: *mut PyObject,
 }
 
-#[cfg(not(PyPy))]
+#[cfg(not(any(PyPy, GraalPy)))]
 #[repr(C)]
 #[derive(Debug)]
 pub struct PyImportErrorObject {
@@ -69,7 +71,7 @@ pub struct PyImportErrorObject {
     pub name_from: *mut PyObject,
 }
 
-#[cfg(not(PyPy))]
+#[cfg(not(any(PyPy, GraalPy)))]
 #[repr(C)]
 #[derive(Debug)]
 pub struct PyUnicodeErrorObject {
@@ -90,7 +92,7 @@ pub struct PyUnicodeErrorObject {
     pub reason: *mut PyObject,
 }
 
-#[cfg(not(PyPy))]
+#[cfg(not(any(PyPy, GraalPy)))]
 #[repr(C)]
 #[derive(Debug)]
 pub struct PySystemExitObject {
@@ -107,7 +109,7 @@ pub struct PySystemExitObject {
     pub code: *mut PyObject,
 }
 
-#[cfg(not(PyPy))]
+#[cfg(not(any(PyPy, GraalPy)))]
 #[repr(C)]
 #[derive(Debug)]
 pub struct PyOSErrorObject {
@@ -152,10 +154,7 @@ pub struct PyStopIterationObject {
     pub value: *mut PyObject,
 }
 
-extern "C" {
-    #[cfg(not(PyPy))]
-    pub fn _PyErr_ChainExceptions(typ: *mut PyObject, val: *mut PyObject, tb: *mut PyObject);
-}
+// skipped _PyErr_ChainExceptions
 
 // skipped PyNameErrorObject
 // skipped PyAttributeErrorObject
diff --git a/pyo3-ffi/src/cpython/pyframe.rs b/pyo3-ffi/src/cpython/pyframe.rs
index d0cfa0a2c6d..6da9ecd5b53 100644
--- a/pyo3-ffi/src/cpython/pyframe.rs
+++ b/pyo3-ffi/src/cpython/pyframe.rs
@@ -1,2 +1,62 @@
-#[cfg(Py_3_11)]
-opaque_struct!(_PyInterpreterFrame);
+#[cfg(any(Py_3_11, all(Py_3_9, not(PyPy))))]
+use crate::PyFrameObject;
+use crate::{PyObject, PyTypeObject, Py_TYPE};
+#[cfg(Py_3_12)]
+use std::ffi::c_char;
+use std::ffi::c_int;
+use std::ptr::addr_of_mut;
+
+// NB used in `_PyEval_EvalFrameDefault`, maybe we remove this too.
+#[cfg(all(Py_3_11, not(PyPy)))]
+opaque_struct!(pub _PyInterpreterFrame);
+
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
+    pub static mut PyFrame_Type: PyTypeObject;
+
+    #[cfg(Py_3_13)]
+    pub static mut PyFrameLocalsProxy_Type: PyTypeObject;
+}
+
+#[inline]
+pub unsafe fn PyFrame_Check(op: *mut PyObject) -> c_int {
+    (Py_TYPE(op) == addr_of_mut!(PyFrame_Type)) as c_int
+}
+
+#[cfg(Py_3_13)]
+#[inline]
+pub unsafe fn PyFrameLocalsProxy_Check(op: *mut PyObject) -> c_int {
+    (Py_TYPE(op) == addr_of_mut!(PyFrameLocalsProxy_Type)) as c_int
+}
+
+extern "C" {
+    #[cfg(all(Py_3_9, not(PyPy)))]
+    pub fn PyFrame_GetBack(frame: *mut PyFrameObject) -> *mut PyFrameObject;
+
+    #[cfg(Py_3_11)]
+    pub fn PyFrame_GetLocals(frame: *mut PyFrameObject) -> *mut PyObject;
+
+    #[cfg(Py_3_11)]
+    pub fn PyFrame_GetGlobals(frame: *mut PyFrameObject) -> *mut PyObject;
+
+    #[cfg(Py_3_11)]
+    pub fn PyFrame_GetBuiltins(frame: *mut PyFrameObject) -> *mut PyObject;
+
+    #[cfg(Py_3_11)]
+    pub fn PyFrame_GetGenerator(frame: *mut PyFrameObject) -> *mut PyObject;
+
+    #[cfg(Py_3_11)]
+    pub fn PyFrame_GetLasti(frame: *mut PyFrameObject) -> c_int;
+
+    #[cfg(Py_3_12)]
+    pub fn PyFrame_GetVar(frame: *mut PyFrameObject, name: *mut PyObject) -> *mut PyObject;
+
+    #[cfg(Py_3_12)]
+    pub fn PyFrame_GetVarString(frame: *mut PyFrameObject, name: *mut c_char) -> *mut PyObject;
+
+    // skipped PyUnstable_InterpreterFrame_GetCode
+    // skipped PyUnstable_InterpreterFrame_GetLasti
+    // skipped PyUnstable_InterpreterFrame_GetLine
+    // skipped PyUnstable_ExecutableKinds
+
+}
diff --git a/pyo3-ffi/src/cpython/pyhash.rs b/pyo3-ffi/src/cpython/pyhash.rs
new file mode 100644
index 00000000000..f5c98c23256
--- /dev/null
+++ b/pyo3-ffi/src/cpython/pyhash.rs
@@ -0,0 +1,38 @@
+#[cfg(Py_3_14)]
+use crate::Py_ssize_t;
+#[cfg(Py_3_13)]
+use crate::{PyObject, Py_hash_t};
+#[cfg(any(Py_3_13, not(PyPy)))]
+use std::ffi::c_void;
+#[cfg(not(PyPy))]
+use std::ffi::{c_char, c_int};
+
+#[cfg(not(PyPy))]
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct PyHash_FuncDef {
+    pub hash:
+        Option<extern "C" fn(arg1: *const c_void, arg2: crate::Py_ssize_t) -> crate::Py_hash_t>,
+    pub name: *const c_char,
+    pub hash_bits: c_int,
+    pub seed_bits: c_int,
+}
+
+#[cfg(not(PyPy))]
+impl Default for PyHash_FuncDef {
+    #[inline]
+    fn default() -> Self {
+        unsafe { std::mem::zeroed() }
+    }
+}
+
+extern "C" {
+    #[cfg(not(PyPy))]
+    pub fn PyHash_GetFuncDef() -> *mut PyHash_FuncDef;
+    #[cfg(Py_3_13)]
+    pub fn Py_HashPointer(ptr: *const c_void) -> Py_hash_t;
+    #[cfg(Py_3_13)]
+    pub fn PyObject_GenericHash(obj: *mut PyObject) -> Py_hash_t;
+    #[cfg(Py_3_14)]
+    pub fn Py_HashBuffer(ptr: *const c_void, len: Py_ssize_t) -> Py_hash_t;
+}
diff --git a/pyo3-ffi/src/cpython/pylifecycle.rs b/pyo3-ffi/src/cpython/pylifecycle.rs
index c259c369efd..975dbce1915 100644
--- a/pyo3-ffi/src/cpython/pylifecycle.rs
+++ b/pyo3-ffi/src/cpython/pylifecycle.rs
@@ -1,10 +1,11 @@
 use crate::{PyConfig, PyPreConfig, PyStatus, Py_ssize_t};
 use libc::wchar_t;
-use std::os::raw::{c_char, c_int};
+use std::ffi::{c_char, c_int};
 
-// "private" functions in cpython/pylifecycle.h accepted in PEP 587
 extern "C" {
-    // skipped _Py_SetStandardStreamEncoding;
+
+    // skipped Py_FrozenMain
+
     pub fn Py_PreInitialize(src_config: *const PyPreConfig) -> PyStatus;
     pub fn Py_PreInitializeFromBytesArgs(
         src_config: *const PyPreConfig,
@@ -16,34 +17,14 @@ extern "C" {
         argc: Py_ssize_t,
         argv: *mut *mut wchar_t,
     ) -> PyStatus;
-    pub fn _Py_IsCoreInitialized() -> c_int;
 
     pub fn Py_InitializeFromConfig(config: *const PyConfig) -> PyStatus;
-    pub fn _Py_InitializeMain() -> PyStatus;
 
     pub fn Py_RunMain() -> c_int;
 
     pub fn Py_ExitStatusException(status: PyStatus) -> !;
 
-    // skipped _Py_RestoreSignals
-
     // skipped Py_FdIsInteractive
-    // skipped _Py_FdIsInteractive
-
-    // skipped _Py_SetProgramFullPath
-
-    // skipped _Py_gitidentifier
-    // skipped _Py_getversion
-
-    // skipped _Py_IsFinalizing
-
-    // skipped _PyOS_URandom
-    // skipped _PyOS_URandomNonblock
-
-    // skipped _Py_CoerceLegacyLocale
-    // skipped _Py_LegacyLocaleDetected
-    // skipped _Py_SetLocaleFromEnv
-
 }
 
 #[cfg(Py_3_12)]
@@ -76,6 +57,11 @@ pub const _PyInterpreterConfig_INIT: PyInterpreterConfig = PyInterpreterConfig {
     gil: PyInterpreterConfig_OWN_GIL,
 };
 
+// https://github.com/python/cpython/blob/902de283a8303177eb95bf5bc252d2421fcbd758/Include/cpython/pylifecycle.h#L63-L65
+#[cfg(Py_3_12)]
+const _PyInterpreterConfig_LEGACY_CHECK_MULTI_INTERP_EXTENSIONS: c_int =
+    if cfg!(Py_GIL_DISABLED) { 1 } else { 0 };
+
 #[cfg(Py_3_12)]
 pub const _PyInterpreterConfig_LEGACY_INIT: PyInterpreterConfig = PyInterpreterConfig {
     use_main_obmalloc: 1,
@@ -83,7 +69,7 @@ pub const _PyInterpreterConfig_LEGACY_INIT: PyInterpreterConfig = PyInterpreterC
     allow_exec: 1,
     allow_threads: 1,
     allow_daemon_threads: 1,
-    check_multi_interp_extensions: 0,
+    check_multi_interp_extensions: _PyInterpreterConfig_LEGACY_CHECK_MULTI_INTERP_EXTENSIONS,
     gil: PyInterpreterConfig_SHARED_GIL,
 };
 
@@ -96,4 +82,4 @@ extern "C" {
 }
 
 // skipped atexit_datacallbackfunc
-// skipped _Py_AtExit
+// skipped PyUnstable_AtExit
diff --git a/pyo3-ffi/src/cpython/pymem.rs b/pyo3-ffi/src/cpython/pymem.rs
index 2dfb3f3bcfa..762e850820f 100644
--- a/pyo3-ffi/src/cpython/pymem.rs
+++ b/pyo3-ffi/src/cpython/pymem.rs
@@ -1,5 +1,5 @@
 use libc::size_t;
-use std::os::raw::c_void;
+use std::ffi::c_void;
 
 extern "C" {
     #[cfg_attr(PyPy, link_name = "PyPyMem_RawMalloc")]
@@ -26,7 +26,7 @@ pub enum PyMemAllocatorDomain {
 }
 
 // skipped PyMemAllocatorName
-#[cfg(not(PyPy))]
+#[cfg(not(any(PyPy, GraalPy)))]
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct PyMemAllocatorEx {
@@ -40,10 +40,10 @@ pub struct PyMemAllocatorEx {
 }
 
 extern "C" {
-    #[cfg(not(PyPy))]
+    #[cfg(not(any(PyPy, GraalPy)))]
     pub fn PyMem_GetAllocator(domain: PyMemAllocatorDomain, allocator: *mut PyMemAllocatorEx);
-    #[cfg(not(PyPy))]
+    #[cfg(not(any(PyPy, GraalPy)))]
     pub fn PyMem_SetAllocator(domain: PyMemAllocatorDomain, allocator: *mut PyMemAllocatorEx);
-    #[cfg(not(PyPy))]
+    #[cfg(not(any(PyPy, GraalPy)))]
     pub fn PyMem_SetupDebugHooks();
 }
diff --git a/pyo3-ffi/src/cpython/pystate.rs b/pyo3-ffi/src/cpython/pystate.rs
index 5481265b55d..96e2635a157 100644
--- a/pyo3-ffi/src/cpython/pystate.rs
+++ b/pyo3-ffi/src/cpython/pystate.rs
@@ -1,7 +1,7 @@
 #[cfg(not(PyPy))]
 use crate::PyThreadState;
 use crate::{PyFrameObject, PyInterpreterState, PyObject};
-use std::os::raw::c_int;
+use std::ffi::c_int;
 
 // skipped _PyInterpreterState_RequiresIDRef
 // skipped _PyInterpreterState_RequireIDRef
@@ -27,16 +27,17 @@ pub const PyTrace_OPCODE: c_int = 7;
 // skipped PyTraceInfo
 // skipped CFrame
 
+/// Private structure used inline in `PyGenObject`
 #[cfg(not(PyPy))]
 #[repr(C)]
 #[derive(Clone, Copy)]
-pub struct _PyErr_StackItem {
+pub(crate) struct _PyErr_StackItem {
     #[cfg(not(Py_3_11))]
-    pub exc_type: *mut PyObject,
-    pub exc_value: *mut PyObject,
+    exc_type: *mut PyObject,
+    exc_value: *mut PyObject,
     #[cfg(not(Py_3_11))]
-    pub exc_traceback: *mut PyObject,
-    pub previous_item: *mut _PyErr_StackItem,
+    exc_traceback: *mut PyObject,
+    previous_item: *mut _PyErr_StackItem,
 }
 
 // skipped _PyStackChunk
@@ -69,21 +70,21 @@ extern "C" {
     pub fn PyThreadState_DeleteCurrent();
 }
 
-#[cfg(all(Py_3_9, not(Py_3_11)))]
+#[cfg(all(Py_3_9, not(any(Py_3_11, PyPy))))]
 pub type _PyFrameEvalFunction = extern "C" fn(
     *mut crate::PyThreadState,
     *mut crate::PyFrameObject,
     c_int,
 ) -> *mut crate::object::PyObject;
 
-#[cfg(Py_3_11)]
+#[cfg(all(Py_3_11, not(PyPy)))]
 pub type _PyFrameEvalFunction = extern "C" fn(
     *mut crate::PyThreadState,
     *mut crate::_PyInterpreterFrame,
     c_int,
 ) -> *mut crate::object::PyObject;
 
-#[cfg(Py_3_9)]
+#[cfg(all(Py_3_9, not(PyPy)))]
 extern "C" {
     /// Get the frame evaluation function.
     pub fn _PyInterpreterState_GetEvalFrameFunc(
diff --git a/pyo3-ffi/src/cpython/pythonrun.rs b/pyo3-ffi/src/cpython/pythonrun.rs
index a92528b7fdc..db3767cb60c 100644
--- a/pyo3-ffi/src/cpython/pythonrun.rs
+++ b/pyo3-ffi/src/cpython/pythonrun.rs
@@ -1,11 +1,11 @@
 use crate::object::*;
-#[cfg(not(any(PyPy, Py_LIMITED_API, Py_3_10)))]
+#[cfg(not(any(PyPy, GraalPy, Py_LIMITED_API, Py_3_10)))]
 use crate::pyarena::PyArena;
 use crate::PyCompilerFlags;
-#[cfg(not(any(PyPy, Py_3_10)))]
+#[cfg(not(any(PyPy, GraalPy, Py_3_10)))]
 use crate::{_mod, _node};
 use libc::FILE;
-use std::os::raw::{c_char, c_int};
+use std::ffi::{c_char, c_int};
 
 extern "C" {
     pub fn PyRun_SimpleStringFlags(arg1: *const c_char, arg2: *mut PyCompilerFlags) -> c_int;
@@ -54,7 +54,7 @@ extern "C" {
         flags: *mut PyCompilerFlags,
     ) -> c_int;
 
-    #[cfg(not(any(PyPy, Py_3_10)))]
+    #[cfg(not(any(PyPy, GraalPy, Py_3_10)))]
     pub fn PyParser_ASTFromString(
         s: *const c_char,
         filename: *const c_char,
@@ -62,7 +62,7 @@ extern "C" {
         flags: *mut PyCompilerFlags,
         arena: *mut PyArena,
     ) -> *mut _mod;
-    #[cfg(not(any(PyPy, Py_3_10)))]
+    #[cfg(not(any(PyPy, GraalPy, Py_3_10)))]
     pub fn PyParser_ASTFromStringObject(
         s: *const c_char,
         filename: *mut PyObject,
@@ -70,7 +70,7 @@ extern "C" {
         flags: *mut PyCompilerFlags,
         arena: *mut PyArena,
     ) -> *mut _mod;
-    #[cfg(not(any(PyPy, Py_3_10)))]
+    #[cfg(not(any(PyPy, GraalPy, Py_3_10)))]
     pub fn PyParser_ASTFromFile(
         fp: *mut FILE,
         filename: *const c_char,
@@ -82,7 +82,7 @@ extern "C" {
         errcode: *mut c_int,
         arena: *mut PyArena,
     ) -> *mut _mod;
-    #[cfg(not(any(PyPy, Py_3_10)))]
+    #[cfg(not(any(PyPy, GraalPy, Py_3_10)))]
     pub fn PyParser_ASTFromFileObject(
         fp: *mut FILE,
         filename: *mut PyObject,
@@ -105,7 +105,7 @@ extern "C" {
         arg4: *mut PyObject,
         arg5: *mut PyCompilerFlags,
     ) -> *mut PyObject;
-    #[cfg(not(PyPy))]
+    #[cfg(not(any(PyPy, GraalPy)))]
     pub fn PyRun_FileExFlags(
         fp: *mut FILE,
         filename: *const c_char,
@@ -116,7 +116,7 @@ extern "C" {
         flags: *mut PyCompilerFlags,
     ) -> *mut PyObject;
 
-    #[cfg(not(PyPy))]
+    #[cfg(not(any(PyPy, GraalPy)))]
     pub fn Py_CompileStringExFlags(
         str: *const c_char,
         filename: *const c_char,
@@ -135,16 +135,13 @@ extern "C" {
 }
 
 #[inline]
+#[cfg(not(any(PyPy, GraalPy)))]
 pub unsafe fn Py_CompileString(string: *const c_char, p: *const c_char, s: c_int) -> *mut PyObject {
-    #[cfg(not(PyPy))]
-    return Py_CompileStringExFlags(string, p, s, std::ptr::null_mut(), -1);
-
-    #[cfg(PyPy)]
-    Py_CompileStringFlags(string, p, s, std::ptr::null_mut())
+    Py_CompileStringExFlags(string, p, s, std::ptr::null_mut(), -1)
 }
 
 #[inline]
-#[cfg(not(PyPy))]
+#[cfg(not(any(PyPy, GraalPy)))]
 pub unsafe fn Py_CompileStringFlags(
     string: *const c_char,
     p: *const c_char,
@@ -164,11 +161,11 @@ extern "C" {
         g: *mut PyObject,
         l: *mut PyObject,
     ) -> *mut PyObject;
-    #[cfg(not(PyPy))]
+    #[cfg(not(any(PyPy, GraalPy)))]
     pub fn PyRun_AnyFile(fp: *mut FILE, name: *const c_char) -> c_int;
-    #[cfg(not(PyPy))]
+    #[cfg(not(any(PyPy, GraalPy)))]
     pub fn PyRun_AnyFileEx(fp: *mut FILE, name: *const c_char, closeit: c_int) -> c_int;
-    #[cfg(not(PyPy))]
+    #[cfg(not(any(PyPy, GraalPy)))]
     pub fn PyRun_AnyFileFlags(
         arg1: *mut FILE,
         arg2: *const c_char,
@@ -176,13 +173,13 @@ extern "C" {
     ) -> c_int;
     #[cfg_attr(PyPy, link_name = "PyPyRun_SimpleString")]
     pub fn PyRun_SimpleString(s: *const c_char) -> c_int;
-    #[cfg(not(PyPy))]
+    #[cfg(not(any(PyPy, GraalPy)))]
     pub fn PyRun_SimpleFile(f: *mut FILE, p: *const c_char) -> c_int;
-    #[cfg(not(PyPy))]
+    #[cfg(not(any(PyPy, GraalPy)))]
     pub fn PyRun_SimpleFileEx(f: *mut FILE, p: *const c_char, c: c_int) -> c_int;
-    #[cfg(not(PyPy))]
+    #[cfg(not(any(PyPy, GraalPy)))]
     pub fn PyRun_InteractiveOne(f: *mut FILE, p: *const c_char) -> c_int;
-    #[cfg(not(PyPy))]
+    #[cfg(not(any(PyPy, GraalPy)))]
     pub fn PyRun_InteractiveLoop(f: *mut FILE, p: *const c_char) -> c_int;
     #[cfg_attr(PyPy, link_name = "PyPyRun_File")]
     pub fn PyRun_File(
@@ -192,7 +189,7 @@ extern "C" {
         g: *mut PyObject,
         l: *mut PyObject,
     ) -> *mut PyObject;
-    #[cfg(not(PyPy))]
+    #[cfg(not(any(PyPy, GraalPy)))]
     pub fn PyRun_FileEx(
         fp: *mut FILE,
         p: *const c_char,
@@ -201,7 +198,7 @@ extern "C" {
         l: *mut PyObject,
         c: c_int,
     ) -> *mut PyObject;
-    #[cfg(not(PyPy))]
+    #[cfg(not(any(PyPy, GraalPy)))]
     pub fn PyRun_FileFlags(
         fp: *mut FILE,
         p: *const c_char,
@@ -218,14 +215,14 @@ extern "C" {
 // skipped macro PyRun_AnyFileFlags
 
 extern "C" {
-    #[cfg(not(any(PyPy, Py_3_10)))]
+    #[cfg(not(any(PyPy, GraalPy, Py_3_10)))]
     #[cfg_attr(Py_3_9, deprecated(note = "Python 3.9"))]
     pub fn PyParser_SimpleParseStringFlags(
         arg1: *const c_char,
         arg2: c_int,
         arg3: c_int,
     ) -> *mut _node;
-    #[cfg(not(any(PyPy, Py_3_10)))]
+    #[cfg(not(any(PyPy, GraalPy, Py_3_10)))]
     #[cfg_attr(Py_3_9, deprecated(note = "Python 3.9"))]
     pub fn PyParser_SimpleParseStringFlagsFilename(
         arg1: *const c_char,
@@ -233,7 +230,7 @@ extern "C" {
         arg3: c_int,
         arg4: c_int,
     ) -> *mut _node;
-    #[cfg(not(any(PyPy, Py_3_10)))]
+    #[cfg(not(any(PyPy, GraalPy, Py_3_10)))]
     #[cfg_attr(Py_3_9, deprecated(note = "Python 3.9"))]
     pub fn PyParser_SimpleParseFileFlags(
         arg1: *mut FILE,
diff --git a/pyo3-ffi/src/cpython/tupleobject.rs b/pyo3-ffi/src/cpython/tupleobject.rs
index 24dde268526..dc1bf8e40d0 100644
--- a/pyo3-ffi/src/cpython/tupleobject.rs
+++ b/pyo3-ffi/src/cpython/tupleobject.rs
@@ -1,20 +1,23 @@
 use crate::object::*;
+#[cfg(Py_3_14)]
+use crate::pyport::Py_hash_t;
 #[cfg(not(PyPy))]
 use crate::pyport::Py_ssize_t;
 
 #[repr(C)]
 pub struct PyTupleObject {
     pub ob_base: PyVarObject,
+    #[cfg(Py_3_14)]
+    pub ob_hash: Py_hash_t,
     pub ob_item: [*mut PyObject; 1],
 }
 
 // skipped _PyTuple_Resize
 // skipped _PyTuple_MaybeUntrack
 
-/// Macro, trading safety for speed
-
 // skipped _PyTuple_CAST
 
+/// Macro, trading safety for speed
 #[inline]
 #[cfg(not(PyPy))]
 pub unsafe fn PyTuple_GET_SIZE(op: *mut PyObject) -> Py_ssize_t {
@@ -22,14 +25,14 @@ pub unsafe fn PyTuple_GET_SIZE(op: *mut PyObject) -> Py_ssize_t {
 }
 
 #[inline]
-#[cfg(not(PyPy))]
+#[cfg(not(any(PyPy, GraalPy)))]
 pub unsafe fn PyTuple_GET_ITEM(op: *mut PyObject, i: Py_ssize_t) -> *mut PyObject {
     *(*(op as *mut PyTupleObject)).ob_item.as_ptr().offset(i)
 }
 
 /// Macro, *only* to be used to fill in brand new tuples
 #[inline]
-#[cfg(not(PyPy))]
+#[cfg(not(any(PyPy, GraalPy)))]
 pub unsafe fn PyTuple_SET_ITEM(op: *mut PyObject, i: Py_ssize_t, v: *mut PyObject) {
     *(*(op as *mut PyTupleObject)).ob_item.as_mut_ptr().offset(i) = v;
 }
diff --git a/pyo3-ffi/src/cpython/unicodeobject.rs b/pyo3-ffi/src/cpython/unicodeobject.rs
index f618ecf0a84..cf0ef54484e 100644
--- a/pyo3-ffi/src/cpython/unicodeobject.rs
+++ b/pyo3-ffi/src/cpython/unicodeobject.rs
@@ -1,9 +1,8 @@
-#[cfg(not(PyPy))]
+#[cfg(any(Py_3_11, not(PyPy)))]
 use crate::Py_hash_t;
-use crate::{PyObject, Py_UCS1, Py_UCS2, Py_UCS4, Py_UNICODE, Py_ssize_t};
-#[cfg(not(Py_3_12))]
+use crate::{PyObject, Py_UCS1, Py_UCS2, Py_UCS4, Py_ssize_t};
 use libc::wchar_t;
-use std::os::raw::{c_char, c_int, c_uint, c_void};
+use std::ffi::{c_char, c_int, c_uint, c_void};
 
 // skipped Py_UNICODE_ISSPACE()
 // skipped Py_UNICODE_ISLOWER()
@@ -32,11 +31,13 @@ use std::os::raw::{c_char, c_int, c_uint, c_void};
 // skipped Py_UNICODE_LOW_SURROGATE
 
 // generated by bindgen v0.63.0 (with small adaptations)
+#[cfg(not(Py_3_14))]
 #[repr(C)]
 struct BitfieldUnit<Storage> {
     storage: Storage,
 }
 
+#[cfg(not(Py_3_14))]
 impl<Storage> BitfieldUnit<Storage> {
     #[inline]
     pub const fn new(storage: Storage) -> Self {
@@ -44,6 +45,7 @@ impl<Storage> BitfieldUnit<Storage> {
     }
 }
 
+#[cfg(not(any(GraalPy, Py_3_14)))]
 impl<Storage> BitfieldUnit<Storage>
 where
     Storage: AsRef<[u8]> + AsMut<[u8]>,
@@ -117,23 +119,37 @@ where
     }
 }
 
+#[cfg(not(any(GraalPy, Py_3_14)))]
 const STATE_INTERNED_INDEX: usize = 0;
+#[cfg(not(any(GraalPy, Py_3_14)))]
 const STATE_INTERNED_WIDTH: u8 = 2;
 
+#[cfg(not(any(GraalPy, Py_3_14)))]
 const STATE_KIND_INDEX: usize = STATE_INTERNED_WIDTH as usize;
+#[cfg(not(any(GraalPy, Py_3_14)))]
 const STATE_KIND_WIDTH: u8 = 3;
 
+#[cfg(not(any(GraalPy, Py_3_14)))]
 const STATE_COMPACT_INDEX: usize = (STATE_INTERNED_WIDTH + STATE_KIND_WIDTH) as usize;
+#[cfg(not(any(GraalPy, Py_3_14)))]
 const STATE_COMPACT_WIDTH: u8 = 1;
 
+#[cfg(not(any(GraalPy, Py_3_14)))]
 const STATE_ASCII_INDEX: usize =
     (STATE_INTERNED_WIDTH + STATE_KIND_WIDTH + STATE_COMPACT_WIDTH) as usize;
+#[cfg(not(any(GraalPy, Py_3_14)))]
 const STATE_ASCII_WIDTH: u8 = 1;
 
-#[cfg(not(Py_3_12))]
+#[cfg(all(not(any(GraalPy, Py_3_14)), Py_3_12))]
+const STATE_STATICALLY_ALLOCATED_INDEX: usize =
+    (STATE_INTERNED_WIDTH + STATE_KIND_WIDTH + STATE_COMPACT_WIDTH + STATE_ASCII_WIDTH) as usize;
+#[cfg(all(not(any(GraalPy, Py_3_14)), Py_3_12))]
+const STATE_STATICALLY_ALLOCATED_WIDTH: u8 = 1;
+
+#[cfg(not(any(Py_3_12, GraalPy)))]
 const STATE_READY_INDEX: usize =
     (STATE_INTERNED_WIDTH + STATE_KIND_WIDTH + STATE_COMPACT_WIDTH + STATE_ASCII_WIDTH) as usize;
-#[cfg(not(Py_3_12))]
+#[cfg(not(any(Py_3_12, GraalPy)))]
 const STATE_READY_WIDTH: u8 = 1;
 
 // generated by bindgen v0.63.0 (with small adaptations)
@@ -145,14 +161,15 @@ const STATE_READY_WIDTH: u8 = 1;
 ///
 /// Memory layout of C bitfields is implementation defined, so these functions are still
 /// unsafe. Users must verify that they work as expected on the architectures they target.
+#[cfg(not(Py_3_14))]
 #[repr(C)]
-#[repr(align(4))]
 struct PyASCIIObjectState {
     bitfield_align: [u8; 0],
     bitfield: BitfieldUnit<[u8; 4usize]>,
 }
 
 // c_uint and u32 are not necessarily the same type on all targets / architectures
+#[cfg(not(any(GraalPy, Py_3_14)))]
 #[allow(clippy::useless_transmute)]
 impl PyASCIIObjectState {
     #[inline]
@@ -206,6 +223,26 @@ impl PyASCIIObjectState {
             .set(STATE_ASCII_INDEX, STATE_ASCII_WIDTH, val as u64)
     }
 
+    #[cfg(Py_3_12)]
+    #[inline]
+    unsafe fn statically_allocated(&self) -> c_uint {
+        std::mem::transmute(self.bitfield.get(
+            STATE_STATICALLY_ALLOCATED_INDEX,
+            STATE_STATICALLY_ALLOCATED_WIDTH,
+        ) as u32)
+    }
+
+    #[cfg(Py_3_12)]
+    #[inline]
+    unsafe fn set_statically_allocated(&mut self, val: c_uint) {
+        let val: u32 = std::mem::transmute(val);
+        self.bitfield.set(
+            STATE_STATICALLY_ALLOCATED_INDEX,
+            STATE_STATICALLY_ALLOCATED_WIDTH,
+            val as u64,
+        )
+    }
+
     #[cfg(not(Py_3_12))]
     #[inline]
     unsafe fn ready(&self) -> c_uint {
@@ -221,6 +258,7 @@ impl PyASCIIObjectState {
     }
 }
 
+#[cfg(not(Py_3_14))]
 impl From<u32> for PyASCIIObjectState {
     #[inline]
     fn from(value: u32) -> Self {
@@ -231,6 +269,7 @@ impl From<u32> for PyASCIIObjectState {
     }
 }
 
+#[cfg(not(Py_3_14))]
 impl From<PyASCIIObjectState> for u32 {
     #[inline]
     fn from(value: PyASCIIObjectState) -> Self {
@@ -242,25 +281,36 @@ impl From<PyASCIIObjectState> for u32 {
 pub struct PyASCIIObject {
     pub ob_base: PyObject,
     pub length: Py_ssize_t,
-    #[cfg(not(PyPy))]
+    #[cfg(any(Py_3_11, not(PyPy)))]
     pub hash: Py_hash_t,
     /// A bit field with various properties.
     ///
     /// Rust doesn't expose bitfields. So we have accessor functions for
     /// retrieving values.
     ///
+    /// Before 3.12:
     /// unsigned int interned:2; // SSTATE_* constants.
     /// unsigned int kind:3;     // PyUnicode_*_KIND constants.
     /// unsigned int compact:1;
     /// unsigned int ascii:1;
     /// unsigned int ready:1;
     /// unsigned int :24;
+    ///
+    /// 3.12, and 3.13
+    /// unsigned int interned:2; // SSTATE_* constants.
+    /// unsigned int kind:3;     // PyUnicode_*_KIND constants.
+    /// unsigned int compact:1;
+    /// unsigned int ascii:1;
+    /// unsigned int statically_allocated:1;
+    /// unsigned int :24;
+    /// on 3.14 and higher PyO3 doesn't access the internal state
     pub state: u32,
     #[cfg(not(Py_3_12))]
     pub wstr: *mut wchar_t,
 }
 
 /// Interacting with the bitfield is not actually well-defined, so we mark these APIs unsafe.
+#[cfg(not(any(GraalPy, Py_3_14)))]
 impl PyASCIIObject {
     #[cfg_attr(not(Py_3_12), allow(rustdoc::broken_intra_doc_links))] // SSTATE_INTERNED_IMMORTAL_STATIC requires 3.12
     /// Get the `interned` field of the [`PyASCIIObject`] state bitfield.
@@ -337,6 +387,7 @@ impl PyASCIIObject {
     ///
     /// Calling this function with an argument that is neither `0` nor `1` is invalid.
     #[inline]
+    #[cfg(not(all(Py_3_14, Py_GIL_DISABLED)))]
     pub unsafe fn set_ascii(&mut self, val: c_uint) {
         let mut state = PyASCIIObjectState::from(self.state);
         state.set_ascii(val);
@@ -362,6 +413,26 @@ impl PyASCIIObject {
         state.set_ready(val);
         self.state = u32::from(state);
     }
+
+    /// Get the `statically_allocated` field of the [`PyASCIIObject`] state bitfield.
+    ///
+    /// Returns either `0` or `1`.
+    #[inline]
+    #[cfg(Py_3_12)]
+    pub unsafe fn statically_allocated(&self) -> c_uint {
+        PyASCIIObjectState::from(self.state).statically_allocated()
+    }
+
+    /// Set the `statically_allocated` flag of the [`PyASCIIObject`] state bitfield.
+    ///
+    /// Calling this function with an argument that is neither `0` nor `1` is invalid.
+    #[inline]
+    #[cfg(Py_3_12)]
+    pub unsafe fn set_statically_allocated(&mut self, val: c_uint) {
+        let mut state = PyASCIIObjectState::from(self.state);
+        state.set_statically_allocated(val);
+        self.state = u32::from(state);
+    }
 }
 
 #[repr(C)]
@@ -388,7 +459,7 @@ pub struct PyUnicodeObject {
 }
 
 extern "C" {
-    #[cfg(not(PyPy))]
+    #[cfg(not(any(PyPy, GraalPy)))]
     pub fn _PyUnicode_CheckConsistency(op: *mut PyObject, check_content: c_int) -> c_int;
 }
 
@@ -403,6 +474,7 @@ pub const SSTATE_INTERNED_IMMORTAL: c_uint = 2;
 #[cfg(Py_3_12)]
 pub const SSTATE_INTERNED_IMMORTAL_STATIC: c_uint = 3;
 
+#[cfg(not(any(GraalPy, Py_3_14)))]
 #[inline]
 pub unsafe fn PyUnicode_IS_ASCII(op: *mut PyObject) -> c_uint {
     debug_assert!(crate::PyUnicode_Check(op) != 0);
@@ -412,11 +484,13 @@ pub unsafe fn PyUnicode_IS_ASCII(op: *mut PyObject) -> c_uint {
     (*(op as *mut PyASCIIObject)).ascii()
 }
 
+#[cfg(not(any(GraalPy, Py_3_14)))]
 #[inline]
 pub unsafe fn PyUnicode_IS_COMPACT(op: *mut PyObject) -> c_uint {
     (*(op as *mut PyASCIIObject)).compact()
 }
 
+#[cfg(not(any(GraalPy, Py_3_14)))]
 #[inline]
 pub unsafe fn PyUnicode_IS_COMPACT_ASCII(op: *mut PyObject) -> c_uint {
     ((*(op as *mut PyASCIIObject)).ascii() != 0 && PyUnicode_IS_COMPACT(op) != 0).into()
@@ -430,21 +504,31 @@ pub const PyUnicode_1BYTE_KIND: c_uint = 1;
 pub const PyUnicode_2BYTE_KIND: c_uint = 2;
 pub const PyUnicode_4BYTE_KIND: c_uint = 4;
 
+#[cfg(not(any(GraalPy, PyPy)))]
 #[inline]
 pub unsafe fn PyUnicode_1BYTE_DATA(op: *mut PyObject) -> *mut Py_UCS1 {
     PyUnicode_DATA(op) as *mut Py_UCS1
 }
 
+#[cfg(not(any(GraalPy, PyPy)))]
 #[inline]
 pub unsafe fn PyUnicode_2BYTE_DATA(op: *mut PyObject) -> *mut Py_UCS2 {
     PyUnicode_DATA(op) as *mut Py_UCS2
 }
 
+#[cfg(not(any(GraalPy, PyPy)))]
 #[inline]
 pub unsafe fn PyUnicode_4BYTE_DATA(op: *mut PyObject) -> *mut Py_UCS4 {
     PyUnicode_DATA(op) as *mut Py_UCS4
 }
 
+#[cfg(all(not(GraalPy), Py_3_14))]
+extern "C" {
+    #[cfg_attr(PyPy, link_name = "PyPyUnicode_KIND")]
+    pub fn PyUnicode_KIND(op: *mut PyObject) -> c_uint;
+}
+
+#[cfg(all(not(GraalPy), not(Py_3_14)))]
 #[inline]
 pub unsafe fn PyUnicode_KIND(op: *mut PyObject) -> c_uint {
     debug_assert!(crate::PyUnicode_Check(op) != 0);
@@ -454,6 +538,7 @@ pub unsafe fn PyUnicode_KIND(op: *mut PyObject) -> c_uint {
     (*(op as *mut PyASCIIObject)).kind()
 }
 
+#[cfg(not(any(GraalPy, Py_3_14)))]
 #[inline]
 pub unsafe fn _PyUnicode_COMPACT_DATA(op: *mut PyObject) -> *mut c_void {
     if PyUnicode_IS_ASCII(op) != 0 {
@@ -463,6 +548,7 @@ pub unsafe fn _PyUnicode_COMPACT_DATA(op: *mut PyObject) -> *mut c_void {
     }
 }
 
+#[cfg(not(any(GraalPy, PyPy)))]
 #[inline]
 pub unsafe fn _PyUnicode_NONCOMPACT_DATA(op: *mut PyObject) -> *mut c_void {
     debug_assert!(!(*(op as *mut PyUnicodeObject)).data.any.is_null());
@@ -470,6 +556,7 @@ pub unsafe fn _PyUnicode_NONCOMPACT_DATA(op: *mut PyObject) -> *mut c_void {
     (*(op as *mut PyUnicodeObject)).data.any
 }
 
+#[cfg(not(any(GraalPy, PyPy, Py_3_14)))]
 #[inline]
 pub unsafe fn PyUnicode_DATA(op: *mut PyObject) -> *mut c_void {
     debug_assert!(crate::PyUnicode_Check(op) != 0);
@@ -481,10 +568,18 @@ pub unsafe fn PyUnicode_DATA(op: *mut PyObject) -> *mut c_void {
     }
 }
 
+#[cfg(Py_3_14)]
+#[cfg(all(not(GraalPy), Py_3_14))]
+extern "C" {
+    #[cfg_attr(PyPy, link_name = "PyPyUnicode_DATA")]
+    pub fn PyUnicode_DATA(op: *mut PyObject) -> *mut c_void;
+}
+
 // skipped PyUnicode_WRITE
 // skipped PyUnicode_READ
 // skipped PyUnicode_READ_CHAR
 
+#[cfg(not(GraalPy))]
 #[inline]
 pub unsafe fn PyUnicode_GET_LENGTH(op: *mut PyObject) -> Py_ssize_t {
     debug_assert!(crate::PyUnicode_Check(op) != 0);
@@ -494,26 +589,26 @@ pub unsafe fn PyUnicode_GET_LENGTH(op: *mut PyObject) -> Py_ssize_t {
     (*(op as *mut PyASCIIObject)).length
 }
 
-#[cfg(Py_3_12)]
+#[cfg(any(Py_3_12, GraalPy))]
 #[inline]
 pub unsafe fn PyUnicode_IS_READY(_op: *mut PyObject) -> c_uint {
     // kept in CPython for backwards compatibility
     1
 }
 
-#[cfg(not(Py_3_12))]
+#[cfg(not(any(GraalPy, Py_3_12)))]
 #[inline]
 pub unsafe fn PyUnicode_IS_READY(op: *mut PyObject) -> c_uint {
     (*(op as *mut PyASCIIObject)).ready()
 }
 
-#[cfg(Py_3_12)]
+#[cfg(any(Py_3_12, GraalPy))]
 #[inline]
 pub unsafe fn PyUnicode_READY(_op: *mut PyObject) -> c_int {
     0
 }
 
-#[cfg(not(Py_3_12))]
+#[cfg(not(any(Py_3_12, GraalPy)))]
 #[inline]
 pub unsafe fn PyUnicode_READY(op: *mut PyObject) -> c_int {
     debug_assert!(crate::PyUnicode_Check(op) != 0);
@@ -561,7 +656,7 @@ extern "C" {
     #[cfg(not(Py_3_12))]
     #[deprecated]
     #[cfg_attr(PyPy, link_name = "PyPyUnicode_FromUnicode")]
-    pub fn PyUnicode_FromUnicode(u: *const Py_UNICODE, size: Py_ssize_t) -> *mut PyObject;
+    pub fn PyUnicode_FromUnicode(u: *const wchar_t, size: Py_ssize_t) -> *mut PyObject;
 
     #[cfg_attr(PyPy, link_name = "PyPyUnicode_FromKindAndData")]
     pub fn PyUnicode_FromKindAndData(
@@ -576,7 +671,7 @@ extern "C" {
     #[cfg(not(Py_3_12))]
     #[deprecated]
     #[cfg_attr(PyPy, link_name = "PyPyUnicode_AsUnicode")]
-    pub fn PyUnicode_AsUnicode(unicode: *mut PyObject) -> *mut Py_UNICODE;
+    pub fn PyUnicode_AsUnicode(unicode: *mut PyObject) -> *mut wchar_t;
 
     // skipped _PyUnicode_AsUnicode
 
@@ -586,7 +681,7 @@ extern "C" {
     pub fn PyUnicode_AsUnicodeAndSize(
         unicode: *mut PyObject,
         size: *mut Py_ssize_t,
-    ) -> *mut Py_UNICODE;
+    ) -> *mut wchar_t;
 
     // skipped PyUnicode_GetMax
 }
@@ -615,14 +710,14 @@ extern "C" {
     // skipped _PyUnicode_AsString
 
     pub fn PyUnicode_Encode(
-        s: *const Py_UNICODE,
+        s: *const wchar_t,
         size: Py_ssize_t,
         encoding: *const c_char,
         errors: *const c_char,
     ) -> *mut PyObject;
 
     pub fn PyUnicode_EncodeUTF7(
-        data: *const Py_UNICODE,
+        data: *const wchar_t,
         length: Py_ssize_t,
         base64SetO: c_int,
         base64WhiteSpace: c_int,
@@ -634,13 +729,13 @@ extern "C" {
 
     #[cfg_attr(PyPy, link_name = "PyPyUnicode_EncodeUTF8")]
     pub fn PyUnicode_EncodeUTF8(
-        data: *const Py_UNICODE,
+        data: *const wchar_t,
         length: Py_ssize_t,
         errors: *const c_char,
     ) -> *mut PyObject;
 
     pub fn PyUnicode_EncodeUTF32(
-        data: *const Py_UNICODE,
+        data: *const wchar_t,
         length: Py_ssize_t,
         errors: *const c_char,
         byteorder: c_int,
@@ -649,7 +744,7 @@ extern "C" {
     // skipped _PyUnicode_EncodeUTF32
 
     pub fn PyUnicode_EncodeUTF16(
-        data: *const Py_UNICODE,
+        data: *const wchar_t,
         length: Py_ssize_t,
         errors: *const c_char,
         byteorder: c_int,
@@ -658,13 +753,11 @@ extern "C" {
     // skipped _PyUnicode_EncodeUTF16
     // skipped _PyUnicode_DecodeUnicodeEscape
 
-    pub fn PyUnicode_EncodeUnicodeEscape(
-        data: *const Py_UNICODE,
-        length: Py_ssize_t,
-    ) -> *mut PyObject;
+    pub fn PyUnicode_EncodeUnicodeEscape(data: *const wchar_t, length: Py_ssize_t)
+        -> *mut PyObject;
 
     pub fn PyUnicode_EncodeRawUnicodeEscape(
-        data: *const Py_UNICODE,
+        data: *const wchar_t,
         length: Py_ssize_t,
     ) -> *mut PyObject;
 
@@ -672,7 +765,7 @@ extern "C" {
 
     #[cfg_attr(PyPy, link_name = "PyPyUnicode_EncodeLatin1")]
     pub fn PyUnicode_EncodeLatin1(
-        data: *const Py_UNICODE,
+        data: *const wchar_t,
         length: Py_ssize_t,
         errors: *const c_char,
     ) -> *mut PyObject;
@@ -681,13 +774,13 @@ extern "C" {
 
     #[cfg_attr(PyPy, link_name = "PyPyUnicode_EncodeASCII")]
     pub fn PyUnicode_EncodeASCII(
-        data: *const Py_UNICODE,
+        data: *const wchar_t,
         length: Py_ssize_t,
         errors: *const c_char,
     ) -> *mut PyObject;
 
     pub fn PyUnicode_EncodeCharmap(
-        data: *const Py_UNICODE,
+        data: *const wchar_t,
         length: Py_ssize_t,
         mapping: *mut PyObject,
         errors: *const c_char,
@@ -696,7 +789,7 @@ extern "C" {
     // skipped _PyUnicode_EncodeCharmap
 
     pub fn PyUnicode_TranslateCharmap(
-        data: *const Py_UNICODE,
+        data: *const wchar_t,
         length: Py_ssize_t,
         table: *mut PyObject,
         errors: *const c_char,
@@ -706,17 +799,14 @@ extern "C" {
 
     #[cfg_attr(PyPy, link_name = "PyPyUnicode_EncodeDecimal")]
     pub fn PyUnicode_EncodeDecimal(
-        s: *mut Py_UNICODE,
+        s: *mut wchar_t,
         length: Py_ssize_t,
         output: *mut c_char,
         errors: *const c_char,
     ) -> c_int;
 
     #[cfg_attr(PyPy, link_name = "PyPyUnicode_TransformDecimalToASCII")]
-    pub fn PyUnicode_TransformDecimalToASCII(
-        s: *mut Py_UNICODE,
-        length: Py_ssize_t,
-    ) -> *mut PyObject;
+    pub fn PyUnicode_TransformDecimalToASCII(s: *mut wchar_t, length: Py_ssize_t) -> *mut PyObject;
 
     // skipped _PyUnicode_TransformDecimalAndSpaceToASCII
 }
diff --git a/pyo3-ffi/src/cpython/weakrefobject.rs b/pyo3-ffi/src/cpython/weakrefobject.rs
index 5a5f85c5f0c..1c50c7a759f 100644
--- a/pyo3-ffi/src/cpython/weakrefobject.rs
+++ b/pyo3-ffi/src/cpython/weakrefobject.rs
@@ -1,4 +1,5 @@
-#[cfg(not(PyPy))]
+// NB publicly re-exported in `src/weakrefobject.rs`
+#[cfg(not(any(PyPy, GraalPy)))]
 pub struct _PyWeakReference {
     pub ob_base: crate::PyObject,
     pub wr_object: *mut crate::PyObject,
@@ -8,6 +9,8 @@ pub struct _PyWeakReference {
     pub wr_next: *mut crate::PyWeakReference,
     #[cfg(Py_3_11)]
     pub vectorcall: Option<crate::vectorcallfunc>,
+    #[cfg(all(Py_3_13, Py_GIL_DISABLED))]
+    pub weakrefs_lock: *mut crate::PyMutex,
 }
 
 // skipped _PyWeakref_GetWeakrefCount
diff --git a/pyo3-ffi/src/datetime.rs b/pyo3-ffi/src/datetime.rs
index 7e5a250990f..dc3a8b32dec 100644
--- a/pyo3-ffi/src/datetime.rs
+++ b/pyo3-ffi/src/datetime.rs
@@ -3,30 +3,26 @@
 //! This is the unsafe thin  wrapper around the [CPython C API](https://docs.python.org/3/c-api/datetime.html),
 //! and covers the various date and time related objects in the Python `datetime`
 //! standard library module.
-//!
-//! A note regarding PyPy (cpyext) support:
-//!
-//! Support for `PyDateTime_CAPI` is limited as of PyPy 7.0.0.
-//! `DateTime_FromTimestamp` and `Date_FromTimestamp` are currently not supported.
 
+#[cfg(not(PyPy))]
+use crate::PyCapsule_Import;
+#[cfg(GraalPy)]
+use crate::{PyLong_AsLong, PyLong_Check, PyObject_GetAttrString, Py_DecRef};
 use crate::{PyObject, PyObject_TypeCheck, PyTypeObject, Py_TYPE};
-use std::cell::UnsafeCell;
-use std::os::raw::{c_char, c_int};
+use std::ffi::c_char;
+use std::ffi::c_int;
 use std::ptr;
+use std::sync::Once;
+use std::{cell::UnsafeCell, ffi::CStr};
 #[cfg(not(PyPy))]
-use {
-    crate::{PyCapsule_Import, Py_hash_t},
-    std::ffi::CString,
-    std::os::raw::c_uchar,
-};
-
+use {crate::Py_hash_t, std::ffi::c_uchar};
 // Type struct wrappers
 const _PyDateTime_DATE_DATASIZE: usize = 4;
 const _PyDateTime_TIME_DATASIZE: usize = 6;
 const _PyDateTime_DATETIME_DATASIZE: usize = 10;
 
 #[repr(C)]
-#[derive(Debug, Copy, Clone)]
+#[derive(Debug)]
 /// Structure representing a `datetime.timedelta`.
 pub struct PyDateTime_Delta {
     pub ob_base: PyObject,
@@ -40,21 +36,19 @@ pub struct PyDateTime_Delta {
 // skipped non-limited PyDateTime_TZInfo
 // skipped non-limited _PyDateTime_BaseTZInfo
 
-#[cfg(not(PyPy))]
+#[cfg(not(any(PyPy, GraalPy)))]
 #[repr(C)]
-#[derive(Debug, Copy, Clone)]
+#[derive(Debug)]
 /// Structure representing a `datetime.time` without a `tzinfo` member.
 pub struct _PyDateTime_BaseTime {
     pub ob_base: PyObject,
-    #[cfg(not(PyPy))]
     pub hashcode: Py_hash_t,
     pub hastzinfo: c_char,
-    #[cfg(not(PyPy))]
     pub data: [c_uchar; _PyDateTime_TIME_DATASIZE],
 }
 
 #[repr(C)]
-#[derive(Debug, Copy, Clone)]
+#[derive(Debug)]
 /// Structure representing a `datetime.time`.
 pub struct PyDateTime_Time {
     pub ob_base: PyObject,
@@ -73,7 +67,7 @@ pub struct PyDateTime_Time {
 }
 
 #[repr(C)]
-#[derive(Debug, Copy, Clone)]
+#[derive(Debug)]
 /// Structure representing a `datetime.date`
 pub struct PyDateTime_Date {
     pub ob_base: PyObject,
@@ -85,21 +79,19 @@ pub struct PyDateTime_Date {
     pub data: [c_uchar; _PyDateTime_DATE_DATASIZE],
 }
 
-#[cfg(not(PyPy))]
+#[cfg(not(any(PyPy, GraalPy)))]
 #[repr(C)]
-#[derive(Debug, Copy, Clone)]
+#[derive(Debug)]
 /// Structure representing a `datetime.datetime` without a `tzinfo` member.
 pub struct _PyDateTime_BaseDateTime {
     pub ob_base: PyObject,
-    #[cfg(not(PyPy))]
     pub hashcode: Py_hash_t,
     pub hastzinfo: c_char,
-    #[cfg(not(PyPy))]
     pub data: [c_uchar; _PyDateTime_DATETIME_DATASIZE],
 }
 
 #[repr(C)]
-#[derive(Debug, Copy, Clone)]
+#[derive(Debug)]
 /// Structure representing a `datetime.datetime`.
 pub struct PyDateTime_DateTime {
     pub ob_base: PyObject,
@@ -121,56 +113,56 @@ pub struct PyDateTime_DateTime {
 
 // Accessor functions for PyDateTime_Date and PyDateTime_DateTime
 #[inline]
-#[cfg(not(PyPy))]
+#[cfg(not(any(PyPy, GraalPy)))]
 /// Retrieve the year component of a `PyDateTime_Date` or `PyDateTime_DateTime`.
 /// Returns a signed integer greater than 0.
 pub unsafe fn PyDateTime_GET_YEAR(o: *mut PyObject) -> c_int {
     // This should work for Date or DateTime
-    let d = *(o as *mut PyDateTime_Date);
-    c_int::from(d.data[0]) << 8 | c_int::from(d.data[1])
+    let data = (*(o as *mut PyDateTime_Date)).data;
+    (c_int::from(data[0]) << 8) | c_int::from(data[1])
 }
 
 #[inline]
-#[cfg(not(PyPy))]
+#[cfg(not(any(PyPy, GraalPy)))]
 /// Retrieve the month component of a `PyDateTime_Date` or `PyDateTime_DateTime`.
 /// Returns a signed integer in the range `[1, 12]`.
 pub unsafe fn PyDateTime_GET_MONTH(o: *mut PyObject) -> c_int {
-    let d = *(o as *mut PyDateTime_Date);
-    c_int::from(d.data[2])
+    let data = (*(o as *mut PyDateTime_Date)).data;
+    c_int::from(data[2])
 }
 
 #[inline]
-#[cfg(not(PyPy))]
+#[cfg(not(any(PyPy, GraalPy)))]
 /// Retrieve the day component of a `PyDateTime_Date` or `PyDateTime_DateTime`.
 /// Returns a signed integer in the interval `[1, 31]`.
 pub unsafe fn PyDateTime_GET_DAY(o: *mut PyObject) -> c_int {
-    let d = *(o as *mut PyDateTime_Date);
-    c_int::from(d.data[3])
+    let data = (*(o as *mut PyDateTime_Date)).data;
+    c_int::from(data[3])
 }
 
 // Accessor macros for times
-#[cfg(not(PyPy))]
+#[cfg(not(any(PyPy, GraalPy)))]
 macro_rules! _PyDateTime_GET_HOUR {
     ($o: expr, $offset:expr) => {
         c_int::from((*$o).data[$offset + 0])
     };
 }
 
-#[cfg(not(PyPy))]
+#[cfg(not(any(PyPy, GraalPy)))]
 macro_rules! _PyDateTime_GET_MINUTE {
     ($o: expr, $offset:expr) => {
         c_int::from((*$o).data[$offset + 1])
     };
 }
 
-#[cfg(not(PyPy))]
+#[cfg(not(any(PyPy, GraalPy)))]
 macro_rules! _PyDateTime_GET_SECOND {
     ($o: expr, $offset:expr) => {
         c_int::from((*$o).data[$offset + 2])
     };
 }
 
-#[cfg(not(PyPy))]
+#[cfg(not(any(PyPy, GraalPy)))]
 macro_rules! _PyDateTime_GET_MICROSECOND {
     ($o: expr, $offset:expr) => {
         (c_int::from((*$o).data[$offset + 3]) << 16)
@@ -179,14 +171,14 @@ macro_rules! _PyDateTime_GET_MICROSECOND {
     };
 }
 
-#[cfg(not(PyPy))]
+#[cfg(not(any(PyPy, GraalPy)))]
 macro_rules! _PyDateTime_GET_FOLD {
     ($o: expr) => {
         (*$o).fold
     };
 }
 
-#[cfg(not(PyPy))]
+#[cfg(not(any(PyPy, GraalPy)))]
 macro_rules! _PyDateTime_GET_TZINFO {
     ($o: expr) => {
         if (*$o).hastzinfo != 0 {
@@ -199,7 +191,7 @@ macro_rules! _PyDateTime_GET_TZINFO {
 
 // Accessor functions for DateTime
 #[inline]
-#[cfg(not(PyPy))]
+#[cfg(not(any(PyPy, GraalPy)))]
 /// Retrieve the hour component of a `PyDateTime_DateTime`.
 /// Returns a signed integer in the interval `[0, 23]`
 pub unsafe fn PyDateTime_DATE_GET_HOUR(o: *mut PyObject) -> c_int {
@@ -207,7 +199,7 @@ pub unsafe fn PyDateTime_DATE_GET_HOUR(o: *mut PyObject) -> c_int {
 }
 
 #[inline]
-#[cfg(not(PyPy))]
+#[cfg(not(any(PyPy, GraalPy)))]
 /// Retrieve the minute component of a `PyDateTime_DateTime`.
 /// Returns a signed integer in the interval `[0, 59]`
 pub unsafe fn PyDateTime_DATE_GET_MINUTE(o: *mut PyObject) -> c_int {
@@ -215,7 +207,7 @@ pub unsafe fn PyDateTime_DATE_GET_MINUTE(o: *mut PyObject) -> c_int {
 }
 
 #[inline]
-#[cfg(not(PyPy))]
+#[cfg(not(any(PyPy, GraalPy)))]
 /// Retrieve the second component of a `PyDateTime_DateTime`.
 /// Returns a signed integer in the interval `[0, 59]`
 pub unsafe fn PyDateTime_DATE_GET_SECOND(o: *mut PyObject) -> c_int {
@@ -223,7 +215,7 @@ pub unsafe fn PyDateTime_DATE_GET_SECOND(o: *mut PyObject) -> c_int {
 }
 
 #[inline]
-#[cfg(not(PyPy))]
+#[cfg(not(any(PyPy, GraalPy)))]
 /// Retrieve the microsecond component of a `PyDateTime_DateTime`.
 /// Returns a signed integer in the interval `[0, 999999]`
 pub unsafe fn PyDateTime_DATE_GET_MICROSECOND(o: *mut PyObject) -> c_int {
@@ -231,7 +223,7 @@ pub unsafe fn PyDateTime_DATE_GET_MICROSECOND(o: *mut PyObject) -> c_int {
 }
 
 #[inline]
-#[cfg(not(PyPy))]
+#[cfg(not(any(PyPy, GraalPy)))]
 /// Retrieve the fold component of a `PyDateTime_DateTime`.
 /// Returns a signed integer in the interval `[0, 1]`
 pub unsafe fn PyDateTime_DATE_GET_FOLD(o: *mut PyObject) -> c_uchar {
@@ -239,7 +231,7 @@ pub unsafe fn PyDateTime_DATE_GET_FOLD(o: *mut PyObject) -> c_uchar {
 }
 
 #[inline]
-#[cfg(not(PyPy))]
+#[cfg(not(any(PyPy, GraalPy)))]
 /// Retrieve the tzinfo component of a `PyDateTime_DateTime`.
 /// Returns a pointer to a `PyObject` that should be either NULL or an instance
 /// of a `datetime.tzinfo` subclass.
@@ -249,7 +241,7 @@ pub unsafe fn PyDateTime_DATE_GET_TZINFO(o: *mut PyObject) -> *mut PyObject {
 
 // Accessor functions for Time
 #[inline]
-#[cfg(not(PyPy))]
+#[cfg(not(any(PyPy, GraalPy)))]
 /// Retrieve the hour component of a `PyDateTime_Time`.
 /// Returns a signed integer in the interval `[0, 23]`
 pub unsafe fn PyDateTime_TIME_GET_HOUR(o: *mut PyObject) -> c_int {
@@ -257,7 +249,7 @@ pub unsafe fn PyDateTime_TIME_GET_HOUR(o: *mut PyObject) -> c_int {
 }
 
 #[inline]
-#[cfg(not(PyPy))]
+#[cfg(not(any(PyPy, GraalPy)))]
 /// Retrieve the minute component of a `PyDateTime_Time`.
 /// Returns a signed integer in the interval `[0, 59]`
 pub unsafe fn PyDateTime_TIME_GET_MINUTE(o: *mut PyObject) -> c_int {
@@ -265,7 +257,7 @@ pub unsafe fn PyDateTime_TIME_GET_MINUTE(o: *mut PyObject) -> c_int {
 }
 
 #[inline]
-#[cfg(not(PyPy))]
+#[cfg(not(any(PyPy, GraalPy)))]
 /// Retrieve the second component of a `PyDateTime_DateTime`.
 /// Returns a signed integer in the interval `[0, 59]`
 pub unsafe fn PyDateTime_TIME_GET_SECOND(o: *mut PyObject) -> c_int {
@@ -273,14 +265,14 @@ pub unsafe fn PyDateTime_TIME_GET_SECOND(o: *mut PyObject) -> c_int {
 }
 
 #[inline]
-#[cfg(not(PyPy))]
+#[cfg(not(any(PyPy, GraalPy)))]
 /// Retrieve the microsecond component of a `PyDateTime_DateTime`.
 /// Returns a signed integer in the interval `[0, 999999]`
 pub unsafe fn PyDateTime_TIME_GET_MICROSECOND(o: *mut PyObject) -> c_int {
     _PyDateTime_GET_MICROSECOND!((o as *mut PyDateTime_Time), 0)
 }
 
-#[cfg(not(PyPy))]
+#[cfg(not(any(PyPy, GraalPy)))]
 #[inline]
 /// Retrieve the fold component of a `PyDateTime_Time`.
 /// Returns a signed integer in the interval `[0, 1]`
@@ -289,7 +281,7 @@ pub unsafe fn PyDateTime_TIME_GET_FOLD(o: *mut PyObject) -> c_uchar {
 }
 
 #[inline]
-#[cfg(not(PyPy))]
+#[cfg(not(any(PyPy, GraalPy)))]
 /// Retrieve the tzinfo component of a `PyDateTime_Time`.
 /// Returns a pointer to a `PyObject` that should be either NULL or an instance
 /// of a `datetime.tzinfo` subclass.
@@ -298,7 +290,7 @@ pub unsafe fn PyDateTime_TIME_GET_TZINFO(o: *mut PyObject) -> *mut PyObject {
 }
 
 // Accessor functions
-#[cfg(not(PyPy))]
+#[cfg(not(any(PyPy, GraalPy)))]
 macro_rules! _access_field {
     ($obj:expr, $type: ident, $field:ident) => {
         (*($obj as *mut $type)).$field
@@ -306,7 +298,7 @@ macro_rules! _access_field {
 }
 
 // Accessor functions for PyDateTime_Delta
-#[cfg(not(PyPy))]
+#[cfg(not(any(PyPy, GraalPy)))]
 macro_rules! _access_delta_field {
     ($obj:expr, $field:ident) => {
         _access_field!($obj, PyDateTime_Delta, $field)
@@ -314,7 +306,7 @@ macro_rules! _access_delta_field {
 }
 
 #[inline]
-#[cfg(not(PyPy))]
+#[cfg(not(any(PyPy, GraalPy)))]
 /// Retrieve the days component of a `PyDateTime_Delta`.
 ///
 /// Returns a signed integer in the interval [-999999999, 999999999].
@@ -326,7 +318,7 @@ pub unsafe fn PyDateTime_DELTA_GET_DAYS(o: *mut PyObject) -> c_int {
 }
 
 #[inline]
-#[cfg(not(PyPy))]
+#[cfg(not(any(PyPy, GraalPy)))]
 /// Retrieve the seconds component of a `PyDateTime_Delta`.
 ///
 /// Returns a signed integer in the interval [0, 86399].
@@ -338,7 +330,7 @@ pub unsafe fn PyDateTime_DELTA_GET_SECONDS(o: *mut PyObject) -> c_int {
 }
 
 #[inline]
-#[cfg(not(PyPy))]
+#[cfg(not(any(PyPy, GraalPy)))]
 /// Retrieve the seconds component of a `PyDateTime_Delta`.
 ///
 /// Returns a signed integer in the interval [0, 999999].
@@ -349,6 +341,132 @@ pub unsafe fn PyDateTime_DELTA_GET_MICROSECONDS(o: *mut PyObject) -> c_int {
     _access_delta_field!(o, microseconds)
 }
 
+// Accessor functions for GraalPy. The macros on GraalPy work differently,
+// but copying them seems suboptimal
+#[inline]
+#[cfg(GraalPy)]
+pub unsafe fn _get_attr(obj: *mut PyObject, field: &std::ffi::CStr) -> c_int {
+    let result = PyObject_GetAttrString(obj, field.as_ptr());
+    Py_DecRef(result); // the original macros are borrowing
+    if PyLong_Check(result) == 1 {
+        PyLong_AsLong(result) as c_int
+    } else {
+        0
+    }
+}
+
+#[inline]
+#[cfg(GraalPy)]
+pub unsafe fn PyDateTime_GET_YEAR(o: *mut PyObject) -> c_int {
+    _get_attr(o, c"year")
+}
+
+#[inline]
+#[cfg(GraalPy)]
+pub unsafe fn PyDateTime_GET_MONTH(o: *mut PyObject) -> c_int {
+    _get_attr(o, c"month")
+}
+
+#[inline]
+#[cfg(GraalPy)]
+pub unsafe fn PyDateTime_GET_DAY(o: *mut PyObject) -> c_int {
+    _get_attr(o, c"day")
+}
+
+#[inline]
+#[cfg(GraalPy)]
+pub unsafe fn PyDateTime_DATE_GET_HOUR(o: *mut PyObject) -> c_int {
+    _get_attr(o, c"hour")
+}
+
+#[inline]
+#[cfg(GraalPy)]
+pub unsafe fn PyDateTime_DATE_GET_MINUTE(o: *mut PyObject) -> c_int {
+    _get_attr(o, c"minute")
+}
+
+#[inline]
+#[cfg(GraalPy)]
+pub unsafe fn PyDateTime_DATE_GET_SECOND(o: *mut PyObject) -> c_int {
+    _get_attr(o, c"second")
+}
+
+#[inline]
+#[cfg(GraalPy)]
+pub unsafe fn PyDateTime_DATE_GET_MICROSECOND(o: *mut PyObject) -> c_int {
+    _get_attr(o, c"microsecond")
+}
+
+#[inline]
+#[cfg(GraalPy)]
+pub unsafe fn PyDateTime_DATE_GET_FOLD(o: *mut PyObject) -> c_int {
+    _get_attr(o, c"fold")
+}
+
+#[inline]
+#[cfg(GraalPy)]
+pub unsafe fn PyDateTime_DATE_GET_TZINFO(o: *mut PyObject) -> *mut PyObject {
+    let res = PyObject_GetAttrString(o, c"tzinfo".as_ptr().cast());
+    Py_DecRef(res); // the original macros are borrowing
+    res
+}
+
+#[inline]
+#[cfg(GraalPy)]
+pub unsafe fn PyDateTime_TIME_GET_HOUR(o: *mut PyObject) -> c_int {
+    _get_attr(o, c"hour")
+}
+
+#[inline]
+#[cfg(GraalPy)]
+pub unsafe fn PyDateTime_TIME_GET_MINUTE(o: *mut PyObject) -> c_int {
+    _get_attr(o, c"minute")
+}
+
+#[inline]
+#[cfg(GraalPy)]
+pub unsafe fn PyDateTime_TIME_GET_SECOND(o: *mut PyObject) -> c_int {
+    _get_attr(o, c"second")
+}
+
+#[inline]
+#[cfg(GraalPy)]
+pub unsafe fn PyDateTime_TIME_GET_MICROSECOND(o: *mut PyObject) -> c_int {
+    _get_attr(o, c"microsecond")
+}
+
+#[inline]
+#[cfg(GraalPy)]
+pub unsafe fn PyDateTime_TIME_GET_FOLD(o: *mut PyObject) -> c_int {
+    _get_attr(o, c"fold")
+}
+
+#[inline]
+#[cfg(GraalPy)]
+pub unsafe fn PyDateTime_TIME_GET_TZINFO(o: *mut PyObject) -> *mut PyObject {
+    let res = PyObject_GetAttrString(o, c"tzinfo".as_ptr().cast());
+    Py_DecRef(res); // the original macros are borrowing
+    res
+}
+
+#[inline]
+#[cfg(GraalPy)]
+pub unsafe fn PyDateTime_DELTA_GET_DAYS(o: *mut PyObject) -> c_int {
+    _get_attr(o, c"days")
+}
+
+#[inline]
+#[cfg(GraalPy)]
+pub unsafe fn PyDateTime_DELTA_GET_SECONDS(o: *mut PyObject) -> c_int {
+    _get_attr(o, c"seconds")
+}
+
+#[inline]
+#[cfg(GraalPy)]
+pub unsafe fn PyDateTime_DELTA_GET_MICROSECONDS(o: *mut PyObject) -> c_int {
+    _get_attr(o, c"microseconds")
+}
+
 #[cfg(PyPy)]
 extern "C" {
     // skipped _PyDateTime_HAS_TZINFO (not in PyPy)
@@ -369,7 +487,9 @@ extern "C" {
     pub fn PyDateTime_DATE_GET_MICROSECOND(o: *mut PyObject) -> c_int;
     #[link_name = "PyPyDateTime_GET_FOLD"]
     pub fn PyDateTime_DATE_GET_FOLD(o: *mut PyObject) -> c_int;
-    // skipped PyDateTime_DATE_GET_TZINFO (not in PyPy)
+    #[link_name = "PyPyDateTime_DATE_GET_TZINFO"]
+    #[cfg(Py_3_10)]
+    pub fn PyDateTime_DATE_GET_TZINFO(o: *mut PyObject) -> *mut PyObject;
 
     #[link_name = "PyPyDateTime_TIME_GET_HOUR"]
     pub fn PyDateTime_TIME_GET_HOUR(o: *mut PyObject) -> c_int;
@@ -381,7 +501,9 @@ extern "C" {
     pub fn PyDateTime_TIME_GET_MICROSECOND(o: *mut PyObject) -> c_int;
     #[link_name = "PyPyDateTime_TIME_GET_FOLD"]
     pub fn PyDateTime_TIME_GET_FOLD(o: *mut PyObject) -> c_int;
-    // skipped PyDateTime_TIME_GET_TZINFO (not in PyPy)
+    #[link_name = "PyPyDateTime_TIME_GET_TZINFO"]
+    #[cfg(Py_3_10)]
+    pub fn PyDateTime_TIME_GET_TZINFO(o: *mut PyObject) -> *mut PyObject;
 
     #[link_name = "PyPyDateTime_DELTA_GET_DAYS"]
     pub fn PyDateTime_DELTA_GET_DAYS(o: *mut PyObject) -> c_int;
@@ -468,6 +590,8 @@ pub struct PyDateTime_CAPI {
 // Python already shares this object between threads, so it's no more evil for us to do it too!
 unsafe impl Sync for PyDateTime_CAPI {}
 
+pub const PyDateTime_CAPSULE_NAME: &CStr = c"datetime.datetime_CAPI";
+
 /// Returns a pointer to a `PyDateTime_CAPI` instance
 ///
 /// # Note
@@ -475,33 +599,38 @@ unsafe impl Sync for PyDateTime_CAPI {}
 /// `PyDateTime_IMPORT` is called
 #[inline]
 pub unsafe fn PyDateTimeAPI() -> *mut PyDateTime_CAPI {
-    *PyDateTimeAPI_impl.0.get()
-}
-
-#[inline]
-pub unsafe fn PyDateTime_TimeZone_UTC() -> *mut PyObject {
-    (*PyDateTimeAPI()).TimeZone_UTC
+    *PyDateTimeAPI_impl.ptr.get()
 }
 
 /// Populates the `PyDateTimeAPI` object
 pub unsafe fn PyDateTime_IMPORT() {
-    // PyPy expects the C-API to be initialized via PyDateTime_Import, so trying to use
-    // `PyCapsule_Import` will behave unexpectedly in pypy.
-    #[cfg(PyPy)]
-    let py_datetime_c_api = PyDateTime_Import();
-
-    #[cfg(not(PyPy))]
-    let py_datetime_c_api = {
-        // PyDateTime_CAPSULE_NAME is a macro in C
-        let PyDateTime_CAPSULE_NAME = CString::new("datetime.datetime_CAPI").unwrap();
-
-        PyCapsule_Import(PyDateTime_CAPSULE_NAME.as_ptr(), 1) as *mut PyDateTime_CAPI
-    };
+    if !PyDateTimeAPI_impl.once.is_completed() {
+        // PyPy expects the C-API to be initialized via PyDateTime_Import, so trying to use
+        // `PyCapsule_Import` will behave unexpectedly in pypy.
+        #[cfg(PyPy)]
+        let py_datetime_c_api = PyDateTime_Import();
+
+        #[cfg(not(PyPy))]
+        let py_datetime_c_api =
+            PyCapsule_Import(PyDateTime_CAPSULE_NAME.as_ptr(), 1) as *mut PyDateTime_CAPI;
+
+        if py_datetime_c_api.is_null() {
+            return;
+        }
 
-    *PyDateTimeAPI_impl.0.get() = py_datetime_c_api;
+        // Protect against race conditions when the datetime API is concurrently
+        // initialized in multiple threads. UnsafeCell.get() cannot panic so this
+        // won't panic either.
+        PyDateTimeAPI_impl.once.call_once(|| {
+            *PyDateTimeAPI_impl.ptr.get() = py_datetime_c_api;
+        });
+    }
 }
 
-// skipped non-limited PyDateTime_TimeZone_UTC
+#[inline]
+pub unsafe fn PyDateTime_TimeZone_UTC() -> *mut PyObject {
+    (*PyDateTimeAPI()).TimeZone_UTC
+}
 
 /// Type Check macros
 ///
@@ -614,8 +743,13 @@ extern "C" {
 
 // Rust specific implementation details
 
-struct PyDateTimeAPISingleton(UnsafeCell<*mut PyDateTime_CAPI>);
+struct PyDateTimeAPISingleton {
+    once: Once,
+    ptr: UnsafeCell<*mut PyDateTime_CAPI>,
+}
 unsafe impl Sync for PyDateTimeAPISingleton {}
 
-static PyDateTimeAPI_impl: PyDateTimeAPISingleton =
-    PyDateTimeAPISingleton(UnsafeCell::new(ptr::null_mut()));
+static PyDateTimeAPI_impl: PyDateTimeAPISingleton = PyDateTimeAPISingleton {
+    once: Once::new(),
+    ptr: UnsafeCell::new(ptr::null_mut()),
+};
diff --git a/pyo3-ffi/src/descrobject.rs b/pyo3-ffi/src/descrobject.rs
index f4a5ce00bf6..8a4d5839a37 100644
--- a/pyo3-ffi/src/descrobject.rs
+++ b/pyo3-ffi/src/descrobject.rs
@@ -1,7 +1,7 @@
 use crate::methodobject::PyMethodDef;
 use crate::object::{PyObject, PyTypeObject};
 use crate::Py_ssize_t;
-use std::os::raw::{c_char, c_int, c_void};
+use std::ffi::{c_char, c_int, c_void};
 use std::ptr;
 
 pub type getter = unsafe extern "C" fn(slf: *mut PyObject, closure: *mut c_void) -> *mut PyObject;
@@ -14,7 +14,7 @@ pub type setter =
 /// Note that CPython may leave fields uninitialized. You must ensure that
 /// `name` != NULL before dereferencing or reading other fields.
 #[repr(C)]
-#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+#[derive(Copy, Clone, Debug)]
 pub struct PyGetSetDef {
     pub name: *const c_char,
     pub get: Option<getter>,
diff --git a/pyo3-ffi/src/dictobject.rs b/pyo3-ffi/src/dictobject.rs
index 8d522df97e2..d8419ba4317 100644
--- a/pyo3-ffi/src/dictobject.rs
+++ b/pyo3-ffi/src/dictobject.rs
@@ -1,6 +1,6 @@
 use crate::object::*;
 use crate::pyport::Py_ssize_t;
-use std::os::raw::{c_char, c_int};
+use std::ffi::{c_char, c_int};
 use std::ptr::addr_of_mut;
 
 #[cfg_attr(windows, link(name = "pythonXY"))]
@@ -66,6 +66,13 @@ extern "C" {
     ) -> c_int;
     #[cfg_attr(PyPy, link_name = "PyPyDict_DelItemString")]
     pub fn PyDict_DelItemString(dp: *mut PyObject, key: *const c_char) -> c_int;
+    #[cfg(Py_3_13)]
+    #[cfg_attr(PyPy, link_name = "PyPyDict_GetItemRef")]
+    pub fn PyDict_GetItemRef(
+        dp: *mut PyObject,
+        key: *mut PyObject,
+        result: *mut *mut PyObject,
+    ) -> c_int;
     // skipped 3.10 / ex-non-limited PyObject_GenericGetDict
 }
 
@@ -109,6 +116,6 @@ extern "C" {
     pub static mut PyDictRevIterItem_Type: PyTypeObject;
 }
 
-#[cfg(any(PyPy, Py_LIMITED_API))]
+#[cfg(any(PyPy, GraalPy, Py_LIMITED_API))]
 // TODO: remove (see https://github.com/PyO3/pyo3/pull/1341#issuecomment-751515985)
-opaque_struct!(PyDictObject);
+opaque_struct!(pub PyDictObject);
diff --git a/pyo3-ffi/src/fileobject.rs b/pyo3-ffi/src/fileobject.rs
index 91618ab7fd2..ec3a0409930 100644
--- a/pyo3-ffi/src/fileobject.rs
+++ b/pyo3-ffi/src/fileobject.rs
@@ -1,5 +1,5 @@
 use crate::object::PyObject;
-use std::os::raw::{c_char, c_int};
+use std::ffi::{c_char, c_int};
 
 pub const PY_STDIOTEXTMODE: &str = "b";
 
diff --git a/pyo3-ffi/src/fileutils.rs b/pyo3-ffi/src/fileutils.rs
index 3f053b72b51..649751babf5 100644
--- a/pyo3-ffi/src/fileutils.rs
+++ b/pyo3-ffi/src/fileutils.rs
@@ -1,6 +1,6 @@
 use crate::pyport::Py_ssize_t;
 use libc::wchar_t;
-use std::os::raw::c_char;
+use std::ffi::c_char;
 
 extern "C" {
     pub fn Py_DecodeLocale(arg1: *const c_char, size: *mut Py_ssize_t) -> *mut wchar_t;
diff --git a/pyo3-ffi/src/floatobject.rs b/pyo3-ffi/src/floatobject.rs
index 65fc1d4c316..18bbc8bece0 100644
--- a/pyo3-ffi/src/floatobject.rs
+++ b/pyo3-ffi/src/floatobject.rs
@@ -1,10 +1,10 @@
 use crate::object::*;
-use std::os::raw::{c_double, c_int};
+use std::ffi::{c_double, c_int};
 use std::ptr::addr_of_mut;
 
 #[cfg(Py_LIMITED_API)]
 // TODO: remove (see https://github.com/PyO3/pyo3/pull/1341#issuecomment-751515985)
-opaque_struct!(PyFloatObject);
+opaque_struct!(pub PyFloatObject);
 
 #[cfg_attr(windows, link(name = "pythonXY"))]
 extern "C" {
diff --git a/pyo3-ffi/src/genericaliasobject.rs b/pyo3-ffi/src/genericaliasobject.rs
new file mode 100644
index 00000000000..7979d7d863e
--- /dev/null
+++ b/pyo3-ffi/src/genericaliasobject.rs
@@ -0,0 +1,12 @@
+#[cfg(Py_3_9)]
+use crate::object::{PyObject, PyTypeObject};
+
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
+    #[cfg(Py_3_9)]
+    #[cfg_attr(PyPy, link_name = "PyPy_GenericAlias")]
+    pub fn Py_GenericAlias(origin: *mut PyObject, args: *mut PyObject) -> *mut PyObject;
+
+    #[cfg(Py_3_9)]
+    pub static mut Py_GenericAliasType: PyTypeObject;
+}
diff --git a/pyo3-ffi/src/impl_/mod.rs b/pyo3-ffi/src/impl_/mod.rs
new file mode 100644
index 00000000000..064df213ba6
--- /dev/null
+++ b/pyo3-ffi/src/impl_/mod.rs
@@ -0,0 +1,22 @@
+#[cfg(Py_GIL_DISABLED)]
+mod atomic_c_ulong {
+    pub struct GetAtomicCULong<const WIDTH: usize>();
+
+    pub trait AtomicCULongType {
+        type Type;
+    }
+    impl AtomicCULongType for GetAtomicCULong<32> {
+        type Type = std::sync::atomic::AtomicU32;
+    }
+    impl AtomicCULongType for GetAtomicCULong<64> {
+        type Type = std::sync::atomic::AtomicU64;
+    }
+
+    pub type TYPE =
+        <GetAtomicCULong<{ std::mem::size_of::<std::ffi::c_ulong>() * 8 }> as AtomicCULongType>::Type;
+}
+
+/// Typedef for an atomic integer to match the platform-dependent c_ulong type.
+#[cfg(Py_GIL_DISABLED)]
+#[doc(hidden)]
+pub type AtomicCULong = atomic_c_ulong::TYPE;
diff --git a/pyo3-ffi/src/import.rs b/pyo3-ffi/src/import.rs
index e00843466e8..ce224af28e1 100644
--- a/pyo3-ffi/src/import.rs
+++ b/pyo3-ffi/src/import.rs
@@ -1,5 +1,5 @@
 use crate::object::PyObject;
-use std::os::raw::{c_char, c_int, c_long};
+use std::ffi::{c_char, c_int, c_long};
 
 extern "C" {
     pub fn PyImport_GetMagicNumber() -> c_long;
@@ -30,6 +30,9 @@ extern "C" {
     pub fn PyImport_AddModuleObject(name: *mut PyObject) -> *mut PyObject;
     #[cfg_attr(PyPy, link_name = "PyPyImport_AddModule")]
     pub fn PyImport_AddModule(name: *const c_char) -> *mut PyObject;
+    #[cfg(Py_3_13)]
+    #[cfg_attr(PyPy, link_name = "PyPyImport_AddModuleRef")]
+    pub fn PyImport_AddModuleRef(name: *const c_char) -> *mut PyObject;
     #[cfg_attr(PyPy, link_name = "PyPyImport_ImportModule")]
     pub fn PyImport_ImportModule(name: *const c_char) -> *mut PyObject;
     #[cfg_attr(PyPy, link_name = "PyPyImport_ImportModuleNoBlock")]
diff --git a/pyo3-ffi/src/intrcheck.rs b/pyo3-ffi/src/intrcheck.rs
index 3d8a58f7f2f..05400557d5a 100644
--- a/pyo3-ffi/src/intrcheck.rs
+++ b/pyo3-ffi/src/intrcheck.rs
@@ -1,4 +1,4 @@
-use std::os::raw::c_int;
+use std::ffi::c_int;
 
 extern "C" {
     #[cfg_attr(PyPy, link_name = "PyPyOS_InterruptOccurred")]
diff --git a/pyo3-ffi/src/iterobject.rs b/pyo3-ffi/src/iterobject.rs
index aa0c7b26db1..04a28d4826f 100644
--- a/pyo3-ffi/src/iterobject.rs
+++ b/pyo3-ffi/src/iterobject.rs
@@ -1,5 +1,5 @@
 use crate::object::*;
-use std::os::raw::c_int;
+use std::ffi::c_int;
 use std::ptr::addr_of_mut;
 
 #[cfg_attr(windows, link(name = "pythonXY"))]
diff --git a/pyo3-ffi/src/lib.rs b/pyo3-ffi/src/lib.rs
index 5e241fbb2c7..3faf4d4c2c3 100644
--- a/pyo3-ffi/src/lib.rs
+++ b/pyo3-ffi/src/lib.rs
@@ -1,3 +1,4 @@
+#![cfg_attr(docsrs, feature(doc_cfg))]
 //! Raw FFI declarations for Python's C API.
 //!
 //! PyO3 can be used to write native Python modules or run Python code and modules from Rust.
@@ -16,7 +17,7 @@
 //! generally the following apply:
 //! - Pointer arguments have to point to a valid Python object of the correct type,
 //! although null pointers are sometimes valid input.
-//! - The vast majority can only be used safely while the GIL is held.
+//! - The vast majority can only be used safely while the thread is attached to the Python interpreter.
 //! - Some functions have additional safety requirements, consult the
 //! [Python/C API Reference Manual][capi]
 //! for more information.
@@ -42,16 +43,46 @@
 //! PyO3 uses `rustc`'s `--cfg` flags to enable or disable code used for different Python versions.
 //! If you want to do this for your own crate, you can do so with the [`pyo3-build-config`] crate.
 //!
-//! - `Py_3_7`, `Py_3_8`, `Py_3_9`, `Py_3_10`: Marks code that is only enabled when
-//!  compiling for a given minimum Python version.
+//! - `Py_3_7`, `Py_3_8`, `Py_3_9`, `Py_3_10`, `Py_3_11`, `Py_3_12`, `Py_3_13`: Marks code that is
+//!    only enabled when compiling for a given minimum Python version.
 //! - `Py_LIMITED_API`: Marks code enabled when the `abi3` feature flag is enabled.
+//! - `Py_GIL_DISABLED`: Marks code that runs only in the free-threaded build of CPython.
 //! - `PyPy` - Marks code enabled when compiling for PyPy.
+//! - `GraalPy` - Marks code enabled when compiling for GraalPy.
+//!
+//! Additionally, you can query for the values `Py_DEBUG`, `Py_REF_DEBUG`,
+//! `Py_TRACE_REFS`, and `COUNT_ALLOCS` from `py_sys_config` to query for the
+//! corresponding C build-time defines. For example, to conditionally define
+//! debug code using `Py_DEBUG`, you could do:
+//!
+//! ```rust,ignore
+//! #[cfg(py_sys_config = "Py_DEBUG")]
+//! println!("only runs if python was compiled with Py_DEBUG")
+//! ```
+//!
+//! To use these attributes, add [`pyo3-build-config`] as a build dependency in
+//! your `Cargo.toml`:
+//!
+//! ```toml
+//! [build-dependencies]
+#![doc = concat!("pyo3-build-config =\"", env!("CARGO_PKG_VERSION"),  "\"")]
+//! ```
+//!
+//! And then either create a new `build.rs` file in the project root or modify
+//! the existing `build.rs` file to call `use_pyo3_cfgs()`:
+//!
+//! ```rust,ignore
+//! fn main() {
+//!     pyo3_build_config::use_pyo3_cfgs();
+//! }
+//! ```
 //!
 //! # Minimum supported Rust and Python versions
 //!
-//! PyO3 supports the following software versions:
-//!   - Python 3.7 and up (CPython and PyPy)
-//!   - Rust 1.56 and up
+//! `pyo3-ffi` supports the following Python distributions:
+//!   - CPython 3.7 or greater
+//!   - PyPy 7.3 (Python 3.11+)
+//!   - GraalPy 24.0 or greater (Python 3.10+)
 //!
 //! # Example: Building Python Native modules
 //!
@@ -77,99 +108,148 @@
 //! [dependencies.pyo3-ffi]
 #![doc = concat!("version = \"", env!("CARGO_PKG_VERSION"),  "\"")]
 //! features = ["extension-module"]
+//!
+//! [build-dependencies]
+//! # This is only necessary if you need to configure your build based on
+//! # the Python version or the compile-time configuration for the interpreter.
+#![doc = concat!("pyo3_build_config = \"", env!("CARGO_PKG_VERSION"),  "\"")]
+//! ```
+//!
+//! If you need to use conditional compilation based on Python version or how
+//! Python was compiled, you need to add `pyo3-build-config` as a
+//! `build-dependency` in your `Cargo.toml` as in the example above and either
+//! create a new `build.rs` file or modify an existing one so that
+//! `pyo3_build_config::use_pyo3_cfgs()` gets called at build time:
+//!
+//! **`build.rs`**
+//! ```rust,ignore
+//! fn main() {
+//!     pyo3_build_config::use_pyo3_cfgs()
+//! }
 //! ```
 //!
 //! **`src/lib.rs`**
-//! ```rust
-//! use std::os::raw::c_char;
+//! ```rust,no_run
+//! use std::ffi::{c_char, c_long};
 //! use std::ptr;
 //!
 //! use pyo3_ffi::*;
 //!
 //! static mut MODULE_DEF: PyModuleDef = PyModuleDef {
 //!     m_base: PyModuleDef_HEAD_INIT,
-//!     m_name: "string_sum\0".as_ptr().cast::<c_char>(),
-//!     m_doc: "A Python module written in Rust.\0"
-//!         .as_ptr()
-//!         .cast::<c_char>(),
+//!     m_name: c"string_sum".as_ptr(),
+//!     m_doc: c"A Python module written in Rust.".as_ptr(),
 //!     m_size: 0,
-//!     m_methods: unsafe { METHODS.as_mut_ptr().cast() },
+//!     m_methods: unsafe { METHODS as *const [PyMethodDef] as *mut PyMethodDef },
 //!     m_slots: std::ptr::null_mut(),
 //!     m_traverse: None,
 //!     m_clear: None,
 //!     m_free: None,
 //! };
 //!
-//! static mut METHODS: [PyMethodDef; 2] = [
+//! static mut METHODS: &[PyMethodDef] = &[
 //!     PyMethodDef {
-//!         ml_name: "sum_as_string\0".as_ptr().cast::<c_char>(),
+//!         ml_name: c"sum_as_string".as_ptr(),
 //!         ml_meth: PyMethodDefPointer {
-//!             _PyCFunctionFast: sum_as_string,
+//!             PyCFunctionFast: sum_as_string,
 //!         },
 //!         ml_flags: METH_FASTCALL,
-//!         ml_doc: "returns the sum of two integers as a string\0"
-//!             .as_ptr()
-//!             .cast::<c_char>(),
+//!         ml_doc: c"returns the sum of two integers as a string".as_ptr(),
 //!     },
 //!     // A zeroed PyMethodDef to mark the end of the array.
-//!     PyMethodDef::zeroed()
+//!     PyMethodDef::zeroed(),
 //! ];
 //!
 //! // The module initialization function, which must be named `PyInit_<your_module>`.
 //! #[allow(non_snake_case)]
 //! #[no_mangle]
 //! pub unsafe extern "C" fn PyInit_string_sum() -> *mut PyObject {
-//!     PyModule_Create(ptr::addr_of_mut!(MODULE_DEF))
+//!     let module = PyModule_Create(ptr::addr_of_mut!(MODULE_DEF));
+//!     if module.is_null() {
+//!         return module;
+//!     }
+//!     #[cfg(Py_GIL_DISABLED)]
+//!     {
+//!         if PyUnstable_Module_SetGIL(module, Py_MOD_GIL_NOT_USED) < 0 {
+//!             Py_DECREF(module);
+//!             return std::ptr::null_mut();
+//!         }
+//!     }
+//!     module
 //! }
 //!
-//! pub unsafe extern "C" fn sum_as_string(
-//!     _self: *mut PyObject,
-//!     args: *mut *mut PyObject,
-//!     nargs: Py_ssize_t,
-//! ) -> *mut PyObject {
-//!     if nargs != 2 {
-//!         PyErr_SetString(
-//!             PyExc_TypeError,
-//!             "sum_as_string() expected 2 positional arguments\0"
-//!                 .as_ptr()
-//!                 .cast::<c_char>(),
+//! /// A helper to parse function arguments
+//! /// If we used PyO3's proc macros they'd handle all of this boilerplate for us :)
+//! unsafe fn parse_arg_as_i32(obj: *mut PyObject, n_arg: usize) -> Option<i32> {
+//!     if PyLong_Check(obj) == 0 {
+//!         let msg = format!(
+//!             "sum_as_string expected an int for positional argument {}\0",
+//!             n_arg
 //!         );
-//!         return std::ptr::null_mut();
+//!         PyErr_SetString(PyExc_TypeError, msg.as_ptr().cast::<c_char>());
+//!         return None;
 //!     }
 //!
-//!     let arg1 = *args;
-//!     if PyLong_Check(arg1) == 0 {
-//!         PyErr_SetString(
-//!             PyExc_TypeError,
-//!             "sum_as_string() expected an int for positional argument 1\0"
-//!                 .as_ptr()
-//!                 .cast::<c_char>(),
-//!         );
-//!         return std::ptr::null_mut();
+//!     // Let's keep the behaviour consistent on platforms where `c_long` is bigger than 32 bits.
+//!     // In particular, it is an i32 on Windows but i64 on most Linux systems
+//!     let mut overflow = 0;
+//!     let i_long: c_long = PyLong_AsLongAndOverflow(obj, &mut overflow);
+//!
+//!     #[allow(irrefutable_let_patterns)] // some platforms have c_long equal to i32
+//!     if overflow != 0 {
+//!         raise_overflowerror(obj);
+//!         None
+//!     } else if let Ok(i) = i_long.try_into() {
+//!         Some(i)
+//!     } else {
+//!         raise_overflowerror(obj);
+//!         None
 //!     }
+//! }
 //!
-//!     let arg1 = PyLong_AsLong(arg1);
-//!     if !PyErr_Occurred().is_null() {
-//!         return ptr::null_mut();
+//! unsafe fn raise_overflowerror(obj: *mut PyObject) {
+//!     let obj_repr = PyObject_Str(obj);
+//!     if !obj_repr.is_null() {
+//!         let mut size = 0;
+//!         let p = PyUnicode_AsUTF8AndSize(obj_repr, &mut size);
+//!         if !p.is_null() {
+//!             let s = std::str::from_utf8_unchecked(std::slice::from_raw_parts(
+//!                 p.cast::<u8>(),
+//!                 size as usize,
+//!             ));
+//!             let msg = format!("cannot fit {} in 32 bits\0", s);
+//!
+//!             PyErr_SetString(PyExc_OverflowError, msg.as_ptr().cast::<c_char>());
+//!         }
+//!         Py_DECREF(obj_repr);
 //!     }
+//! }
 //!
-//!     let arg2 = *args.add(1);
-//!     if PyLong_Check(arg2) == 0 {
+//! pub unsafe extern "C" fn sum_as_string(
+//!     _self: *mut PyObject,
+//!     args: *mut *mut PyObject,
+//!     nargs: Py_ssize_t,
+//! ) -> *mut PyObject {
+//!     if nargs != 2 {
 //!         PyErr_SetString(
 //!             PyExc_TypeError,
-//!             "sum_as_string() expected an int for positional argument 2\0"
-//!                 .as_ptr()
-//!                 .cast::<c_char>(),
+//!             c"sum_as_string expected 2 positional arguments".as_ptr(),
 //!         );
 //!         return std::ptr::null_mut();
 //!     }
 //!
-//!     let arg2 = PyLong_AsLong(arg2);
-//!     if !PyErr_Occurred().is_null() {
-//!         return ptr::null_mut();
-//!     }
+//!     let (first, second) = (*args, *args.add(1));
+//!
+//!     let first = match parse_arg_as_i32(first, 1) {
+//!         Some(x) => x,
+//!         None => return std::ptr::null_mut(),
+//!     };
+//!     let second = match parse_arg_as_i32(second, 2) {
+//!         Some(x) => x,
+//!         None => return std::ptr::null_mut(),
+//!     };
 //!
-//!     match arg1.checked_add(arg2) {
+//!     match first.checked_add(second) {
 //!         Some(sum) => {
 //!             let string = sum.to_string();
 //!             PyUnicode_FromStringAndSize(string.as_ptr().cast::<c_char>(), string.len() as isize)
@@ -177,7 +257,7 @@
 //!         None => {
 //!             PyErr_SetString(
 //!                 PyExc_OverflowError,
-//!                 "arguments too large to add\0".as_ptr().cast::<c_char>(),
+//!                 c"arguments too large to add".as_ptr(),
 //!             );
 //!             std::ptr::null_mut()
 //!         }
@@ -209,6 +289,12 @@
 //! [manually][manual_builds]. Both offer more flexibility than `maturin` but require further
 //! configuration.
 //!
+//! This example stores the module definition statically and uses the `PyModule_Create` function
+//! in the CPython C API to register the module. This is the "old" style for registering modules
+//! and has the limitation that it cannot support subinterpreters. You can also create a module
+//! using the new multi-phase initialization API that does support subinterpreters. See the
+//! `sequential` project located in the `examples` directory at the root of the `pyo3-ffi` crate
+//! for a worked example of how to this using `pyo3-ffi`.
 //!
 //! # Using Python from Rust
 //!
@@ -231,31 +317,73 @@
 //! [`maturin`]: https://github.com/PyO3/maturin "Build and publish crates with pyo3, rust-cpython and cffi bindings as well as rust binaries as python packages"
 //! [`pyo3-build-config`]: https://docs.rs/pyo3-build-config
 //! [feature flags]: https://doc.rust-lang.org/cargo/reference/features.html "Features - The Cargo Book"
-//! [manual_builds]: https://pyo3.rs/latest/building_and_distribution.html#manual-builds "Manual builds - Building and Distribution - PyO3 user guide"
+#![doc = concat!("[manual_builds]: https://pyo3.rs/v", env!("CARGO_PKG_VERSION"), "/building-and-distribution.html#manual-builds \"Manual builds - Building and Distribution - PyO3 user guide\"")]
 //! [setuptools-rust]: https://github.com/PyO3/setuptools-rust "Setuptools plugin for Rust extensions"
 //! [PEP 384]: https://www.python.org/dev/peps/pep-0384 "PEP 384 -- Defining a Stable ABI"
-//! [Features chapter of the guide]: https://pyo3.rs/latest/features.html#features-reference "Features Reference - PyO3 user guide"
-
+#![doc = concat!("[Features chapter of the guide]: https://pyo3.rs/v", env!("CARGO_PKG_VERSION"), "/features.html#features-reference \"Features eference - PyO3 user guide\"")]
 #![allow(
     missing_docs,
     non_camel_case_types,
     non_snake_case,
     non_upper_case_globals,
     clippy::upper_case_acronyms,
-    clippy::missing_safety_doc
+    clippy::missing_safety_doc,
+    clippy::ptr_eq
 )]
 #![warn(elided_lifetimes_in_paths, unused_lifetimes)]
+// This crate is a hand-maintained translation of CPython's headers, so requiring "unsafe"
+// blocks within those translations increases maintenance burden without providing any
+// additional safety. The safety of the functions in this crate is determined by the
+// original CPython headers
+#![allow(unsafe_op_in_unsafe_fn)]
 
 // Until `extern type` is stabilized, use the recommended approach to
 // model opaque types:
 // https://doc.rust-lang.org/nomicon/ffi.html#representing-opaque-structs
 macro_rules! opaque_struct {
-    ($name:ident) => {
+    ($(#[$attrs:meta])* $pub:vis $name:ident) => {
+        $(#[$attrs])*
         #[repr(C)]
-        pub struct $name([u8; 0]);
+        $pub struct $name([u8; 0]);
     };
 }
 
+/// This is a helper macro to create a `&'static CStr`.
+///
+/// It can be used on all Rust versions supported by PyO3, unlike c"" literals which
+/// were stabilised in Rust 1.77.
+///
+/// Due to the nature of PyO3 making heavy use of C FFI interop with Python, it is
+/// common for PyO3 to use CStr.
+///
+/// Examples:
+///
+/// ```rust,no_run
+/// use std::ffi::CStr;
+///
+/// const HELLO: &CStr = pyo3_ffi::c_str!("hello");
+/// static WORLD: &CStr = pyo3_ffi::c_str!("world");
+/// ```
+#[macro_export]
+macro_rules! c_str {
+    // TODO: deprecate this now MSRV is above 1.77
+    ($s:expr) => {
+        $crate::_cstr_from_utf8_with_nul_checked(concat!($s, "\0"))
+    };
+}
+
+/// Private helper for `c_str!` macro.
+#[doc(hidden)]
+pub const fn _cstr_from_utf8_with_nul_checked(s: &str) -> &std::ffi::CStr {
+    match std::ffi::CStr::from_bytes_with_nul(s.as_bytes()) {
+        Ok(cstr) => cstr,
+        Err(_) => panic!("string contains nul bytes"),
+    }
+}
+
+pub mod compat;
+mod impl_;
+
 pub use self::abstract_::*;
 pub use self::bltinmodule::*;
 pub use self::boolobject::*;
@@ -277,6 +405,8 @@ pub use self::enumobject::*;
 pub use self::fileobject::*;
 pub use self::fileutils::*;
 pub use self::floatobject::*;
+#[cfg(Py_3_9)]
+pub use self::genericaliasobject::*;
 pub use self::import::*;
 pub use self::intrcheck::*;
 pub use self::iterobject::*;
@@ -305,7 +435,9 @@ pub use self::pyport::*;
 pub use self::pystate::*;
 pub use self::pystrtod::*;
 pub use self::pythonrun::*;
+pub use self::pytypedefs::*;
 pub use self::rangeobject::*;
+pub use self::refcount::*;
 pub use self::setobject::*;
 pub use self::sliceobject::*;
 pub use self::structseq::*;
@@ -346,7 +478,7 @@ mod fileobject;
 mod fileutils;
 mod floatobject;
 // skipped empty frameobject.h
-// skipped genericaliasobject.h
+mod genericaliasobject;
 mod import;
 // skipped interpreteridobject.h
 mod intrcheck;
@@ -397,7 +529,9 @@ mod pythonrun;
 mod pystrtod;
 // skipped pythread.h
 // skipped pytime.h
+mod pytypedefs;
 mod rangeobject;
+mod refcount;
 mod setobject;
 mod sliceobject;
 mod structseq;
diff --git a/pyo3-ffi/src/listobject.rs b/pyo3-ffi/src/listobject.rs
index 32c6a2dc26a..6fd28ff0c99 100644
--- a/pyo3-ffi/src/listobject.rs
+++ b/pyo3-ffi/src/listobject.rs
@@ -1,6 +1,6 @@
 use crate::object::*;
 use crate::pyport::Py_ssize_t;
-use std::os::raw::c_int;
+use std::ffi::c_int;
 use std::ptr::addr_of_mut;
 
 #[cfg_attr(windows, link(name = "pythonXY"))]
@@ -28,6 +28,9 @@ extern "C" {
     pub fn PyList_Size(arg1: *mut PyObject) -> Py_ssize_t;
     #[cfg_attr(PyPy, link_name = "PyPyList_GetItem")]
     pub fn PyList_GetItem(arg1: *mut PyObject, arg2: Py_ssize_t) -> *mut PyObject;
+    #[cfg(Py_3_13)]
+    #[cfg_attr(PyPy, link_name = "PyPyList_GetItemRef")]
+    pub fn PyList_GetItemRef(arg1: *mut PyObject, arg2: Py_ssize_t) -> *mut PyObject;
     #[cfg_attr(PyPy, link_name = "PyPyList_SetItem")]
     pub fn PyList_SetItem(arg1: *mut PyObject, arg2: Py_ssize_t, arg3: *mut PyObject) -> c_int;
     #[cfg_attr(PyPy, link_name = "PyPyList_Insert")]
@@ -47,6 +50,10 @@ extern "C" {
         arg3: Py_ssize_t,
         arg4: *mut PyObject,
     ) -> c_int;
+    #[cfg(Py_3_13)]
+    pub fn PyList_Extend(list: *mut PyObject, iterable: *mut PyObject) -> c_int;
+    #[cfg(Py_3_13)]
+    pub fn PyList_Clear(list: *mut PyObject) -> c_int;
     #[cfg_attr(PyPy, link_name = "PyPyList_Sort")]
     pub fn PyList_Sort(arg1: *mut PyObject) -> c_int;
     #[cfg_attr(PyPy, link_name = "PyPyList_Reverse")]
@@ -54,14 +61,16 @@ extern "C" {
     #[cfg_attr(PyPy, link_name = "PyPyList_AsTuple")]
     pub fn PyList_AsTuple(arg1: *mut PyObject) -> *mut PyObject;
 
-    // CPython macros exported as functions on PyPy
-    #[cfg(PyPy)]
+    // CPython macros exported as functions on PyPy or GraalPy
+    #[cfg(any(PyPy, GraalPy))]
     #[cfg_attr(PyPy, link_name = "PyPyList_GET_ITEM")]
+    #[cfg_attr(GraalPy, link_name = "PyList_GetItem")]
     pub fn PyList_GET_ITEM(arg1: *mut PyObject, arg2: Py_ssize_t) -> *mut PyObject;
     #[cfg(PyPy)]
     #[cfg_attr(PyPy, link_name = "PyPyList_GET_SIZE")]
     pub fn PyList_GET_SIZE(arg1: *mut PyObject) -> Py_ssize_t;
-    #[cfg(PyPy)]
+    #[cfg(any(PyPy, GraalPy))]
     #[cfg_attr(PyPy, link_name = "PyPyList_SET_ITEM")]
+    #[cfg_attr(GraalPy, link_name = "_PyList_SET_ITEM")]
     pub fn PyList_SET_ITEM(arg1: *mut PyObject, arg2: Py_ssize_t, arg3: *mut PyObject);
 }
diff --git a/pyo3-ffi/src/longobject.rs b/pyo3-ffi/src/longobject.rs
index 55ea8fa1462..6927fcbef5a 100644
--- a/pyo3-ffi/src/longobject.rs
+++ b/pyo3-ffi/src/longobject.rs
@@ -1,18 +1,10 @@
 use crate::object::*;
 use crate::pyport::Py_ssize_t;
 use libc::size_t;
-#[cfg(not(Py_LIMITED_API))]
-use std::os::raw::c_uchar;
-use std::os::raw::{c_char, c_double, c_int, c_long, c_longlong, c_ulong, c_ulonglong, c_void};
+use std::ffi::{c_char, c_double, c_int, c_long, c_longlong, c_ulong, c_ulonglong, c_void};
 use std::ptr::addr_of_mut;
 
-opaque_struct!(PyLongObject);
-
-#[cfg_attr(windows, link(name = "pythonXY"))]
-extern "C" {
-    #[cfg_attr(PyPy, link_name = "PyPyLong_Type")]
-    pub static mut PyLong_Type: PyTypeObject;
-}
+opaque_struct!(pub PyLongObject);
 
 #[inline]
 pub unsafe fn PyLong_Check(op: *mut PyObject) -> c_int {
@@ -90,34 +82,11 @@ extern "C" {
         arg3: c_int,
     ) -> *mut PyObject;
 }
-// skipped non-limited PyLong_FromUnicodeObject
-// skipped non-limited _PyLong_FromBytes
 
 #[cfg(not(Py_LIMITED_API))]
 extern "C" {
-    // skipped non-limited _PyLong_Sign
-
     #[cfg_attr(PyPy, link_name = "_PyPyLong_NumBits")]
     pub fn _PyLong_NumBits(obj: *mut PyObject) -> size_t;
-
-    // skipped _PyLong_DivmodNear
-
-    #[cfg_attr(PyPy, link_name = "_PyPyLong_FromByteArray")]
-    pub fn _PyLong_FromByteArray(
-        bytes: *const c_uchar,
-        n: size_t,
-        little_endian: c_int,
-        is_signed: c_int,
-    ) -> *mut PyObject;
-
-    #[cfg_attr(PyPy, link_name = "_PyPyLong_AsByteArrayO")]
-    pub fn _PyLong_AsByteArray(
-        v: *mut PyLongObject,
-        bytes: *mut c_uchar,
-        n: size_t,
-        little_endian: c_int,
-        is_signed: c_int,
-    ) -> c_int;
 }
 
 // skipped non-limited _PyLong_Format
@@ -130,6 +99,5 @@ extern "C" {
     pub fn PyOS_strtol(arg1: *const c_char, arg2: *mut *mut c_char, arg3: c_int) -> c_long;
 }
 
-// skipped non-limited _PyLong_GCD
 // skipped non-limited _PyLong_Rshift
 // skipped non-limited _PyLong_Lshift
diff --git a/pyo3-ffi/src/marshal.rs b/pyo3-ffi/src/marshal.rs
index 562f6f91620..bba8f5ece50 100644
--- a/pyo3-ffi/src/marshal.rs
+++ b/pyo3-ffi/src/marshal.rs
@@ -1,5 +1,5 @@
 use super::{PyObject, Py_ssize_t};
-use std::os::raw::{c_char, c_int};
+use std::ffi::{c_char, c_int};
 
 // skipped Py_MARSHAL_VERSION
 // skipped PyMarshal_WriteLongToFile
diff --git a/pyo3-ffi/src/memoryobject.rs b/pyo3-ffi/src/memoryobject.rs
index b7ef9e2ef1d..01ceea3bdbe 100644
--- a/pyo3-ffi/src/memoryobject.rs
+++ b/pyo3-ffi/src/memoryobject.rs
@@ -1,13 +1,12 @@
 use crate::object::*;
 use crate::pyport::Py_ssize_t;
-use std::os::raw::{c_char, c_int};
+use std::ffi::{c_char, c_int};
 use std::ptr::addr_of_mut;
 
+// skipped _PyManagedBuffer_Type
+
 #[cfg_attr(windows, link(name = "pythonXY"))]
 extern "C" {
-    #[cfg(not(Py_LIMITED_API))]
-    pub static mut _PyManagedBuffer_Type: PyTypeObject;
-
     #[cfg_attr(PyPy, link_name = "PyPyMemoryView_Type")]
     pub static mut PyMemoryView_Type: PyTypeObject;
 }
@@ -18,7 +17,7 @@ pub unsafe fn PyMemoryView_Check(op: *mut PyObject) -> c_int {
 }
 
 // skipped non-limited PyMemoryView_GET_BUFFER
-// skipped non-limited PyMemeryView_GET_BASE
+// skipped non-limited PyMemoryView_GET_BASE
 
 extern "C" {
     #[cfg_attr(PyPy, link_name = "PyPyMemoryView_FromObject")]
diff --git a/pyo3-ffi/src/methodobject.rs b/pyo3-ffi/src/methodobject.rs
index e80d5668e78..5f367c9bd48 100644
--- a/pyo3-ffi/src/methodobject.rs
+++ b/pyo3-ffi/src/methodobject.rs
@@ -1,10 +1,10 @@
 use crate::object::{PyObject, PyTypeObject, Py_TYPE};
 #[cfg(Py_3_9)]
 use crate::PyObject_TypeCheck;
-use std::os::raw::{c_char, c_int, c_void};
+use std::ffi::{c_char, c_int, c_void};
 use std::{mem, ptr};
 
-#[cfg(all(Py_3_9, not(Py_LIMITED_API)))]
+#[cfg(all(Py_3_9, not(Py_LIMITED_API), not(GraalPy)))]
 pub struct PyCFunctionObject {
     pub ob_base: PyObject,
     pub m_ml: *mut PyMethodDef,
@@ -43,26 +43,34 @@ pub type PyCFunction =
     unsafe extern "C" fn(slf: *mut PyObject, args: *mut PyObject) -> *mut PyObject;
 
 #[cfg(any(Py_3_10, not(Py_LIMITED_API)))]
-pub type _PyCFunctionFast = unsafe extern "C" fn(
+pub type PyCFunctionFast = unsafe extern "C" fn(
     slf: *mut PyObject,
     args: *mut *mut PyObject,
     nargs: crate::pyport::Py_ssize_t,
 ) -> *mut PyObject;
 
+#[cfg(any(Py_3_10, not(Py_LIMITED_API)))]
+#[deprecated(note = "renamed to `PyCFunctionFast`")]
+pub type _PyCFunctionFast = PyCFunctionFast;
+
 pub type PyCFunctionWithKeywords = unsafe extern "C" fn(
     slf: *mut PyObject,
     args: *mut PyObject,
     kwds: *mut PyObject,
 ) -> *mut PyObject;
 
-#[cfg(not(Py_LIMITED_API))]
-pub type _PyCFunctionFastWithKeywords = unsafe extern "C" fn(
+#[cfg(any(Py_3_10, not(Py_LIMITED_API)))]
+pub type PyCFunctionFastWithKeywords = unsafe extern "C" fn(
     slf: *mut PyObject,
     args: *const *mut PyObject,
     nargs: crate::pyport::Py_ssize_t,
     kwnames: *mut PyObject,
 ) -> *mut PyObject;
 
+#[cfg(any(Py_3_10, not(Py_LIMITED_API)))]
+#[deprecated(note = "renamed to `PyCFunctionFastWithKeywords`")]
+pub type _PyCFunctionFastWithKeywords = PyCFunctionFastWithKeywords;
+
 #[cfg(all(Py_3_9, not(Py_LIMITED_API)))]
 pub type PyCMethod = unsafe extern "C" fn(
     slf: *mut PyObject,
@@ -77,6 +85,7 @@ extern "C" {
     pub fn PyCFunction_GetFunction(f: *mut PyObject) -> Option<PyCFunction>;
     pub fn PyCFunction_GetSelf(f: *mut PyObject) -> *mut PyObject;
     pub fn PyCFunction_GetFlags(f: *mut PyObject) -> c_int;
+    #[cfg(not(Py_3_13))]
     #[cfg_attr(Py_3_9, deprecated(note = "Python 3.9"))]
     pub fn PyCFunction_Call(
         f: *mut PyObject,
@@ -144,11 +153,21 @@ pub union PyMethodDefPointer {
 
     /// This variant corresponds with [`METH_FASTCALL`].
     #[cfg(any(Py_3_10, not(Py_LIMITED_API)))]
-    pub _PyCFunctionFast: _PyCFunctionFast,
+    #[deprecated(note = "renamed to `PyCFunctionFast`")]
+    pub _PyCFunctionFast: PyCFunctionFast,
+
+    /// This variant corresponds with [`METH_FASTCALL`].
+    #[cfg(any(Py_3_10, not(Py_LIMITED_API)))]
+    pub PyCFunctionFast: PyCFunctionFast,
+
+    /// This variant corresponds with [`METH_FASTCALL`] | [`METH_KEYWORDS`].
+    #[cfg(any(Py_3_10, not(Py_LIMITED_API)))]
+    #[deprecated(note = "renamed to `PyCFunctionFastWithKeywords`")]
+    pub _PyCFunctionFastWithKeywords: PyCFunctionFastWithKeywords,
 
     /// This variant corresponds with [`METH_FASTCALL`] | [`METH_KEYWORDS`].
-    #[cfg(not(Py_LIMITED_API))]
-    pub _PyCFunctionFastWithKeywords: _PyCFunctionFastWithKeywords,
+    #[cfg(any(Py_3_10, not(Py_LIMITED_API)))]
+    pub PyCFunctionFastWithKeywords: PyCFunctionFastWithKeywords,
 
     /// This variant corresponds with [`METH_METHOD`] | [`METH_FASTCALL`] | [`METH_KEYWORDS`].
     #[cfg(all(Py_3_9, not(Py_LIMITED_API)))]
@@ -186,9 +205,8 @@ impl std::fmt::Pointer for PyMethodDefPointer {
     }
 }
 
-// TODO: This can be a const assert on Rust 1.57
 const _: () =
-    [()][mem::size_of::<PyMethodDefPointer>() - mem::size_of::<Option<extern "C" fn()>>()];
+    assert!(mem::size_of::<PyMethodDefPointer>() == mem::size_of::<Option<extern "C" fn()>>());
 
 #[cfg(not(Py_3_9))]
 extern "C" {
diff --git a/pyo3-ffi/src/modsupport.rs b/pyo3-ffi/src/modsupport.rs
index b259c70059e..8cda23a8c2d 100644
--- a/pyo3-ffi/src/modsupport.rs
+++ b/pyo3-ffi/src/modsupport.rs
@@ -2,7 +2,7 @@ use crate::methodobject::PyMethodDef;
 use crate::moduleobject::PyModuleDef;
 use crate::object::PyObject;
 use crate::pyport::Py_ssize_t;
-use std::os::raw::{c_char, c_int, c_long};
+use std::ffi::{c_char, c_int, c_long};
 
 extern "C" {
     #[cfg_attr(PyPy, link_name = "PyPyArg_Parse")]
@@ -14,9 +14,14 @@ extern "C" {
         arg1: *mut PyObject,
         arg2: *mut PyObject,
         arg3: *const c_char,
-        arg4: *mut *mut c_char,
+        #[cfg(not(Py_3_13))] arg4: *mut *mut c_char,
+        #[cfg(Py_3_13)] arg4: *const *const c_char,
         ...
     ) -> c_int;
+
+    // skipped PyArg_VaParse
+    // skipped PyArg_VaParseTupleAndKeywords
+
     pub fn PyArg_ValidateKeywordArguments(arg1: *mut PyObject) -> c_int;
     #[cfg_attr(PyPy, link_name = "PyPyArg_UnpackTuple")]
     pub fn PyArg_UnpackTuple(
@@ -26,33 +31,13 @@ extern "C" {
         arg4: Py_ssize_t,
         ...
     ) -> c_int;
+
     #[cfg_attr(PyPy, link_name = "PyPy_BuildValue")]
     pub fn Py_BuildValue(arg1: *const c_char, ...) -> *mut PyObject;
-    // #[cfg_attr(PyPy, link_name = "_PyPy_BuildValue_SizeT")]
-    //pub fn _Py_BuildValue_SizeT(arg1: *const c_char, ...)
-    // -> *mut PyObject;
-    // #[cfg_attr(PyPy, link_name = "PyPy_VaBuildValue")]
-
-    // skipped non-limited _PyArg_UnpackStack
-    // skipped non-limited _PyArg_NoKeywords
-    // skipped non-limited _PyArg_NoKwnames
-    // skipped non-limited _PyArg_NoPositional
-    // skipped non-limited _PyArg_BadArgument
-    // skipped non-limited _PyArg_CheckPositional
-
-    //pub fn Py_VaBuildValue(arg1: *const c_char, arg2: va_list)
-    // -> *mut PyObject;
-
-    // skipped non-limited _Py_VaBuildStack
-    // skipped non-limited _PyArg_Parser
-
-    // skipped non-limited _PyArg_ParseTupleAndKeywordsFast
-    // skipped non-limited _PyArg_ParseStack
-    // skipped non-limited _PyArg_ParseStackAndKeywords
-    // skipped non-limited _PyArg_VaParseTupleAndKeywordsFast
-    // skipped non-limited _PyArg_UnpackKeywords
-    // skipped non-limited _PyArg_Fini
+    // skipped Py_VaBuildValue
 
+    #[cfg(Py_3_13)]
+    pub fn PyModule_Add(module: *mut PyObject, name: *const c_char, value: *mut PyObject) -> c_int;
     #[cfg(Py_3_10)]
     #[cfg_attr(PyPy, link_name = "PyPyModule_AddObjectRef")]
     pub fn PyModule_AddObjectRef(
@@ -88,6 +73,7 @@ extern "C" {
     // skipped PyModule_AddStringMacro
     pub fn PyModule_SetDocString(arg1: *mut PyObject, arg2: *const c_char) -> c_int;
     pub fn PyModule_AddFunctions(arg1: *mut PyObject, arg2: *mut PyMethodDef) -> c_int;
+    #[cfg_attr(PyPy, link_name = "PyPyModule_ExecDef")]
     pub fn PyModule_ExecDef(module: *mut PyObject, def: *mut PyModuleDef) -> c_int;
 }
 
@@ -105,6 +91,7 @@ extern "C" {
     fn PyModule_Create2TraceRefs(module: *mut PyModuleDef, apiver: c_int) -> *mut PyObject;
 
     #[cfg(not(py_sys_config = "Py_TRACE_REFS"))]
+    #[cfg_attr(PyPy, link_name = "PyPyModule_FromDefAndSpec2")]
     pub fn PyModule_FromDefAndSpec2(
         def: *mut PyModuleDef,
         spec: *mut PyObject,
@@ -159,9 +146,3 @@ pub unsafe fn PyModule_FromDefAndSpec(def: *mut PyModuleDef, spec: *mut PyObject
         },
     )
 }
-
-#[cfg(not(Py_LIMITED_API))]
-#[cfg_attr(windows, link(name = "pythonXY"))]
-extern "C" {
-    pub static mut _Py_PackageContext: *const c_char;
-}
diff --git a/pyo3-ffi/src/moduleobject.rs b/pyo3-ffi/src/moduleobject.rs
index f4306b18639..0d46b6d3130 100644
--- a/pyo3-ffi/src/moduleobject.rs
+++ b/pyo3-ffi/src/moduleobject.rs
@@ -1,7 +1,7 @@
 use crate::methodobject::PyMethodDef;
 use crate::object::*;
 use crate::pyport::Py_ssize_t;
-use std::os::raw::{c_char, c_int, c_void};
+use std::ffi::{c_char, c_int, c_void};
 use std::ptr::addr_of_mut;
 
 #[cfg_attr(windows, link(name = "pythonXY"))]
@@ -21,6 +21,7 @@ pub unsafe fn PyModule_CheckExact(op: *mut PyObject) -> c_int {
 }
 
 extern "C" {
+    #[cfg_attr(PyPy, link_name = "PyPyModule_NewObject")]
     pub fn PyModule_NewObject(name: *mut PyObject) -> *mut PyObject;
     #[cfg_attr(PyPy, link_name = "PyPyModule_New")]
     pub fn PyModule_New(name: *const c_char) -> *mut PyObject;
@@ -52,7 +53,6 @@ extern "C" {
 }
 
 #[repr(C)]
-#[derive(Copy, Clone)]
 pub struct PyModuleDef_Base {
     pub ob_base: PyObject,
     pub m_init: Option<extern "C" fn() -> *mut PyObject>,
@@ -60,6 +60,7 @@ pub struct PyModuleDef_Base {
     pub m_copy: *mut PyObject,
 }
 
+#[allow(clippy::declare_interior_mutable_const)]
 pub const PyModuleDef_HEAD_INIT: PyModuleDef_Base = PyModuleDef_Base {
     ob_base: PyObject_HEAD_INIT,
     m_init: None,
@@ -87,18 +88,31 @@ pub const Py_mod_create: c_int = 1;
 pub const Py_mod_exec: c_int = 2;
 #[cfg(Py_3_12)]
 pub const Py_mod_multiple_interpreters: c_int = 3;
+#[cfg(Py_3_13)]
+pub const Py_mod_gil: c_int = 4;
+
+// skipped private _Py_mod_LAST_SLOT
 
 #[cfg(Py_3_12)]
+#[allow(clippy::zero_ptr)] // matches the way that the rest of these constants are defined
 pub const Py_MOD_MULTIPLE_INTERPRETERS_NOT_SUPPORTED: *mut c_void = 0 as *mut c_void;
 #[cfg(Py_3_12)]
 pub const Py_MOD_MULTIPLE_INTERPRETERS_SUPPORTED: *mut c_void = 1 as *mut c_void;
 #[cfg(Py_3_12)]
 pub const Py_MOD_PER_INTERPRETER_GIL_SUPPORTED: *mut c_void = 2 as *mut c_void;
 
-// skipped non-limited _Py_mod_LAST_SLOT
+#[cfg(Py_3_13)]
+#[allow(clippy::zero_ptr)] // matches the way that the rest of these constants are defined
+pub const Py_MOD_GIL_USED: *mut c_void = 0 as *mut c_void;
+#[cfg(Py_3_13)]
+pub const Py_MOD_GIL_NOT_USED: *mut c_void = 1 as *mut c_void;
+
+#[cfg(all(not(Py_LIMITED_API), Py_GIL_DISABLED))]
+extern "C" {
+    pub fn PyUnstable_Module_SetGIL(module: *mut PyObject, gil: *mut c_void) -> c_int;
+}
 
 #[repr(C)]
-#[derive(Copy, Clone)]
 pub struct PyModuleDef {
     pub m_base: PyModuleDef_Base,
     pub m_name: *const c_char,
diff --git a/pyo3-ffi/src/object.rs b/pyo3-ffi/src/object.rs
index 0e0243cd764..0842c5d2f5e 100644
--- a/pyo3-ffi/src/object.rs
+++ b/pyo3-ffi/src/object.rs
@@ -1,119 +1,221 @@
 use crate::pyport::{Py_hash_t, Py_ssize_t};
+#[cfg(Py_GIL_DISABLED)]
+use crate::refcount;
+#[cfg(Py_GIL_DISABLED)]
+use crate::PyMutex;
+use std::ffi::{c_char, c_int, c_uint, c_ulong, c_void};
 use std::mem;
-use std::os::raw::{c_char, c_int, c_uint, c_ulong, c_void};
 use std::ptr;
+#[cfg(Py_GIL_DISABLED)]
+use std::sync::atomic::{AtomicIsize, AtomicU32};
 
 #[cfg(Py_LIMITED_API)]
-opaque_struct!(PyTypeObject);
+opaque_struct!(pub PyTypeObject);
 
 #[cfg(not(Py_LIMITED_API))]
 pub use crate::cpython::object::PyTypeObject;
 
-// _PyObject_HEAD_EXTRA: conditionally defined in PyObject_HEAD_INIT
-// _PyObject_EXTRA_INIT: conditionally defined in PyObject_HEAD_INIT
+// skip PyObject_HEAD
 
-#[cfg(Py_3_12)]
-pub const _Py_IMMORTAL_REFCNT: Py_ssize_t = {
-    if cfg!(target_pointer_width = "64") {
-        c_uint::MAX as Py_ssize_t
-    } else {
-        // for 32-bit systems, use the lower 30 bits (see comment in CPython's object.h)
-        (c_uint::MAX >> 2) as Py_ssize_t
-    }
-};
-
-pub const PyObject_HEAD_INIT: PyObject = PyObject {
-    #[cfg(py_sys_config = "Py_TRACE_REFS")]
-    _ob_next: std::ptr::null_mut(),
-    #[cfg(py_sys_config = "Py_TRACE_REFS")]
-    _ob_prev: std::ptr::null_mut(),
-    #[cfg(Py_3_12)]
-    ob_refcnt: PyObjectObRefcnt { ob_refcnt: 1 },
-    #[cfg(not(Py_3_12))]
-    ob_refcnt: 1,
-    #[cfg(PyPy)]
-    ob_pypy_link: 0,
-    ob_type: std::ptr::null_mut(),
-};
+#[repr(C)]
+#[derive(Copy, Clone)]
+#[cfg(all(
+    target_pointer_width = "64",
+    Py_3_14,
+    not(Py_GIL_DISABLED),
+    target_endian = "big"
+))]
+/// This struct is anonymous in CPython, so the name was given by PyO3 because
+/// Rust structs need a name.
+pub struct PyObjectObFlagsAndRefcnt {
+    pub ob_flags: u16,
+    pub ob_overflow: u16,
+    pub ob_refcnt: u32,
+}
 
-// skipped PyObject_VAR_HEAD
-// skipped Py_INVALID_SIZE
+#[repr(C)]
+#[derive(Copy, Clone)]
+#[cfg(all(
+    target_pointer_width = "64",
+    Py_3_14,
+    not(Py_GIL_DISABLED),
+    target_endian = "little"
+))]
+/// This struct is anonymous in CPython, so the name was given by PyO3 because
+/// Rust structs need a name.
+pub struct PyObjectObFlagsAndRefcnt {
+    pub ob_refcnt: u32,
+    pub ob_overflow: u16,
+    pub ob_flags: u16,
+}
 
 #[repr(C)]
 #[derive(Copy, Clone)]
-#[cfg(Py_3_12)]
+#[cfg(all(Py_3_12, not(Py_GIL_DISABLED)))]
 /// This union is anonymous in CPython, so the name was given by PyO3 because
-/// Rust unions need a name.
+/// Rust union need a name.
 pub union PyObjectObRefcnt {
+    #[cfg(all(target_pointer_width = "64", Py_3_14))]
+    pub ob_refcnt_full: crate::PY_INT64_T,
+    #[cfg(all(target_pointer_width = "64", Py_3_14))]
+    pub refcnt_and_flags: PyObjectObFlagsAndRefcnt,
     pub ob_refcnt: Py_ssize_t,
-    #[cfg(target_pointer_width = "64")]
+    #[cfg(all(target_pointer_width = "64", not(Py_3_14)))]
     pub ob_refcnt_split: [crate::PY_UINT32_T; 2],
 }
 
-#[cfg(Py_3_12)]
+#[cfg(all(Py_3_12, not(Py_GIL_DISABLED)))]
 impl std::fmt::Debug for PyObjectObRefcnt {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(f, "{}", unsafe { self.ob_refcnt })
     }
 }
 
-#[cfg(not(Py_3_12))]
+#[cfg(all(not(Py_3_12), not(Py_GIL_DISABLED)))]
 pub type PyObjectObRefcnt = Py_ssize_t;
 
+// PyObject_HEAD_INIT comes before the PyObject definition in object.h
+// but we put it after PyObject because HEAD_INIT uses PyObject
+
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
+#[derive(Debug)]
 pub struct PyObject {
     #[cfg(py_sys_config = "Py_TRACE_REFS")]
     pub _ob_next: *mut PyObject,
     #[cfg(py_sys_config = "Py_TRACE_REFS")]
     pub _ob_prev: *mut PyObject,
+    #[cfg(Py_GIL_DISABLED)]
+    pub ob_tid: libc::uintptr_t,
+    #[cfg(all(Py_GIL_DISABLED, not(Py_3_14)))]
+    pub _padding: u16,
+    #[cfg(all(Py_GIL_DISABLED, Py_3_14))]
+    pub ob_flags: u16,
+    #[cfg(Py_GIL_DISABLED)]
+    pub ob_mutex: PyMutex, // per-object lock
+    #[cfg(Py_GIL_DISABLED)]
+    pub ob_gc_bits: u8, // gc-related state
+    #[cfg(Py_GIL_DISABLED)]
+    pub ob_ref_local: AtomicU32, // local reference count
+    #[cfg(Py_GIL_DISABLED)]
+    pub ob_ref_shared: AtomicIsize, // shared reference count
+    #[cfg(not(Py_GIL_DISABLED))]
     pub ob_refcnt: PyObjectObRefcnt,
     #[cfg(PyPy)]
     pub ob_pypy_link: Py_ssize_t,
     pub ob_type: *mut PyTypeObject,
 }
 
+#[allow(clippy::declare_interior_mutable_const)]
+pub const PyObject_HEAD_INIT: PyObject = PyObject {
+    #[cfg(py_sys_config = "Py_TRACE_REFS")]
+    _ob_next: std::ptr::null_mut(),
+    #[cfg(py_sys_config = "Py_TRACE_REFS")]
+    _ob_prev: std::ptr::null_mut(),
+    #[cfg(Py_GIL_DISABLED)]
+    ob_tid: 0,
+    #[cfg(all(Py_GIL_DISABLED, Py_3_14))]
+    ob_flags: 0,
+    #[cfg(all(Py_GIL_DISABLED, not(Py_3_14)))]
+    _padding: 0,
+    #[cfg(Py_GIL_DISABLED)]
+    ob_mutex: PyMutex::new(),
+    #[cfg(Py_GIL_DISABLED)]
+    ob_gc_bits: 0,
+    #[cfg(Py_GIL_DISABLED)]
+    ob_ref_local: AtomicU32::new(refcount::_Py_IMMORTAL_REFCNT_LOCAL),
+    #[cfg(Py_GIL_DISABLED)]
+    ob_ref_shared: AtomicIsize::new(0),
+    #[cfg(all(not(Py_GIL_DISABLED), Py_3_12))]
+    ob_refcnt: PyObjectObRefcnt { ob_refcnt: 1 },
+    #[cfg(not(Py_3_12))]
+    ob_refcnt: 1,
+    #[cfg(PyPy)]
+    ob_pypy_link: 0,
+    ob_type: std::ptr::null_mut(),
+};
+
+// skipped _Py_UNOWNED_TID
+
 // skipped _PyObject_CAST
 
 #[repr(C)]
-#[derive(Debug, Copy, Clone)]
+#[derive(Debug)]
 pub struct PyVarObject {
     pub ob_base: PyObject,
+    #[cfg(not(GraalPy))]
     pub ob_size: Py_ssize_t,
+    // On GraalPy the field is physically there, but not always populated. We hide it to prevent accidental misuse
+    #[cfg(GraalPy)]
+    pub _ob_size_graalpy: Py_ssize_t,
 }
 
-// skipped _PyVarObject_CAST
+// skipped private _PyVarObject_CAST
 
 #[inline]
+#[cfg(not(any(GraalPy, PyPy)))]
+#[cfg_attr(docsrs, doc(cfg(all())))]
 pub unsafe fn Py_Is(x: *mut PyObject, y: *mut PyObject) -> c_int {
     (x == y).into()
 }
 
-#[inline]
-#[cfg(Py_3_12)]
-pub unsafe fn Py_REFCNT(ob: *mut PyObject) -> Py_ssize_t {
-    (*ob).ob_refcnt.ob_refcnt
+#[cfg(any(GraalPy, PyPy))]
+#[cfg_attr(docsrs, doc(cfg(all())))]
+extern "C" {
+    #[cfg_attr(PyPy, link_name = "PyPy_Is")]
+    pub fn Py_Is(x: *mut PyObject, y: *mut PyObject) -> c_int;
 }
 
-#[inline]
-#[cfg(not(Py_3_12))]
-pub unsafe fn Py_REFCNT(ob: *mut PyObject) -> Py_ssize_t {
-    (*ob).ob_refcnt
+// skipped _Py_GetThreadLocal_Addr
+
+// skipped _Py_ThreadID
+
+// skipped _Py_IsOwnedByCurrentThread
+
+#[cfg(GraalPy)]
+extern "C" {
+    #[cfg(GraalPy)]
+    fn _Py_TYPE(arg1: *const PyObject) -> *mut PyTypeObject;
+
+    #[cfg(GraalPy)]
+    fn _Py_SIZE(arg1: *const PyObject) -> Py_ssize_t;
 }
 
 #[inline]
+#[cfg(not(Py_3_14))]
 pub unsafe fn Py_TYPE(ob: *mut PyObject) -> *mut PyTypeObject {
-    (*ob).ob_type
+    #[cfg(not(GraalPy))]
+    return (*ob).ob_type;
+    #[cfg(GraalPy)]
+    return _Py_TYPE(ob);
+}
+
+#[cfg_attr(windows, link(name = "pythonXY"))]
+#[cfg(Py_3_14)]
+extern "C" {
+    #[cfg_attr(PyPy, link_name = "PyPy_TYPE")]
+    pub fn Py_TYPE(ob: *mut PyObject) -> *mut PyTypeObject;
 }
 
-// PyLong_Type defined in longobject.rs
-// PyBool_Type defined in boolobject.rs
+// skip _Py_TYPE compat shim
+
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
+    #[cfg_attr(PyPy, link_name = "PyPyLong_Type")]
+    pub static mut PyLong_Type: PyTypeObject;
+    #[cfg_attr(PyPy, link_name = "PyPyBool_Type")]
+    pub static mut PyBool_Type: PyTypeObject;
+}
 
 #[inline]
 pub unsafe fn Py_SIZE(ob: *mut PyObject) -> Py_ssize_t {
-    debug_assert_ne!((*ob).ob_type, std::ptr::addr_of_mut!(crate::PyLong_Type));
-    debug_assert_ne!((*ob).ob_type, std::ptr::addr_of_mut!(crate::PyBool_Type));
-    (*ob.cast::<PyVarObject>()).ob_size
+    #[cfg(not(GraalPy))]
+    {
+        debug_assert_ne!((*ob).ob_type, std::ptr::addr_of_mut!(crate::PyLong_Type));
+        debug_assert_ne!((*ob).ob_type, std::ptr::addr_of_mut!(crate::PyBool_Type));
+        (*ob.cast::<PyVarObject>()).ob_size
+    }
+    #[cfg(GraalPy)]
+    _Py_SIZE(ob)
 }
 
 #[inline]
@@ -121,23 +223,8 @@ pub unsafe fn Py_IS_TYPE(ob: *mut PyObject, tp: *mut PyTypeObject) -> c_int {
     (Py_TYPE(ob) == tp) as c_int
 }
 
-#[inline(always)]
-#[cfg(all(Py_3_12, target_pointer_width = "64"))]
-pub unsafe fn _Py_IsImmortal(op: *mut PyObject) -> c_int {
-    (((*op).ob_refcnt.ob_refcnt as crate::PY_INT32_T) < 0) as c_int
-}
-
-#[inline(always)]
-#[cfg(all(Py_3_12, target_pointer_width = "32"))]
-pub unsafe fn _Py_IsImmortal(op: *mut PyObject) -> c_int {
-    ((*op).ob_refcnt.ob_refcnt == _Py_IMMORTAL_REFCNT) as c_int
-}
-
-// skipped _Py_SET_REFCNT
-// skipped Py_SET_REFCNT
-// skipped _Py_SET_TYPE
 // skipped Py_SET_TYPE
-// skipped _Py_SET_SIZE
+
 // skipped Py_SET_SIZE
 
 pub type unaryfunc = unsafe extern "C" fn(*mut PyObject) -> *mut PyObject;
@@ -249,6 +336,14 @@ extern "C" {
     #[cfg_attr(PyPy, link_name = "PyPyType_GetQualName")]
     pub fn PyType_GetQualName(arg1: *mut PyTypeObject) -> *mut PyObject;
 
+    #[cfg(Py_3_13)]
+    #[cfg_attr(PyPy, link_name = "PyPyType_GetFullyQualifiedName")]
+    pub fn PyType_GetFullyQualifiedName(arg1: *mut PyTypeObject) -> *mut PyObject;
+
+    #[cfg(Py_3_13)]
+    #[cfg_attr(PyPy, link_name = "PyPyType_GetModuleName")]
+    pub fn PyType_GetModuleName(arg1: *mut PyTypeObject) -> *mut PyObject;
+
     #[cfg(Py_3_12)]
     #[cfg_attr(PyPy, link_name = "PyPyType_FromMetaclass")]
     pub fn PyType_FromMetaclass(
@@ -272,7 +367,7 @@ extern "C" {
 
 #[inline]
 pub unsafe fn PyObject_TypeCheck(ob: *mut PyObject, tp: *mut PyTypeObject) -> c_int {
-    (Py_TYPE(ob) == tp || PyType_IsSubtype(Py_TYPE(ob), tp) != 0) as c_int
+    (Py_IS_TYPE(ob, tp) != 0 || PyType_IsSubtype(Py_TYPE(ob), tp) != 0) as c_int
 }
 
 #[cfg_attr(windows, link(name = "pythonXY"))]
@@ -329,18 +424,43 @@ extern "C" {
         arg2: *const c_char,
         arg3: *mut PyObject,
     ) -> c_int;
+    #[cfg(any(Py_3_13, all(PyPy, not(Py_3_11))))] // CPython defined in 3.12 as an inline function in abstract.h
+    #[cfg_attr(PyPy, link_name = "PyPyObject_DelAttrString")]
+    pub fn PyObject_DelAttrString(arg1: *mut PyObject, arg2: *const c_char) -> c_int;
     #[cfg_attr(PyPy, link_name = "PyPyObject_HasAttrString")]
     pub fn PyObject_HasAttrString(arg1: *mut PyObject, arg2: *const c_char) -> c_int;
     #[cfg_attr(PyPy, link_name = "PyPyObject_GetAttr")]
     pub fn PyObject_GetAttr(arg1: *mut PyObject, arg2: *mut PyObject) -> *mut PyObject;
+    #[cfg(Py_3_13)]
+    #[cfg_attr(PyPy, link_name = "PyPyObject_GetOptionalAttr")]
+    pub fn PyObject_GetOptionalAttr(
+        arg1: *mut PyObject,
+        arg2: *mut PyObject,
+        arg3: *mut *mut PyObject,
+    ) -> c_int;
+    #[cfg(Py_3_13)]
+    #[cfg_attr(PyPy, link_name = "PyPyObject_GetOptionalAttrString")]
+    pub fn PyObject_GetOptionalAttrString(
+        arg1: *mut PyObject,
+        arg2: *const c_char,
+        arg3: *mut *mut PyObject,
+    ) -> c_int;
     #[cfg_attr(PyPy, link_name = "PyPyObject_SetAttr")]
     pub fn PyObject_SetAttr(arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject)
         -> c_int;
+    #[cfg(any(Py_3_13, all(PyPy, not(Py_3_11))))] // CPython defined in 3.12 as an inline function in abstract.h
+    #[cfg_attr(PyPy, link_name = "PyPyObject_DelAttr")]
+    pub fn PyObject_DelAttr(arg1: *mut PyObject, arg2: *mut PyObject) -> c_int;
     #[cfg_attr(PyPy, link_name = "PyPyObject_HasAttr")]
     pub fn PyObject_HasAttr(arg1: *mut PyObject, arg2: *mut PyObject) -> c_int;
+    #[cfg(Py_3_13)]
+    #[cfg_attr(PyPy, link_name = "PyPyObject_HasAttrWithError")]
+    pub fn PyObject_HasAttrWithError(arg1: *mut PyObject, arg2: *mut PyObject) -> c_int;
+    #[cfg(Py_3_13)]
+    #[cfg_attr(PyPy, link_name = "PyPyObject_HasAttrStringWithError")]
+    pub fn PyObject_HasAttrStringWithError(arg1: *mut PyObject, arg2: *const c_char) -> c_int;
     #[cfg_attr(PyPy, link_name = "PyPyObject_SelfIter")]
     pub fn PyObject_SelfIter(arg1: *mut PyObject) -> *mut PyObject;
-
     #[cfg_attr(PyPy, link_name = "PyPyObject_GenericGetAttr")]
     pub fn PyObject_GenericGetAttr(arg1: *mut PyObject, arg2: *mut PyObject) -> *mut PyObject;
     #[cfg_attr(PyPy, link_name = "PyPyObject_GenericSetAttr")]
@@ -350,7 +470,9 @@ extern "C" {
         arg3: *mut PyObject,
     ) -> c_int;
     #[cfg(not(all(Py_LIMITED_API, not(Py_3_10))))]
+    #[cfg_attr(PyPy, link_name = "PyPyObject_GenericGetDict")]
     pub fn PyObject_GenericGetDict(arg1: *mut PyObject, arg2: *mut c_void) -> *mut PyObject;
+    #[cfg_attr(PyPy, link_name = "PyPyObject_GenericSetDict")]
     pub fn PyObject_GenericSetDict(
         arg1: *mut PyObject,
         arg2: *mut PyObject,
@@ -378,8 +500,8 @@ extern "C" {
 // Flag bits for printing:
 pub const Py_PRINT_RAW: c_int = 1; // No string quotes etc.
 
-#[cfg(all(Py_3_12, not(Py_LIMITED_API)))]
-pub const _Py_TPFLAGS_STATIC_BUILTIN: c_ulong = 1 << 1;
+// skipped because is a private API
+// const _Py_TPFLAGS_STATIC_BUILTIN: c_ulong = 1 << 1;
 
 #[cfg(all(Py_3_12, not(Py_LIMITED_API)))]
 pub const Py_TPFLAGS_MANAGED_WEAKREF: c_ulong = 1 << 3;
@@ -408,7 +530,7 @@ pub const Py_TPFLAGS_BASETYPE: c_ulong = 1 << 10;
 /// Set if the type implements the vectorcall protocol (PEP 590)
 #[cfg(any(Py_3_12, all(Py_3_8, not(Py_LIMITED_API))))]
 pub const Py_TPFLAGS_HAVE_VECTORCALL: c_ulong = 1 << 11;
-// skipped non-limited _Py_TPFLAGS_HAVE_VECTORCALL
+// skipped backwards-compatibility alias _Py_TPFLAGS_HAVE_VECTORCALL
 
 /// Set if the type is 'ready' -- fully initialized
 pub const Py_TPFLAGS_READY: c_ulong = 1 << 12;
@@ -452,230 +574,56 @@ pub const Py_TPFLAGS_DEFAULT: c_ulong = if cfg!(Py_3_10) {
 pub const Py_TPFLAGS_HAVE_FINALIZE: c_ulong = 1;
 pub const Py_TPFLAGS_HAVE_VERSION_TAG: c_ulong = 1 << 18;
 
-extern "C" {
-    #[cfg(all(py_sys_config = "Py_REF_DEBUG", not(Py_LIMITED_API)))]
-    pub fn _Py_NegativeRefcount(filename: *const c_char, lineno: c_int, op: *mut PyObject);
-    #[cfg(all(Py_3_12, py_sys_config = "Py_REF_DEBUG", not(Py_LIMITED_API)))]
-    fn _Py_INCREF_IncRefTotal();
-    #[cfg(all(Py_3_12, py_sys_config = "Py_REF_DEBUG", not(Py_LIMITED_API)))]
-    fn _Py_DECREF_DecRefTotal();
-
-    #[cfg_attr(PyPy, link_name = "_PyPy_Dealloc")]
-    pub fn _Py_Dealloc(arg1: *mut PyObject);
-
-    #[cfg_attr(PyPy, link_name = "PyPy_IncRef")]
-    pub fn Py_IncRef(o: *mut PyObject);
-    #[cfg_attr(PyPy, link_name = "PyPy_DecRef")]
-    pub fn Py_DecRef(o: *mut PyObject);
-
-    #[cfg(Py_3_10)]
-    #[cfg_attr(PyPy, link_name = "_PyPy_IncRef")]
-    pub fn _Py_IncRef(o: *mut PyObject);
-    #[cfg(Py_3_10)]
-    #[cfg_attr(PyPy, link_name = "_PyPy_DecRef")]
-    pub fn _Py_DecRef(o: *mut PyObject);
-}
-
-#[inline(always)]
-pub unsafe fn Py_INCREF(op: *mut PyObject) {
-    #[cfg(any(
-        all(Py_LIMITED_API, Py_3_12),
-        all(
-            py_sys_config = "Py_REF_DEBUG",
-            Py_3_10,
-            not(all(Py_3_12, not(Py_LIMITED_API)))
-        )
-    ))]
-    {
-        _Py_IncRef(op);
-    }
-
-    #[cfg(all(py_sys_config = "Py_REF_DEBUG", not(Py_3_10)))]
-    {
-        return Py_IncRef(op);
-    }
-
-    #[cfg(any(
-        all(Py_LIMITED_API, not(Py_3_12)),
-        all(
-            not(Py_LIMITED_API),
-            any(
-                not(py_sys_config = "Py_REF_DEBUG"),
-                all(py_sys_config = "Py_REF_DEBUG", Py_3_12),
-            )
-        ),
-    ))]
-    {
-        #[cfg(all(Py_3_12, target_pointer_width = "64"))]
-        {
-            let cur_refcnt = (*op).ob_refcnt.ob_refcnt_split[crate::PY_BIG_ENDIAN];
-            let new_refcnt = cur_refcnt.wrapping_add(1);
-            if new_refcnt == 0 {
-                return;
-            }
-            (*op).ob_refcnt.ob_refcnt_split[crate::PY_BIG_ENDIAN] = new_refcnt;
-        }
-
-        #[cfg(all(Py_3_12, target_pointer_width = "32"))]
-        {
-            if _Py_IsImmortal(op) != 0 {
-                return;
-            }
-            (*op).ob_refcnt.ob_refcnt += 1
-        }
-
-        #[cfg(not(Py_3_12))]
-        {
-            (*op).ob_refcnt += 1
-        }
-
-        // Skipped _Py_INCREF_STAT_INC - if anyone wants this, please file an issue
-        // or submit a PR supporting Py_STATS build option and pystats.h
-
-        #[cfg(all(py_sys_config = "Py_REF_DEBUG", Py_3_12))]
-        _Py_INCREF_IncRefTotal();
-    }
-}
-
-#[inline(always)]
-#[cfg_attr(
-    all(py_sys_config = "Py_REF_DEBUG", Py_3_12, not(Py_LIMITED_API)),
-    track_caller
-)]
-pub unsafe fn Py_DECREF(op: *mut PyObject) {
-    #[cfg(any(
-        all(Py_LIMITED_API, Py_3_12),
-        all(
-            py_sys_config = "Py_REF_DEBUG",
-            Py_3_10,
-            not(all(Py_3_12, not(Py_LIMITED_API)))
-        )
-    ))]
-    {
-        _Py_DecRef(op);
-    }
-
-    #[cfg(all(py_sys_config = "Py_REF_DEBUG", not(Py_3_10)))]
-    {
-        return Py_DecRef(op);
-    }
-
-    #[cfg(any(
-        all(Py_LIMITED_API, not(Py_3_12)),
-        all(
-            not(Py_LIMITED_API),
-            any(
-                not(py_sys_config = "Py_REF_DEBUG"),
-                all(py_sys_config = "Py_REF_DEBUG", Py_3_12),
-            )
-        ),
-    ))]
-    {
-        #[cfg(Py_3_12)]
-        if _Py_IsImmortal(op) != 0 {
-            return;
-        }
-
-        // Skipped _Py_DECREF_STAT_INC - if anyone needs this, please file an issue
-        // or submit a PR supporting Py_STATS build option and pystats.h
-
-        #[cfg(all(py_sys_config = "Py_REF_DEBUG", Py_3_12))]
-        _Py_DECREF_DecRefTotal();
-
-        #[cfg(Py_3_12)]
-        {
-            (*op).ob_refcnt.ob_refcnt -= 1;
-
-            #[cfg(py_sys_config = "Py_REF_DEBUG")]
-            if (*op).ob_refcnt.ob_refcnt < 0 {
-                let location = std::panic::Location::caller();
-                let filename = std::ffi::CString::new(location.file()).unwrap();
-                _Py_NegativeRefcount(filename.as_ptr(), location.line() as i32, op);
-            }
-
-            if (*op).ob_refcnt.ob_refcnt == 0 {
-                _Py_Dealloc(op);
-            }
-        }
-
-        #[cfg(not(Py_3_12))]
-        {
-            (*op).ob_refcnt -= 1;
-
-            if (*op).ob_refcnt == 0 {
-                _Py_Dealloc(op);
-            }
-        }
-    }
-}
-
-#[inline]
-pub unsafe fn Py_CLEAR(op: *mut *mut PyObject) {
-    let tmp = *op;
-    if !tmp.is_null() {
-        *op = ptr::null_mut();
-        Py_DECREF(tmp);
-    }
-}
-
-#[inline]
-pub unsafe fn Py_XINCREF(op: *mut PyObject) {
-    if !op.is_null() {
-        Py_INCREF(op)
-    }
-}
-
-#[inline]
-pub unsafe fn Py_XDECREF(op: *mut PyObject) {
-    if !op.is_null() {
-        Py_DECREF(op)
-    }
-}
+#[cfg(Py_3_13)]
+pub const Py_CONSTANT_NONE: c_uint = 0;
+#[cfg(Py_3_13)]
+pub const Py_CONSTANT_FALSE: c_uint = 1;
+#[cfg(Py_3_13)]
+pub const Py_CONSTANT_TRUE: c_uint = 2;
+#[cfg(Py_3_13)]
+pub const Py_CONSTANT_ELLIPSIS: c_uint = 3;
+#[cfg(Py_3_13)]
+pub const Py_CONSTANT_NOT_IMPLEMENTED: c_uint = 4;
+#[cfg(Py_3_13)]
+pub const Py_CONSTANT_ZERO: c_uint = 5;
+#[cfg(Py_3_13)]
+pub const Py_CONSTANT_ONE: c_uint = 6;
+#[cfg(Py_3_13)]
+pub const Py_CONSTANT_EMPTY_STR: c_uint = 7;
+#[cfg(Py_3_13)]
+pub const Py_CONSTANT_EMPTY_BYTES: c_uint = 8;
+#[cfg(Py_3_13)]
+pub const Py_CONSTANT_EMPTY_TUPLE: c_uint = 9;
 
 extern "C" {
-    #[cfg(all(Py_3_10, Py_LIMITED_API))]
-    pub fn Py_NewRef(obj: *mut PyObject) -> *mut PyObject;
-    #[cfg(all(Py_3_10, Py_LIMITED_API))]
-    pub fn Py_XNewRef(obj: *mut PyObject) -> *mut PyObject;
-}
-
-// Technically these macros are only available in the C header from 3.10 and up, however their
-// implementation works on all supported Python versions so we define these macros on all
-// versions for simplicity.
-
-#[inline]
-pub unsafe fn _Py_NewRef(obj: *mut PyObject) -> *mut PyObject {
-    Py_INCREF(obj);
-    obj
-}
-
-#[inline]
-pub unsafe fn _Py_XNewRef(obj: *mut PyObject) -> *mut PyObject {
-    Py_XINCREF(obj);
-    obj
-}
-
-#[cfg(all(Py_3_10, not(Py_LIMITED_API)))]
-#[inline]
-pub unsafe fn Py_NewRef(obj: *mut PyObject) -> *mut PyObject {
-    _Py_NewRef(obj)
-}
-
-#[cfg(all(Py_3_10, not(Py_LIMITED_API)))]
-#[inline]
-pub unsafe fn Py_XNewRef(obj: *mut PyObject) -> *mut PyObject {
-    _Py_XNewRef(obj)
+    #[cfg(Py_3_13)]
+    #[cfg_attr(PyPy, link_name = "PyPy_GetConstant")]
+    pub fn Py_GetConstant(constant_id: c_uint) -> *mut PyObject;
+    #[cfg(Py_3_13)]
+    #[cfg_attr(PyPy, link_name = "PyPy_GetConstantBorrowed")]
+    pub fn Py_GetConstantBorrowed(constant_id: c_uint) -> *mut PyObject;
 }
 
 #[cfg_attr(windows, link(name = "pythonXY"))]
 extern "C" {
+    #[cfg(all(not(GraalPy), not(all(Py_3_13, Py_LIMITED_API))))]
     #[cfg_attr(PyPy, link_name = "_PyPy_NoneStruct")]
     static mut _Py_NoneStruct: PyObject;
+
+    #[cfg(GraalPy)]
+    static mut _Py_NoneStructReference: *mut PyObject;
 }
 
 #[inline]
 pub unsafe fn Py_None() -> *mut PyObject {
-    ptr::addr_of_mut!(_Py_NoneStruct)
+    #[cfg(all(not(GraalPy), all(Py_3_13, Py_LIMITED_API)))]
+    return Py_GetConstantBorrowed(Py_CONSTANT_NONE);
+
+    #[cfg(all(not(GraalPy), not(all(Py_3_13, Py_LIMITED_API))))]
+    return ptr::addr_of_mut!(_Py_NoneStruct);
+
+    #[cfg(GraalPy)]
+    return _Py_NoneStructReference;
 }
 
 #[inline]
@@ -687,13 +635,24 @@ pub unsafe fn Py_IsNone(x: *mut PyObject) -> c_int {
 
 #[cfg_attr(windows, link(name = "pythonXY"))]
 extern "C" {
+    #[cfg(all(not(GraalPy), not(all(Py_3_13, Py_LIMITED_API))))]
     #[cfg_attr(PyPy, link_name = "_PyPy_NotImplementedStruct")]
     static mut _Py_NotImplementedStruct: PyObject;
+
+    #[cfg(GraalPy)]
+    static mut _Py_NotImplementedStructReference: *mut PyObject;
 }
 
 #[inline]
 pub unsafe fn Py_NotImplemented() -> *mut PyObject {
-    ptr::addr_of_mut!(_Py_NotImplementedStruct)
+    #[cfg(all(not(GraalPy), all(Py_3_13, Py_LIMITED_API)))]
+    return Py_GetConstantBorrowed(Py_CONSTANT_NOT_IMPLEMENTED);
+
+    #[cfg(all(not(GraalPy), not(all(Py_3_13, Py_LIMITED_API))))]
+    return ptr::addr_of_mut!(_Py_NotImplementedStruct);
+
+    #[cfg(GraalPy)]
+    return _Py_NotImplementedStructReference;
 }
 
 // skipped Py_RETURN_NOTIMPLEMENTED
@@ -718,15 +677,17 @@ pub enum PySendResult {
 // skipped Py_RETURN_RICHCOMPARE
 
 #[inline]
-#[cfg(Py_LIMITED_API)]
-pub unsafe fn PyType_HasFeature(t: *mut PyTypeObject, f: c_ulong) -> c_int {
-    ((PyType_GetFlags(t) & f) != 0) as c_int
-}
+pub unsafe fn PyType_HasFeature(ty: *mut PyTypeObject, feature: c_ulong) -> c_int {
+    #[cfg(Py_LIMITED_API)]
+    let flags = PyType_GetFlags(ty);
 
-#[inline]
-#[cfg(not(Py_LIMITED_API))]
-pub unsafe fn PyType_HasFeature(t: *mut PyTypeObject, f: c_ulong) -> c_int {
-    (((*t).tp_flags & f) != 0) as c_int
+    #[cfg(all(not(Py_LIMITED_API), Py_GIL_DISABLED))]
+    let flags = (*ty).tp_flags.load(std::sync::atomic::Ordering::Relaxed);
+
+    #[cfg(all(not(Py_LIMITED_API), not(Py_GIL_DISABLED)))]
+    let flags = (*ty).tp_flags;
+
+    ((flags & feature) != 0) as c_int
 }
 
 #[inline]
@@ -739,7 +700,21 @@ pub unsafe fn PyType_Check(op: *mut PyObject) -> c_int {
     PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_TYPE_SUBCLASS)
 }
 
+// skipped _PyType_CAST
+
 #[inline]
 pub unsafe fn PyType_CheckExact(op: *mut PyObject) -> c_int {
     Py_IS_TYPE(op, ptr::addr_of_mut!(PyType_Type))
 }
+
+extern "C" {
+    #[cfg(any(Py_3_13, all(Py_3_11, not(Py_LIMITED_API))))]
+    #[cfg_attr(PyPy, link_name = "PyPyType_GetModuleByDef")]
+    pub fn PyType_GetModuleByDef(
+        arg1: *mut crate::PyTypeObject,
+        arg2: *mut crate::PyModuleDef,
+    ) -> *mut PyObject;
+
+    #[cfg(Py_3_14)]
+    pub fn PyType_Freeze(tp: *mut crate::PyTypeObject) -> c_int;
+}
diff --git a/pyo3-ffi/src/objimpl.rs b/pyo3-ffi/src/objimpl.rs
index 76835a6d158..338228a53ea 100644
--- a/pyo3-ffi/src/objimpl.rs
+++ b/pyo3-ffi/src/objimpl.rs
@@ -1,5 +1,5 @@
 use libc::size_t;
-use std::os::raw::{c_int, c_void};
+use std::ffi::{c_int, c_void};
 
 use crate::object::*;
 use crate::pyport::Py_ssize_t;
diff --git a/pyo3-ffi/src/pyarena.rs b/pyo3-ffi/src/pyarena.rs
index 87d5f28a7a5..1200de3df48 100644
--- a/pyo3-ffi/src/pyarena.rs
+++ b/pyo3-ffi/src/pyarena.rs
@@ -1 +1 @@
-opaque_struct!(PyArena);
+opaque_struct!(pub PyArena);
diff --git a/pyo3-ffi/src/pybuffer.rs b/pyo3-ffi/src/pybuffer.rs
index a414f333ce6..44ae47bdc30 100644
--- a/pyo3-ffi/src/pybuffer.rs
+++ b/pyo3-ffi/src/pybuffer.rs
@@ -1,6 +1,6 @@
 use crate::object::PyObject;
 use crate::pyport::Py_ssize_t;
-use std::os::raw::{c_char, c_int, c_void};
+use std::ffi::{c_char, c_int, c_void};
 use std::ptr;
 
 #[repr(C)]
@@ -27,6 +27,7 @@ pub struct Py_buffer {
 }
 
 impl Py_buffer {
+    #[allow(clippy::new_without_default)]
     pub const fn new() -> Self {
         Py_buffer {
             buf: ptr::null_mut(),
@@ -102,7 +103,7 @@ extern "C" {
 }
 
 /// Maximum number of dimensions
-pub const PyBUF_MAX_NDIM: c_int = if cfg!(PyPy) { 36 } else { 64 };
+pub const PyBUF_MAX_NDIM: usize = 64;
 
 /* Flags for getting buffers */
 pub const PyBUF_SIMPLE: c_int = 0;
diff --git a/pyo3-ffi/src/pycapsule.rs b/pyo3-ffi/src/pycapsule.rs
index 5b77841c23c..65df8837063 100644
--- a/pyo3-ffi/src/pycapsule.rs
+++ b/pyo3-ffi/src/pycapsule.rs
@@ -1,5 +1,5 @@
 use crate::object::*;
-use std::os::raw::{c_char, c_int, c_void};
+use std::ffi::{c_char, c_int, c_void};
 use std::ptr::addr_of_mut;
 
 #[cfg_attr(windows, link(name = "pythonXY"))]
diff --git a/pyo3-ffi/src/pyerrors.rs b/pyo3-ffi/src/pyerrors.rs
index 9da00ea390e..557f314c7cb 100644
--- a/pyo3-ffi/src/pyerrors.rs
+++ b/pyo3-ffi/src/pyerrors.rs
@@ -1,6 +1,6 @@
 use crate::object::*;
 use crate::pyport::Py_ssize_t;
-use std::os::raw::{c_char, c_int};
+use std::ffi::{c_char, c_int};
 
 extern "C" {
     #[cfg_attr(PyPy, link_name = "PyPyErr_SetNone")]
@@ -101,7 +101,7 @@ pub unsafe fn PyUnicodeDecodeError_Create(
 ) -> *mut PyObject {
     crate::_PyObject_CallFunction_SizeT(
         PyExc_UnicodeDecodeError,
-        b"sy#nns\0".as_ptr().cast::<c_char>(),
+        c"sy#nns".as_ptr(),
         encoding,
         object,
         length,
@@ -116,6 +116,7 @@ extern "C" {
     #[cfg_attr(PyPy, link_name = "PyPyExc_BaseException")]
     pub static mut PyExc_BaseException: *mut PyObject;
     #[cfg(Py_3_11)]
+    #[cfg_attr(PyPy, link_name = "PyPyExc_BaseExceptionGroup")]
     pub static mut PyExc_BaseExceptionGroup: *mut PyObject;
     #[cfg_attr(PyPy, link_name = "PyPyExc_Exception")]
     pub static mut PyExc_Exception: *mut PyObject;
diff --git a/pyo3-ffi/src/pyframe.rs b/pyo3-ffi/src/pyframe.rs
index 43a9d1f6777..f91069929ed 100644
--- a/pyo3-ffi/src/pyframe.rs
+++ b/pyo3-ffi/src/pyframe.rs
@@ -1,14 +1,15 @@
+#[allow(unused_imports)]
+use crate::object::PyObject;
+#[cfg(not(GraalPy))]
 #[cfg(any(Py_3_10, all(Py_3_9, not(Py_LIMITED_API))))]
 use crate::PyCodeObject;
-#[cfg(not(Py_LIMITED_API))]
 use crate::PyFrameObject;
-use std::os::raw::c_int;
-
-#[cfg(Py_LIMITED_API)]
-opaque_struct!(PyFrameObject);
+use std::ffi::c_int;
 
 extern "C" {
-    pub fn PyFrame_GetLineNumber(f: *mut PyFrameObject) -> c_int;
+    pub fn PyFrame_GetLineNumber(frame: *mut PyFrameObject) -> c_int;
+
+    #[cfg(not(GraalPy))]
     #[cfg(any(Py_3_10, all(Py_3_9, not(Py_LIMITED_API))))]
-    pub fn PyFrame_GetCode(f: *mut PyFrameObject) -> *mut PyCodeObject;
+    pub fn PyFrame_GetCode(frame: *mut PyFrameObject) -> *mut PyCodeObject;
 }
diff --git a/pyo3-ffi/src/pyhash.rs b/pyo3-ffi/src/pyhash.rs
index f8072d85108..4fab07d00d4 100644
--- a/pyo3-ffi/src/pyhash.rs
+++ b/pyo3-ffi/src/pyhash.rs
@@ -1,9 +1,9 @@
 #[cfg(not(any(Py_LIMITED_API, PyPy)))]
 use crate::pyport::{Py_hash_t, Py_ssize_t};
 #[cfg(not(any(Py_LIMITED_API, PyPy)))]
-use std::os::raw::{c_char, c_void};
+use std::ffi::c_void;
 
-use std::os::raw::{c_int, c_ulong};
+use std::ffi::{c_int, c_ulong};
 
 extern "C" {
     // skipped non-limited _Py_HashDouble
@@ -20,29 +20,6 @@ pub const _PyHASH_MULTIPLIER: c_ulong = 1000003;
 
 // skipped non-limited _Py_HashSecret_t
 
-#[cfg(not(any(Py_LIMITED_API, PyPy)))]
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct PyHash_FuncDef {
-    pub hash: Option<extern "C" fn(arg1: *const c_void, arg2: Py_ssize_t) -> Py_hash_t>,
-    pub name: *const c_char,
-    pub hash_bits: c_int,
-    pub seed_bits: c_int,
-}
-
-#[cfg(not(any(Py_LIMITED_API, PyPy)))]
-impl Default for PyHash_FuncDef {
-    #[inline]
-    fn default() -> Self {
-        unsafe { std::mem::zeroed() }
-    }
-}
-
-extern "C" {
-    #[cfg(not(any(Py_LIMITED_API, PyPy)))]
-    pub fn PyHash_GetFuncDef() -> *mut PyHash_FuncDef;
-}
-
 // skipped Py_HASH_CUTOFF
 
 pub const Py_HASH_EXTERNAL: c_int = 0;
diff --git a/pyo3-ffi/src/pylifecycle.rs b/pyo3-ffi/src/pylifecycle.rs
index 7f73e3f0e9b..e822da09f98 100644
--- a/pyo3-ffi/src/pylifecycle.rs
+++ b/pyo3-ffi/src/pylifecycle.rs
@@ -1,7 +1,7 @@
 use crate::pystate::PyThreadState;
 
 use libc::wchar_t;
-use std::os::raw::{c_char, c_int};
+use std::ffi::{c_char, c_int};
 
 extern "C" {
     pub fn Py_Initialize();
@@ -18,23 +18,60 @@ extern "C" {
     #[cfg_attr(PyPy, link_name = "PyPy_AtExit")]
     pub fn Py_AtExit(func: Option<extern "C" fn()>) -> c_int;
 
-    pub fn Py_Exit(arg1: c_int);
+    pub fn Py_Exit(arg1: c_int) -> !;
 
     pub fn Py_Main(argc: c_int, argv: *mut *mut wchar_t) -> c_int;
     pub fn Py_BytesMain(argc: c_int, argv: *mut *mut c_char) -> c_int;
 
+    #[cfg_attr(
+        Py_3_11,
+        deprecated(note = "Deprecated since Python 3.11. Use `PyConfig.program_name` instead.")
+    )]
     pub fn Py_SetProgramName(arg1: *const wchar_t);
     #[cfg_attr(PyPy, link_name = "PyPy_GetProgramName")]
+    #[cfg_attr(
+        Py_3_13,
+        deprecated(note = "Deprecated since Python 3.13. Use `sys.executable` instead.")
+    )]
     pub fn Py_GetProgramName() -> *mut wchar_t;
 
+    #[cfg_attr(
+        Py_3_11,
+        deprecated(note = "Deprecated since Python 3.11. Use `PyConfig.home` instead.")
+    )]
     pub fn Py_SetPythonHome(arg1: *const wchar_t);
+    #[cfg_attr(
+        Py_3_13,
+        deprecated(
+            note = "Deprecated since Python 3.13. Use `PyConfig.home` or the value of the `PYTHONHOME` environment variable instead."
+        )
+    )]
     pub fn Py_GetPythonHome() -> *mut wchar_t;
-
+    #[cfg_attr(
+        Py_3_13,
+        deprecated(note = "Deprecated since Python 3.13. Use `sys.executable` instead.")
+    )]
     pub fn Py_GetProgramFullPath() -> *mut wchar_t;
-
+    #[cfg_attr(
+        Py_3_13,
+        deprecated(note = "Deprecated since Python 3.13. Use `sys.prefix` instead.")
+    )]
     pub fn Py_GetPrefix() -> *mut wchar_t;
+    #[cfg_attr(
+        Py_3_13,
+        deprecated(note = "Deprecated since Python 3.13. Use `sys.exec_prefix` instead.")
+    )]
     pub fn Py_GetExecPrefix() -> *mut wchar_t;
+    #[cfg_attr(
+        Py_3_13,
+        deprecated(note = "Deprecated since Python 3.13. Use `sys.path` instead.")
+    )]
     pub fn Py_GetPath() -> *mut wchar_t;
+    #[cfg(not(Py_3_13))]
+    #[cfg_attr(
+        Py_3_11,
+        deprecated(note = "Deprecated since Python 3.11. Use `sys.path` instead.")
+    )]
     pub fn Py_SetPath(arg1: *const wchar_t);
 
     // skipped _Py_CheckPython3
@@ -52,4 +89,10 @@ type PyOS_sighandler_t = unsafe extern "C" fn(arg1: c_int);
 extern "C" {
     pub fn PyOS_getsig(arg1: c_int) -> PyOS_sighandler_t;
     pub fn PyOS_setsig(arg1: c_int, arg2: PyOS_sighandler_t) -> PyOS_sighandler_t;
+
+    #[cfg(Py_3_11)]
+    pub static Py_Version: std::ffi::c_ulong;
+
+    #[cfg(Py_3_13)]
+    pub fn Py_IsFinalizing() -> c_int;
 }
diff --git a/pyo3-ffi/src/pymem.rs b/pyo3-ffi/src/pymem.rs
index ab0c3d74af9..aaa5a4f6e8d 100644
--- a/pyo3-ffi/src/pymem.rs
+++ b/pyo3-ffi/src/pymem.rs
@@ -1,5 +1,5 @@
 use libc::size_t;
-use std::os::raw::c_void;
+use std::ffi::c_void;
 
 extern "C" {
     #[cfg_attr(PyPy, link_name = "PyPyMem_Malloc")]
diff --git a/pyo3-ffi/src/pyport.rs b/pyo3-ffi/src/pyport.rs
index 741b0db7bf8..3a066353ca4 100644
--- a/pyo3-ffi/src/pyport.rs
+++ b/pyo3-ffi/src/pyport.rs
@@ -1,3 +1,8 @@
+// NB libc does not define this constant on all platforms, so we hard code it
+// like CPython does.
+// https://github.com/python/cpython/blob/d8b9011702443bb57579f8834f3effe58e290dfc/Include/pyport.h#L372
+pub const INT_MAX: std::ffi::c_int = 2147483647;
+
 pub type PY_UINT32_T = u32;
 pub type PY_UINT64_T = u64;
 
@@ -11,8 +16,8 @@ pub type Py_ssize_t = ::libc::ssize_t;
 pub type Py_hash_t = Py_ssize_t;
 pub type Py_uhash_t = ::libc::size_t;
 
-pub const PY_SSIZE_T_MIN: Py_ssize_t = std::isize::MIN as Py_ssize_t;
-pub const PY_SSIZE_T_MAX: Py_ssize_t = std::isize::MAX as Py_ssize_t;
+pub const PY_SSIZE_T_MIN: Py_ssize_t = Py_ssize_t::MIN;
+pub const PY_SSIZE_T_MAX: Py_ssize_t = Py_ssize_t::MAX;
 
 #[cfg(target_endian = "big")]
 pub const PY_BIG_ENDIAN: usize = 1;
diff --git a/pyo3-ffi/src/pystate.rs b/pyo3-ffi/src/pystate.rs
index d2fd39e497d..8b8cf13ce70 100644
--- a/pyo3-ffi/src/pystate.rs
+++ b/pyo3-ffi/src/pystate.rs
@@ -1,15 +1,17 @@
-#[cfg(any(not(PyPy), Py_3_9))]
 use crate::moduleobject::PyModuleDef;
 use crate::object::PyObject;
-use std::os::raw::c_int;
+use std::ffi::c_int;
+
+#[cfg(all(Py_3_10, not(PyPy), not(Py_LIMITED_API)))]
+use crate::PyFrameObject;
 
 #[cfg(not(PyPy))]
-use std::os::raw::c_long;
+use std::ffi::c_long;
 
 pub const MAX_CO_EXTRA_USERS: c_int = 255;
 
-opaque_struct!(PyThreadState);
-opaque_struct!(PyInterpreterState);
+opaque_struct!(pub PyThreadState);
+opaque_struct!(pub PyInterpreterState);
 
 extern "C" {
     #[cfg(not(PyPy))]
@@ -28,17 +30,13 @@ extern "C" {
     #[cfg(not(PyPy))]
     pub fn PyInterpreterState_GetID(arg1: *mut PyInterpreterState) -> i64;
 
-    #[cfg(any(not(PyPy), Py_3_9))] // only on PyPy since 3.9
     #[cfg_attr(PyPy, link_name = "PyPyState_AddModule")]
     pub fn PyState_AddModule(arg1: *mut PyObject, arg2: *mut PyModuleDef) -> c_int;
 
-    #[cfg(any(not(PyPy), Py_3_9))] // only on PyPy since 3.9
     #[cfg_attr(PyPy, link_name = "PyPyState_RemoveModule")]
     pub fn PyState_RemoveModule(arg1: *mut PyModuleDef) -> c_int;
 
-    #[cfg(any(not(PyPy), Py_3_9))] // only on PyPy since 3.9
-    // only has PyPy prefix since 3.10
-    #[cfg_attr(all(PyPy, Py_3_10), link_name = "PyPyState_FindModule")]
+    #[cfg_attr(PyPy, link_name = "PyPyState_FindModule")]
     pub fn PyState_FindModule(arg1: *mut PyModuleDef) -> *mut PyObject;
 
     #[cfg_attr(PyPy, link_name = "PyPyThreadState_New")]
@@ -67,9 +65,14 @@ extern "C" {
 }
 
 // skipped non-limited / 3.9 PyThreadState_GetInterpreter
-// skipped non-limited / 3.9 PyThreadState_GetFrame
 // skipped non-limited / 3.9 PyThreadState_GetID
 
+extern "C" {
+    // PyThreadState_GetFrame
+    #[cfg(all(Py_3_10, not(PyPy), not(Py_LIMITED_API)))]
+    pub fn PyThreadState_GetFrame(arg1: *mut PyThreadState) -> *mut PyFrameObject;
+}
+
 #[repr(C)]
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
 pub enum PyGILState_STATE {
@@ -77,9 +80,70 @@ pub enum PyGILState_STATE {
     PyGILState_UNLOCKED,
 }
 
+#[cfg(not(any(Py_3_14, target_arch = "wasm32")))]
+struct HangThread;
+
+#[cfg(not(any(Py_3_14, target_arch = "wasm32")))]
+impl Drop for HangThread {
+    fn drop(&mut self) {
+        loop {
+            std::thread::park(); // Block forever.
+        }
+    }
+}
+
+// The PyGILState_Ensure function will call pthread_exit during interpreter shutdown,
+// which causes undefined behavior. Redirect to the "safe" version that hangs instead,
+// as Python 3.14 does.
+//
+// See https://github.com/rust-lang/rust/issues/135929
+
+// C-unwind only supported (and necessary) since 1.71. Python 3.14+ does not do
+// pthread_exit from PyGILState_Ensure (https://github.com/python/cpython/issues/87135).
+mod raw {
+    #[cfg(not(any(Py_3_14, target_arch = "wasm32")))]
+    extern "C-unwind" {
+        #[cfg_attr(PyPy, link_name = "PyPyGILState_Ensure")]
+        pub fn PyGILState_Ensure() -> super::PyGILState_STATE;
+    }
+
+    #[cfg(any(Py_3_14, target_arch = "wasm32"))]
+    extern "C" {
+        #[cfg_attr(PyPy, link_name = "PyPyGILState_Ensure")]
+        pub fn PyGILState_Ensure() -> super::PyGILState_STATE;
+    }
+}
+
+#[cfg(not(any(Py_3_14, target_arch = "wasm32")))]
+pub unsafe extern "C" fn PyGILState_Ensure() -> PyGILState_STATE {
+    let guard = HangThread;
+    // If `PyGILState_Ensure` calls `pthread_exit`, which it does on Python < 3.14
+    // when the interpreter is shutting down, this will cause a forced unwind.
+    // doing a forced unwind through a function with a Rust destructor is unspecified
+    // behavior.
+    //
+    // However, currently it runs the destructor, which will cause the thread to
+    // hang as it should.
+    //
+    // And if we don't catch the unwinding here, then one of our callers probably has a destructor,
+    // so it's unspecified behavior anyway, and on many configurations causes the process to abort.
+    //
+    // The alternative is for pyo3 to contain custom C or C++ code that catches the `pthread_exit`,
+    // but that's also annoying from a portability point of view.
+    //
+    // On Windows, `PyGILState_Ensure` calls `_endthreadex` instead, which AFAICT can't be caught
+    // and therefore will cause unsafety if there are pinned objects on the stack. AFAICT there's
+    // nothing we can do it other than waiting for Python 3.14 or not using Windows. At least,
+    // if there is nothing pinned on the stack, it won't cause the process to crash.
+    let ret: PyGILState_STATE = raw::PyGILState_Ensure();
+    std::mem::forget(guard);
+    ret
+}
+
+#[cfg(any(Py_3_14, target_arch = "wasm32"))]
+pub use self::raw::PyGILState_Ensure;
+
 extern "C" {
-    #[cfg_attr(PyPy, link_name = "PyPyGILState_Ensure")]
-    pub fn PyGILState_Ensure() -> PyGILState_STATE;
     #[cfg_attr(PyPy, link_name = "PyPyGILState_Release")]
     pub fn PyGILState_Release(arg1: PyGILState_STATE);
     #[cfg(not(PyPy))]
diff --git a/pyo3-ffi/src/pystrtod.rs b/pyo3-ffi/src/pystrtod.rs
index 1f027686bd9..20d5a24387b 100644
--- a/pyo3-ffi/src/pystrtod.rs
+++ b/pyo3-ffi/src/pystrtod.rs
@@ -1,5 +1,5 @@
 use crate::object::PyObject;
-use std::os::raw::{c_char, c_double, c_int};
+use std::ffi::{c_char, c_double, c_int};
 
 extern "C" {
     #[cfg_attr(PyPy, link_name = "PyPyOS_string_to_double")]
diff --git a/pyo3-ffi/src/pythonrun.rs b/pyo3-ffi/src/pythonrun.rs
index e5f20de0058..090c964d665 100644
--- a/pyo3-ffi/src/pythonrun.rs
+++ b/pyo3-ffi/src/pythonrun.rs
@@ -1,12 +1,12 @@
 use crate::object::*;
 #[cfg(not(any(PyPy, Py_LIMITED_API, Py_3_10)))]
 use libc::FILE;
-#[cfg(all(not(PyPy), any(Py_LIMITED_API, not(Py_3_10))))]
-use std::os::raw::c_char;
-use std::os::raw::c_int;
+#[cfg(any(Py_LIMITED_API, not(Py_3_10), PyPy, GraalPy))]
+use std::ffi::c_char;
+use std::ffi::c_int;
 
 extern "C" {
-    #[cfg(all(Py_LIMITED_API, not(PyPy)))]
+    #[cfg(any(all(Py_LIMITED_API, not(PyPy)), GraalPy))]
     pub fn Py_CompileString(string: *const c_char, p: *const c_char, s: c_int) -> *mut PyObject;
 
     #[cfg_attr(PyPy, link_name = "PyPyErr_Print")]
@@ -20,6 +20,28 @@ extern "C" {
     pub fn PyErr_DisplayException(exc: *mut PyObject);
 }
 
+#[inline]
+#[cfg(PyPy)]
+pub unsafe fn Py_CompileString(string: *const c_char, p: *const c_char, s: c_int) -> *mut PyObject {
+    // PyPy's implementation of Py_CompileString always forwards to Py_CompileStringFlags; this
+    // is only available in the non-limited API and has a real definition for all versions in
+    // the cpython/ subdirectory.
+    #[cfg(Py_LIMITED_API)]
+    extern "C" {
+        #[link_name = "PyPy_CompileStringFlags"]
+        pub fn Py_CompileStringFlags(
+            string: *const c_char,
+            p: *const c_char,
+            s: c_int,
+            f: *mut std::ffi::c_void, // Actually *mut Py_CompilerFlags in the real definition
+        ) -> *mut PyObject;
+    }
+    #[cfg(not(Py_LIMITED_API))]
+    use crate::Py_CompileStringFlags;
+
+    Py_CompileStringFlags(string, p, s, std::ptr::null_mut())
+}
+
 // skipped PyOS_InputHook
 
 pub const PYOS_STACK_MARGIN: c_int = 2048;
@@ -27,12 +49,12 @@ pub const PYOS_STACK_MARGIN: c_int = 2048;
 // skipped PyOS_CheckStack under Microsoft C
 
 #[cfg(not(any(PyPy, Py_LIMITED_API, Py_3_10)))]
-opaque_struct!(_mod);
+opaque_struct!(pub _mod);
 
 #[cfg(not(any(PyPy, Py_3_10)))]
-opaque_struct!(symtable);
+opaque_struct!(pub symtable);
 #[cfg(not(any(PyPy, Py_3_10)))]
-opaque_struct!(_node);
+opaque_struct!(pub _node);
 
 #[cfg(not(any(PyPy, Py_LIMITED_API, Py_3_10)))]
 #[cfg_attr(Py_3_9, deprecated(note = "Python 3.9"))]
diff --git a/pyo3-ffi/src/pytypedefs.rs b/pyo3-ffi/src/pytypedefs.rs
new file mode 100644
index 00000000000..7172724ce1f
--- /dev/null
+++ b/pyo3-ffi/src/pytypedefs.rs
@@ -0,0 +1,4 @@
+// TODO: Created this file as part of fixing pyframe.rs and cpython/pyframe.rs
+// TODO: Finish defining or moving declarations now in Include/pytypedefs.h
+
+opaque_struct!(pub PyFrameObject);
diff --git a/pyo3-ffi/src/rangeobject.rs b/pyo3-ffi/src/rangeobject.rs
index 408b5cdc5a4..35667fed8c2 100644
--- a/pyo3-ffi/src/rangeobject.rs
+++ b/pyo3-ffi/src/rangeobject.rs
@@ -1,5 +1,5 @@
 use crate::object::*;
-use std::os::raw::c_int;
+use std::ffi::c_int;
 use std::ptr::addr_of_mut;
 
 #[cfg_attr(windows, link(name = "pythonXY"))]
diff --git a/pyo3-ffi/src/refcount.rs b/pyo3-ffi/src/refcount.rs
new file mode 100644
index 00000000000..22a6268c729
--- /dev/null
+++ b/pyo3-ffi/src/refcount.rs
@@ -0,0 +1,369 @@
+use crate::pyport::Py_ssize_t;
+use crate::PyObject;
+#[cfg(py_sys_config = "Py_REF_DEBUG")]
+use std::ffi::c_char;
+#[cfg(Py_3_12)]
+use std::ffi::c_int;
+#[cfg(all(Py_3_14, any(not(Py_GIL_DISABLED), target_pointer_width = "32")))]
+use std::ffi::c_long;
+#[cfg(any(Py_GIL_DISABLED, all(Py_3_12, not(Py_3_14))))]
+use std::ffi::c_uint;
+#[cfg(all(Py_3_14, not(Py_GIL_DISABLED)))]
+use std::ffi::c_ulong;
+use std::ptr;
+#[cfg(Py_GIL_DISABLED)]
+use std::sync::atomic::Ordering::Relaxed;
+
+#[cfg(Py_3_14)]
+const _Py_STATICALLY_ALLOCATED_FLAG: c_int = 1 << 7;
+
+#[cfg(all(Py_3_12, not(Py_3_14)))]
+const _Py_IMMORTAL_REFCNT: Py_ssize_t = {
+    if cfg!(target_pointer_width = "64") {
+        c_uint::MAX as Py_ssize_t
+    } else {
+        // for 32-bit systems, use the lower 30 bits (see comment in CPython's object.h)
+        (c_uint::MAX >> 2) as Py_ssize_t
+    }
+};
+
+// comments in Python.h about the choices for these constants
+
+#[cfg(all(Py_3_14, not(Py_GIL_DISABLED)))]
+const _Py_IMMORTAL_INITIAL_REFCNT: Py_ssize_t = {
+    if cfg!(target_pointer_width = "64") {
+        ((3 as c_ulong) << (30 as c_ulong)) as Py_ssize_t
+    } else {
+        ((5 as c_long) << (28 as c_long)) as Py_ssize_t
+    }
+};
+
+#[cfg(all(Py_3_14, not(Py_GIL_DISABLED)))]
+const _Py_STATIC_IMMORTAL_INITIAL_REFCNT: Py_ssize_t = {
+    if cfg!(target_pointer_width = "64") {
+        _Py_IMMORTAL_INITIAL_REFCNT
+            | ((_Py_STATICALLY_ALLOCATED_FLAG as Py_ssize_t) << (32 as Py_ssize_t))
+    } else {
+        ((7 as c_long) << (28 as c_long)) as Py_ssize_t
+    }
+};
+
+#[cfg(all(Py_3_14, target_pointer_width = "32"))]
+const _Py_IMMORTAL_MINIMUM_REFCNT: Py_ssize_t = ((1 as c_long) << (30 as c_long)) as Py_ssize_t;
+
+#[cfg(all(Py_3_14, target_pointer_width = "32"))]
+const _Py_STATIC_IMMORTAL_MINIMUM_REFCNT: Py_ssize_t =
+    ((6 as c_long) << (28 as c_long)) as Py_ssize_t;
+
+#[cfg(all(Py_3_14, Py_GIL_DISABLED))]
+const _Py_IMMORTAL_INITIAL_REFCNT: Py_ssize_t = c_uint::MAX as Py_ssize_t;
+
+#[cfg(Py_GIL_DISABLED)]
+pub(crate) const _Py_IMMORTAL_REFCNT_LOCAL: u32 = u32::MAX;
+
+#[cfg(Py_GIL_DISABLED)]
+const _Py_REF_SHARED_SHIFT: isize = 2;
+// skipped private _Py_REF_SHARED_FLAG_MASK
+
+// skipped private _Py_REF_SHARED_INIT
+// skipped private _Py_REF_MAYBE_WEAKREF
+// skipped private _Py_REF_QUEUED
+// skipped private _Py_REF_MERGED
+
+// skipped private _Py_REF_SHARED
+
+extern "C" {
+    #[cfg(all(Py_3_14, Py_LIMITED_API))]
+    pub fn Py_REFCNT(ob: *mut PyObject) -> Py_ssize_t;
+}
+
+#[cfg(not(all(Py_3_14, Py_LIMITED_API)))]
+#[inline]
+pub unsafe fn Py_REFCNT(ob: *mut PyObject) -> Py_ssize_t {
+    #[cfg(Py_GIL_DISABLED)]
+    {
+        let local = (*ob).ob_ref_local.load(Relaxed);
+        if local == _Py_IMMORTAL_REFCNT_LOCAL {
+            #[cfg(not(Py_3_14))]
+            return _Py_IMMORTAL_REFCNT;
+            #[cfg(Py_3_14)]
+            return _Py_IMMORTAL_INITIAL_REFCNT;
+        }
+        let shared = (*ob).ob_ref_shared.load(Relaxed);
+        local as Py_ssize_t + Py_ssize_t::from(shared >> _Py_REF_SHARED_SHIFT)
+    }
+
+    #[cfg(all(Py_LIMITED_API, Py_3_14))]
+    {
+        Py_REFCNT(ob)
+    }
+
+    #[cfg(all(not(Py_GIL_DISABLED), not(all(Py_LIMITED_API, Py_3_14)), Py_3_12))]
+    {
+        (*ob).ob_refcnt.ob_refcnt
+    }
+
+    #[cfg(all(not(Py_GIL_DISABLED), not(Py_3_12), not(GraalPy)))]
+    {
+        (*ob).ob_refcnt
+    }
+
+    #[cfg(all(not(Py_GIL_DISABLED), not(Py_3_12), GraalPy))]
+    {
+        _Py_REFCNT(ob)
+    }
+}
+
+#[cfg(Py_3_12)]
+#[inline(always)]
+unsafe fn _Py_IsImmortal(op: *mut PyObject) -> c_int {
+    #[cfg(all(target_pointer_width = "64", not(Py_GIL_DISABLED)))]
+    {
+        (((*op).ob_refcnt.ob_refcnt as crate::PY_INT32_T) < 0) as c_int
+    }
+
+    #[cfg(all(target_pointer_width = "32", not(Py_GIL_DISABLED)))]
+    {
+        #[cfg(not(Py_3_14))]
+        {
+            ((*op).ob_refcnt.ob_refcnt == _Py_IMMORTAL_REFCNT) as c_int
+        }
+
+        #[cfg(Py_3_14)]
+        {
+            ((*op).ob_refcnt.ob_refcnt >= _Py_IMMORTAL_MINIMUM_REFCNT) as c_int
+        }
+    }
+
+    #[cfg(Py_GIL_DISABLED)]
+    {
+        ((*op).ob_ref_local.load(Relaxed) == _Py_IMMORTAL_REFCNT_LOCAL) as c_int
+    }
+}
+
+// skipped _Py_IsStaticImmortal
+
+// TODO: Py_SET_REFCNT
+
+extern "C" {
+    #[cfg(all(py_sys_config = "Py_REF_DEBUG", not(Py_LIMITED_API)))]
+    fn _Py_NegativeRefcount(filename: *const c_char, lineno: c_int, op: *mut PyObject);
+    #[cfg(all(Py_3_12, py_sys_config = "Py_REF_DEBUG", not(Py_LIMITED_API)))]
+    fn _Py_INCREF_IncRefTotal();
+    #[cfg(all(Py_3_12, py_sys_config = "Py_REF_DEBUG", not(Py_LIMITED_API)))]
+    fn _Py_DECREF_DecRefTotal();
+
+    #[cfg_attr(PyPy, link_name = "_PyPy_Dealloc")]
+    fn _Py_Dealloc(arg1: *mut PyObject);
+
+    #[cfg_attr(PyPy, link_name = "PyPy_IncRef")]
+    #[cfg_attr(GraalPy, link_name = "_Py_IncRef")]
+    pub fn Py_IncRef(o: *mut PyObject);
+    #[cfg_attr(PyPy, link_name = "PyPy_DecRef")]
+    #[cfg_attr(GraalPy, link_name = "_Py_DecRef")]
+    pub fn Py_DecRef(o: *mut PyObject);
+
+    #[cfg(all(Py_3_10, not(PyPy)))]
+    fn _Py_IncRef(o: *mut PyObject);
+    #[cfg(all(Py_3_10, not(PyPy)))]
+    fn _Py_DecRef(o: *mut PyObject);
+
+    #[cfg(GraalPy)]
+    fn _Py_REFCNT(arg1: *const PyObject) -> Py_ssize_t;
+}
+
+#[inline(always)]
+pub unsafe fn Py_INCREF(op: *mut PyObject) {
+    // On limited API, the free-threaded build, or with refcount debugging, let the interpreter do refcounting
+    // TODO: reimplement the logic in the header in the free-threaded build, for a little bit of performance.
+    #[cfg(any(
+        Py_GIL_DISABLED,
+        Py_LIMITED_API,
+        py_sys_config = "Py_REF_DEBUG",
+        GraalPy
+    ))]
+    {
+        // _Py_IncRef was added to the ABI in 3.10; skips null checks
+        #[cfg(all(Py_3_10, not(PyPy)))]
+        {
+            _Py_IncRef(op);
+        }
+
+        #[cfg(any(not(Py_3_10), PyPy))]
+        {
+            Py_IncRef(op);
+        }
+    }
+
+    // version-specific builds are allowed to directly manipulate the reference count
+    #[cfg(not(any(
+        Py_GIL_DISABLED,
+        Py_LIMITED_API,
+        py_sys_config = "Py_REF_DEBUG",
+        GraalPy
+    )))]
+    {
+        #[cfg(all(Py_3_14, target_pointer_width = "64"))]
+        {
+            let cur_refcnt = (*op).ob_refcnt.ob_refcnt;
+            if (cur_refcnt as i32) < 0 {
+                return;
+            }
+            (*op).ob_refcnt.ob_refcnt = cur_refcnt.wrapping_add(1);
+        }
+
+        #[cfg(all(Py_3_12, not(Py_3_14), target_pointer_width = "64"))]
+        {
+            let cur_refcnt = (*op).ob_refcnt.ob_refcnt_split[crate::PY_BIG_ENDIAN];
+            let new_refcnt = cur_refcnt.wrapping_add(1);
+            if new_refcnt == 0 {
+                return;
+            }
+            (*op).ob_refcnt.ob_refcnt_split[crate::PY_BIG_ENDIAN] = new_refcnt;
+        }
+
+        #[cfg(all(Py_3_12, target_pointer_width = "32"))]
+        {
+            if _Py_IsImmortal(op) != 0 {
+                return;
+            }
+            (*op).ob_refcnt.ob_refcnt += 1
+        }
+
+        #[cfg(not(Py_3_12))]
+        {
+            (*op).ob_refcnt += 1
+        }
+
+        // Skipped _Py_INCREF_STAT_INC - if anyone wants this, please file an issue
+        // or submit a PR supporting Py_STATS build option and pystats.h
+    }
+}
+
+// skipped _Py_DecRefShared
+// skipped _Py_DecRefSharedDebug
+// skipped _Py_MergeZeroLocalRefcount
+
+#[inline(always)]
+#[cfg_attr(
+    all(py_sys_config = "Py_REF_DEBUG", Py_3_12, not(Py_LIMITED_API)),
+    track_caller
+)]
+pub unsafe fn Py_DECREF(op: *mut PyObject) {
+    // On limited API, the free-threaded build, or with refcount debugging, let the interpreter do refcounting
+    // On 3.12+ we implement refcount debugging to get better assertion locations on negative refcounts
+    // TODO: reimplement the logic in the header in the free-threaded build, for a little bit of performance.
+    #[cfg(any(
+        Py_GIL_DISABLED,
+        Py_LIMITED_API,
+        all(py_sys_config = "Py_REF_DEBUG", not(Py_3_12)),
+        GraalPy
+    ))]
+    {
+        // _Py_DecRef was added to the ABI in 3.10; skips null checks
+        #[cfg(all(Py_3_10, not(PyPy)))]
+        {
+            _Py_DecRef(op);
+        }
+
+        #[cfg(any(not(Py_3_10), PyPy))]
+        {
+            Py_DecRef(op);
+        }
+    }
+
+    #[cfg(not(any(
+        Py_GIL_DISABLED,
+        Py_LIMITED_API,
+        all(py_sys_config = "Py_REF_DEBUG", not(Py_3_12)),
+        GraalPy
+    )))]
+    {
+        #[cfg(Py_3_12)]
+        if _Py_IsImmortal(op) != 0 {
+            return;
+        }
+
+        // Skipped _Py_DECREF_STAT_INC - if anyone needs this, please file an issue
+        // or submit a PR supporting Py_STATS build option and pystats.h
+
+        #[cfg(py_sys_config = "Py_REF_DEBUG")]
+        _Py_DECREF_DecRefTotal();
+
+        #[cfg(Py_3_12)]
+        {
+            (*op).ob_refcnt.ob_refcnt -= 1;
+
+            #[cfg(py_sys_config = "Py_REF_DEBUG")]
+            if (*op).ob_refcnt.ob_refcnt < 0 {
+                let location = std::panic::Location::caller();
+                let filename = std::ffi::CString::new(location.file()).unwrap();
+                _Py_NegativeRefcount(filename.as_ptr(), location.line() as i32, op);
+            }
+
+            if (*op).ob_refcnt.ob_refcnt == 0 {
+                _Py_Dealloc(op);
+            }
+        }
+
+        #[cfg(not(Py_3_12))]
+        {
+            (*op).ob_refcnt -= 1;
+
+            if (*op).ob_refcnt == 0 {
+                _Py_Dealloc(op);
+            }
+        }
+    }
+}
+
+#[inline]
+pub unsafe fn Py_CLEAR(op: *mut *mut PyObject) {
+    let tmp = *op;
+    if !tmp.is_null() {
+        *op = ptr::null_mut();
+        Py_DECREF(tmp);
+    }
+}
+
+#[inline]
+pub unsafe fn Py_XINCREF(op: *mut PyObject) {
+    if !op.is_null() {
+        Py_INCREF(op)
+    }
+}
+
+#[inline]
+pub unsafe fn Py_XDECREF(op: *mut PyObject) {
+    if !op.is_null() {
+        Py_DECREF(op)
+    }
+}
+
+extern "C" {
+    #[cfg(all(Py_3_10, Py_LIMITED_API, not(PyPy)))]
+    #[cfg_attr(docsrs, doc(cfg(Py_3_10)))]
+    pub fn Py_NewRef(obj: *mut PyObject) -> *mut PyObject;
+    #[cfg(all(Py_3_10, Py_LIMITED_API, not(PyPy)))]
+    #[cfg_attr(docsrs, doc(cfg(Py_3_10)))]
+    pub fn Py_XNewRef(obj: *mut PyObject) -> *mut PyObject;
+}
+
+// macro _Py_NewRef not public; reimplemented directly inside Py_NewRef here
+// macro _Py_XNewRef not public; reimplemented directly inside Py_XNewRef here
+
+#[cfg(all(Py_3_10, any(not(Py_LIMITED_API), PyPy)))]
+#[cfg_attr(docsrs, doc(cfg(Py_3_10)))]
+#[inline]
+pub unsafe fn Py_NewRef(obj: *mut PyObject) -> *mut PyObject {
+    Py_INCREF(obj);
+    obj
+}
+
+#[cfg(all(Py_3_10, any(not(Py_LIMITED_API), PyPy)))]
+#[cfg_attr(docsrs, doc(cfg(Py_3_10)))]
+#[inline]
+pub unsafe fn Py_XNewRef(obj: *mut PyObject) -> *mut PyObject {
+    Py_XINCREF(obj);
+    obj
+}
diff --git a/pyo3-ffi/src/setobject.rs b/pyo3-ffi/src/setobject.rs
index 84a368a7f27..4c32952238c 100644
--- a/pyo3-ffi/src/setobject.rs
+++ b/pyo3-ffi/src/setobject.rs
@@ -1,13 +1,13 @@
 use crate::object::*;
-#[cfg(not(any(Py_LIMITED_API, PyPy)))]
+#[cfg(not(any(Py_LIMITED_API, PyPy, GraalPy)))]
 use crate::pyport::Py_hash_t;
 use crate::pyport::Py_ssize_t;
-use std::os::raw::c_int;
+use std::ffi::c_int;
 use std::ptr::addr_of_mut;
 
 pub const PySet_MINSIZE: usize = 8;
 
-#[cfg(not(any(Py_LIMITED_API, PyPy)))]
+#[cfg(not(any(Py_LIMITED_API, PyPy, GraalPy)))]
 #[repr(C)]
 #[derive(Debug)]
 pub struct setentry {
@@ -15,7 +15,7 @@ pub struct setentry {
     pub hash: Py_hash_t,
 }
 
-#[cfg(not(any(Py_LIMITED_API, PyPy)))]
+#[cfg(not(any(Py_LIMITED_API, PyPy, GraalPy)))]
 #[repr(C)]
 #[derive(Debug)]
 pub struct PySetObject {
@@ -32,18 +32,14 @@ pub struct PySetObject {
 
 // skipped
 #[inline]
-#[cfg(all(not(PyPy), not(Py_LIMITED_API)))]
+#[cfg(all(not(any(PyPy, GraalPy)), not(Py_LIMITED_API)))]
 pub unsafe fn PySet_GET_SIZE(so: *mut PyObject) -> Py_ssize_t {
     debug_assert_eq!(PyAnySet_Check(so), 1);
     let so = so.cast::<PySetObject>();
     (*so).used
 }
 
-#[cfg(not(Py_LIMITED_API))]
-#[cfg_attr(windows, link(name = "pythonXY"))]
-extern "C" {
-    pub static mut _PySet_Dummy: *mut PyObject;
-}
+// skipped _PySet_Dummy
 
 extern "C" {
     #[cfg(not(Py_LIMITED_API))]
@@ -92,7 +88,7 @@ extern "C" {
 }
 
 #[inline]
-#[cfg(not(PyPy))]
+#[cfg(not(any(PyPy, GraalPy)))]
 pub unsafe fn PyFrozenSet_CheckExact(ob: *mut PyObject) -> c_int {
     (Py_TYPE(ob) == addr_of_mut!(PyFrozenSet_Type)) as c_int
 }
diff --git a/pyo3-ffi/src/sliceobject.rs b/pyo3-ffi/src/sliceobject.rs
index 6f09906fcc4..7f90289e010 100644
--- a/pyo3-ffi/src/sliceobject.rs
+++ b/pyo3-ffi/src/sliceobject.rs
@@ -1,25 +1,35 @@
 use crate::object::*;
 use crate::pyport::Py_ssize_t;
-use std::os::raw::c_int;
+use std::ffi::c_int;
 use std::ptr::addr_of_mut;
 
 #[cfg_attr(windows, link(name = "pythonXY"))]
 extern "C" {
+    #[cfg(not(GraalPy))]
     #[cfg_attr(PyPy, link_name = "_PyPy_EllipsisObject")]
     static mut _Py_EllipsisObject: PyObject;
+
+    #[cfg(GraalPy)]
+    static mut _Py_EllipsisObjectReference: *mut PyObject;
 }
 
 #[inline]
 pub unsafe fn Py_Ellipsis() -> *mut PyObject {
-    addr_of_mut!(_Py_EllipsisObject)
+    #[cfg(not(GraalPy))]
+    return addr_of_mut!(_Py_EllipsisObject);
+    #[cfg(GraalPy)]
+    return _Py_EllipsisObjectReference;
 }
 
 #[cfg(not(Py_LIMITED_API))]
 #[repr(C)]
 pub struct PySliceObject {
     pub ob_base: PyObject,
+    #[cfg(not(GraalPy))]
     pub start: *mut PyObject,
+    #[cfg(not(GraalPy))]
     pub stop: *mut PyObject,
+    #[cfg(not(GraalPy))]
     pub step: *mut PyObject,
 }
 
@@ -83,7 +93,7 @@ extern "C" {
         step: *mut Py_ssize_t,
     ) -> c_int;
 
-    #[cfg_attr(all(PyPy, Py_3_10), link_name = "PyPySlice_AdjustIndices")]
+    #[cfg_attr(PyPy, link_name = "PyPySlice_AdjustIndices")]
     pub fn PySlice_AdjustIndices(
         length: Py_ssize_t,
         start: *mut Py_ssize_t,
diff --git a/pyo3-ffi/src/structmember.rs b/pyo3-ffi/src/structmember.rs
index afae165c5b3..2d9dd5a4a1f 100644
--- a/pyo3-ffi/src/structmember.rs
+++ b/pyo3-ffi/src/structmember.rs
@@ -1,4 +1,4 @@
-use std::os::raw::c_int;
+use std::ffi::c_int;
 
 pub use crate::PyMemberDef;
 
diff --git a/pyo3-ffi/src/structseq.rs b/pyo3-ffi/src/structseq.rs
index 6dfc1daf158..e5cfee1a876 100644
--- a/pyo3-ffi/src/structseq.rs
+++ b/pyo3-ffi/src/structseq.rs
@@ -1,7 +1,7 @@
 use crate::object::{PyObject, PyTypeObject};
 #[cfg(not(PyPy))]
 use crate::pyport::Py_ssize_t;
-use std::os::raw::{c_char, c_int};
+use std::ffi::{c_char, c_int};
 
 #[repr(C)]
 #[derive(Copy, Clone)]
@@ -42,13 +42,13 @@ extern "C" {
 #[cfg(not(Py_LIMITED_API))]
 pub type PyStructSequence = crate::PyTupleObject;
 
-#[cfg(not(any(Py_LIMITED_API, PyPy)))]
+#[cfg(not(any(Py_LIMITED_API, PyPy, GraalPy)))]
 #[inline]
 pub unsafe fn PyStructSequence_SET_ITEM(op: *mut PyObject, i: Py_ssize_t, v: *mut PyObject) {
     crate::PyTuple_SET_ITEM(op, i, v)
 }
 
-#[cfg(not(any(Py_LIMITED_API, PyPy)))]
+#[cfg(not(any(Py_LIMITED_API, PyPy, GraalPy)))]
 #[inline]
 pub unsafe fn PyStructSequence_GET_ITEM(op: *mut PyObject, i: Py_ssize_t) -> *mut PyObject {
     crate::PyTuple_GET_ITEM(op, i)
diff --git a/pyo3-ffi/src/sysmodule.rs b/pyo3-ffi/src/sysmodule.rs
index 3c552254244..c0a3f176228 100644
--- a/pyo3-ffi/src/sysmodule.rs
+++ b/pyo3-ffi/src/sysmodule.rs
@@ -1,6 +1,6 @@
 use crate::object::PyObject;
 use libc::wchar_t;
-use std::os::raw::{c_char, c_int};
+use std::ffi::{c_char, c_int};
 
 extern "C" {
     #[cfg_attr(PyPy, link_name = "PyPySys_GetObject")]
@@ -8,7 +8,19 @@ extern "C" {
     #[cfg_attr(PyPy, link_name = "PyPySys_SetObject")]
     pub fn PySys_SetObject(arg1: *const c_char, arg2: *mut PyObject) -> c_int;
 
+    #[cfg_attr(
+        Py_3_11,
+        deprecated(
+            note = "Deprecated in Python 3.11, use `PyConfig.argv` and `PyConfig.parse_argv` instead"
+        )
+    )]
     pub fn PySys_SetArgv(arg1: c_int, arg2: *mut *mut wchar_t);
+    #[cfg_attr(
+        Py_3_11,
+        deprecated(
+            note = "Deprecated in Python 3.11, use `PyConfig.argv` and `PyConfig.parse_argv` instead"
+        )
+    )]
     pub fn PySys_SetArgvEx(arg1: c_int, arg2: *mut *mut wchar_t, arg3: c_int);
     pub fn PySys_SetPath(arg1: *const wchar_t);
 
@@ -19,6 +31,12 @@ extern "C" {
     pub fn PySys_FormatStdout(format: *const c_char, ...);
     pub fn PySys_FormatStderr(format: *const c_char, ...);
 
+    #[cfg_attr(
+        Py_3_13,
+        deprecated(
+            note = "Deprecated since Python 3.13. Clear sys.warnoptions and warnings.filters instead."
+        )
+    )]
     pub fn PySys_ResetWarnOptions();
     #[cfg_attr(Py_3_11, deprecated(note = "Python 3.11"))]
     pub fn PySys_AddWarnOption(arg1: *const wchar_t);
diff --git a/pyo3-ffi/src/traceback.rs b/pyo3-ffi/src/traceback.rs
index 432b6980ef5..8b1ac216bea 100644
--- a/pyo3-ffi/src/traceback.rs
+++ b/pyo3-ffi/src/traceback.rs
@@ -1,5 +1,5 @@
 use crate::object::*;
-use std::os::raw::c_int;
+use std::ffi::c_int;
 #[cfg(not(PyPy))]
 use std::ptr::addr_of_mut;
 
diff --git a/pyo3-ffi/src/tupleobject.rs b/pyo3-ffi/src/tupleobject.rs
index d265c91a4b1..1bd34081bce 100644
--- a/pyo3-ffi/src/tupleobject.rs
+++ b/pyo3-ffi/src/tupleobject.rs
@@ -1,6 +1,6 @@
 use crate::object::*;
 use crate::pyport::Py_ssize_t;
-use std::os::raw::c_int;
+use std::ffi::c_int;
 use std::ptr::addr_of_mut;
 
 #[cfg_attr(windows, link(name = "pythonXY"))]
diff --git a/pyo3-ffi/src/typeslots.rs b/pyo3-ffi/src/typeslots.rs
index da7c60b310c..fd0c3b77a74 100644
--- a/pyo3-ffi/src/typeslots.rs
+++ b/pyo3-ffi/src/typeslots.rs
@@ -1,4 +1,4 @@
-use std::os::raw::c_int;
+use std::ffi::c_int;
 
 pub const Py_bf_getbuffer: c_int = 1;
 pub const Py_bf_releasebuffer: c_int = 2;
diff --git a/pyo3-ffi/src/unicodeobject.rs b/pyo3-ffi/src/unicodeobject.rs
index 087160a1efc..8ba645bfa05 100644
--- a/pyo3-ffi/src/unicodeobject.rs
+++ b/pyo3-ffi/src/unicodeobject.rs
@@ -1,11 +1,15 @@
 use crate::object::*;
 use crate::pyport::Py_ssize_t;
 use libc::wchar_t;
-use std::os::raw::{c_char, c_int, c_void};
+use std::ffi::{c_char, c_int, c_void};
 #[cfg(not(PyPy))]
 use std::ptr::addr_of_mut;
 
 #[cfg(not(Py_LIMITED_API))]
+#[cfg_attr(
+    Py_3_13,
+    deprecated(note = "Deprecated since Python 3.13. Use `libc::wchar_t` instead.")
+)]
 pub type Py_UNICODE = wchar_t;
 
 pub type Py_UCS4 = u32;
@@ -328,6 +332,15 @@ extern "C" {
     pub fn PyUnicode_Compare(left: *mut PyObject, right: *mut PyObject) -> c_int;
     #[cfg_attr(PyPy, link_name = "PyPyUnicode_CompareWithASCIIString")]
     pub fn PyUnicode_CompareWithASCIIString(left: *mut PyObject, right: *const c_char) -> c_int;
+    #[cfg(Py_3_13)]
+    pub fn PyUnicode_EqualToUTF8(unicode: *mut PyObject, string: *const c_char) -> c_int;
+    #[cfg(Py_3_13)]
+    pub fn PyUnicode_EqualToUTF8AndSize(
+        unicode: *mut PyObject,
+        string: *const c_char,
+        size: Py_ssize_t,
+    ) -> c_int;
+
     pub fn PyUnicode_RichCompare(
         left: *mut PyObject,
         right: *mut PyObject,
diff --git a/pyo3-ffi/src/warnings.rs b/pyo3-ffi/src/warnings.rs
index d58f37435de..f2cd8adbf9b 100644
--- a/pyo3-ffi/src/warnings.rs
+++ b/pyo3-ffi/src/warnings.rs
@@ -1,6 +1,6 @@
 use crate::object::PyObject;
 use crate::pyport::Py_ssize_t;
-use std::os::raw::{c_char, c_int};
+use std::ffi::{c_char, c_int};
 
 extern "C" {
     #[cfg_attr(PyPy, link_name = "PyPyErr_WarnEx")]
diff --git a/pyo3-ffi/src/weakrefobject.rs b/pyo3-ffi/src/weakrefobject.rs
index d065ae23e0f..3921310cee8 100644
--- a/pyo3-ffi/src/weakrefobject.rs
+++ b/pyo3-ffi/src/weakrefobject.rs
@@ -1,19 +1,21 @@
 use crate::object::*;
-use std::os::raw::c_int;
+use std::ffi::c_int;
 #[cfg(not(PyPy))]
 use std::ptr::addr_of_mut;
 
-#[cfg(all(not(PyPy), Py_LIMITED_API))]
-opaque_struct!(PyWeakReference);
+#[cfg(all(not(PyPy), Py_LIMITED_API, not(GraalPy)))]
+opaque_struct!(pub PyWeakReference);
 
-#[cfg(all(not(PyPy), not(Py_LIMITED_API)))]
+#[cfg(all(not(PyPy), not(Py_LIMITED_API), not(GraalPy)))]
 pub use crate::_PyWeakReference as PyWeakReference;
 
 #[cfg_attr(windows, link(name = "pythonXY"))]
 extern "C" {
+    // TODO: PyO3 is depending on this symbol in `reference.rs`, we should change this and
+    // remove the export as this is a private symbol.
     pub static mut _PyWeakref_RefType: PyTypeObject;
-    pub static mut _PyWeakref_ProxyType: PyTypeObject;
-    pub static mut _PyWeakref_CallableProxyType: PyTypeObject;
+    static mut _PyWeakref_ProxyType: PyTypeObject;
+    static mut _PyWeakref_CallableProxyType: PyTypeObject;
 
     #[cfg(PyPy)]
     #[link_name = "PyPyWeakref_CheckRef"]
@@ -58,5 +60,12 @@ extern "C" {
     #[cfg_attr(PyPy, link_name = "PyPyWeakref_NewProxy")]
     pub fn PyWeakref_NewProxy(ob: *mut PyObject, callback: *mut PyObject) -> *mut PyObject;
     #[cfg_attr(PyPy, link_name = "PyPyWeakref_GetObject")]
-    pub fn PyWeakref_GetObject(_ref: *mut PyObject) -> *mut PyObject;
+    #[cfg_attr(
+        Py_3_13,
+        deprecated(note = "deprecated since Python 3.13. Use `PyWeakref_GetRef` instead.")
+    )]
+    pub fn PyWeakref_GetObject(reference: *mut PyObject) -> *mut PyObject;
+    #[cfg(Py_3_13)]
+    #[cfg_attr(PyPy, link_name = "PyPyWeakref_GetRef")]
+    pub fn PyWeakref_GetRef(reference: *mut PyObject, pobj: *mut *mut PyObject) -> c_int;
 }
diff --git a/pyo3-introspection/Cargo.toml b/pyo3-introspection/Cargo.toml
new file mode 100644
index 00000000000..ae78c7d5030
--- /dev/null
+++ b/pyo3-introspection/Cargo.toml
@@ -0,0 +1,21 @@
+[package]
+name = "pyo3-introspection"
+version = "0.27.0"
+description = "Introspect dynamic libraries built with PyO3 to get metadata about the exported Python types"
+authors = ["PyO3 Project and Contributors <https://github.com/PyO3>"]
+homepage = "https://github.com/pyo3/pyo3"
+repository = "https://github.com/pyo3/pyo3"
+license = "MIT OR Apache-2.0"
+edition = "2021"
+
+[dependencies]
+anyhow = "1"
+goblin = ">=0.9, <0.11"
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+
+[dev-dependencies]
+tempfile = "3.12.0"
+
+[lints]
+workspace = true
diff --git a/pyo3-introspection/LICENSE-APACHE b/pyo3-introspection/LICENSE-APACHE
new file mode 120000
index 00000000000..965b606f331
--- /dev/null
+++ b/pyo3-introspection/LICENSE-APACHE
@@ -0,0 +1 @@
+../LICENSE-APACHE
\ No newline at end of file
diff --git a/pyo3-introspection/LICENSE-MIT b/pyo3-introspection/LICENSE-MIT
new file mode 120000
index 00000000000..76219eb72e8
--- /dev/null
+++ b/pyo3-introspection/LICENSE-MIT
@@ -0,0 +1 @@
+../LICENSE-MIT
\ No newline at end of file
diff --git a/pyo3-introspection/src/introspection.rs b/pyo3-introspection/src/introspection.rs
new file mode 100644
index 00000000000..ea57fdaf814
--- /dev/null
+++ b/pyo3-introspection/src/introspection.rs
@@ -0,0 +1,522 @@
+use crate::model::{
+    Argument, Arguments, Attribute, Class, Function, Module, TypeHint, TypeHintExpr,
+    VariableLengthArgument,
+};
+use anyhow::{anyhow, bail, ensure, Context, Result};
+use goblin::elf::section_header::SHN_XINDEX;
+use goblin::elf::Elf;
+use goblin::mach::load_command::CommandVariant;
+use goblin::mach::symbols::{NO_SECT, N_SECT};
+use goblin::mach::{Mach, MachO, SingleArch};
+use goblin::pe::PE;
+use goblin::Object;
+use serde::de::value::MapAccessDeserializer;
+use serde::de::{Error, MapAccess, Visitor};
+use serde::{Deserialize, Deserializer};
+use std::cmp::Ordering;
+use std::collections::HashMap;
+use std::path::Path;
+use std::{fmt, fs, str};
+
+/// Introspect a cdylib built with PyO3 and returns the definition of a Python module.
+///
+/// This function currently supports the ELF (most *nix including Linux), Match-O (macOS) and PE (Windows) formats.
+pub fn introspect_cdylib(library_path: impl AsRef<Path>, main_module_name: &str) -> Result<Module> {
+    let chunks = find_introspection_chunks_in_binary_object(library_path.as_ref())?;
+    parse_chunks(&chunks, main_module_name)
+}
+
+/// Parses the introspection chunks found in the binary
+fn parse_chunks(chunks: &[Chunk], main_module_name: &str) -> Result<Module> {
+    let mut chunks_by_id = HashMap::<&str, &Chunk>::new();
+    let mut chunks_by_parent = HashMap::<&str, Vec<&Chunk>>::new();
+    for chunk in chunks {
+        let (id, parent) = match chunk {
+            Chunk::Module { id, .. } | Chunk::Class { id, .. } => (Some(id.as_str()), None),
+            Chunk::Function { id, parent, .. } | Chunk::Attribute { id, parent, .. } => {
+                (id.as_deref(), parent.as_deref())
+            }
+        };
+        if let Some(id) = id {
+            chunks_by_id.insert(id, chunk);
+        }
+        if let Some(parent) = parent {
+            chunks_by_parent.entry(parent).or_default().push(chunk);
+        }
+    }
+    // We look for the root chunk
+    for chunk in chunks {
+        if let Chunk::Module {
+            id,
+            name,
+            members,
+            incomplete,
+        } = chunk
+        {
+            if name == main_module_name {
+                return convert_module(
+                    id,
+                    name,
+                    members,
+                    *incomplete,
+                    &chunks_by_id,
+                    &chunks_by_parent,
+                );
+            }
+        }
+    }
+    bail!("No module named {main_module_name} found")
+}
+
+fn convert_module(
+    id: &str,
+    name: &str,
+    members: &[String],
+    incomplete: bool,
+    chunks_by_id: &HashMap<&str, &Chunk>,
+    chunks_by_parent: &HashMap<&str, Vec<&Chunk>>,
+) -> Result<Module> {
+    let (modules, classes, functions, attributes) = convert_members(
+        members
+            .iter()
+            .filter_map(|id| chunks_by_id.get(id.as_str()).copied())
+            .chain(chunks_by_parent.get(&id).into_iter().flatten().copied()),
+        chunks_by_id,
+        chunks_by_parent,
+    )?;
+
+    Ok(Module {
+        name: name.into(),
+        modules,
+        classes,
+        functions,
+        attributes,
+        incomplete,
+    })
+}
+
+type Members = (Vec<Module>, Vec<Class>, Vec<Function>, Vec<Attribute>);
+
+/// Convert a list of members of a module or a class
+fn convert_members<'a>(
+    chunks: impl IntoIterator<Item = &'a Chunk>,
+    chunks_by_id: &HashMap<&str, &Chunk>,
+    chunks_by_parent: &HashMap<&str, Vec<&Chunk>>,
+) -> Result<Members> {
+    let mut modules = Vec::new();
+    let mut classes = Vec::new();
+    let mut functions = Vec::new();
+    let mut attributes = Vec::new();
+    for chunk in chunks {
+        match chunk {
+            Chunk::Module {
+                name,
+                id,
+                members,
+                incomplete,
+            } => {
+                modules.push(convert_module(
+                    id,
+                    name,
+                    members,
+                    *incomplete,
+                    chunks_by_id,
+                    chunks_by_parent,
+                )?);
+            }
+            Chunk::Class { name, id } => {
+                classes.push(convert_class(id, name, chunks_by_id, chunks_by_parent)?)
+            }
+            Chunk::Function {
+                name,
+                id: _,
+                arguments,
+                parent: _,
+                decorators,
+                returns,
+            } => functions.push(convert_function(name, arguments, decorators, returns)),
+            Chunk::Attribute {
+                name,
+                id: _,
+                parent: _,
+                value,
+                annotation,
+            } => attributes.push(convert_attribute(name, value, annotation)),
+        }
+    }
+    // We sort elements to get a stable output
+    modules.sort_by(|l, r| l.name.cmp(&r.name));
+    classes.sort_by(|l, r| l.name.cmp(&r.name));
+    functions.sort_by(|l, r| match l.name.cmp(&r.name) {
+        Ordering::Equal => {
+            // We put the getter before the setter
+            if l.decorators.iter().any(|d| d == "property") {
+                Ordering::Less
+            } else if r.decorators.iter().any(|d| d == "property") {
+                Ordering::Greater
+            } else {
+                // We pick an ordering based on decorators
+                l.decorators.cmp(&r.decorators)
+            }
+        }
+        o => o,
+    });
+    attributes.sort_by(|l, r| l.name.cmp(&r.name));
+    Ok((modules, classes, functions, attributes))
+}
+
+fn convert_class(
+    id: &str,
+    name: &str,
+    chunks_by_id: &HashMap<&str, &Chunk>,
+    chunks_by_parent: &HashMap<&str, Vec<&Chunk>>,
+) -> Result<Class> {
+    let (nested_modules, nested_classes, methods, attributes) = convert_members(
+        chunks_by_parent.get(&id).into_iter().flatten().copied(),
+        chunks_by_id,
+        chunks_by_parent,
+    )?;
+    ensure!(
+        nested_modules.is_empty(),
+        "Classes cannot contain nested modules"
+    );
+    ensure!(
+        nested_classes.is_empty(),
+        "Nested classes are not supported yet"
+    );
+    Ok(Class {
+        name: name.into(),
+        methods,
+        attributes,
+    })
+}
+
+fn convert_function(
+    name: &str,
+    arguments: &ChunkArguments,
+    decorators: &[String],
+    returns: &Option<ChunkTypeHint>,
+) -> Function {
+    Function {
+        name: name.into(),
+        decorators: decorators.to_vec(),
+        arguments: Arguments {
+            positional_only_arguments: arguments.posonlyargs.iter().map(convert_argument).collect(),
+            arguments: arguments.args.iter().map(convert_argument).collect(),
+            vararg: arguments
+                .vararg
+                .as_ref()
+                .map(convert_variable_length_argument),
+            keyword_only_arguments: arguments.kwonlyargs.iter().map(convert_argument).collect(),
+            kwarg: arguments
+                .kwarg
+                .as_ref()
+                .map(convert_variable_length_argument),
+        },
+        returns: returns.as_ref().map(convert_type_hint),
+    }
+}
+
+fn convert_argument(arg: &ChunkArgument) -> Argument {
+    Argument {
+        name: arg.name.clone(),
+        default_value: arg.default.clone(),
+        annotation: arg.annotation.as_ref().map(convert_type_hint),
+    }
+}
+
+fn convert_variable_length_argument(arg: &ChunkArgument) -> VariableLengthArgument {
+    VariableLengthArgument {
+        name: arg.name.clone(),
+        annotation: arg.annotation.as_ref().map(convert_type_hint),
+    }
+}
+
+fn convert_attribute(
+    name: &str,
+    value: &Option<String>,
+    annotation: &Option<ChunkTypeHint>,
+) -> Attribute {
+    Attribute {
+        name: name.into(),
+        value: value.clone(),
+        annotation: annotation.as_ref().map(convert_type_hint),
+    }
+}
+
+fn convert_type_hint(arg: &ChunkTypeHint) -> TypeHint {
+    match arg {
+        ChunkTypeHint::Ast(expr) => TypeHint::Ast(convert_type_hint_expr(expr)),
+        ChunkTypeHint::Plain(t) => TypeHint::Plain(t.clone()),
+    }
+}
+
+fn convert_type_hint_expr(expr: &ChunkTypeHintExpr) -> TypeHintExpr {
+    match expr {
+        ChunkTypeHintExpr::Builtin { id } => TypeHintExpr::Builtin { id: id.clone() },
+        ChunkTypeHintExpr::Attribute { module, attr } => TypeHintExpr::Attribute {
+            module: module.clone(),
+            attr: attr.clone(),
+        },
+        ChunkTypeHintExpr::Union { elts } => TypeHintExpr::Union {
+            elts: elts.iter().map(convert_type_hint_expr).collect(),
+        },
+        ChunkTypeHintExpr::Subscript { value, slice } => TypeHintExpr::Subscript {
+            value: Box::new(convert_type_hint_expr(value)),
+            slice: slice.iter().map(convert_type_hint_expr).collect(),
+        },
+    }
+}
+
+fn find_introspection_chunks_in_binary_object(path: &Path) -> Result<Vec<Chunk>> {
+    let library_content =
+        fs::read(path).with_context(|| format!("Failed to read {}", path.display()))?;
+    match Object::parse(&library_content)
+        .context("The built library is not valid or not supported by our binary parser")?
+    {
+        Object::Elf(elf) => find_introspection_chunks_in_elf(&elf, &library_content),
+        Object::Mach(Mach::Binary(macho)) => {
+            find_introspection_chunks_in_macho(&macho, &library_content)
+        }
+        Object::Mach(Mach::Fat(multi_arch)) => {
+            for arch in &multi_arch {
+                match arch? {
+                    SingleArch::MachO(macho) => {
+                        return find_introspection_chunks_in_macho(&macho, &library_content)
+                    }
+                    SingleArch::Archive(_) => (),
+                }
+            }
+            bail!("No Mach-o chunk found in the multi-arch Mach-o container")
+        }
+        Object::PE(pe) => find_introspection_chunks_in_pe(&pe, &library_content),
+        _ => {
+            bail!("Only ELF, Mach-o and PE containers can be introspected")
+        }
+    }
+}
+
+fn find_introspection_chunks_in_elf(elf: &Elf<'_>, library_content: &[u8]) -> Result<Vec<Chunk>> {
+    let mut chunks = Vec::new();
+    for sym in &elf.syms {
+        if is_introspection_symbol(elf.strtab.get_at(sym.st_name).unwrap_or_default()) {
+            ensure!(u32::try_from(sym.st_shndx)? != SHN_XINDEX, "Section names length is greater than SHN_LORESERVE in ELF, this is not supported by PyO3 yet");
+            let section_header = &elf.section_headers[sym.st_shndx];
+            let data_offset = sym.st_value + section_header.sh_offset - section_header.sh_addr;
+            chunks.push(deserialize_chunk(
+                &library_content[usize::try_from(data_offset).context("File offset overflow")?..],
+                elf.little_endian,
+            )?);
+        }
+    }
+    Ok(chunks)
+}
+
+fn find_introspection_chunks_in_macho(
+    macho: &MachO<'_>,
+    library_content: &[u8],
+) -> Result<Vec<Chunk>> {
+    if !macho.little_endian {
+        bail!("Only little endian Mach-o binaries are supported");
+    }
+    ensure!(
+        !macho.load_commands.iter().any(|command| {
+            matches!(command.command, CommandVariant::DyldChainedFixups(_))
+        }),
+        "Mach-O binaries with fixup chains are not supported yet, to avoid using fixup chains, use `--codegen=link-arg=-no_fixup_chains` option."
+    );
+
+    let sections = macho
+        .segments
+        .sections()
+        .flatten()
+        .map(|t| t.map(|s| s.0))
+        .collect::<Result<Vec<_>, _>>()?;
+    let mut chunks = Vec::new();
+    for symbol in macho.symbols() {
+        let (name, nlist) = symbol?;
+        if nlist.is_global()
+            && nlist.get_type() == N_SECT
+            && nlist.n_sect != NO_SECT as usize
+            && is_introspection_symbol(name)
+        {
+            let section = &sections[nlist.n_sect - 1]; // Sections are counted from 1
+            let data_offset = nlist.n_value + u64::from(section.offset) - section.addr;
+            chunks.push(deserialize_chunk(
+                &library_content[usize::try_from(data_offset).context("File offset overflow")?..],
+                macho.little_endian,
+            )?);
+        }
+    }
+    Ok(chunks)
+}
+
+fn find_introspection_chunks_in_pe(pe: &PE<'_>, library_content: &[u8]) -> Result<Vec<Chunk>> {
+    let mut chunks = Vec::new();
+    for export in &pe.exports {
+        if is_introspection_symbol(export.name.unwrap_or_default()) {
+            chunks.push(deserialize_chunk(
+                &library_content[export.offset.context("No symbol offset")?..],
+                true,
+            )?);
+        }
+    }
+    Ok(chunks)
+}
+
+fn deserialize_chunk(
+    content_with_chunk_at_the_beginning: &[u8],
+    is_little_endian: bool,
+) -> Result<Chunk> {
+    let length = content_with_chunk_at_the_beginning
+        .split_at(4)
+        .0
+        .try_into()
+        .context("The introspection chunk must contain a length")?;
+    let length = if is_little_endian {
+        u32::from_le_bytes(length)
+    } else {
+        u32::from_be_bytes(length)
+    };
+    let chunk = content_with_chunk_at_the_beginning
+        .get(4..4 + length as usize)
+        .ok_or_else(|| {
+            anyhow!("The introspection chunk length {length} is greater that the binary size")
+        })?;
+    serde_json::from_slice(chunk).with_context(|| {
+        format!(
+            "Failed to parse introspection chunk: '{}'",
+            String::from_utf8_lossy(chunk)
+        )
+    })
+}
+
+fn is_introspection_symbol(name: &str) -> bool {
+    name.strip_prefix('_')
+        .unwrap_or(name)
+        .starts_with("PYO3_INTROSPECTION_1_")
+}
+
+#[derive(Deserialize)]
+#[serde(tag = "type", rename_all = "lowercase")]
+enum Chunk {
+    Module {
+        id: String,
+        name: String,
+        members: Vec<String>,
+        incomplete: bool,
+    },
+    Class {
+        id: String,
+        name: String,
+    },
+    Function {
+        #[serde(default)]
+        id: Option<String>,
+        name: String,
+        arguments: Box<ChunkArguments>,
+        #[serde(default)]
+        parent: Option<String>,
+        #[serde(default)]
+        decorators: Vec<String>,
+        #[serde(default, deserialize_with = "deserialize_type_hint")]
+        returns: Option<ChunkTypeHint>,
+    },
+    Attribute {
+        #[serde(default)]
+        id: Option<String>,
+        #[serde(default)]
+        parent: Option<String>,
+        name: String,
+        #[serde(default)]
+        value: Option<String>,
+        #[serde(default, deserialize_with = "deserialize_type_hint")]
+        annotation: Option<ChunkTypeHint>,
+    },
+}
+
+#[derive(Deserialize)]
+struct ChunkArguments {
+    #[serde(default)]
+    posonlyargs: Vec<ChunkArgument>,
+    #[serde(default)]
+    args: Vec<ChunkArgument>,
+    #[serde(default)]
+    vararg: Option<ChunkArgument>,
+    #[serde(default)]
+    kwonlyargs: Vec<ChunkArgument>,
+    #[serde(default)]
+    kwarg: Option<ChunkArgument>,
+}
+
+#[derive(Deserialize)]
+struct ChunkArgument {
+    name: String,
+    #[serde(default)]
+    default: Option<String>,
+    #[serde(default, deserialize_with = "deserialize_type_hint")]
+    annotation: Option<ChunkTypeHint>,
+}
+
+/// Variant of [`TypeHint`] that implements deserialization.
+///
+/// We keep separated type to allow them to evolve independently (this type will need to handle backward compatibility).
+enum ChunkTypeHint {
+    Ast(ChunkTypeHintExpr),
+    Plain(String),
+}
+
+#[derive(Deserialize)]
+#[serde(tag = "type", rename_all = "lowercase")]
+enum ChunkTypeHintExpr {
+    Builtin {
+        id: String,
+    },
+    Attribute {
+        module: String,
+        attr: String,
+    },
+    Union {
+        elts: Vec<ChunkTypeHintExpr>,
+    },
+    Subscript {
+        value: Box<ChunkTypeHintExpr>,
+        slice: Vec<ChunkTypeHintExpr>,
+    },
+}
+
+fn deserialize_type_hint<'de, D: Deserializer<'de>>(
+    deserializer: D,
+) -> Result<Option<ChunkTypeHint>, D::Error> {
+    struct AnnotationVisitor;
+
+    impl<'de> Visitor<'de> for AnnotationVisitor {
+        type Value = ChunkTypeHint;
+
+        fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+            formatter.write_str("annotation")
+        }
+
+        fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+        where
+            E: Error,
+        {
+            self.visit_string(v.into())
+        }
+
+        fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
+        where
+            E: Error,
+        {
+            Ok(ChunkTypeHint::Plain(v))
+        }
+
+        fn visit_map<M: MapAccess<'de>>(self, map: M) -> Result<ChunkTypeHint, M::Error> {
+            Ok(ChunkTypeHint::Ast(Deserialize::deserialize(
+                MapAccessDeserializer::new(map),
+            )?))
+        }
+    }
+
+    Ok(Some(deserializer.deserialize_any(AnnotationVisitor)?))
+}
diff --git a/pyo3-introspection/src/lib.rs b/pyo3-introspection/src/lib.rs
new file mode 100644
index 00000000000..22aac933e85
--- /dev/null
+++ b/pyo3-introspection/src/lib.rs
@@ -0,0 +1,8 @@
+//! Utilities to introspect cdylib built using PyO3 and generate [type stubs](https://typing.readthedocs.io/en/latest/source/stubs.html).
+
+pub use crate::introspection::introspect_cdylib;
+pub use crate::stubs::module_stub_files;
+
+mod introspection;
+pub mod model;
+mod stubs;
diff --git a/pyo3-introspection/src/model.rs b/pyo3-introspection/src/model.rs
new file mode 100644
index 00000000000..5d13d15c51b
--- /dev/null
+++ b/pyo3-introspection/src/model.rs
@@ -0,0 +1,91 @@
+#[derive(Debug, Eq, PartialEq, Clone, Hash)]
+pub struct Module {
+    pub name: String,
+    pub modules: Vec<Module>,
+    pub classes: Vec<Class>,
+    pub functions: Vec<Function>,
+    pub attributes: Vec<Attribute>,
+    pub incomplete: bool,
+}
+
+#[derive(Debug, Eq, PartialEq, Clone, Hash)]
+pub struct Class {
+    pub name: String,
+    pub methods: Vec<Function>,
+    pub attributes: Vec<Attribute>,
+}
+
+#[derive(Debug, Eq, PartialEq, Clone, Hash)]
+pub struct Function {
+    pub name: String,
+    /// decorator like 'property' or 'staticmethod'
+    pub decorators: Vec<String>,
+    pub arguments: Arguments,
+    /// return type
+    pub returns: Option<TypeHint>,
+}
+
+#[derive(Debug, Eq, PartialEq, Clone, Hash)]
+pub struct Attribute {
+    pub name: String,
+    /// Value as a Python expression if easily expressible
+    pub value: Option<String>,
+    /// Type annotation as a Python expression
+    pub annotation: Option<TypeHint>,
+}
+
+#[derive(Debug, Eq, PartialEq, Clone, Hash)]
+pub struct Arguments {
+    /// Arguments before /
+    pub positional_only_arguments: Vec<Argument>,
+    /// Regular arguments (between / and *)
+    pub arguments: Vec<Argument>,
+    /// *vararg
+    pub vararg: Option<VariableLengthArgument>,
+    /// Arguments after *
+    pub keyword_only_arguments: Vec<Argument>,
+    /// **kwarg
+    pub kwarg: Option<VariableLengthArgument>,
+}
+
+#[derive(Debug, Eq, PartialEq, Clone, Hash)]
+pub struct Argument {
+    pub name: String,
+    /// Default value as a Python expression
+    pub default_value: Option<String>,
+    /// Type annotation as a Python expression
+    pub annotation: Option<TypeHint>,
+}
+
+/// A variable length argument ie. *vararg or **kwarg
+#[derive(Debug, Eq, PartialEq, Clone, Hash)]
+pub struct VariableLengthArgument {
+    pub name: String,
+    /// Type annotation as a Python expression
+    pub annotation: Option<TypeHint>,
+}
+
+/// A type hint annotation
+///
+/// Might be a plain string or an AST fragment
+#[derive(Debug, Eq, PartialEq, Clone, Hash)]
+pub enum TypeHint {
+    Ast(TypeHintExpr),
+    Plain(String),
+}
+
+/// A type hint annotation as an AST fragment
+#[derive(Debug, Eq, PartialEq, Clone, Hash)]
+pub enum TypeHintExpr {
+    /// A Python builtin like `int`
+    Builtin { id: String },
+    /// The attribute of a python object like `{value}.{attr}`
+    Attribute { module: String, attr: String },
+    /// A union `{left} | {right}`
+    Union { elts: Vec<TypeHintExpr> },
+    /// A subscript `{value}[*slice]`
+    Subscript {
+        value: Box<TypeHintExpr>,
+        slice: Vec<TypeHintExpr>,
+    },
+}
diff --git a/pyo3-introspection/src/stubs.rs b/pyo3-introspection/src/stubs.rs
new file mode 100644
index 00000000000..d66d899ce00
--- /dev/null
+++ b/pyo3-introspection/src/stubs.rs
@@ -0,0 +1,638 @@
+use crate::model::{
+    Argument, Arguments, Attribute, Class, Function, Module, TypeHint, TypeHintExpr,
+    VariableLengthArgument,
+};
+use std::collections::{BTreeMap, BTreeSet, HashMap};
+use std::path::PathBuf;
+use std::str::FromStr;
+
+/// Generates the [type stubs](https://typing.readthedocs.io/en/latest/source/stubs.html) of a given module.
+/// It returns a map between the file name and the file content.
+/// The root module stubs will be in the `__init__.pyi` file and the submodules directory
+/// in files with a relevant name.
+pub fn module_stub_files(module: &Module) -> HashMap<PathBuf, String> {
+    let mut output_files = HashMap::new();
+    add_module_stub_files(module, &[], &mut output_files);
+    output_files
+}
+
+fn add_module_stub_files(
+    module: &Module,
+    module_path: &[&str],
+    output_files: &mut HashMap<PathBuf, String>,
+) {
+    let mut file_path = PathBuf::new();
+    for e in module_path {
+        file_path = file_path.join(e);
+    }
+    output_files.insert(
+        file_path.join("__init__.pyi"),
+        module_stubs(module, module_path),
+    );
+    let mut module_path = module_path.to_vec();
+    module_path.push(&module.name);
+    for submodule in &module.modules {
+        if submodule.modules.is_empty() {
+            output_files.insert(
+                file_path.join(format!("{}.pyi", submodule.name)),
+                module_stubs(submodule, &module_path),
+            );
+        } else {
+            add_module_stub_files(submodule, &module_path, output_files);
+        }
+    }
+}
+
+/// Generates the module stubs to a String, not including submodules
+fn module_stubs(module: &Module, parents: &[&str]) -> String {
+    let imports = Imports::create(module, parents);
+    let mut elements = Vec::new();
+    for attribute in &module.attributes {
+        elements.push(attribute_stubs(attribute, &imports));
+    }
+    for class in &module.classes {
+        elements.push(class_stubs(class, &imports));
+    }
+    for function in &module.functions {
+        elements.push(function_stubs(function, &imports));
+    }
+
+    // We generate a __getattr__ method to tag incomplete stubs
+    // See https://typing.python.org/en/latest/guides/writing_stubs.html#incomplete-stubs
+    if module.incomplete && !module.functions.iter().any(|f| f.name == "__getattr__") {
+        elements.push(function_stubs(
+            &Function {
+                name: "__getattr__".into(),
+                decorators: Vec::new(),
+                arguments: Arguments {
+                    positional_only_arguments: Vec::new(),
+                    arguments: vec![Argument {
+                        name: "name".to_string(),
+                        default_value: None,
+                        annotation: Some(TypeHint::Ast(TypeHintExpr::Builtin { id: "str".into() })),
+                    }],
+                    vararg: None,
+                    keyword_only_arguments: Vec::new(),
+                    kwarg: None,
+                },
+                returns: Some(TypeHint::Ast(TypeHintExpr::Attribute {
+                    module: "_typeshed".into(),
+                    attr: "Incomplete".into(),
+                })),
+            },
+            &imports,
+        ));
+    }
+
+    let mut final_elements = imports.imports;
+    final_elements.extend(elements);
+
+    let mut output = String::new();
+
+    // We insert two line jumps (i.e. empty strings) only above and below multiple line elements (classes with methods, functions with decorators)
+    for element in final_elements {
+        let is_multiline = element.contains('\n');
+        if is_multiline && !output.is_empty() && !output.ends_with("\n\n") {
+            output.push('\n');
+        }
+        output.push_str(&element);
+        output.push('\n');
+        if is_multiline {
+            output.push('\n');
+        }
+    }
+
+    // We remove a line jump at the end if they are two
+    if output.ends_with("\n\n") {
+        output.pop();
+    }
+    output
+}
+
+fn class_stubs(class: &Class, imports: &Imports) -> String {
+    let mut buffer = format!("class {}:", class.name);
+    if class.methods.is_empty() && class.attributes.is_empty() {
+        buffer.push_str(" ...");
+        return buffer;
+    }
+    for attribute in &class.attributes {
+        // We do the indentation
+        buffer.push_str("\n    ");
+        buffer.push_str(&attribute_stubs(attribute, imports).replace('\n', "\n    "));
+    }
+    for method in &class.methods {
+        // We do the indentation
+        buffer.push_str("\n    ");
+        buffer.push_str(&function_stubs(method, imports).replace('\n', "\n    "));
+    }
+    buffer
+}
+
+fn function_stubs(function: &Function, imports: &Imports) -> String {
+    // Signature
+    let mut parameters = Vec::new();
+    for argument in &function.arguments.positional_only_arguments {
+        parameters.push(argument_stub(argument, imports));
+    }
+    if !function.arguments.positional_only_arguments.is_empty() {
+        parameters.push("/".into());
+    }
+    for argument in &function.arguments.arguments {
+        parameters.push(argument_stub(argument, imports));
+    }
+    if let Some(argument) = &function.arguments.vararg {
+        parameters.push(format!(
+            "*{}",
+            variable_length_argument_stub(argument, imports)
+        ));
+    } else if !function.arguments.keyword_only_arguments.is_empty() {
+        parameters.push("*".into());
+    }
+    for argument in &function.arguments.keyword_only_arguments {
+        parameters.push(argument_stub(argument, imports));
+    }
+    if let Some(argument) = &function.arguments.kwarg {
+        parameters.push(format!(
+            "**{}",
+            variable_length_argument_stub(argument, imports)
+        ));
+    }
+    let mut buffer = String::new();
+    for decorator in &function.decorators {
+        buffer.push('@');
+        buffer.push_str(decorator);
+        buffer.push('\n');
+    }
+    buffer.push_str("def ");
+    buffer.push_str(&function.name);
+    buffer.push('(');
+    buffer.push_str(&parameters.join(", "));
+    buffer.push(')');
+    if let Some(returns) = &function.returns {
+        buffer.push_str(" -> ");
+        type_hint_stub(returns, imports, &mut buffer);
+    }
+    buffer.push_str(": ...");
+    buffer
+}
+
+fn attribute_stubs(attribute: &Attribute, imports: &Imports) -> String {
+    let mut buffer = attribute.name.clone();
+    if let Some(annotation) = &attribute.annotation {
+        buffer.push_str(": ");
+        type_hint_stub(annotation, imports, &mut buffer);
+    }
+    if let Some(value) = &attribute.value {
+        buffer.push_str(" = ");
+        buffer.push_str(value);
+    }
+    buffer
+}
+
+fn argument_stub(argument: &Argument, imports: &Imports) -> String {
+    let mut buffer = argument.name.clone();
+    if let Some(annotation) = &argument.annotation {
+        buffer.push_str(": ");
+        type_hint_stub(annotation, imports, &mut buffer);
+    }
+    if let Some(default_value) = &argument.default_value {
+        buffer.push_str(if argument.annotation.is_some() {
+            " = "
+        } else {
+            "="
+        });
+        buffer.push_str(default_value);
+    }
+    buffer
+}
+
+fn variable_length_argument_stub(argument: &VariableLengthArgument, imports: &Imports) -> String {
+    let mut buffer = argument.name.clone();
+    if let Some(annotation) = &argument.annotation {
+        buffer.push_str(": ");
+        type_hint_stub(annotation, imports, &mut buffer);
+    }
+    buffer
+}
+
+fn type_hint_stub(type_hint: &TypeHint, imports: &Imports, buffer: &mut String) {
+    match type_hint {
+        TypeHint::Ast(t) => imports.serialize_type_hint(t, buffer),
+        TypeHint::Plain(t) => buffer.push_str(t),
+    }
+}
+
+/// Datastructure to deduplicate, validate and generate imports
+#[derive(Default)]
+struct Imports {
+    /// Import lines ready to use
+    imports: Vec<String>,
+    /// Renaming map: from module name and member name return the name to use in type hints
+    renaming: BTreeMap<(String, String), String>,
+}
+
+impl Imports {
+    /// This generates a map from the builtin or module name to the actual alias used in the file
+    ///
+    /// For Python builtins and elements declared by the module the alias is always the actual name.
+    ///
+    /// For other elements, we can alias them using the `from X import Y as Z` syntax.
+    /// So, we first list all builtins and local elements, then iterate on imports
+    /// and create the aliases when needed.
+    fn create(module: &Module, module_parents: &[&str]) -> Self {
+        let mut elements_used_in_annotations = ElementsUsedInAnnotations::new();
+        elements_used_in_annotations.walk_module(module);
+
+        let mut imports = Vec::new();
+        let mut renaming = BTreeMap::new();
+        let mut local_name_to_module_and_attribute = BTreeMap::new();
+
+        // We first process local and built-ins elements, they are never aliased or imported
+        for name in module
+            .classes
+            .iter()
+            .map(|c| c.name.clone())
+            .chain(module.functions.iter().map(|f| f.name.clone()))
+            .chain(module.attributes.iter().map(|a| a.name.clone()))
+            .chain(elements_used_in_annotations.builtins)
+        {
+            local_name_to_module_and_attribute.insert(name.clone(), (None, name.clone()));
+        }
+
+        // We compute the set of ways the current module can be named
+        let mut possible_current_module_names = vec![module.name.clone()];
+        let mut current_module_name = Some(module.name.clone());
+        for parent in module_parents.iter().rev() {
+            let path = if let Some(current) = current_module_name {
+                format!("{parent}.{current}")
+            } else {
+                parent.to_string()
+            };
+            possible_current_module_names.push(path.clone());
+            current_module_name = Some(path);
+        }
+
+        // We process then imports, normalizing local imports
+        for (module, attrs) in elements_used_in_annotations.module_members {
+            let normalized_module = if possible_current_module_names.contains(&module) {
+                None
+            } else {
+                Some(module.clone())
+            };
+            let mut import_for_module = Vec::new();
+            for attr in attrs {
+                // We split nested classes A.B in "A" (the part that must be imported and can have naming conflicts) and ".B"
+                let (root_attr, attr_path) = attr
+                    .split_once('.')
+                    .map_or((attr.as_str(), None), |(root, path)| (root, Some(path)));
+                let mut local_name = root_attr.to_owned();
+                let mut already_imported = false;
+                while let Some((possible_conflict_module, possible_conflict_attr)) =
+                    local_name_to_module_and_attribute.get(&local_name)
+                {
+                    if *possible_conflict_module == normalized_module
+                        && *possible_conflict_attr == root_attr
+                    {
+                        // It's the same
+                        already_imported = true;
+                        break;
+                    }
+                    // We generate a new local name
+                    // TODO: we use currently a format like Foo2. It might be nicer to use something like ModFoo
+                    let number_of_digits_at_the_end = local_name
+                        .bytes()
+                        .rev()
+                        .take_while(|b| b.is_ascii_digit())
+                        .count();
+                    let (local_name_prefix, local_name_number) =
+                        local_name.split_at(local_name.len() - number_of_digits_at_the_end);
+                    local_name = format!(
+                        "{local_name_prefix}{}",
+                        u64::from_str(local_name_number).unwrap_or(1) + 1
+                    );
+                }
+                renaming.insert(
+                    (module.clone(), attr.clone()),
+                    if let Some(attr_path) = attr_path {
+                        format!("{local_name}.{attr_path}")
+                    } else {
+                        local_name.clone()
+                    },
+                );
+                if !already_imported {
+                    local_name_to_module_and_attribute.insert(
+                        local_name.clone(),
+                        (normalized_module.clone(), root_attr.to_owned()),
+                    );
+                    import_for_module.push(if local_name == root_attr {
+                        local_name
+                    } else {
+                        format!("{root_attr} as {local_name}")
+                    });
+                }
+            }
+            if let Some(module) = normalized_module {
+                imports.push(format!(
+                    "from {module} import {}",
+                    import_for_module.join(", ")
+                ));
+            }
+        }
+
+        Self { imports, renaming }
+    }
+
+    fn serialize_type_hint(&self, expr: &TypeHintExpr, buffer: &mut String) {
+        match expr {
+            TypeHintExpr::Builtin { id } => buffer.push_str(id),
+            TypeHintExpr::Attribute { module, attr } => {
+                let alias = self
+                    .renaming
+                    .get(&(module.clone(), attr.clone()))
+                    .expect("All type hint attributes should have been visited");
+                buffer.push_str(alias)
+            }
+            TypeHintExpr::Union { elts } => {
+                for (i, elt) in elts.iter().enumerate() {
+                    if i > 0 {
+                        buffer.push_str(" | ");
+                    }
+                    self.serialize_type_hint(elt, buffer);
+                }
+            }
+            TypeHintExpr::Subscript { value, slice } => {
+                self.serialize_type_hint(value, buffer);
+                buffer.push('[');
+                for (i, elt) in slice.iter().enumerate() {
+                    if i > 0 {
+                        buffer.push_str(", ");
+                    }
+                    self.serialize_type_hint(elt, buffer);
+                }
+                buffer.push(']');
+            }
+        }
+    }
+}
+
+/// Lists all the elements used in annotations
+struct ElementsUsedInAnnotations {
+    /// module -> name
+    module_members: BTreeMap<String, BTreeSet<String>>,
+    builtins: BTreeSet<String>,
+}
+
+impl ElementsUsedInAnnotations {
+    fn new() -> Self {
+        Self {
+            module_members: BTreeMap::new(),
+            builtins: BTreeSet::new(),
+        }
+    }
+
+    fn walk_module(&mut self, module: &Module) {
+        for attr in &module.attributes {
+            self.walk_attribute(attr);
+        }
+        for class in &module.classes {
+            self.walk_class(class);
+        }
+        for function in &module.functions {
+            self.walk_function(function);
+        }
+        if module.incomplete {
+            self.builtins.insert("str".into());
+            self.module_members
+                .entry("_typeshed".into())
+                .or_default()
+                .insert("Incomplete".into());
+        }
+    }
+
+    fn walk_class(&mut self, class: &Class) {
+        for method in &class.methods {
+            self.walk_function(method);
+        }
+        for attr in &class.attributes {
+            self.walk_attribute(attr);
+        }
+    }
+
+    fn walk_attribute(&mut self, attribute: &Attribute) {
+        if let Some(type_hint) = &attribute.annotation {
+            self.walk_type_hint(type_hint);
+        }
+    }
+
+    fn walk_function(&mut self, function: &Function) {
+        for decorator in &function.decorators {
+            self.builtins.insert(decorator.clone());
+        }
+        for arg in function
+            .arguments
+            .positional_only_arguments
+            .iter()
+            .chain(&function.arguments.arguments)
+            .chain(&function.arguments.keyword_only_arguments)
+        {
+            if let Some(type_hint) = &arg.annotation {
+                self.walk_type_hint(type_hint);
+            }
+        }
+        for arg in function
+            .arguments
+            .vararg
+            .as_ref()
+            .iter()
+            .chain(&function.arguments.kwarg.as_ref())
+        {
+            if let Some(type_hint) = &arg.annotation {
+                self.walk_type_hint(type_hint);
+            }
+        }
+        if let Some(type_hint) = &function.returns {
+            self.walk_type_hint(type_hint);
+        }
+    }
+
+    fn walk_type_hint(&mut self, type_hint: &TypeHint) {
+        if let TypeHint::Ast(type_hint) = type_hint {
+            self.walk_type_hint_expr(type_hint);
+        }
+    }
+
+    fn walk_type_hint_expr(&mut self, expr: &TypeHintExpr) {
+        match expr {
+            TypeHintExpr::Builtin { id } => {
+                self.builtins.insert(id.clone());
+            }
+            TypeHintExpr::Attribute { module, attr } => {
+                self.module_members
+                    .entry(module.clone())
+                    .or_default()
+                    .insert(attr.clone());
+            }
+            TypeHintExpr::Union { elts } => {
+                for elt in elts {
+                    self.walk_type_hint_expr(elt)
+                }
+            }
+            TypeHintExpr::Subscript { value, slice } => {
+                self.walk_type_hint_expr(value);
+                for elt in slice {
+                    self.walk_type_hint_expr(elt);
+                }
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::model::Arguments;
+
+    #[test]
+    fn function_stubs_with_variable_length() {
+        let function = Function {
+            name: "func".into(),
+            decorators: Vec::new(),
+            arguments: Arguments {
+                positional_only_arguments: vec![Argument {
+                    name: "posonly".into(),
+                    default_value: None,
+                    annotation: None,
+                }],
+                arguments: vec![Argument {
+                    name: "arg".into(),
+                    default_value: None,
+                    annotation: None,
+                }],
+                vararg: Some(VariableLengthArgument {
+                    name: "varargs".into(),
+                    annotation: None,
+                }),
+                keyword_only_arguments: vec![Argument {
+                    name: "karg".into(),
+                    default_value: None,
+                    annotation: Some(TypeHint::Plain("str".into())),
+                }],
+                kwarg: Some(VariableLengthArgument {
+                    name: "kwarg".into(),
+                    annotation: Some(TypeHint::Plain("str".into())),
+                }),
+            },
+            returns: Some(TypeHint::Plain("list[str]".into())),
+        };
+        assert_eq!(
+            "def func(posonly, /, arg, *varargs, karg: str, **kwarg: str) -> list[str]: ...",
+            function_stubs(&function, &Imports::default())
+        )
+    }
+
+    #[test]
+    fn function_stubs_without_variable_length() {
+        let function = Function {
+            name: "afunc".into(),
+            decorators: Vec::new(),
+            arguments: Arguments {
+                positional_only_arguments: vec![Argument {
+                    name: "posonly".into(),
+                    default_value: Some("1".into()),
+                    annotation: None,
+                }],
+                arguments: vec![Argument {
+                    name: "arg".into(),
+                    default_value: Some("True".into()),
+                    annotation: None,
+                }],
+                vararg: None,
+                keyword_only_arguments: vec![Argument {
+                    name: "karg".into(),
+                    default_value: Some("\"foo\"".into()),
+                    annotation: Some(TypeHint::Plain("str".into())),
+                }],
+                kwarg: None,
+            },
+            returns: None,
+        };
+        assert_eq!(
+            "def afunc(posonly=1, /, arg=True, *, karg: str = \"foo\"): ...",
+            function_stubs(&function, &Imports::default())
+        )
+    }
+
+    #[test]
+    fn test_import() {
+        let big_type = TypeHintExpr::Subscript {
+            value: Box::new(TypeHintExpr::Builtin { id: "dict".into() }),
+            slice: vec![
+                TypeHintExpr::Attribute {
+                    module: "foo.bar".into(),
+                    attr: "A".into(),
+                },
+                TypeHintExpr::Union {
+                    elts: vec![
+                        TypeHintExpr::Attribute {
+                            module: "bar".into(),
+                            attr: "A".into(),
+                        },
+                        TypeHintExpr::Attribute {
+                            module: "foo".into(),
+                            attr: "A.C".into(),
+                        },
+                        TypeHintExpr::Attribute {
+                            module: "foo".into(),
+                            attr: "A.D".into(),
+                        },
+                        TypeHintExpr::Attribute {
+                            module: "foo".into(),
+                            attr: "B".into(),
+                        },
+                        TypeHintExpr::Attribute {
+                            module: "bat".into(),
+                            attr: "A".into(),
+                        },
+                    ],
+                },
+            ],
+        };
+        let imports = Imports::create(
+            &Module {
+                name: "bar".into(),
+                modules: Vec::new(),
+                classes: vec![Class {
+                    name: "A".into(),
+                    methods: Vec::new(),
+                    attributes: Vec::new(),
+                }],
+                functions: vec![Function {
+                    name: String::new(),
+                    decorators: Vec::new(),
+                    arguments: Arguments {
+                        positional_only_arguments: Vec::new(),
+                        arguments: Vec::new(),
+                        vararg: None,
+                        keyword_only_arguments: Vec::new(),
+                        kwarg: None,
+                    },
+                    returns: Some(TypeHint::Ast(big_type.clone())),
+                }],
+                attributes: Vec::new(),
+                incomplete: true,
+            },
+            &["foo"],
+        );
+        assert_eq!(
+            &imports.imports,
+            &[
+                "from _typeshed import Incomplete",
+                "from bat import A as A2",
+                "from foo import A as A3, B"
+            ]
+        );
+        let mut output = String::new();
+        imports.serialize_type_hint(&big_type, &mut output);
+        assert_eq!(output, "dict[A, A | A3.C | A3.D | B | A2]");
+    }
+}
diff --git a/pyo3-introspection/tests/test.rs b/pyo3-introspection/tests/test.rs
new file mode 100644
index 00000000000..cf01329e9b1
--- /dev/null
+++ b/pyo3-introspection/tests/test.rs
@@ -0,0 +1,106 @@
+use anyhow::{ensure, Result};
+use pyo3_introspection::{introspect_cdylib, module_stub_files};
+use std::collections::HashMap;
+use std::io::{Read, Seek, SeekFrom, Write};
+use std::path::{Path, PathBuf};
+use std::process::Command;
+use std::{env, fs};
+use tempfile::NamedTempFile;
+
+#[test]
+fn pytests_stubs() -> Result<()> {
+    // We run the introspection
+    let binary = env::var_os("PYO3_PYTEST_LIB_PATH")
+        .expect("The PYO3_PYTEST_LIB_PATH constant must be set and target the pyo3-pytests cdylib");
+    let module = introspect_cdylib(binary, "pyo3_pytests")?;
+    let actual_stubs = module_stub_files(&module);
+
+    // We read the expected stubs
+    let expected_subs_dir = Path::new(env!("CARGO_MANIFEST_DIR"))
+        .parent()
+        .unwrap()
+        .join("pytests")
+        .join("stubs");
+    let mut expected_subs = HashMap::new();
+    add_dir_files(
+        &expected_subs_dir,
+        &expected_subs_dir.canonicalize()?,
+        &mut expected_subs,
+    )?;
+
+    // We ensure we do not have extra generated files
+    for file_name in actual_stubs.keys() {
+        assert!(
+            expected_subs.contains_key(file_name),
+            "The generated file {} is not in the expected stubs directory pytests/stubs",
+            file_name.display()
+        );
+    }
+
+    // We ensure the expected files are generated properly
+    for (file_name, expected_file_content) in &expected_subs {
+        let actual_file_content = actual_stubs.get(file_name).unwrap_or_else(|| {
+            panic!(
+                "The expected stub file {} has not been generated",
+                file_name.display()
+            )
+        });
+
+        let actual_file_content = format_with_ruff(actual_file_content)?;
+
+        // We normalize line jumps for compatibility with Windows
+        assert_eq!(
+            expected_file_content.replace('\r', ""),
+            actual_file_content.replace('\r', ""),
+            "The content of file {} is different",
+            file_name.display()
+        )
+    }
+
+    Ok(())
+}
+
+fn add_dir_files(
+    dir_path: &Path,
+    base_dir_path: &Path,
+    output: &mut HashMap<PathBuf, String>,
+) -> Result<()> {
+    for entry in fs::read_dir(dir_path)? {
+        let entry = entry?;
+        if entry.file_type()?.is_dir() {
+            add_dir_files(&entry.path(), base_dir_path, output)?;
+        } else {
+            output.insert(
+                entry
+                    .path()
+                    .canonicalize()?
+                    .strip_prefix(base_dir_path)?
+                    .into(),
+                fs::read_to_string(entry.path())?,
+            );
+        }
+    }
+    Ok(())
+}
+
+fn format_with_ruff(code: &str) -> Result<String> {
+    let temp_file = NamedTempFile::with_suffix(".pyi")?;
+    // Write to file
+    {
+        let mut file = temp_file.as_file();
+        file.write_all(code.as_bytes())?;
+        file.flush()?;
+        file.seek(SeekFrom::Start(0))?;
+    }
+    ensure!(
+        Command::new("ruff")
+            .arg("format")
+            .arg(temp_file.path())
+            .status()?
+            .success(),
+        "Failed to run ruff"
+    );
+    let mut content = String::new();
+    temp_file.as_file().read_to_string(&mut content)?;
+    Ok(content)
+}
diff --git a/pyo3-macros-backend/Cargo.toml b/pyo3-macros-backend/Cargo.toml
index 458b280f881..eadee73d0c6 100644
--- a/pyo3-macros-backend/Cargo.toml
+++ b/pyo3-macros-backend/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "pyo3-macros-backend"
-version = "0.21.0-dev"
+version = "0.27.0"
 description = "Code generation for PyO3 package"
 authors = ["PyO3 Project and Contributors <https://github.com/PyO3>"]
 keywords = ["pyo3", "python", "cpython", "ffi"]
@@ -9,20 +9,29 @@ repository = "https://github.com/pyo3/pyo3"
 categories = ["api-bindings", "development-tools::ffi"]
 license = "MIT OR Apache-2.0"
 edition = "2021"
+rust-version.workspace = true
 
 # Note: we use default-features = false for proc-macro related crates
 # not to depend on proc-macro itself.
 # See https://github.com/PyO3/pyo3/pull/810 for more.
 [dependencies]
-heck = "0.4"
-proc-macro2 = { version = "1", default-features = false }
-pyo3-build-config = { path = "../pyo3-build-config", version = "0.21.0-dev", features = ["resolve-config"] }
-quote = { version = "1", default-features = false }
+heck = "0.5"
+proc-macro2 = { version = "1.0.60", default-features = false }
+pyo3-build-config = { path = "../pyo3-build-config", version = "=0.27.0", features = ["resolve-config"] }
+quote = { version = "1.0.37", default-features = false }
 
 [dependencies.syn]
-version = "2"
+# 2.0.59 for `LitCStr`
+version = "2.0.59"
 default-features = false
-features = ["derive", "parsing", "printing", "clone-impls", "full", "extra-traits"]
+features = ["derive", "parsing", "printing", "clone-impls", "full", "extra-traits", "visit-mut"]
+
+[build-dependencies]
+pyo3-build-config = { path = "../pyo3-build-config", version = "=0.27.0" }
 
 [lints]
 workspace = true
+
+[features]
+experimental-async = []
+experimental-inspect = []
diff --git a/pyo3-macros-backend/build.rs b/pyo3-macros-backend/build.rs
new file mode 100644
index 00000000000..55aa0ba03c5
--- /dev/null
+++ b/pyo3-macros-backend/build.rs
@@ -0,0 +1,4 @@
+fn main() {
+    pyo3_build_config::print_expected_cfgs();
+    pyo3_build_config::print_feature_cfgs();
+}
diff --git a/pyo3-macros-backend/src/attributes.rs b/pyo3-macros-backend/src/attributes.rs
index e91b3b8d9a2..6e7de98e318 100644
--- a/pyo3-macros-backend/src/attributes.rs
+++ b/pyo3-macros-backend/src/attributes.rs
@@ -1,40 +1,179 @@
 use proc_macro2::TokenStream;
-use quote::ToTokens;
+use quote::{quote, ToTokens};
+use syn::parse::Parser;
 use syn::{
+    ext::IdentExt,
     parse::{Parse, ParseStream},
     punctuated::Punctuated,
     spanned::Spanned,
     token::Comma,
-    Attribute, Expr, ExprPath, Ident, LitStr, Path, Result, Token,
+    Attribute, Expr, ExprPath, Ident, Index, LitBool, LitStr, Member, Path, Result, Token,
 };
 
+use crate::combine_errors::CombineErrors;
+
 pub mod kw {
     syn::custom_keyword!(annotation);
     syn::custom_keyword!(attribute);
     syn::custom_keyword!(cancel_handle);
+    syn::custom_keyword!(constructor);
     syn::custom_keyword!(dict);
+    syn::custom_keyword!(eq);
+    syn::custom_keyword!(eq_int);
     syn::custom_keyword!(extends);
     syn::custom_keyword!(freelist);
     syn::custom_keyword!(from_py_with);
     syn::custom_keyword!(frozen);
     syn::custom_keyword!(get);
     syn::custom_keyword!(get_all);
+    syn::custom_keyword!(hash);
+    syn::custom_keyword!(into_py_with);
     syn::custom_keyword!(item);
+    syn::custom_keyword!(immutable_type);
     syn::custom_keyword!(from_item_all);
     syn::custom_keyword!(mapping);
     syn::custom_keyword!(module);
     syn::custom_keyword!(name);
+    syn::custom_keyword!(ord);
     syn::custom_keyword!(pass_module);
     syn::custom_keyword!(rename_all);
     syn::custom_keyword!(sequence);
     syn::custom_keyword!(set);
     syn::custom_keyword!(set_all);
     syn::custom_keyword!(signature);
+    syn::custom_keyword!(str);
     syn::custom_keyword!(subclass);
+    syn::custom_keyword!(submodule);
     syn::custom_keyword!(text_signature);
     syn::custom_keyword!(transparent);
     syn::custom_keyword!(unsendable);
     syn::custom_keyword!(weakref);
+    syn::custom_keyword!(generic);
+    syn::custom_keyword!(gil_used);
+    syn::custom_keyword!(warn);
+    syn::custom_keyword!(message);
+    syn::custom_keyword!(category);
+    syn::custom_keyword!(from_py_object);
+    syn::custom_keyword!(skip_from_py_object);
+}
+
+fn take_int(read: &mut &str, tracker: &mut usize) -> String {
+    let mut int = String::new();
+    for (i, ch) in read.char_indices() {
+        match ch {
+            '0'..='9' => {
+                *tracker += 1;
+                int.push(ch)
+            }
+            _ => {
+                *read = &read[i..];
+                break;
+            }
+        }
+    }
+    int
+}
+
+fn take_ident(read: &mut &str, tracker: &mut usize) -> Ident {
+    let mut ident = String::new();
+    if read.starts_with("r#") {
+        ident.push_str("r#");
+        *tracker += 2;
+        *read = &read[2..];
+    }
+    for (i, ch) in read.char_indices() {
+        match ch {
+            'a'..='z' | 'A'..='Z' | '0'..='9' | '_' => {
+                *tracker += 1;
+                ident.push(ch)
+            }
+            _ => {
+                *read = &read[i..];
+                break;
+            }
+        }
+    }
+    Ident::parse_any.parse_str(&ident).unwrap()
+}
+
+// shorthand parsing logic inspiration taken from https://github.com/dtolnay/thiserror/blob/master/impl/src/fmt.rs
+fn parse_shorthand_format(fmt: LitStr) -> Result<(LitStr, Vec<Member>)> {
+    let span = fmt.span();
+    let token = fmt.token();
+    let value = fmt.value();
+    let mut read = value.as_str();
+    let mut out = String::new();
+    let mut members = Vec::new();
+    let mut tracker = 1;
+    while let Some(brace) = read.find('{') {
+        tracker += brace;
+        out += &read[..brace + 1];
+        read = &read[brace + 1..];
+        if read.starts_with('{') {
+            out.push('{');
+            read = &read[1..];
+            tracker += 2;
+            continue;
+        }
+        let next = match read.chars().next() {
+            Some(next) => next,
+            None => break,
+        };
+        tracker += 1;
+        let member = match next {
+            '0'..='9' => {
+                let start = tracker;
+                let index = take_int(&mut read, &mut tracker).parse::<u32>().unwrap();
+                let end = tracker;
+                let subspan = token.subspan(start..end).unwrap_or(span);
+                let idx = Index {
+                    index,
+                    span: subspan,
+                };
+                Member::Unnamed(idx)
+            }
+            'a'..='z' | 'A'..='Z' | '_' => {
+                let start = tracker;
+                let mut ident = take_ident(&mut read, &mut tracker);
+                let end = tracker;
+                let subspan = token.subspan(start..end).unwrap_or(span);
+                ident.set_span(subspan);
+                Member::Named(ident)
+            }
+            '}' | ':' => {
+                let start = tracker;
+                tracker += 1;
+                let end = tracker;
+                let subspan = token.subspan(start..end).unwrap_or(span);
+                // we found a closing bracket or formatting ':' without finding a member, we assume the user wants the instance formatted here
+                bail_spanned!(subspan.span() => "No member found, you must provide a named or positionally specified member.")
+            }
+            _ => continue,
+        };
+        members.push(member);
+    }
+    out += read;
+    Ok((LitStr::new(&out, span), members))
+}
+
+#[derive(Clone, Debug)]
+pub struct StringFormatter {
+    pub fmt: LitStr,
+    pub args: Vec<Member>,
+}
+
+impl Parse for crate::attributes::StringFormatter {
+    fn parse(input: ParseStream<'_>) -> Result<Self> {
+        let (fmt, args) = parse_shorthand_format(input.parse()?)?;
+        Ok(Self { fmt, args })
+    }
+}
+
+impl ToTokens for crate::attributes::StringFormatter {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
+        self.fmt.to_tokens(tokens);
+        tokens.extend(quote! {self.args})
+    }
 }
 
 #[derive(Clone, Debug)]
@@ -43,6 +182,12 @@ pub struct KeywordAttribute<K, V> {
     pub value: V,
 }
 
+#[derive(Clone, Debug)]
+pub struct OptionalKeywordAttribute<K, V> {
+    pub kw: K,
+    pub value: Option<V>,
+}
+
 /// A helper type which parses the inner type via a literal string
 /// e.g. `LitStrValue<Path>` -> parses "some::path" in quotes.
 #[derive(Clone, Debug, PartialEq, Eq)]
@@ -68,7 +213,7 @@ pub struct NameLitStr(pub Ident);
 impl Parse for NameLitStr {
     fn parse(input: ParseStream<'_>) -> Result<Self> {
         let string_literal: LitStr = input.parse()?;
-        if let Ok(ident) = string_literal.parse() {
+        if let Ok(ident) = string_literal.parse_with(Ident::parse_any) {
             Ok(NameLitStr(ident))
         } else {
             bail_spanned!(string_literal.span() => "expected a single identifier in double quotes")
@@ -131,7 +276,7 @@ impl ToTokens for RenamingRuleLitStr {
     }
 }
 
-/// Text signatue can be either a literal string or opt-in/out
+/// Text signature can be either a literal string or opt-in/out
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub enum TextSignatureAttributeValue {
     Str(LitStr),
@@ -171,7 +316,10 @@ pub type FreelistAttribute = KeywordAttribute<kw::freelist, Box<Expr>>;
 pub type ModuleAttribute = KeywordAttribute<kw::module, LitStr>;
 pub type NameAttribute = KeywordAttribute<kw::name, NameLitStr>;
 pub type RenameAllAttribute = KeywordAttribute<kw::rename_all, RenamingRuleLitStr>;
+pub type StrFormatterAttribute = OptionalKeywordAttribute<kw::str, StringFormatter>;
 pub type TextSignatureAttribute = KeywordAttribute<kw::text_signature, TextSignatureAttributeValue>;
+pub type SubmoduleAttribute = kw::submodule;
+pub type GILUsedAttribute = KeywordAttribute<kw::gil_used, LitBool>;
 
 impl<K: Parse + std::fmt::Debug, V: Parse> Parse for KeywordAttribute<K, V> {
     fn parse(input: ParseStream<'_>) -> Result<Self> {
@@ -190,7 +338,31 @@ impl<K: ToTokens, V: ToTokens> ToTokens for KeywordAttribute<K, V> {
     }
 }
 
-pub type FromPyWithAttribute = KeywordAttribute<kw::from_py_with, LitStrValue<ExprPath>>;
+impl<K: Parse + std::fmt::Debug, V: Parse> Parse for OptionalKeywordAttribute<K, V> {
+    fn parse(input: ParseStream<'_>) -> Result<Self> {
+        let kw: K = input.parse()?;
+        let value = match input.parse::<Token![=]>() {
+            Ok(_) => Some(input.parse()?),
+            Err(_) => None,
+        };
+        Ok(OptionalKeywordAttribute { kw, value })
+    }
+}
+
+impl<K: ToTokens, V: ToTokens> ToTokens for OptionalKeywordAttribute<K, V> {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
+        self.kw.to_tokens(tokens);
+        if self.value.is_some() {
+            Token![=](self.kw.span()).to_tokens(tokens);
+            self.value.to_tokens(tokens);
+        }
+    }
+}
+
+pub type FromPyWithAttribute = KeywordAttribute<kw::from_py_with, ExprPath>;
+pub type IntoPyWithAttribute = KeywordAttribute<kw::into_py_with, ExprPath>;
+
+pub type DefaultAttribute = OptionalKeywordAttribute<Token![default], Expr>;
 
 /// For specifying the path to the pyo3 crate.
 pub type CrateAttribute = KeywordAttribute<Token![crate], LitStrValue<Path>>;
@@ -227,13 +399,23 @@ pub fn take_attributes(
 
 pub fn take_pyo3_options<T: Parse>(attrs: &mut Vec<syn::Attribute>) -> Result<Vec<T>> {
     let mut out = Vec::new();
-    take_attributes(attrs, |attr| {
-        if let Some(options) = get_pyo3_options(attr)? {
-            out.extend(options);
+
+    take_attributes(attrs, |attr| match get_pyo3_options(attr) {
+        Ok(result) => {
+            if let Some(options) = result {
+                out.extend(options.into_iter().map(|a| Ok(a)));
+                Ok(true)
+            } else {
+                Ok(false)
+            }
+        }
+        Err(err) => {
+            out.push(Err(err));
             Ok(true)
-        } else {
-            Ok(false)
         }
     })?;
+
+    let out: Vec<T> = out.into_iter().try_combine_syn_errors()?;
+
     Ok(out)
 }
diff --git a/pyo3-macros-backend/src/combine_errors.rs b/pyo3-macros-backend/src/combine_errors.rs
new file mode 100644
index 00000000000..235831ac486
--- /dev/null
+++ b/pyo3-macros-backend/src/combine_errors.rs
@@ -0,0 +1,36 @@
+pub(crate) trait CombineErrors: Iterator {
+    type Ok;
+    fn try_combine_syn_errors(self) -> syn::Result<Vec<Self::Ok>>;
+}
+
+impl<I, T> CombineErrors for I
+where
+    I: Iterator<Item = syn::Result<T>>,
+{
+    type Ok = T;
+
+    fn try_combine_syn_errors(self) -> syn::Result<Vec<Self::Ok>> {
+        let mut oks: Vec<Self::Ok> = Vec::new();
+        let mut errors: Vec<syn::Error> = Vec::new();
+
+        for res in self {
+            match res {
+                Ok(val) => oks.push(val),
+                Err(e) => errors.push(e),
+            }
+        }
+
+        let mut err_iter = errors.into_iter();
+        let mut err = match err_iter.next() {
+            // There are no errors
+            None => return Ok(oks),
+            Some(e) => e,
+        };
+
+        for e in err_iter {
+            err.combine(e);
+        }
+
+        Err(err)
+    }
+}
diff --git a/pyo3-macros-backend/src/deprecations.rs b/pyo3-macros-backend/src/deprecations.rs
deleted file mode 100644
index ea2922737b9..00000000000
--- a/pyo3-macros-backend/src/deprecations.rs
+++ /dev/null
@@ -1,44 +0,0 @@
-use proc_macro2::{Span, TokenStream};
-use quote::{quote_spanned, ToTokens};
-
-pub enum Deprecation {
-    PyMethodsNewDeprecatedForm,
-}
-
-impl Deprecation {
-    fn ident(&self, span: Span) -> syn::Ident {
-        let string = match self {
-            Deprecation::PyMethodsNewDeprecatedForm => "PYMETHODS_NEW_DEPRECATED_FORM",
-        };
-        syn::Ident::new(string, span)
-    }
-}
-
-#[derive(Default)]
-pub struct Deprecations(Vec<(Deprecation, Span)>);
-
-impl Deprecations {
-    pub fn new() -> Self {
-        Deprecations(Vec::new())
-    }
-
-    pub fn push(&mut self, deprecation: Deprecation, span: Span) {
-        self.0.push((deprecation, span))
-    }
-}
-
-impl ToTokens for Deprecations {
-    fn to_tokens(&self, tokens: &mut TokenStream) {
-        for (deprecation, span) in &self.0 {
-            let ident = deprecation.ident(*span);
-            quote_spanned!(
-                *span =>
-                #[allow(clippy::let_unit_value)]
-                {
-                    let _ = _pyo3::impl_::deprecations::#ident;
-                }
-            )
-            .to_tokens(tokens)
-        }
-    }
-}
diff --git a/pyo3-macros-backend/src/derive_attributes.rs b/pyo3-macros-backend/src/derive_attributes.rs
new file mode 100644
index 00000000000..6ec78e17eb0
--- /dev/null
+++ b/pyo3-macros-backend/src/derive_attributes.rs
@@ -0,0 +1,217 @@
+use crate::attributes::{
+    self, get_pyo3_options, CrateAttribute, DefaultAttribute, FromPyWithAttribute,
+    IntoPyWithAttribute, RenameAllAttribute,
+};
+use proc_macro2::Span;
+use syn::parse::{Parse, ParseStream};
+use syn::spanned::Spanned;
+use syn::{parenthesized, Attribute, LitStr, Result, Token};
+
+/// Attributes for deriving `FromPyObject`/`IntoPyObject` scoped on containers.
+pub enum ContainerAttribute {
+    /// Treat the Container as a Wrapper, operate directly on its field
+    Transparent(attributes::kw::transparent),
+    /// Force every field to be extracted from item of source Python object.
+    ItemAll(attributes::kw::from_item_all),
+    /// Change the name of an enum variant in the generated error message.
+    ErrorAnnotation(LitStr),
+    /// Change the path for the pyo3 crate
+    Crate(CrateAttribute),
+    /// Converts the field idents according to the [RenamingRule](attributes::RenamingRule) before extraction
+    RenameAll(RenameAllAttribute),
+}
+
+impl Parse for ContainerAttribute {
+    fn parse(input: ParseStream<'_>) -> Result<Self> {
+        let lookahead = input.lookahead1();
+        if lookahead.peek(attributes::kw::transparent) {
+            let kw: attributes::kw::transparent = input.parse()?;
+            Ok(ContainerAttribute::Transparent(kw))
+        } else if lookahead.peek(attributes::kw::from_item_all) {
+            let kw: attributes::kw::from_item_all = input.parse()?;
+            Ok(ContainerAttribute::ItemAll(kw))
+        } else if lookahead.peek(attributes::kw::annotation) {
+            let _: attributes::kw::annotation = input.parse()?;
+            let _: Token![=] = input.parse()?;
+            input.parse().map(ContainerAttribute::ErrorAnnotation)
+        } else if lookahead.peek(Token![crate]) {
+            input.parse().map(ContainerAttribute::Crate)
+        } else if lookahead.peek(attributes::kw::rename_all) {
+            input.parse().map(ContainerAttribute::RenameAll)
+        } else {
+            Err(lookahead.error())
+        }
+    }
+}
+
+#[derive(Default, Clone)]
+pub struct ContainerAttributes {
+    /// Treat the Container as a Wrapper, operate directly on its field
+    pub transparent: Option<attributes::kw::transparent>,
+    /// Force every field to be extracted from item of source Python object.
+    pub from_item_all: Option<attributes::kw::from_item_all>,
+    /// Change the name of an enum variant in the generated error message.
+    pub annotation: Option<syn::LitStr>,
+    /// Change the path for the pyo3 crate
+    pub krate: Option<CrateAttribute>,
+    /// Converts the field idents according to the [RenamingRule](attributes::RenamingRule) before extraction
+    pub rename_all: Option<RenameAllAttribute>,
+}
+
+impl ContainerAttributes {
+    pub fn from_attrs(attrs: &[Attribute]) -> Result<Self> {
+        let mut options = ContainerAttributes::default();
+
+        for attr in attrs {
+            if let Some(pyo3_attrs) = get_pyo3_options(attr)? {
+                pyo3_attrs
+                    .into_iter()
+                    .try_for_each(|opt| options.set_option(opt))?;
+            }
+        }
+        Ok(options)
+    }
+
+    fn set_option(&mut self, option: ContainerAttribute) -> syn::Result<()> {
+        macro_rules! set_option {
+            ($key:ident) => {
+                {
+                    ensure_spanned!(
+                        self.$key.is_none(),
+                        $key.span() => concat!("`", stringify!($key), "` may only be specified once")
+                    );
+                    self.$key = Some($key);
+                }
+            };
+        }
+
+        match option {
+            ContainerAttribute::Transparent(transparent) => set_option!(transparent),
+            ContainerAttribute::ItemAll(from_item_all) => set_option!(from_item_all),
+            ContainerAttribute::ErrorAnnotation(annotation) => set_option!(annotation),
+            ContainerAttribute::Crate(krate) => set_option!(krate),
+            ContainerAttribute::RenameAll(rename_all) => set_option!(rename_all),
+        }
+        Ok(())
+    }
+}
+
+#[derive(Clone, Debug)]
+pub enum FieldGetter {
+    GetItem(attributes::kw::item, Option<syn::Lit>),
+    GetAttr(attributes::kw::attribute, Option<syn::LitStr>),
+}
+
+impl FieldGetter {
+    pub fn span(&self) -> Span {
+        match self {
+            FieldGetter::GetItem(item, _) => item.span,
+            FieldGetter::GetAttr(attribute, _) => attribute.span,
+        }
+    }
+}
+
+pub enum FieldAttribute {
+    Getter(FieldGetter),
+    FromPyWith(FromPyWithAttribute),
+    IntoPyWith(IntoPyWithAttribute),
+    Default(DefaultAttribute),
+}
+
+impl Parse for FieldAttribute {
+    fn parse(input: ParseStream<'_>) -> Result<Self> {
+        let lookahead = input.lookahead1();
+        if lookahead.peek(attributes::kw::attribute) {
+            let attr_kw: attributes::kw::attribute = input.parse()?;
+            if input.peek(syn::token::Paren) {
+                let content;
+                let _ = parenthesized!(content in input);
+                let attr_name: LitStr = content.parse()?;
+                if !content.is_empty() {
+                    return Err(content.error(
+                        "expected at most one argument: `attribute` or `attribute(\"name\")`",
+                    ));
+                }
+                ensure_spanned!(
+                    !attr_name.value().is_empty(),
+                    attr_name.span() => "attribute name cannot be empty"
+                );
+                Ok(Self::Getter(FieldGetter::GetAttr(attr_kw, Some(attr_name))))
+            } else {
+                Ok(Self::Getter(FieldGetter::GetAttr(attr_kw, None)))
+            }
+        } else if lookahead.peek(attributes::kw::item) {
+            let item_kw: attributes::kw::item = input.parse()?;
+            if input.peek(syn::token::Paren) {
+                let content;
+                let _ = parenthesized!(content in input);
+                let key = content.parse()?;
+                if !content.is_empty() {
+                    return Err(
+                        content.error("expected at most one argument: `item` or `item(key)`")
+                    );
+                }
+                Ok(Self::Getter(FieldGetter::GetItem(item_kw, Some(key))))
+            } else {
+                Ok(Self::Getter(FieldGetter::GetItem(item_kw, None)))
+            }
+        } else if lookahead.peek(attributes::kw::from_py_with) {
+            input.parse().map(Self::FromPyWith)
+        } else if lookahead.peek(attributes::kw::into_py_with) {
+            input.parse().map(FieldAttribute::IntoPyWith)
+        } else if lookahead.peek(Token![default]) {
+            input.parse().map(Self::Default)
+        } else {
+            Err(lookahead.error())
+        }
+    }
+}
+
+#[derive(Clone, Debug, Default)]
+pub struct FieldAttributes {
+    pub getter: Option<FieldGetter>,
+    pub from_py_with: Option<FromPyWithAttribute>,
+    pub into_py_with: Option<IntoPyWithAttribute>,
+    pub default: Option<DefaultAttribute>,
+}
+
+impl FieldAttributes {
+    /// Extract the field attributes.
+    pub fn from_attrs(attrs: &[Attribute]) -> Result<Self> {
+        let mut options = FieldAttributes::default();
+
+        for attr in attrs {
+            if let Some(pyo3_attrs) = get_pyo3_options(attr)? {
+                pyo3_attrs
+                    .into_iter()
+                    .try_for_each(|opt| options.set_option(opt))?;
+            }
+        }
+        Ok(options)
+    }
+
+    fn set_option(&mut self, option: FieldAttribute) -> syn::Result<()> {
+        macro_rules! set_option {
+            ($key:ident) => {
+                set_option!($key, concat!("`", stringify!($key), "` may only be specified once"))
+            };
+            ($key:ident, $msg: expr) => {{
+                ensure_spanned!(
+                    self.$key.is_none(),
+                    $key.span() => $msg
+                );
+                self.$key = Some($key);
+            }}
+        }
+
+        match option {
+            FieldAttribute::Getter(getter) => {
+                set_option!(getter, "only one of `attribute` or `item` can be provided")
+            }
+            FieldAttribute::FromPyWith(from_py_with) => set_option!(from_py_with),
+            FieldAttribute::IntoPyWith(into_py_with) => set_option!(into_py_with),
+            FieldAttribute::Default(default) => set_option!(default),
+        }
+        Ok(())
+    }
+}
diff --git a/pyo3-macros-backend/src/frompyobject.rs b/pyo3-macros-backend/src/frompyobject.rs
index 5e193bf4a24..841fcd2039f 100644
--- a/pyo3-macros-backend/src/frompyobject.rs
+++ b/pyo3-macros-backend/src/frompyobject.rs
@@ -1,16 +1,13 @@
-use crate::{
-    attributes::{self, get_pyo3_options, CrateAttribute, FromPyWithAttribute},
-    utils::get_pyo3_crate,
-};
+use crate::attributes::{DefaultAttribute, FromPyWithAttribute, RenamingRule};
+use crate::derive_attributes::{ContainerAttributes, FieldAttributes, FieldGetter};
+#[cfg(feature = "experimental-inspect")]
+use crate::introspection::elide_lifetimes;
+use crate::utils::{self, Ctx};
 use proc_macro2::TokenStream;
-use quote::{format_ident, quote};
+use quote::{format_ident, quote, quote_spanned, ToTokens};
 use syn::{
-    parenthesized,
-    parse::{Parse, ParseStream},
-    parse_quote,
-    punctuated::Punctuated,
-    spanned::Spanned,
-    Attribute, DataEnum, DeriveInput, Fields, Ident, LitStr, Result, Token,
+    ext::IdentExt, parse_quote, punctuated::Punctuated, spanned::Spanned, DataEnum, DeriveInput,
+    Fields, Ident, Result, Token,
 };
 
 /// Describes derivation input of an enum.
@@ -24,7 +21,11 @@ impl<'a> Enum<'a> {
     ///
     /// `data_enum` is the `syn` representation of the input enum, `ident` is the
     /// `Identifier` of the enum.
-    fn new(data_enum: &'a DataEnum, ident: &'a Ident) -> Result<Self> {
+    fn new(
+        data_enum: &'a DataEnum,
+        ident: &'a Ident,
+        options: ContainerAttributes,
+    ) -> Result<Self> {
         ensure_spanned!(
             !data_enum.variants.is_empty(),
             ident.span() => "cannot derive FromPyObject for empty enum"
@@ -33,9 +34,21 @@ impl<'a> Enum<'a> {
             .variants
             .iter()
             .map(|variant| {
-                let attrs = ContainerOptions::from_attrs(&variant.attrs)?;
+                let mut variant_options = ContainerAttributes::from_attrs(&variant.attrs)?;
+                if let Some(rename_all) = &options.rename_all {
+                    ensure_spanned!(
+                        variant_options.rename_all.is_none(),
+                        variant_options.rename_all.span() => "Useless variant `rename_all` - enum is already annotated with `rename_all"
+                    );
+                    variant_options.rename_all = Some(rename_all.clone());
+
+                }
                 let var_ident = &variant.ident;
-                Container::new(&variant.fields, parse_quote!(#ident::#var_ident), attrs)
+                Container::new(
+                    &variant.fields,
+                    parse_quote!(#ident::#var_ident),
+                    variant_options,
+                )
             })
             .collect::<Result<Vec<_>>>()?;
 
@@ -46,14 +59,16 @@ impl<'a> Enum<'a> {
     }
 
     /// Build derivation body for enums.
-    fn build(&self) -> TokenStream {
+    fn build(&self, ctx: &Ctx) -> TokenStream {
+        let Ctx { pyo3_path, .. } = ctx;
         let mut var_extracts = Vec::new();
         let mut variant_names = Vec::new();
         let mut error_names = Vec::new();
+
         for var in &self.variants {
-            let struct_derive = var.build();
+            let struct_derive = var.build(ctx);
             let ext = quote!({
-                let maybe_ret = || -> _pyo3::PyResult<Self> {
+                let maybe_ret = || -> #pyo3_path::PyResult<Self> {
                     #struct_derive
                 }();
 
@@ -73,7 +88,7 @@ impl<'a> Enum<'a> {
                 #(#var_extracts),*
             ];
             ::std::result::Result::Err(
-                _pyo3::impl_::frompyobject::failed_to_extract_enum(
+                #pyo3_path::impl_::frompyobject::failed_to_extract_enum(
                     obj.py(),
                     #ty_name,
                     &[#(#variant_names),*],
@@ -83,16 +98,28 @@ impl<'a> Enum<'a> {
             )
         )
     }
+
+    #[cfg(feature = "experimental-inspect")]
+    fn input_type(&self, ctx: &Ctx) -> TokenStream {
+        let pyo3_crate_path = &ctx.pyo3_path;
+        let variants = self.variants.iter().map(|var| var.input_type(ctx));
+        quote! {
+            #pyo3_crate_path::inspect::TypeHint::union(&[#(#variants),*])
+        }
+    }
 }
 
 struct NamedStructField<'a> {
     ident: &'a syn::Ident,
     getter: Option<FieldGetter>,
     from_py_with: Option<FromPyWithAttribute>,
+    default: Option<DefaultAttribute>,
+    ty: &'a syn::Type,
 }
 
 struct TupleStructField {
     from_py_with: Option<FromPyWithAttribute>,
+    ty: syn::Type,
 }
 
 /// Container Style
@@ -106,7 +133,8 @@ enum ContainerType<'a> {
     /// Newtype struct container, e.g. `#[transparent] struct Foo { a: String }`
     ///
     /// The field specified by the identifier is extracted directly from the object.
-    StructNewtype(&'a syn::Ident, Option<FromPyWithAttribute>),
+    #[cfg_attr(not(feature = "experimental-inspect"), allow(unused))]
+    StructNewtype(&'a syn::Ident, Option<FromPyWithAttribute>, &'a syn::Type),
     /// Tuple struct, e.g. `struct Foo(String)`.
     ///
     /// Variant contains a list of conversion methods for each of the fields that are directly
@@ -115,7 +143,8 @@ enum ContainerType<'a> {
     /// Tuple newtype, e.g. `#[transparent] struct Foo(String)`
     ///
     /// The wrapped field is directly extracted from the object.
-    TupleNewtype(Option<FromPyWithAttribute>),
+    #[cfg_attr(not(feature = "experimental-inspect"), allow(unused))]
+    TupleNewtype(Option<FromPyWithAttribute>, Box<syn::Type>),
 }
 
 /// Data container
@@ -125,26 +154,36 @@ struct Container<'a> {
     path: syn::Path,
     ty: ContainerType<'a>,
     err_name: String,
+    rename_rule: Option<RenamingRule>,
 }
 
 impl<'a> Container<'a> {
     /// Construct a container based on fields, identifier and attributes.
     ///
     /// Fails if the variant has no fields or incompatible attributes.
-    fn new(fields: &'a Fields, path: syn::Path, options: ContainerOptions) -> Result<Self> {
+    fn new(fields: &'a Fields, path: syn::Path, options: ContainerAttributes) -> Result<Self> {
         let style = match fields {
             Fields::Unnamed(unnamed) if !unnamed.unnamed.is_empty() => {
+                ensure_spanned!(
+                    options.rename_all.is_none(),
+                    options.rename_all.span() => "`rename_all` is useless on tuple structs and variants."
+                );
                 let mut tuple_fields = unnamed
                     .unnamed
                     .iter()
                     .map(|field| {
-                        let attrs = FieldPyO3Attributes::from_attrs(&field.attrs)?;
+                        let attrs = FieldAttributes::from_attrs(&field.attrs)?;
                         ensure_spanned!(
                             attrs.getter.is_none(),
                             field.span() => "`getter` is not permitted on tuple struct elements."
                         );
+                        ensure_spanned!(
+                            attrs.default.is_none(),
+                            field.span() => "`default` is not permitted on tuple struct elements."
+                        );
                         Ok(TupleStructField {
                             from_py_with: attrs.from_py_with,
+                            ty: field.ty.clone(),
                         })
                     })
                     .collect::<Result<Vec<_>>>()?;
@@ -153,8 +192,8 @@ impl<'a> Container<'a> {
                     // Always treat a 1-length tuple struct as "transparent", even without the
                     // explicit annotation.
                     let field = tuple_fields.pop().unwrap();
-                    ContainerType::TupleNewtype(field.from_py_with)
-                } else if options.transparent {
+                    ContainerType::TupleNewtype(field.from_py_with, Box::new(field.ty))
+                } else if options.transparent.is_some() {
                     bail_spanned!(
                         fields.span() => "transparent structs and variants can only have 1 field"
                     );
@@ -171,17 +210,17 @@ impl<'a> Container<'a> {
                             .ident
                             .as_ref()
                             .expect("Named fields should have identifiers");
-                        let mut attrs = FieldPyO3Attributes::from_attrs(&field.attrs)?;
+                        let mut attrs = FieldAttributes::from_attrs(&field.attrs)?;
 
                         if let Some(ref from_item_all) = options.from_item_all {
-                            if let Some(replaced) = attrs.getter.replace(FieldGetter::GetItem(None))
+                            if let Some(replaced) = attrs.getter.replace(FieldGetter::GetItem(parse_quote!(item), None))
                             {
                                 match replaced {
-                                    FieldGetter::GetItem(Some(item_name)) => {
-                                        attrs.getter = Some(FieldGetter::GetItem(Some(item_name)));
+                                    FieldGetter::GetItem(item, Some(item_name)) => {
+                                        attrs.getter = Some(FieldGetter::GetItem(item, Some(item_name)));
                                     }
-                                    FieldGetter::GetItem(None) => bail_spanned!(from_item_all.span() => "Useless `item` - the struct is already annotated with `from_item_all`"),
-                                    FieldGetter::GetAttr(_) => bail_spanned!(
+                                    FieldGetter::GetItem(_, None) => bail_spanned!(from_item_all.span() => "Useless `item` - the struct is already annotated with `from_item_all`"),
+                                    FieldGetter::GetAttr(_, _) => bail_spanned!(
                                         from_item_all.span() => "The struct is already annotated with `from_item_all`, `attribute` is not allowed"
                                     ),
                                 }
@@ -192,20 +231,30 @@ impl<'a> Container<'a> {
                             ident,
                             getter: attrs.getter,
                             from_py_with: attrs.from_py_with,
+                            default: attrs.default,
+                            ty: &field.ty,
                         })
                     })
                     .collect::<Result<Vec<_>>>()?;
-                if options.transparent {
+                if struct_fields.iter().all(|field| field.default.is_some()) {
+                    bail_spanned!(
+                        fields.span() => "cannot derive FromPyObject for structs and variants with only default values"
+                    )
+                } else if options.transparent.is_some() {
                     ensure_spanned!(
                         struct_fields.len() == 1,
                         fields.span() => "transparent structs and variants can only have 1 field"
                     );
+                    ensure_spanned!(
+                        options.rename_all.is_none(),
+                        options.rename_all.span() => "`rename_all` is not permitted on `transparent` structs and variants"
+                    );
                     let field = struct_fields.pop().unwrap();
                     ensure_spanned!(
                         field.getter.is_none(),
                         field.ident.span() => "`transparent` structs may not have a `getter` for the inner field"
                     );
-                    ContainerType::StructNewtype(field.ident, field.from_py_with)
+                    ContainerType::StructNewtype(field.ident, field.from_py_with, field.ty)
                 } else {
                     ContainerType::Struct(struct_fields)
                 }
@@ -223,6 +272,7 @@ impl<'a> Container<'a> {
             path,
             ty: style,
             err_name,
+            rename_rule: options.rename_all.map(|v| v.value.rule),
         };
         Ok(v)
     }
@@ -239,16 +289,16 @@ impl<'a> Container<'a> {
     }
 
     /// Build derivation body for a struct.
-    fn build(&self) -> TokenStream {
+    fn build(&self, ctx: &Ctx) -> TokenStream {
         match &self.ty {
-            ContainerType::StructNewtype(ident, from_py_with) => {
-                self.build_newtype_struct(Some(ident), from_py_with)
+            ContainerType::StructNewtype(ident, from_py_with, _) => {
+                self.build_newtype_struct(Some(ident), from_py_with, ctx)
             }
-            ContainerType::TupleNewtype(from_py_with) => {
-                self.build_newtype_struct(None, from_py_with)
+            ContainerType::TupleNewtype(from_py_with, _) => {
+                self.build_newtype_struct(None, from_py_with, ctx)
             }
-            ContainerType::Tuple(tups) => self.build_tuple_struct(tups),
-            ContainerType::Struct(tups) => self.build_struct(tups),
+            ContainerType::Tuple(tups) => self.build_tuple_struct(tups, ctx),
+            ContainerType::Struct(tups) => self.build_struct(tups, ctx),
         }
     }
 
@@ -256,291 +306,194 @@ impl<'a> Container<'a> {
         &self,
         field_ident: Option<&Ident>,
         from_py_with: &Option<FromPyWithAttribute>,
+        ctx: &Ctx,
     ) -> TokenStream {
+        let Ctx { pyo3_path, .. } = ctx;
         let self_ty = &self.path;
         let struct_name = self.name();
         if let Some(ident) = field_ident {
             let field_name = ident.to_string();
-            match from_py_with {
-                None => quote! {
+            if let Some(FromPyWithAttribute {
+                kw,
+                value: expr_path,
+            }) = from_py_with
+            {
+                let extractor = quote_spanned! { kw.span =>
+                    { let from_py_with: fn(_) -> _ = #expr_path; from_py_with }
+                };
+                quote! {
                     Ok(#self_ty {
-                        #ident: _pyo3::impl_::frompyobject::extract_struct_field(obj, #struct_name, #field_name)?
+                        #ident: #pyo3_path::impl_::frompyobject::extract_struct_field_with(#extractor, obj, #struct_name, #field_name)?
                     })
-                },
-                Some(FromPyWithAttribute {
-                    value: expr_path, ..
-                }) => quote! {
+                }
+            } else {
+                quote! {
                     Ok(#self_ty {
-                        #ident: _pyo3::impl_::frompyobject::extract_struct_field_with(#expr_path as fn(_) -> _, obj, #struct_name, #field_name)?
+                        #ident: #pyo3_path::impl_::frompyobject::extract_struct_field(obj, #struct_name, #field_name)?
                     })
-                },
+                }
+            }
+        } else if let Some(FromPyWithAttribute {
+            kw,
+            value: expr_path,
+        }) = from_py_with
+        {
+            let extractor = quote_spanned! { kw.span =>
+                { let from_py_with: fn(_) -> _ = #expr_path; from_py_with }
+            };
+            quote! {
+                #pyo3_path::impl_::frompyobject::extract_tuple_struct_field_with(#extractor, obj, #struct_name, 0).map(#self_ty)
             }
         } else {
-            match from_py_with {
-                None => quote!(
-                    _pyo3::impl_::frompyobject::extract_tuple_struct_field(obj, #struct_name, 0).map(#self_ty)
-                ),
-                Some(FromPyWithAttribute {
-                    value: expr_path, ..
-                }) => quote! (
-                    _pyo3::impl_::frompyobject::extract_tuple_struct_field_with(#expr_path as fn(_) -> _, obj, #struct_name, 0).map(#self_ty)
-                ),
+            quote! {
+                #pyo3_path::impl_::frompyobject::extract_tuple_struct_field(obj, #struct_name, 0).map(#self_ty)
             }
         }
     }
 
-    fn build_tuple_struct(&self, struct_fields: &[TupleStructField]) -> TokenStream {
+    fn build_tuple_struct(&self, struct_fields: &[TupleStructField], ctx: &Ctx) -> TokenStream {
+        let Ctx { pyo3_path, .. } = ctx;
         let self_ty = &self.path;
         let struct_name = &self.name();
         let field_idents: Vec<_> = (0..struct_fields.len())
             .map(|i| format_ident!("arg{}", i))
             .collect();
         let fields = struct_fields.iter().zip(&field_idents).enumerate().map(|(index, (field, ident))| {
-            match &field.from_py_with {
-                None => quote!(
-                    _pyo3::impl_::frompyobject::extract_tuple_struct_field(&#ident, #struct_name, #index)?
-                ),
-                Some(FromPyWithAttribute {
-                    value: expr_path, ..
-                }) => quote! (
-                    _pyo3::impl_::frompyobject::extract_tuple_struct_field_with(#expr_path as fn(_) -> _, &#ident, #struct_name, #index)?
-                ),
-            }
+            if let Some(FromPyWithAttribute {
+                kw,
+                value: expr_path, ..
+            }) = &field.from_py_with {
+                let extractor = quote_spanned! { kw.span =>
+                    { let from_py_with: fn(_) -> _ = #expr_path; from_py_with }
+                };
+               quote! {
+                    #pyo3_path::impl_::frompyobject::extract_tuple_struct_field_with(#extractor, &#ident, #struct_name, #index)?
+               }
+            } else {
+                quote!{
+                    #pyo3_path::impl_::frompyobject::extract_tuple_struct_field(&#ident, #struct_name, #index)?
+            }}
         });
+
         quote!(
-            match obj.extract() {
+            match #pyo3_path::types::PyAnyMethods::extract(obj) {
                 ::std::result::Result::Ok((#(#field_idents),*)) => ::std::result::Result::Ok(#self_ty(#(#fields),*)),
                 ::std::result::Result::Err(err) => ::std::result::Result::Err(err),
             }
         )
     }
 
-    fn build_struct(&self, struct_fields: &[NamedStructField<'_>]) -> TokenStream {
+    fn build_struct(&self, struct_fields: &[NamedStructField<'_>], ctx: &Ctx) -> TokenStream {
+        let Ctx { pyo3_path, .. } = ctx;
         let self_ty = &self.path;
-        let struct_name = &self.name();
-        let mut fields: Punctuated<TokenStream, syn::Token![,]> = Punctuated::new();
+        let struct_name = self.name();
+        let mut fields: Punctuated<TokenStream, Token![,]> = Punctuated::new();
         for field in struct_fields {
-            let ident = &field.ident;
-            let field_name = ident.to_string();
-            let getter = match field.getter.as_ref().unwrap_or(&FieldGetter::GetAttr(None)) {
-                FieldGetter::GetAttr(Some(name)) => {
-                    quote!(getattr(_pyo3::intern!(obj.py(), #name)))
+            let ident = field.ident;
+            let field_name = ident.unraw().to_string();
+            let getter = match field
+                .getter
+                .as_ref()
+                .unwrap_or(&FieldGetter::GetAttr(parse_quote!(attribute), None))
+            {
+                FieldGetter::GetAttr(_, Some(name)) => {
+                    quote!(#pyo3_path::types::PyAnyMethods::getattr(obj, #pyo3_path::intern!(obj.py(), #name)))
                 }
-                FieldGetter::GetAttr(None) => {
-                    quote!(getattr(_pyo3::intern!(obj.py(), #field_name)))
+                FieldGetter::GetAttr(_, None) => {
+                    let name = self
+                        .rename_rule
+                        .map(|rule| utils::apply_renaming_rule(rule, &field_name));
+                    let name = name.as_deref().unwrap_or(&field_name);
+                    quote!(#pyo3_path::types::PyAnyMethods::getattr(obj, #pyo3_path::intern!(obj.py(), #name)))
                 }
-                FieldGetter::GetItem(Some(syn::Lit::Str(key))) => {
-                    quote!(get_item(_pyo3::intern!(obj.py(), #key)))
+                FieldGetter::GetItem(_, Some(syn::Lit::Str(key))) => {
+                    quote!(#pyo3_path::types::PyAnyMethods::get_item(obj, #pyo3_path::intern!(obj.py(), #key)))
                 }
-                FieldGetter::GetItem(Some(key)) => quote!(get_item(#key)),
-                FieldGetter::GetItem(None) => {
-                    quote!(get_item(_pyo3::intern!(obj.py(), #field_name)))
+                FieldGetter::GetItem(_, Some(key)) => {
+                    quote!(#pyo3_path::types::PyAnyMethods::get_item(obj, #key))
                 }
-            };
-            let extractor = match &field.from_py_with {
-                None => {
-                    quote!(_pyo3::impl_::frompyobject::extract_struct_field(&obj.#getter?, #struct_name, #field_name)?)
-                }
-                Some(FromPyWithAttribute {
-                    value: expr_path, ..
-                }) => {
-                    quote! (_pyo3::impl_::frompyobject::extract_struct_field_with(#expr_path as fn(_) -> _, &obj.#getter?, #struct_name, #field_name)?)
+                FieldGetter::GetItem(_, None) => {
+                    let name = self
+                        .rename_rule
+                        .map(|rule| utils::apply_renaming_rule(rule, &field_name));
+                    let name = name.as_deref().unwrap_or(&field_name);
+                    quote!(#pyo3_path::types::PyAnyMethods::get_item(obj, #pyo3_path::intern!(obj.py(), #name)))
                 }
             };
+            let extractor = if let Some(FromPyWithAttribute {
+                kw,
+                value: expr_path,
+            }) = &field.from_py_with
+            {
+                let extractor = quote_spanned! { kw.span =>
+                    { let from_py_with: fn(_) -> _ = #expr_path; from_py_with }
+                };
+                quote! (#pyo3_path::impl_::frompyobject::extract_struct_field_with(#extractor, &#getter?, #struct_name, #field_name)?)
+            } else {
+                quote!(#pyo3_path::impl_::frompyobject::extract_struct_field(&value, #struct_name, #field_name)?)
+            };
+            let extracted = if let Some(default) = &field.default {
+                let default_expr = if let Some(default_expr) = &default.value {
+                    default_expr.to_token_stream()
+                } else {
+                    quote!(::std::default::Default::default())
+                };
+                quote!(if let ::std::result::Result::Ok(value) = #getter {
+                    #extractor
+                } else {
+                    #default_expr
+                })
+            } else {
+                quote!({
+                    let value = #getter?;
+                    #extractor
+                })
+            };
 
-            fields.push(quote!(#ident: #extractor));
+            fields.push(quote!(#ident: #extracted));
         }
-        quote!(::std::result::Result::Ok(#self_ty{#fields}))
-    }
-}
-
-#[derive(Default)]
-struct ContainerOptions {
-    /// Treat the Container as a Wrapper, directly extract its fields from the input object.
-    transparent: bool,
-    /// Force every field to be extracted from item of source Python object.
-    from_item_all: Option<attributes::kw::from_item_all>,
-    /// Change the name of an enum variant in the generated error message.
-    annotation: Option<syn::LitStr>,
-    /// Change the path for the pyo3 crate
-    krate: Option<CrateAttribute>,
-}
-
-/// Attributes for deriving FromPyObject scoped on containers.
-enum ContainerPyO3Attribute {
-    /// Treat the Container as a Wrapper, directly extract its fields from the input object.
-    Transparent(attributes::kw::transparent),
-    /// Force every field to be extracted from item of source Python object.
-    ItemAll(attributes::kw::from_item_all),
-    /// Change the name of an enum variant in the generated error message.
-    ErrorAnnotation(LitStr),
-    /// Change the path for the pyo3 crate
-    Crate(CrateAttribute),
-}
 
-impl Parse for ContainerPyO3Attribute {
-    fn parse(input: ParseStream<'_>) -> Result<Self> {
-        let lookahead = input.lookahead1();
-        if lookahead.peek(attributes::kw::transparent) {
-            let kw: attributes::kw::transparent = input.parse()?;
-            Ok(ContainerPyO3Attribute::Transparent(kw))
-        } else if lookahead.peek(attributes::kw::from_item_all) {
-            let kw: attributes::kw::from_item_all = input.parse()?;
-            Ok(ContainerPyO3Attribute::ItemAll(kw))
-        } else if lookahead.peek(attributes::kw::annotation) {
-            let _: attributes::kw::annotation = input.parse()?;
-            let _: Token![=] = input.parse()?;
-            input.parse().map(ContainerPyO3Attribute::ErrorAnnotation)
-        } else if lookahead.peek(Token![crate]) {
-            input.parse().map(ContainerPyO3Attribute::Crate)
-        } else {
-            Err(lookahead.error())
-        }
+        quote!(::std::result::Result::Ok(#self_ty{#fields}))
     }
-}
 
-impl ContainerOptions {
-    fn from_attrs(attrs: &[Attribute]) -> Result<Self> {
-        let mut options = ContainerOptions::default();
-
-        for attr in attrs {
-            if let Some(pyo3_attrs) = get_pyo3_options(attr)? {
-                for pyo3_attr in pyo3_attrs {
-                    match pyo3_attr {
-                        ContainerPyO3Attribute::Transparent(kw) => {
-                            ensure_spanned!(
-                                !options.transparent,
-                                kw.span() => "`transparent` may only be provided once"
-                            );
-                            options.transparent = true;
-                        }
-                        ContainerPyO3Attribute::ItemAll(kw) => {
-                            ensure_spanned!(
-                                options.from_item_all.is_none(),
-                                kw.span() => "`from_item_all` may only be provided once"
-                            );
-                            options.from_item_all = Some(kw);
-                        }
-                        ContainerPyO3Attribute::ErrorAnnotation(lit_str) => {
-                            ensure_spanned!(
-                                options.annotation.is_none(),
-                                lit_str.span() => "`annotation` may only be provided once"
-                            );
-                            options.annotation = Some(lit_str);
-                        }
-                        ContainerPyO3Attribute::Crate(path) => {
-                            ensure_spanned!(
-                                options.krate.is_none(),
-                                path.span() => "`crate` may only be provided once"
-                            );
-                            options.krate = Some(path);
-                        }
-                    }
-                }
+    #[cfg(feature = "experimental-inspect")]
+    fn input_type(&self, ctx: &Ctx) -> TokenStream {
+        let pyo3_crate_path = &ctx.pyo3_path;
+        match &self.ty {
+            ContainerType::StructNewtype(_, from_py_with, ty) => {
+                Self::field_input_type(from_py_with, ty, ctx)
             }
-        }
-        Ok(options)
-    }
-}
-
-/// Attributes for deriving FromPyObject scoped on fields.
-#[derive(Clone, Debug)]
-struct FieldPyO3Attributes {
-    getter: Option<FieldGetter>,
-    from_py_with: Option<FromPyWithAttribute>,
-}
-
-#[derive(Clone, Debug)]
-enum FieldGetter {
-    GetItem(Option<syn::Lit>),
-    GetAttr(Option<LitStr>),
-}
-
-enum FieldPyO3Attribute {
-    Getter(FieldGetter),
-    FromPyWith(FromPyWithAttribute),
-}
-
-impl Parse for FieldPyO3Attribute {
-    fn parse(input: ParseStream<'_>) -> Result<Self> {
-        let lookahead = input.lookahead1();
-        if lookahead.peek(attributes::kw::attribute) {
-            let _: attributes::kw::attribute = input.parse()?;
-            if input.peek(syn::token::Paren) {
-                let content;
-                let _ = parenthesized!(content in input);
-                let attr_name: LitStr = content.parse()?;
-                if !content.is_empty() {
-                    return Err(content.error(
-                        "expected at most one argument: `attribute` or `attribute(\"name\")`",
-                    ));
-                }
-                ensure_spanned!(
-                    !attr_name.value().is_empty(),
-                    attr_name.span() => "attribute name cannot be empty"
-                );
-                Ok(FieldPyO3Attribute::Getter(FieldGetter::GetAttr(Some(
-                    attr_name,
-                ))))
-            } else {
-                Ok(FieldPyO3Attribute::Getter(FieldGetter::GetAttr(None)))
+            ContainerType::TupleNewtype(from_py_with, ty) => {
+                Self::field_input_type(from_py_with, ty, ctx)
             }
-        } else if lookahead.peek(attributes::kw::item) {
-            let _: attributes::kw::item = input.parse()?;
-            if input.peek(syn::token::Paren) {
-                let content;
-                let _ = parenthesized!(content in input);
-                let key = content.parse()?;
-                if !content.is_empty() {
-                    return Err(
-                        content.error("expected at most one argument: `item` or `item(key)`")
-                    );
-                }
-                Ok(FieldPyO3Attribute::Getter(FieldGetter::GetItem(Some(key))))
-            } else {
-                Ok(FieldPyO3Attribute::Getter(FieldGetter::GetItem(None)))
+            ContainerType::Tuple(tups) => {
+                let elements = tups.iter().map(|TupleStructField { from_py_with, ty }| {
+                    Self::field_input_type(from_py_with, ty, ctx)
+                });
+                quote! { #pyo3_crate_path::inspect::TypeHint::subscript(&#pyo3_crate_path::inspect::TypeHint::builtin("tuple"), &[#(#elements),*]) }
+            }
+            ContainerType::Struct(_) => {
+                // TODO: implement using a Protocol?
+                quote! { #pyo3_crate_path::inspect::TypeHint::module_attr("_typeshed", "Incomplete") }
             }
-        } else if lookahead.peek(attributes::kw::from_py_with) {
-            input.parse().map(FieldPyO3Attribute::FromPyWith)
-        } else {
-            Err(lookahead.error())
         }
     }
-}
 
-impl FieldPyO3Attributes {
-    /// Extract the field attributes.
-    fn from_attrs(attrs: &[Attribute]) -> Result<Self> {
-        let mut getter = None;
-        let mut from_py_with = None;
-
-        for attr in attrs {
-            if let Some(pyo3_attrs) = get_pyo3_options(attr)? {
-                for pyo3_attr in pyo3_attrs {
-                    match pyo3_attr {
-                        FieldPyO3Attribute::Getter(field_getter) => {
-                            ensure_spanned!(
-                                getter.is_none(),
-                                attr.span() => "only one of `attribute` or `item` can be provided"
-                            );
-                            getter = Some(field_getter);
-                        }
-                        FieldPyO3Attribute::FromPyWith(from_py_with_attr) => {
-                            ensure_spanned!(
-                                from_py_with.is_none(),
-                                attr.span() => "`from_py_with` may only be provided once"
-                            );
-                            from_py_with = Some(from_py_with_attr);
-                        }
-                    }
-                }
-            }
+    #[cfg(feature = "experimental-inspect")]
+    fn field_input_type(
+        from_py_with: &Option<FromPyWithAttribute>,
+        ty: &syn::Type,
+        ctx: &Ctx,
+    ) -> TokenStream {
+        let pyo3_crate_path = &ctx.pyo3_path;
+        if from_py_with.is_some() {
+            // We don't know what from_py_with is doing
+            quote! { #pyo3_crate_path::inspect::TypeHint::module_attr("_typeshed", "Incomplete") }
+        } else {
+            let mut ty = ty.clone();
+            elide_lifetimes(&mut ty);
+            quote! { <#ty as #pyo3_crate_path::FromPyObject<'_, '_>>::INPUT_TYPE }
         }
-
-        Ok(FieldPyO3Attributes {
-            getter,
-            from_py_with,
-        })
     }
 }
 
@@ -563,57 +516,91 @@ fn verify_and_get_lifetime(generics: &syn::Generics) -> Result<Option<&syn::Life
 ///   * Derivation for structs with generic fields like `struct<T> Foo(T)`
 ///     adds `T: FromPyObject` on the derived implementation.
 pub fn build_derive_from_pyobject(tokens: &DeriveInput) -> Result<TokenStream> {
+    let options = ContainerAttributes::from_attrs(&tokens.attrs)?;
+    let ctx = &Ctx::new(&options.krate, None);
+    let Ctx { pyo3_path, .. } = &ctx;
+
+    let (_, ty_generics, _) = tokens.generics.split_for_impl();
     let mut trait_generics = tokens.generics.clone();
-    let generics = &tokens.generics;
-    let lt_param = if let Some(lt) = verify_and_get_lifetime(generics)? {
+    let lt_param = if let Some(lt) = verify_and_get_lifetime(&trait_generics)? {
         lt.clone()
     } else {
         trait_generics.params.push(parse_quote!('py));
         parse_quote!('py)
     };
-    let mut where_clause: syn::WhereClause = parse_quote!(where);
-    for param in generics.type_params() {
+    let (impl_generics, _, where_clause) = trait_generics.split_for_impl();
+
+    let mut where_clause = where_clause.cloned().unwrap_or_else(|| parse_quote!(where));
+    for param in trait_generics.type_params() {
         let gen_ident = &param.ident;
         where_clause
             .predicates
-            .push(parse_quote!(#gen_ident: FromPyObject<#lt_param>))
+            .push(parse_quote!(#gen_ident: #pyo3_path::conversion::FromPyObjectOwned<#lt_param>))
     }
-    let options = ContainerOptions::from_attrs(&tokens.attrs)?;
-    let krate = get_pyo3_crate(&options.krate);
+
     let derives = match &tokens.data {
         syn::Data::Enum(en) => {
-            if options.transparent || options.annotation.is_some() {
+            if options.transparent.is_some() || options.annotation.is_some() {
                 bail_spanned!(tokens.span() => "`transparent` or `annotation` is not supported \
                                                 at top level for enums");
             }
-            let en = Enum::new(en, &tokens.ident)?;
-            en.build()
+            let en = Enum::new(en, &tokens.ident, options.clone())?;
+            en.build(ctx)
         }
         syn::Data::Struct(st) => {
             if let Some(lit_str) = &options.annotation {
                 bail_spanned!(lit_str.span() => "`annotation` is unsupported for structs");
             }
             let ident = &tokens.ident;
-            let st = Container::new(&st.fields, parse_quote!(#ident), options)?;
-            st.build()
+            let st = Container::new(&st.fields, parse_quote!(#ident), options.clone())?;
+            st.build(ctx)
         }
         syn::Data::Union(_) => bail_spanned!(
             tokens.span() => "#[derive(FromPyObject)] is not supported for unions"
         ),
     };
 
-    let ident = &tokens.ident;
-    Ok(quote!(
-        const _: () = {
-            use #krate as _pyo3;
-            use _pyo3::prelude::PyAnyMethods;
-
-            #[automatically_derived]
-            impl #trait_generics _pyo3::FromPyObject<#lt_param> for #ident #generics #where_clause {
-                fn extract_bound(obj: &_pyo3::Bound<#lt_param, _pyo3::PyAny>) -> _pyo3::PyResult<Self>  {
-                    #derives
+    #[cfg(feature = "experimental-inspect")]
+    let input_type = {
+        let pyo3_crate_path = &ctx.pyo3_path;
+        let input_type = if tokens
+            .generics
+            .params
+            .iter()
+            .all(|p| matches!(p, syn::GenericParam::Lifetime(_)))
+        {
+            match &tokens.data {
+                syn::Data::Enum(en) => Enum::new(en, &tokens.ident, options)?.input_type(ctx),
+                syn::Data::Struct(st) => {
+                    let ident = &tokens.ident;
+                    Container::new(&st.fields, parse_quote!(#ident), options.clone())?
+                        .input_type(ctx)
+                }
+                syn::Data::Union(_) => {
+                    // Not supported at this point
+                    quote! { #pyo3_crate_path::inspect::TypeHint::module_attr("_typeshed", "Incomplete") }
                 }
             }
+        } else {
+            // We don't know how to deal with generic parameters
+            // Blocked by https://github.com/rust-lang/rust/issues/76560
+            quote! { #pyo3_crate_path::inspect::TypeHint::module_attr("_typeshed", "Incomplete") }
         };
+        quote! { const INPUT_TYPE: #pyo3_crate_path::inspect::TypeHint = #input_type; }
+    };
+    #[cfg(not(feature = "experimental-inspect"))]
+    let input_type = quote! {};
+
+    let ident = &tokens.ident;
+    Ok(quote!(
+        #[automatically_derived]
+        impl #impl_generics #pyo3_path::FromPyObject<'_, #lt_param> for #ident #ty_generics #where_clause {
+            type Error = #pyo3_path::PyErr;
+            fn extract(obj: #pyo3_path::Borrowed<'_, #lt_param, #pyo3_path::PyAny>) -> ::std::result::Result<Self, Self::Error> {
+                let obj: &#pyo3_path::Bound<'_, _> = &*obj;
+                #derives
+            }
+            #input_type
+        }
     ))
 }
diff --git a/pyo3-macros-backend/src/intopyobject.rs b/pyo3-macros-backend/src/intopyobject.rs
new file mode 100644
index 00000000000..75dfe054fa7
--- /dev/null
+++ b/pyo3-macros-backend/src/intopyobject.rs
@@ -0,0 +1,631 @@
+use crate::attributes::{IntoPyWithAttribute, RenamingRule};
+use crate::derive_attributes::{ContainerAttributes, FieldAttributes};
+#[cfg(feature = "experimental-inspect")]
+use crate::introspection::elide_lifetimes;
+use crate::utils::{self, Ctx};
+use proc_macro2::{Span, TokenStream};
+use quote::{format_ident, quote, quote_spanned, ToTokens};
+use syn::ext::IdentExt;
+use syn::spanned::Spanned as _;
+use syn::{parse_quote, DataEnum, DeriveInput, Fields, Ident, Index, Result};
+
+struct ItemOption(Option<syn::Lit>);
+
+enum IntoPyObjectTypes {
+    Transparent(syn::Type),
+    Opaque {
+        target: TokenStream,
+        output: TokenStream,
+        error: TokenStream,
+    },
+}
+
+struct IntoPyObjectImpl {
+    types: IntoPyObjectTypes,
+    body: TokenStream,
+}
+
+struct NamedStructField<'a> {
+    ident: &'a syn::Ident,
+    field: &'a syn::Field,
+    item: Option<ItemOption>,
+    into_py_with: Option<IntoPyWithAttribute>,
+}
+
+struct TupleStructField<'a> {
+    field: &'a syn::Field,
+    into_py_with: Option<IntoPyWithAttribute>,
+}
+
+/// Container Style
+///
+/// Covers Structs, Tuplestructs and corresponding Newtypes.
+enum ContainerType<'a> {
+    /// Struct Container, e.g. `struct Foo { a: String }`
+    ///
+    /// Variant contains the list of field identifiers and the corresponding extraction call.
+    Struct(Vec<NamedStructField<'a>>),
+    /// Newtype struct container, e.g. `#[transparent] struct Foo { a: String }`
+    ///
+    /// The field specified by the identifier is extracted directly from the object.
+    StructNewtype(&'a syn::Field),
+    /// Tuple struct, e.g. `struct Foo(String)`.
+    ///
+    /// Variant contains a list of conversion methods for each of the fields that are directly
+    ///  extracted from the tuple.
+    Tuple(Vec<TupleStructField<'a>>),
+    /// Tuple newtype, e.g. `#[transparent] struct Foo(String)`
+    ///
+    /// The wrapped field is directly extracted from the object.
+    TupleNewtype(&'a syn::Field),
+}
+
+/// Data container
+///
+/// Either describes a struct or an enum variant.
+struct Container<'a, const REF: bool> {
+    path: syn::Path,
+    receiver: Option<Ident>,
+    ty: ContainerType<'a>,
+    rename_rule: Option<RenamingRule>,
+}
+
+/// Construct a container based on fields, identifier and attributes.
+impl<'a, const REF: bool> Container<'a, REF> {
+    ///
+    /// Fails if the variant has no fields or incompatible attributes.
+    fn new(
+        receiver: Option<Ident>,
+        fields: &'a Fields,
+        path: syn::Path,
+        options: ContainerAttributes,
+    ) -> Result<Self> {
+        let style = match fields {
+            Fields::Unnamed(unnamed) if !unnamed.unnamed.is_empty() => {
+                ensure_spanned!(
+                    options.rename_all.is_none(),
+                    options.rename_all.span() => "`rename_all` is useless on tuple structs and variants."
+                );
+                let mut tuple_fields = unnamed
+                    .unnamed
+                    .iter()
+                    .map(|field| {
+                        let attrs = FieldAttributes::from_attrs(&field.attrs)?;
+                        ensure_spanned!(
+                            attrs.getter.is_none(),
+                            attrs.getter.unwrap().span() => "`item` and `attribute` are not permitted on tuple struct elements."
+                        );
+                        Ok(TupleStructField {
+                            field,
+                            into_py_with: attrs.into_py_with,
+                        })
+                    })
+                    .collect::<Result<Vec<_>>>()?;
+                if tuple_fields.len() == 1 {
+                    // Always treat a 1-length tuple struct as "transparent", even without the
+                    // explicit annotation.
+                    let TupleStructField {
+                        field,
+                        into_py_with,
+                    } = tuple_fields.pop().unwrap();
+                    ensure_spanned!(
+                        into_py_with.is_none(),
+                        into_py_with.span() => "`into_py_with` is not permitted on `transparent` structs"
+                    );
+                    ContainerType::TupleNewtype(field)
+                } else if options.transparent.is_some() {
+                    bail_spanned!(
+                        fields.span() => "transparent structs and variants can only have 1 field"
+                    );
+                } else {
+                    ContainerType::Tuple(tuple_fields)
+                }
+            }
+            Fields::Named(named) if !named.named.is_empty() => {
+                if options.transparent.is_some() {
+                    ensure_spanned!(
+                        named.named.iter().count() == 1,
+                        fields.span() => "transparent structs and variants can only have 1 field"
+                    );
+
+                    let field = named.named.iter().next().unwrap();
+                    let attrs = FieldAttributes::from_attrs(&field.attrs)?;
+                    ensure_spanned!(
+                        attrs.getter.is_none(),
+                        attrs.getter.unwrap().span() => "`transparent` structs may not have `item` nor `attribute` for the inner field"
+                    );
+                    ensure_spanned!(
+                        options.rename_all.is_none(),
+                        options.rename_all.span() => "`rename_all` is not permitted on `transparent` structs and variants"
+                    );
+                    ensure_spanned!(
+                        attrs.into_py_with.is_none(),
+                        attrs.into_py_with.span() => "`into_py_with` is not permitted on `transparent` structs or variants"
+                    );
+                    ContainerType::StructNewtype(field)
+                } else {
+                    let struct_fields = named
+                        .named
+                        .iter()
+                        .map(|field| {
+                            let ident = field
+                                .ident
+                                .as_ref()
+                                .expect("Named fields should have identifiers");
+
+                            let attrs = FieldAttributes::from_attrs(&field.attrs)?;
+
+                            Ok(NamedStructField {
+                                ident,
+                                field,
+                                item: attrs.getter.and_then(|getter| match getter {
+                                    crate::derive_attributes::FieldGetter::GetItem(_, lit) => {
+                                        Some(ItemOption(lit))
+                                    }
+                                    crate::derive_attributes::FieldGetter::GetAttr(_, _) => None,
+                                }),
+                                into_py_with: attrs.into_py_with,
+                            })
+                        })
+                        .collect::<Result<Vec<_>>>()?;
+                    ContainerType::Struct(struct_fields)
+                }
+            }
+            _ => bail_spanned!(
+                fields.span() => "cannot derive `IntoPyObject` for empty structs"
+            ),
+        };
+
+        let v = Container {
+            path,
+            receiver,
+            ty: style,
+            rename_rule: options.rename_all.map(|v| v.value.rule),
+        };
+        Ok(v)
+    }
+
+    fn match_pattern(&self) -> TokenStream {
+        let path = &self.path;
+        let pattern = match &self.ty {
+            ContainerType::Struct(fields) => fields
+                .iter()
+                .enumerate()
+                .map(|(i, f)| {
+                    let ident = f.ident;
+                    let new_ident = format_ident!("arg{i}");
+                    quote! {#ident: #new_ident,}
+                })
+                .collect::<TokenStream>(),
+            ContainerType::StructNewtype(field) => {
+                let ident = field.ident.as_ref().unwrap();
+                quote!(#ident: arg0)
+            }
+            ContainerType::Tuple(fields) => {
+                let i = (0..fields.len()).map(Index::from);
+                let idents = (0..fields.len()).map(|i| format_ident!("arg{i}"));
+                quote! { #(#i: #idents,)* }
+            }
+            ContainerType::TupleNewtype(_) => quote!(0: arg0),
+        };
+
+        quote! { #path{ #pattern } }
+    }
+
+    /// Build derivation body for a struct.
+    fn build(&self, ctx: &Ctx) -> IntoPyObjectImpl {
+        match &self.ty {
+            ContainerType::StructNewtype(field) | ContainerType::TupleNewtype(field) => {
+                self.build_newtype_struct(field, ctx)
+            }
+            ContainerType::Tuple(fields) => self.build_tuple_struct(fields, ctx),
+            ContainerType::Struct(fields) => self.build_struct(fields, ctx),
+        }
+    }
+
+    fn build_newtype_struct(&self, field: &syn::Field, ctx: &Ctx) -> IntoPyObjectImpl {
+        let Ctx { pyo3_path, .. } = ctx;
+        let ty = &field.ty;
+
+        let unpack = self
+            .receiver
+            .as_ref()
+            .map(|i| {
+                let pattern = self.match_pattern();
+                quote! { let #pattern = #i;}
+            })
+            .unwrap_or_default();
+
+        IntoPyObjectImpl {
+            types: IntoPyObjectTypes::Transparent(ty.clone()),
+            body: quote_spanned! { ty.span() =>
+                #unpack
+                #pyo3_path::conversion::IntoPyObject::into_pyobject(arg0, py)
+            },
+        }
+    }
+
+    fn build_struct(&self, fields: &[NamedStructField<'_>], ctx: &Ctx) -> IntoPyObjectImpl {
+        let Ctx { pyo3_path, .. } = ctx;
+
+        let unpack = self
+            .receiver
+            .as_ref()
+            .map(|i| {
+                let pattern = self.match_pattern();
+                quote! { let #pattern = #i;}
+            })
+            .unwrap_or_default();
+
+        let setter = fields
+            .iter()
+            .enumerate()
+            .map(|(i, f)| {
+                let key = f
+                    .item
+                    .as_ref()
+                    .and_then(|item| item.0.as_ref())
+                    .map(|item| item.into_token_stream())
+                    .unwrap_or_else(|| {
+                        let name = f.ident.unraw().to_string();
+                        self.rename_rule.map(|rule| utils::apply_renaming_rule(rule, &name)).unwrap_or(name).into_token_stream()
+                    });
+                let value = Ident::new(&format!("arg{i}"), f.field.ty.span());
+
+                if let Some(expr_path) = f.into_py_with.as_ref().map(|i|&i.value) {
+                    let cow = if REF {
+                        quote!(::std::borrow::Cow::Borrowed(#value))
+                    } else {
+                        quote!(::std::borrow::Cow::Owned(#value))
+                    };
+                    quote! {
+                        let into_py_with: fn(::std::borrow::Cow<'_, _>, #pyo3_path::Python<'py>) -> #pyo3_path::PyResult<#pyo3_path::Bound<'py, #pyo3_path::PyAny>> = #expr_path;
+                        #pyo3_path::types::PyDictMethods::set_item(&dict, #key, into_py_with(#cow, py)?)?;
+                    }
+                } else {
+                    quote! {
+                        #pyo3_path::types::PyDictMethods::set_item(&dict, #key, #value)?;
+                    }
+                }
+            })
+            .collect::<TokenStream>();
+
+        IntoPyObjectImpl {
+            types: IntoPyObjectTypes::Opaque {
+                target: quote!(#pyo3_path::types::PyDict),
+                output: quote!(#pyo3_path::Bound<'py, Self::Target>),
+                error: quote!(#pyo3_path::PyErr),
+            },
+            body: quote! {
+                #unpack
+                let dict = #pyo3_path::types::PyDict::new(py);
+                #setter
+                ::std::result::Result::Ok::<_, Self::Error>(dict)
+            },
+        }
+    }
+
+    fn build_tuple_struct(&self, fields: &[TupleStructField<'_>], ctx: &Ctx) -> IntoPyObjectImpl {
+        let Ctx { pyo3_path, .. } = ctx;
+
+        let unpack = self
+            .receiver
+            .as_ref()
+            .map(|i| {
+                let pattern = self.match_pattern();
+                quote! { let #pattern = #i;}
+            })
+            .unwrap_or_default();
+
+        let setter = fields
+            .iter()
+            .enumerate()
+            .map(|(i, f)| {
+                let ty = &f.field.ty;
+                let value = Ident::new(&format!("arg{i}"), f.field.ty.span());
+
+                if let Some(expr_path) = f.into_py_with.as_ref().map(|i|&i.value) {
+                    let cow = if REF {
+                        quote!(::std::borrow::Cow::Borrowed(#value))
+                    } else {
+                        quote!(::std::borrow::Cow::Owned(#value))
+                    };
+                    quote_spanned! { ty.span() =>
+                        {
+                            let into_py_with: fn(::std::borrow::Cow<'_, _>, #pyo3_path::Python<'py>) -> #pyo3_path::PyResult<#pyo3_path::Bound<'py, #pyo3_path::PyAny>> = #expr_path;
+                            into_py_with(#cow, py)?
+                        },
+                    }
+                } else {
+                    quote_spanned! { ty.span() =>
+                        #pyo3_path::conversion::IntoPyObject::into_pyobject(#value, py)
+                            .map(#pyo3_path::BoundObject::into_any)
+                            .map(#pyo3_path::BoundObject::into_bound)?,
+                    }
+                }
+            })
+            .collect::<TokenStream>();
+
+        IntoPyObjectImpl {
+            types: IntoPyObjectTypes::Opaque {
+                target: quote!(#pyo3_path::types::PyTuple),
+                output: quote!(#pyo3_path::Bound<'py, Self::Target>),
+                error: quote!(#pyo3_path::PyErr),
+            },
+            body: quote! {
+                #unpack
+                #pyo3_path::types::PyTuple::new(py, [#setter])
+            },
+        }
+    }
+
+    #[cfg(feature = "experimental-inspect")]
+    fn output_type(&self, ctx: &Ctx) -> TokenStream {
+        let pyo3_crate_path = &ctx.pyo3_path;
+        match &self.ty {
+            ContainerType::StructNewtype(field) | ContainerType::TupleNewtype(field) => {
+                Self::field_output_type(&None, &field.ty, ctx)
+            }
+            ContainerType::Tuple(tups) => {
+                let elements = tups.iter().map(
+                    |TupleStructField {
+                         into_py_with,
+                         field,
+                     }| {
+                        Self::field_output_type(into_py_with, &field.ty, ctx)
+                    },
+                );
+                quote! { #pyo3_crate_path::inspect::TypeHint::subscript(&#pyo3_crate_path::inspect::TypeHint::builtin("tuple"), &[#(#elements),*]) }
+            }
+            ContainerType::Struct(_) => {
+                // TODO: implement using a Protocol?
+                quote! { #pyo3_crate_path::inspect::TypeHint::module_attr("_typeshed", "Incomplete") }
+            }
+        }
+    }
+
+    #[cfg(feature = "experimental-inspect")]
+    fn field_output_type(
+        into_py_with: &Option<IntoPyWithAttribute>,
+        ty: &syn::Type,
+        ctx: &Ctx,
+    ) -> TokenStream {
+        let pyo3_crate_path = &ctx.pyo3_path;
+        if into_py_with.is_some() {
+            // We don't know what into_py_with is doing
+            quote! { #pyo3_crate_path::inspect::TypeHint::module_attr("_typeshed", "Incomplete") }
+        } else {
+            let mut ty = ty.clone();
+            elide_lifetimes(&mut ty);
+            quote! { <#ty as #pyo3_crate_path::IntoPyObject<'_>>::OUTPUT_TYPE }
+        }
+    }
+}
+
+/// Describes derivation input of an enum.
+struct Enum<'a, const REF: bool> {
+    variants: Vec<Container<'a, REF>>,
+}
+
+impl<'a, const REF: bool> Enum<'a, REF> {
+    /// Construct a new enum representation.
+    ///
+    /// `data_enum` is the `syn` representation of the input enum, `ident` is the
+    /// `Identifier` of the enum.
+    fn new(data_enum: &'a DataEnum, ident: &'a Ident) -> Result<Self> {
+        ensure_spanned!(
+            !data_enum.variants.is_empty(),
+            ident.span() => "cannot derive `IntoPyObject` for empty enum"
+        );
+        let variants = data_enum
+            .variants
+            .iter()
+            .map(|variant| {
+                let attrs = ContainerAttributes::from_attrs(&variant.attrs)?;
+                let var_ident = &variant.ident;
+
+                ensure_spanned!(
+                    !variant.fields.is_empty(),
+                    variant.ident.span() => "cannot derive `IntoPyObject` for empty variants"
+                );
+
+                Container::new(
+                    None,
+                    &variant.fields,
+                    parse_quote!(#ident::#var_ident),
+                    attrs,
+                )
+            })
+            .collect::<Result<Vec<_>>>()?;
+
+        Ok(Enum { variants })
+    }
+
+    /// Build derivation body for enums.
+    fn build(&self, ctx: &Ctx) -> IntoPyObjectImpl {
+        let Ctx { pyo3_path, .. } = ctx;
+
+        let variants = self
+            .variants
+            .iter()
+            .map(|v| {
+                let IntoPyObjectImpl { body, .. } = v.build(ctx);
+                let pattern = v.match_pattern();
+                quote! {
+                    #pattern => {
+                        {#body}
+                            .map(#pyo3_path::BoundObject::into_any)
+                            .map(#pyo3_path::BoundObject::into_bound)
+                            .map_err(::std::convert::Into::<#pyo3_path::PyErr>::into)
+                    }
+                }
+            })
+            .collect::<TokenStream>();
+
+        IntoPyObjectImpl {
+            types: IntoPyObjectTypes::Opaque {
+                target: quote!(#pyo3_path::types::PyAny),
+                output: quote!(#pyo3_path::Bound<'py, <Self as #pyo3_path::conversion::IntoPyObject<'py>>::Target>),
+                error: quote!(#pyo3_path::PyErr),
+            },
+            body: quote! {
+                match self {
+                    #variants
+                }
+            },
+        }
+    }
+
+    #[cfg(feature = "experimental-inspect")]
+    fn output_type(&self, ctx: &Ctx) -> TokenStream {
+        let pyo3_crate_path = &ctx.pyo3_path;
+        let variants = self.variants.iter().map(|var| var.output_type(ctx));
+        quote! {
+            #pyo3_crate_path::inspect::TypeHint::union(&[#(#variants),*])
+        }
+    }
+}
+
+// if there is a `'py` lifetime, we treat it as the `Python<'py>` lifetime
+fn verify_and_get_lifetime(generics: &syn::Generics) -> Option<&syn::LifetimeParam> {
+    let mut lifetimes = generics.lifetimes();
+    lifetimes.find(|l| l.lifetime.ident == "py")
+}
+
+pub fn build_derive_into_pyobject<const REF: bool>(tokens: &DeriveInput) -> Result<TokenStream> {
+    let options = ContainerAttributes::from_attrs(&tokens.attrs)?;
+    let ctx = &Ctx::new(&options.krate, None);
+    let Ctx { pyo3_path, .. } = &ctx;
+
+    let (_, ty_generics, _) = tokens.generics.split_for_impl();
+    let mut trait_generics = tokens.generics.clone();
+    if REF {
+        trait_generics.params.push(parse_quote!('_a));
+    }
+    let lt_param = if let Some(lt) = verify_and_get_lifetime(&trait_generics) {
+        lt.clone()
+    } else {
+        trait_generics.params.push(parse_quote!('py));
+        parse_quote!('py)
+    };
+    let (impl_generics, _, where_clause) = trait_generics.split_for_impl();
+
+    let mut where_clause = where_clause.cloned().unwrap_or_else(|| parse_quote!(where));
+    for param in trait_generics.type_params() {
+        let gen_ident = &param.ident;
+        where_clause.predicates.push(if REF {
+            parse_quote!(&'_a #gen_ident: #pyo3_path::conversion::IntoPyObject<'py>)
+        } else {
+            parse_quote!(#gen_ident: #pyo3_path::conversion::IntoPyObject<'py>)
+        })
+    }
+
+    let IntoPyObjectImpl { types, body } = match &tokens.data {
+        syn::Data::Enum(en) => {
+            if options.transparent.is_some() {
+                bail_spanned!(tokens.span() => "`transparent` is not supported at top level for enums");
+            }
+            if let Some(rename_all) = options.rename_all {
+                bail_spanned!(rename_all.span() => "`rename_all` is not supported at top level for enums");
+            }
+            let en = Enum::<REF>::new(en, &tokens.ident)?;
+            en.build(ctx)
+        }
+        syn::Data::Struct(st) => {
+            let ident = &tokens.ident;
+            let st = Container::<REF>::new(
+                Some(Ident::new("self", Span::call_site())),
+                &st.fields,
+                parse_quote!(#ident),
+                options.clone(),
+            )?;
+            st.build(ctx)
+        }
+        syn::Data::Union(_) => bail_spanned!(
+            tokens.span() => "#[derive(`IntoPyObject`)] is not supported for unions"
+        ),
+    };
+
+    let (target, output, error) = match types {
+        IntoPyObjectTypes::Transparent(ty) => {
+            if REF {
+                (
+                    quote! { <&'_a #ty as #pyo3_path::IntoPyObject<'py>>::Target },
+                    quote! { <&'_a #ty as #pyo3_path::IntoPyObject<'py>>::Output },
+                    quote! { <&'_a #ty as #pyo3_path::IntoPyObject<'py>>::Error },
+                )
+            } else {
+                (
+                    quote! { <#ty as #pyo3_path::IntoPyObject<'py>>::Target },
+                    quote! { <#ty as #pyo3_path::IntoPyObject<'py>>::Output },
+                    quote! { <#ty as #pyo3_path::IntoPyObject<'py>>::Error },
+                )
+            }
+        }
+        IntoPyObjectTypes::Opaque {
+            target,
+            output,
+            error,
+        } => (target, output, error),
+    };
+
+    let ident = &tokens.ident;
+    let ident = if REF {
+        quote! { &'_a #ident}
+    } else {
+        quote! { #ident }
+    };
+
+    #[cfg(feature = "experimental-inspect")]
+    let output_type = {
+        let pyo3_crate_path = &ctx.pyo3_path;
+        let output_type = if tokens
+            .generics
+            .params
+            .iter()
+            .all(|p| matches!(p, syn::GenericParam::Lifetime(_)))
+        {
+            match &tokens.data {
+                syn::Data::Enum(en) => Enum::<REF>::new(en, &tokens.ident)?.output_type(ctx),
+                syn::Data::Struct(st) => {
+                    let ident = &tokens.ident;
+                    Container::<REF>::new(
+                        Some(Ident::new("self", Span::call_site())),
+                        &st.fields,
+                        parse_quote!(#ident),
+                        options,
+                    )?
+                    .output_type(ctx)
+                }
+                syn::Data::Union(_) => {
+                    // Not supported at this point
+                    quote! { #pyo3_crate_path::inspect::TypeHint::module_attr("_typeshed", "Incomplete") }
+                }
+            }
+        } else {
+            // We don't know how to deal with generic parameters
+            // Blocked by https://github.com/rust-lang/rust/issues/76560
+            quote! { #pyo3_crate_path::inspect::TypeHint::module_attr("_typeshed", "Incomplete") }
+        };
+        quote! { const OUTPUT_TYPE: #pyo3_path::inspect::TypeHint = #output_type; }
+    };
+    #[cfg(not(feature = "experimental-inspect"))]
+    let output_type = quote! {};
+
+    Ok(quote!(
+        #[automatically_derived]
+        impl #impl_generics #pyo3_path::conversion::IntoPyObject<#lt_param> for #ident #ty_generics #where_clause {
+            type Target = #target;
+            type Output = #output;
+            type Error = #error;
+            #output_type
+
+            fn into_pyobject(self, py: #pyo3_path::Python<#lt_param>) -> ::std::result::Result<
+                <Self as #pyo3_path::conversion::IntoPyObject<#lt_param>>::Output,
+                <Self as #pyo3_path::conversion::IntoPyObject<#lt_param>>::Error,
+            > {
+                #body
+            }
+        }
+    ))
+}
diff --git a/pyo3-macros-backend/src/introspection.rs b/pyo3-macros-backend/src/introspection.rs
new file mode 100644
index 00000000000..1aa53e516e0
--- /dev/null
+++ b/pyo3-macros-backend/src/introspection.rs
@@ -0,0 +1,666 @@
+//! Generates introspection data i.e. JSON strings in the .pyo3i0 section.
+//!
+//! There is a JSON per PyO3 proc macro (pyclass, pymodule, pyfunction...).
+//!
+//! These JSON blobs can refer to each others via the _PYO3_INTROSPECTION_ID constants
+//! providing unique ids for each element.
+//!
+//! The JSON blobs format must be synchronized with the `pyo3_introspection::introspection.rs::Chunk`
+//! type that is used to parse them.
+
+use crate::method::{FnArg, RegularArg};
+use crate::pyfunction::FunctionSignature;
+use crate::utils::PyO3CratePath;
+use proc_macro2::{Span, TokenStream};
+use quote::{format_ident, quote, ToTokens};
+use std::borrow::Cow;
+use std::collections::hash_map::DefaultHasher;
+use std::collections::HashMap;
+use std::hash::{Hash, Hasher};
+use std::mem::take;
+use std::sync::atomic::{AtomicUsize, Ordering};
+use syn::visit_mut::{visit_type_mut, VisitMut};
+use syn::{Attribute, Ident, Lifetime, ReturnType, Type, TypePath};
+
+static GLOBAL_COUNTER_FOR_UNIQUE_NAMES: AtomicUsize = AtomicUsize::new(0);
+
+#[allow(clippy::too_many_arguments)]
+pub fn module_introspection_code<'a>(
+    pyo3_crate_path: &PyO3CratePath,
+    name: &str,
+    members: impl IntoIterator<Item = &'a Ident>,
+    members_cfg_attrs: impl IntoIterator<Item = &'a Vec<Attribute>>,
+    incomplete: bool,
+) -> TokenStream {
+    IntrospectionNode::Map(
+        [
+            ("type", IntrospectionNode::String("module".into())),
+            ("id", IntrospectionNode::IntrospectionId(None)),
+            ("name", IntrospectionNode::String(name.into())),
+            (
+                "members",
+                IntrospectionNode::List(
+                    members
+                        .into_iter()
+                        .zip(members_cfg_attrs)
+                        .map(|(member, attributes)| AttributedIntrospectionNode {
+                            node: IntrospectionNode::IntrospectionId(Some(ident_to_type(member))),
+                            attributes,
+                        })
+                        .collect(),
+                ),
+            ),
+            ("incomplete", IntrospectionNode::Bool(incomplete)),
+        ]
+        .into(),
+    )
+    .emit(pyo3_crate_path)
+}
+
+pub fn class_introspection_code(
+    pyo3_crate_path: &PyO3CratePath,
+    ident: &Ident,
+    name: &str,
+) -> TokenStream {
+    IntrospectionNode::Map(
+        [
+            ("type", IntrospectionNode::String("class".into())),
+            (
+                "id",
+                IntrospectionNode::IntrospectionId(Some(ident_to_type(ident))),
+            ),
+            ("name", IntrospectionNode::String(name.into())),
+        ]
+        .into(),
+    )
+    .emit(pyo3_crate_path)
+}
+
+#[allow(clippy::too_many_arguments)]
+pub fn function_introspection_code(
+    pyo3_crate_path: &PyO3CratePath,
+    ident: Option<&Ident>,
+    name: &str,
+    signature: &FunctionSignature<'_>,
+    first_argument: Option<&'static str>,
+    returns: ReturnType,
+    decorators: impl IntoIterator<Item = String>,
+    parent: Option<&Type>,
+) -> TokenStream {
+    let mut desc = HashMap::from([
+        ("type", IntrospectionNode::String("function".into())),
+        ("name", IntrospectionNode::String(name.into())),
+        (
+            "arguments",
+            arguments_introspection_data(signature, first_argument, parent),
+        ),
+        (
+            "returns",
+            if let Some((_, returns)) = signature
+                .attribute
+                .as_ref()
+                .and_then(|attribute| attribute.value.returns.as_ref())
+            {
+                IntrospectionNode::String(returns.to_python().into())
+            } else {
+                match returns {
+                    ReturnType::Default => IntrospectionNode::ConstantType {
+                        name: "None",
+                        module: None,
+                    },
+                    ReturnType::Type(_, ty) => match *ty {
+                        Type::Tuple(t) if t.elems.is_empty() => {
+                            // () is converted to None in return types
+                            IntrospectionNode::ConstantType {
+                                name: "None",
+                                module: None,
+                            }
+                        }
+                        mut ty => {
+                            if let Some(class_type) = parent {
+                                replace_self(&mut ty, class_type);
+                            }
+                            elide_lifetimes(&mut ty);
+                            IntrospectionNode::OutputType {
+                                rust_type: ty,
+                                is_final: false,
+                            }
+                        }
+                    },
+                }
+            },
+        ),
+    ]);
+    if let Some(ident) = ident {
+        desc.insert(
+            "id",
+            IntrospectionNode::IntrospectionId(Some(ident_to_type(ident))),
+        );
+    }
+    let decorators = decorators
+        .into_iter()
+        .map(|d| IntrospectionNode::String(d.into()).into())
+        .collect::<Vec<_>>();
+    if !decorators.is_empty() {
+        desc.insert("decorators", IntrospectionNode::List(decorators));
+    }
+    if let Some(parent) = parent {
+        desc.insert(
+            "parent",
+            IntrospectionNode::IntrospectionId(Some(Cow::Borrowed(parent))),
+        );
+    }
+    IntrospectionNode::Map(desc).emit(pyo3_crate_path)
+}
+
+pub fn attribute_introspection_code(
+    pyo3_crate_path: &PyO3CratePath,
+    parent: Option<&Type>,
+    name: String,
+    value: String,
+    mut rust_type: Type,
+    is_final: bool,
+) -> TokenStream {
+    let mut desc = HashMap::from([
+        ("type", IntrospectionNode::String("attribute".into())),
+        ("name", IntrospectionNode::String(name.into())),
+        (
+            "parent",
+            IntrospectionNode::IntrospectionId(parent.map(Cow::Borrowed)),
+        ),
+    ]);
+    if value == "..." {
+        // We need to set a type, but not need to set the value to ..., all attributes have a value
+        if let Some(parent) = parent {
+            replace_self(&mut rust_type, parent);
+        }
+        elide_lifetimes(&mut rust_type);
+        desc.insert(
+            "annotation",
+            IntrospectionNode::OutputType {
+                rust_type,
+                is_final,
+            },
+        );
+    } else {
+        desc.insert(
+            "annotation",
+            if is_final {
+                // Type checkers can infer the type from the value because it's typing.Literal[value]
+                // So, following stubs best practices, we only write typing.Final and not
+                // typing.Final[typing.literal[value]]
+                IntrospectionNode::ConstantType {
+                    name: "Final",
+                    module: Some("typing"),
+                }
+            } else {
+                IntrospectionNode::OutputType {
+                    rust_type,
+                    is_final,
+                }
+            },
+        );
+        desc.insert("value", IntrospectionNode::String(value.into()));
+    }
+    IntrospectionNode::Map(desc).emit(pyo3_crate_path)
+}
+
+fn arguments_introspection_data<'a>(
+    signature: &'a FunctionSignature<'a>,
+    first_argument: Option<&'a str>,
+    class_type: Option<&Type>,
+) -> IntrospectionNode<'a> {
+    let mut argument_desc = signature.arguments.iter().filter(|arg| {
+        matches!(
+            arg,
+            FnArg::Regular(_) | FnArg::VarArgs(_) | FnArg::KwArgs(_)
+        )
+    });
+
+    let mut posonlyargs = Vec::new();
+    let mut args = Vec::new();
+    let mut vararg = None;
+    let mut kwonlyargs = Vec::new();
+    let mut kwarg = None;
+
+    if let Some(first_argument) = first_argument {
+        posonlyargs.push(
+            IntrospectionNode::Map(
+                [("name", IntrospectionNode::String(first_argument.into()))].into(),
+            )
+            .into(),
+        );
+    }
+
+    for (i, param) in signature
+        .python_signature
+        .positional_parameters
+        .iter()
+        .enumerate()
+    {
+        let arg_desc = if let Some(FnArg::Regular(arg_desc)) = argument_desc.next() {
+            arg_desc
+        } else {
+            panic!("Less arguments than in python signature");
+        };
+        let arg = argument_introspection_data(param, arg_desc, class_type);
+        if i < signature.python_signature.positional_only_parameters {
+            posonlyargs.push(arg);
+        } else {
+            args.push(arg)
+        }
+    }
+
+    if let Some(param) = &signature.python_signature.varargs {
+        let Some(FnArg::VarArgs(arg_desc)) = argument_desc.next() else {
+            panic!("Fewer arguments than in python signature");
+        };
+        let mut params = HashMap::from([("name", IntrospectionNode::String(param.into()))]);
+        if let Some(annotation) = &arg_desc.annotation {
+            params.insert("annotation", IntrospectionNode::String(annotation.into()));
+        }
+        vararg = Some(IntrospectionNode::Map(params));
+    }
+
+    for (param, _) in &signature.python_signature.keyword_only_parameters {
+        let Some(FnArg::Regular(arg_desc)) = argument_desc.next() else {
+            panic!("Less arguments than in python signature");
+        };
+        kwonlyargs.push(argument_introspection_data(param, arg_desc, class_type));
+    }
+
+    if let Some(param) = &signature.python_signature.kwargs {
+        let Some(FnArg::KwArgs(arg_desc)) = argument_desc.next() else {
+            panic!("Less arguments than in python signature");
+        };
+        let mut params = HashMap::from([("name", IntrospectionNode::String(param.into()))]);
+        if let Some(annotation) = &arg_desc.annotation {
+            params.insert("annotation", IntrospectionNode::String(annotation.into()));
+        }
+        kwarg = Some(IntrospectionNode::Map(params));
+    }
+
+    let mut map = HashMap::new();
+    if !posonlyargs.is_empty() {
+        map.insert("posonlyargs", IntrospectionNode::List(posonlyargs));
+    }
+    if !args.is_empty() {
+        map.insert("args", IntrospectionNode::List(args));
+    }
+    if let Some(vararg) = vararg {
+        map.insert("vararg", vararg);
+    }
+    if !kwonlyargs.is_empty() {
+        map.insert("kwonlyargs", IntrospectionNode::List(kwonlyargs));
+    }
+    if let Some(kwarg) = kwarg {
+        map.insert("kwarg", kwarg);
+    }
+    IntrospectionNode::Map(map)
+}
+
+fn argument_introspection_data<'a>(
+    name: &'a str,
+    desc: &'a RegularArg<'_>,
+    class_type: Option<&Type>,
+) -> AttributedIntrospectionNode<'a> {
+    let mut params: HashMap<_, _> = [("name", IntrospectionNode::String(name.into()))].into();
+    if desc.default_value.is_some() {
+        params.insert(
+            "default",
+            IntrospectionNode::String(desc.default_value().into()),
+        );
+    }
+
+    if let Some(annotation) = &desc.annotation {
+        params.insert("annotation", IntrospectionNode::String(annotation.into()));
+    } else if desc.from_py_with.is_none() {
+        // If from_py_with is set we don't know anything on the input type
+        if let Some(ty) = desc.option_wrapped_type {
+            // Special case to properly generate a `T | None` annotation
+            let mut ty = ty.clone();
+            if let Some(class_type) = class_type {
+                replace_self(&mut ty, class_type);
+            }
+            elide_lifetimes(&mut ty);
+            params.insert(
+                "annotation",
+                IntrospectionNode::InputType {
+                    rust_type: ty,
+                    nullable: true,
+                },
+            );
+        } else {
+            let mut ty = desc.ty.clone();
+            if let Some(class_type) = class_type {
+                replace_self(&mut ty, class_type);
+            }
+            elide_lifetimes(&mut ty);
+            params.insert(
+                "annotation",
+                IntrospectionNode::InputType {
+                    rust_type: ty,
+                    nullable: false,
+                },
+            );
+        }
+    }
+    IntrospectionNode::Map(params).into()
+}
+
+enum IntrospectionNode<'a> {
+    String(Cow<'a, str>),
+    Bool(bool),
+    IntrospectionId(Option<Cow<'a, Type>>),
+    InputType {
+        rust_type: Type,
+        nullable: bool,
+    },
+    OutputType {
+        rust_type: Type,
+        is_final: bool,
+    },
+    ConstantType {
+        name: &'static str,
+        module: Option<&'static str>,
+    },
+    Map(HashMap<&'static str, IntrospectionNode<'a>>),
+    List(Vec<AttributedIntrospectionNode<'a>>),
+}
+
+impl IntrospectionNode<'_> {
+    fn emit(self, pyo3_crate_path: &PyO3CratePath) -> TokenStream {
+        let mut content = ConcatenationBuilder::default();
+        self.add_to_serialization(&mut content, pyo3_crate_path);
+        content.into_static(
+            pyo3_crate_path,
+            format_ident!("PYO3_INTROSPECTION_1_{}", unique_element_id()),
+        )
+    }
+
+    fn add_to_serialization(
+        self,
+        content: &mut ConcatenationBuilder,
+        pyo3_crate_path: &PyO3CratePath,
+    ) {
+        match self {
+            Self::String(string) => {
+                content.push_str_to_escape(&string);
+            }
+            Self::Bool(value) => content.push_str(if value { "true" } else { "false" }),
+            Self::IntrospectionId(ident) => {
+                content.push_str("\"");
+                content.push_tokens(if let Some(ident) = ident {
+                    quote! { #ident::_PYO3_INTROSPECTION_ID.as_bytes() }
+                } else {
+                    quote! { _PYO3_INTROSPECTION_ID.as_bytes() }
+                });
+                content.push_str("\"");
+            }
+            Self::InputType {
+                rust_type,
+                nullable,
+            } => {
+                let mut annotation = quote! {
+                    <#rust_type as #pyo3_crate_path::impl_::extract_argument::PyFunctionArgument<
+                        {
+                            #[allow(unused_imports)]
+                            use #pyo3_crate_path::impl_::pyclass::Probe as _;
+                            #pyo3_crate_path::impl_::pyclass::IsFromPyObject::<#rust_type>::VALUE
+                        }
+                    >>::INPUT_TYPE
+                };
+                if nullable {
+                    annotation = quote! { #pyo3_crate_path::inspect::TypeHint::union(&[#annotation, #pyo3_crate_path::inspect::TypeHint::builtin("None")]) };
+                }
+                content.push_tokens(serialize_type_hint(annotation, pyo3_crate_path));
+            }
+            Self::OutputType {
+                rust_type,
+                is_final,
+            } => {
+                let mut annotation = quote! { <#rust_type as #pyo3_crate_path::impl_::introspection::PyReturnType>::OUTPUT_TYPE };
+                if is_final {
+                    annotation = quote! { #pyo3_crate_path::inspect::TypeHint::subscript(&#pyo3_crate_path::inspect::TypeHint::module_attr("typing", "Final"), &[#annotation]) };
+                }
+                content.push_tokens(serialize_type_hint(annotation, pyo3_crate_path));
+            }
+            Self::ConstantType { name, module } => {
+                let annotation = if let Some(module) = module {
+                    quote! { #pyo3_crate_path::inspect::TypeHint::module_attr(#module, #name) }
+                } else {
+                    quote! { #pyo3_crate_path::inspect::TypeHint::builtin(#name) }
+                };
+                content.push_tokens(serialize_type_hint(annotation, pyo3_crate_path));
+            }
+            Self::Map(map) => {
+                content.push_str("{");
+                for (i, (key, value)) in map.into_iter().enumerate() {
+                    if i > 0 {
+                        content.push_str(",");
+                    }
+                    content.push_str_to_escape(key);
+                    content.push_str(":");
+                    value.add_to_serialization(content, pyo3_crate_path);
+                }
+                content.push_str("}");
+            }
+            Self::List(list) => {
+                content.push_str("[");
+                for (i, AttributedIntrospectionNode { node, attributes }) in
+                    list.into_iter().enumerate()
+                {
+                    if attributes.is_empty() {
+                        if i > 0 {
+                            content.push_str(",");
+                        }
+                        node.add_to_serialization(content, pyo3_crate_path);
+                    } else {
+                        // We serialize the element to easily gate it behind the attributes
+                        let mut nested_builder = ConcatenationBuilder::default();
+                        if i > 0 {
+                            nested_builder.push_str(",");
+                        }
+                        node.add_to_serialization(&mut nested_builder, pyo3_crate_path);
+                        let nested_content = nested_builder.into_token_stream(pyo3_crate_path);
+                        content.push_tokens(quote! { #(#attributes)* #nested_content });
+                    }
+                }
+                content.push_str("]");
+            }
+        }
+    }
+}
+
+fn serialize_type_hint(hint: TokenStream, pyo3_crate_path: &PyO3CratePath) -> TokenStream {
+    quote! {{
+        const TYPE_HINT: #pyo3_crate_path::inspect::TypeHint = #hint;
+        const TYPE_HINT_LEN: usize = #pyo3_crate_path::inspect::serialized_len_for_introspection(&TYPE_HINT);
+        const TYPE_HINT_SER: [u8; TYPE_HINT_LEN] = {
+            let mut result: [u8; TYPE_HINT_LEN] = [0; TYPE_HINT_LEN];
+            #pyo3_crate_path::inspect::serialize_for_introspection(&TYPE_HINT, &mut result);
+            result
+        };
+        &TYPE_HINT_SER
+    }}
+}
+
+struct AttributedIntrospectionNode<'a> {
+    node: IntrospectionNode<'a>,
+    attributes: &'a [Attribute],
+}
+
+impl<'a> From<IntrospectionNode<'a>> for AttributedIntrospectionNode<'a> {
+    fn from(node: IntrospectionNode<'a>) -> Self {
+        Self {
+            node,
+            attributes: &[],
+        }
+    }
+}
+
+#[derive(Default)]
+pub struct ConcatenationBuilder {
+    elements: Vec<ConcatenationBuilderElement>,
+    current_string: String,
+}
+
+impl ConcatenationBuilder {
+    pub fn push_tokens(&mut self, token_stream: TokenStream) {
+        if !self.current_string.is_empty() {
+            self.elements.push(ConcatenationBuilderElement::String(take(
+                &mut self.current_string,
+            )));
+        }
+        self.elements
+            .push(ConcatenationBuilderElement::TokenStream(token_stream));
+    }
+
+    pub fn push_str(&mut self, value: &str) {
+        self.current_string.push_str(value);
+    }
+
+    fn push_str_to_escape(&mut self, value: &str) {
+        self.current_string.push('"');
+        for c in value.chars() {
+            match c {
+                '\\' => self.current_string.push_str("\\\\"),
+                '"' => self.current_string.push_str("\\\""),
+                c => {
+                    if c < char::from(32) {
+                        panic!("ASCII chars below 32 are not allowed")
+                    } else {
+                        self.current_string.push(c);
+                    }
+                }
+            }
+        }
+        self.current_string.push('"');
+    }
+
+    pub fn into_token_stream(self, pyo3_crate_path: &PyO3CratePath) -> TokenStream {
+        let mut elements = self.elements;
+        if !self.current_string.is_empty() {
+            elements.push(ConcatenationBuilderElement::String(self.current_string));
+        }
+
+        if let [ConcatenationBuilderElement::String(string)] = elements.as_slice() {
+            // We avoid the const_concat! macro if there is only a single string
+            return quote! { #string.as_bytes() };
+        }
+
+        quote! {
+            {
+                const PIECES: &[&[u8]] = &[#(#elements , )*];
+                &#pyo3_crate_path::impl_::concat::combine_to_array::<{
+                    #pyo3_crate_path::impl_::concat::combined_len(PIECES)
+                }>(PIECES)
+            }
+        }
+    }
+
+    fn into_static(self, pyo3_crate_path: &PyO3CratePath, ident: Ident) -> TokenStream {
+        let mut elements = self.elements;
+        if !self.current_string.is_empty() {
+            elements.push(ConcatenationBuilderElement::String(self.current_string));
+        }
+
+        // #[no_mangle] is required to make sure some linkers like Linux ones do not mangle the section name too.
+        quote! {
+            const _: () = {
+                const PIECES: &[&[u8]] = &[#(#elements , )*];
+                const PIECES_LEN: usize = #pyo3_crate_path::impl_::concat::combined_len(PIECES);
+                #[used]
+                #[no_mangle]
+                static #ident: #pyo3_crate_path::impl_::introspection::SerializedIntrospectionFragment<PIECES_LEN> = #pyo3_crate_path::impl_::introspection::SerializedIntrospectionFragment {
+                    length: PIECES_LEN as u32,
+                    fragment: #pyo3_crate_path::impl_::concat::combine_to_array::<PIECES_LEN>(PIECES)
+                };
+            };
+        }
+    }
+}
+
+enum ConcatenationBuilderElement {
+    String(String),
+    TokenStream(TokenStream),
+}
+
+impl ToTokens for ConcatenationBuilderElement {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
+        match self {
+            Self::String(s) => quote! { #s.as_bytes() }.to_tokens(tokens),
+            Self::TokenStream(ts) => ts.to_tokens(tokens),
+        }
+    }
+}
+
+/// Generates a new unique identifier for linking introspection objects together
+pub fn introspection_id_const() -> TokenStream {
+    let id = unique_element_id().to_string();
+    quote! {
+        #[doc(hidden)]
+        pub const _PYO3_INTROSPECTION_ID: &'static str = #id;
+    }
+}
+
+pub fn unique_element_id() -> u64 {
+    let mut hasher = DefaultHasher::new();
+    format!("{:?}", Span::call_site()).hash(&mut hasher); // Distinguishes between call sites
+    GLOBAL_COUNTER_FOR_UNIQUE_NAMES
+        .fetch_add(1, Ordering::Relaxed)
+        .hash(&mut hasher); // If there are multiple elements in the same call site
+    hasher.finish()
+}
+
+fn ident_to_type(ident: &Ident) -> Cow<'static, Type> {
+    Cow::Owned(
+        TypePath {
+            path: ident.clone().into(),
+            qself: None,
+        }
+        .into(),
+    )
+}
+
+/// Replaces all explicit lifetimes in `self` with elided (`'_`) lifetimes
+///
+/// This is useful if `Self` is used in `const` context, where explicit
+/// lifetimes are not allowed (yet).
+pub fn elide_lifetimes(ty: &mut Type) {
+    struct ElideLifetimesVisitor;
+
+    impl VisitMut for ElideLifetimesVisitor {
+        fn visit_lifetime_mut(&mut self, l: &mut syn::Lifetime) {
+            *l = Lifetime::new("'_", l.span());
+        }
+    }
+
+    ElideLifetimesVisitor.visit_type_mut(ty);
+}
+
+// Replace Self in types with the given type
+fn replace_self(ty: &mut Type, self_target: &Type) {
+    struct SelfReplacementVisitor<'a> {
+        self_target: &'a Type,
+    }
+
+    impl VisitMut for SelfReplacementVisitor<'_> {
+        fn visit_type_mut(&mut self, ty: &mut Type) {
+            if let Type::Path(type_path) = ty {
+                if type_path.qself.is_none()
+                    && type_path.path.segments.len() == 1
+                    && type_path.path.segments[0].ident == "Self"
+                    && type_path.path.segments[0].arguments.is_empty()
+                {
+                    // It is Self
+                    *ty = self.self_target.clone();
+                    return;
+                }
+            }
+            visit_type_mut(self, ty);
+        }
+    }
+
+    SelfReplacementVisitor { self_target }.visit_type_mut(ty);
+}
diff --git a/pyo3-macros-backend/src/konst.rs b/pyo3-macros-backend/src/konst.rs
index 935c9d4a302..e56afd0516d 100644
--- a/pyo3-macros-backend/src/konst.rs
+++ b/pyo3-macros-backend/src/konst.rs
@@ -1,11 +1,9 @@
 use std::borrow::Cow;
+use std::ffi::CString;
 
-use crate::{
-    attributes::{self, get_pyo3_options, take_attributes, NameAttribute},
-    deprecations::Deprecations,
-};
-use proc_macro2::{Ident, TokenStream};
-use quote::quote;
+use crate::attributes::{self, get_pyo3_options, take_attributes, NameAttribute};
+use proc_macro2::{Ident, Span};
+use syn::LitCStr;
 use syn::{
     ext::IdentExt,
     parse::{Parse, ParseStream},
@@ -28,16 +26,15 @@ impl ConstSpec {
     }
 
     /// Null-terminated Python name
-    pub fn null_terminated_python_name(&self) -> TokenStream {
-        let name = format!("{}\0", self.python_name());
-        quote!({#name})
+    pub fn null_terminated_python_name(&self) -> LitCStr {
+        let name = self.python_name().to_string();
+        LitCStr::new(&CString::new(name).unwrap(), Span::call_site())
     }
 }
 
 pub struct ConstAttributes {
     pub is_class_attr: bool,
     pub name: Option<NameAttribute>,
-    pub deprecations: Deprecations,
 }
 
 pub enum PyO3ConstAttribute {
@@ -60,7 +57,6 @@ impl ConstAttributes {
         let mut attributes = ConstAttributes {
             is_class_attr: false,
             name: None,
-            deprecations: Deprecations::new(),
         };
 
         take_attributes(attrs, |attr| {
diff --git a/pyo3-macros-backend/src/lib.rs b/pyo3-macros-backend/src/lib.rs
index 745a8471c2b..5a99f499f19 100644
--- a/pyo3-macros-backend/src/lib.rs
+++ b/pyo3-macros-backend/src/lib.rs
@@ -1,7 +1,7 @@
 //! This crate contains the implementation of the proc macro attributes
 
 #![warn(elided_lifetimes_in_paths, unused_lifetimes)]
-#![cfg_attr(docsrs, feature(doc_cfg, doc_auto_cfg))]
+#![cfg_attr(docsrs, feature(doc_cfg))]
 #![recursion_limit = "1024"]
 
 // Listed first so that macros in this module are available in the rest of the crate.
@@ -9,8 +9,12 @@
 mod utils;
 
 mod attributes;
-mod deprecations;
+mod combine_errors;
+mod derive_attributes;
 mod frompyobject;
+mod intopyobject;
+#[cfg(feature = "experimental-inspect")]
+mod introspection;
 mod konst;
 mod method;
 mod module;
@@ -19,10 +23,12 @@ mod pyclass;
 mod pyfunction;
 mod pyimpl;
 mod pymethod;
+mod pyversions;
 mod quotes;
 
 pub use frompyobject::build_derive_from_pyobject;
-pub use module::{process_functions_in_module, pymodule_impl, PyModuleOptions};
+pub use intopyobject::build_derive_into_pyobject;
+pub use module::{pymodule_function_impl, pymodule_module_impl, PyModuleOptions};
 pub use pyclass::{build_py_class, build_py_enum, PyClassArgs};
 pub use pyfunction::{build_py_function, PyFunctionOptions};
 pub use pyimpl::{build_py_methods, PyClassMethodsType};
diff --git a/pyo3-macros-backend/src/method.rs b/pyo3-macros-backend/src/method.rs
index f492a330c92..5484b8d5d0c 100644
--- a/pyo3-macros-backend/src/method.rs
+++ b/pyo3-macros-backend/src/method.rs
@@ -1,34 +1,172 @@
+use std::borrow::Cow;
+use std::ffi::CString;
 use std::fmt::Display;
 
 use proc_macro2::{Span, TokenStream};
-use quote::{quote, quote_spanned, ToTokens};
+use quote::{format_ident, quote, quote_spanned, ToTokens};
+use syn::LitCStr;
 use syn::{ext::IdentExt, spanned::Spanned, Ident, Result};
 
+use crate::pyfunction::{PyFunctionWarning, WarningFactory};
+use crate::pyversions::is_abi3_before;
+use crate::utils::{expr_to_python, Ctx};
 use crate::{
-    attributes::{TextSignatureAttribute, TextSignatureAttributeValue},
-    deprecations::{Deprecation, Deprecations},
-    params::impl_arg_params,
+    attributes::{FromPyWithAttribute, TextSignatureAttribute, TextSignatureAttributeValue},
+    params::{impl_arg_params, Holders},
     pyfunction::{
         FunctionSignature, PyFunctionArgPyO3Attributes, PyFunctionOptions, SignatureAttribute,
     },
     quotes,
-    utils::{self, is_abi3, PythonDoc},
+    utils::{self, PythonDoc},
 };
 
 #[derive(Clone, Debug)]
-pub struct FnArg<'a> {
+pub struct RegularArg<'a> {
+    pub name: Cow<'a, syn::Ident>,
+    pub ty: &'a syn::Type,
+    pub from_py_with: Option<FromPyWithAttribute>,
+    pub default_value: Option<syn::Expr>,
+    pub option_wrapped_type: Option<&'a syn::Type>,
+    #[cfg(feature = "experimental-inspect")]
+    pub annotation: Option<String>,
+}
+
+impl RegularArg<'_> {
+    pub fn default_value(&self) -> String {
+        if let Self {
+            default_value: Some(arg_default),
+            ..
+        } = self
+        {
+            expr_to_python(arg_default)
+        } else if let RegularArg {
+            option_wrapped_type: Some(..),
+            ..
+        } = self
+        {
+            // functions without a `#[pyo3(signature = (...))]` option
+            // will treat trailing `Option<T>` arguments as having a default of `None`
+            "None".to_string()
+        } else {
+            "...".to_string()
+        }
+    }
+}
+
+/// Pythons *args argument
+#[derive(Clone, Debug)]
+pub struct VarargsArg<'a> {
+    pub name: Cow<'a, syn::Ident>,
+    pub ty: &'a syn::Type,
+    #[cfg(feature = "experimental-inspect")]
+    pub annotation: Option<String>,
+}
+
+/// Pythons **kwarg argument
+#[derive(Clone, Debug)]
+pub struct KwargsArg<'a> {
+    pub name: Cow<'a, syn::Ident>,
+    pub ty: &'a syn::Type,
+    #[cfg(feature = "experimental-inspect")]
+    pub annotation: Option<String>,
+}
+
+#[derive(Clone, Debug)]
+pub struct CancelHandleArg<'a> {
+    pub name: &'a syn::Ident,
+    pub ty: &'a syn::Type,
+}
+
+#[derive(Clone, Debug)]
+pub struct PyArg<'a> {
     pub name: &'a syn::Ident,
     pub ty: &'a syn::Type,
-    pub optional: Option<&'a syn::Type>,
-    pub default: Option<syn::Expr>,
-    pub py: bool,
-    pub attrs: PyFunctionArgPyO3Attributes,
-    pub is_varargs: bool,
-    pub is_kwargs: bool,
-    pub is_cancel_handle: bool,
+}
+
+#[allow(clippy::large_enum_variant)] // See #5039
+#[derive(Clone, Debug)]
+pub enum FnArg<'a> {
+    Regular(RegularArg<'a>),
+    VarArgs(VarargsArg<'a>),
+    KwArgs(KwargsArg<'a>),
+    Py(PyArg<'a>),
+    CancelHandle(CancelHandleArg<'a>),
 }
 
 impl<'a> FnArg<'a> {
+    pub fn name(&self) -> &syn::Ident {
+        match self {
+            FnArg::Regular(RegularArg { name, .. }) => name,
+            FnArg::VarArgs(VarargsArg { name, .. }) => name,
+            FnArg::KwArgs(KwargsArg { name, .. }) => name,
+            FnArg::Py(PyArg { name, .. }) => name,
+            FnArg::CancelHandle(CancelHandleArg { name, .. }) => name,
+        }
+    }
+
+    pub fn ty(&self) -> &'a syn::Type {
+        match self {
+            FnArg::Regular(RegularArg { ty, .. }) => ty,
+            FnArg::VarArgs(VarargsArg { ty, .. }) => ty,
+            FnArg::KwArgs(KwargsArg { ty, .. }) => ty,
+            FnArg::Py(PyArg { ty, .. }) => ty,
+            FnArg::CancelHandle(CancelHandleArg { ty, .. }) => ty,
+        }
+    }
+
+    #[allow(clippy::wrong_self_convention)]
+    pub fn from_py_with(&self) -> Option<&FromPyWithAttribute> {
+        if let FnArg::Regular(RegularArg { from_py_with, .. }) = self {
+            from_py_with.as_ref()
+        } else {
+            None
+        }
+    }
+
+    pub fn to_varargs_mut(&mut self) -> Result<&mut Self> {
+        if let Self::Regular(RegularArg {
+            name,
+            ty,
+            option_wrapped_type: None,
+            #[cfg(feature = "experimental-inspect")]
+            annotation,
+            ..
+        }) = self
+        {
+            *self = Self::VarArgs(VarargsArg {
+                name: name.clone(),
+                ty,
+                #[cfg(feature = "experimental-inspect")]
+                annotation: annotation.clone(),
+            });
+            Ok(self)
+        } else {
+            bail_spanned!(self.name().span() => "args cannot be optional")
+        }
+    }
+
+    pub fn to_kwargs_mut(&mut self) -> Result<&mut Self> {
+        if let Self::Regular(RegularArg {
+            name,
+            ty,
+            option_wrapped_type: Some(..),
+            #[cfg(feature = "experimental-inspect")]
+            annotation,
+            ..
+        }) = self
+        {
+            *self = Self::KwArgs(KwargsArg {
+                name: name.clone(),
+                ty,
+                #[cfg(feature = "experimental-inspect")]
+                annotation: annotation.clone(),
+            });
+            Ok(self)
+        } else {
+            bail_spanned!(self.name().span() => "kwargs must be Option<_>")
+        }
+    }
+
     /// Transforms a rust fn arg parsed with syn into a method::FnArg
     pub fn parse(arg: &'a mut syn::FnArg) -> Result<Self> {
         match arg {
@@ -40,28 +178,53 @@ impl<'a> FnArg<'a> {
                     bail_spanned!(cap.ty.span() => IMPL_TRAIT_ERR);
                 }
 
-                let arg_attrs = PyFunctionArgPyO3Attributes::from_attrs(&mut cap.attrs)?;
+                let PyFunctionArgPyO3Attributes {
+                    from_py_with,
+                    cancel_handle,
+                } = PyFunctionArgPyO3Attributes::from_attrs(&mut cap.attrs)?;
                 let ident = match &*cap.pat {
                     syn::Pat::Ident(syn::PatIdent { ident, .. }) => ident,
                     other => return Err(handle_argument_error(other)),
                 };
 
-                let is_cancel_handle = arg_attrs.cancel_handle.is_some();
+                if utils::is_python(&cap.ty) {
+                    return Ok(Self::Py(PyArg {
+                        name: ident,
+                        ty: &cap.ty,
+                    }));
+                }
 
-                Ok(FnArg {
-                    name: ident,
+                if cancel_handle.is_some() {
+                    // `PyFunctionArgPyO3Attributes::from_attrs` validates that
+                    // only compatible attributes are specified, either
+                    // `cancel_handle` or `from_py_with`, duplicates and any
+                    // combination of the two are already rejected.
+                    return Ok(Self::CancelHandle(CancelHandleArg {
+                        name: ident,
+                        ty: &cap.ty,
+                    }));
+                }
+
+                Ok(Self::Regular(RegularArg {
+                    name: Cow::Borrowed(ident),
                     ty: &cap.ty,
-                    optional: utils::option_type_argument(&cap.ty),
-                    default: None,
-                    py: utils::is_python(&cap.ty),
-                    attrs: arg_attrs,
-                    is_varargs: false,
-                    is_kwargs: false,
-                    is_cancel_handle,
-                })
+                    from_py_with,
+                    default_value: None,
+                    option_wrapped_type: utils::option_type_argument(&cap.ty),
+                    #[cfg(feature = "experimental-inspect")]
+                    annotation: None,
+                }))
             }
         }
     }
+
+    pub fn default_value(&self) -> String {
+        if let Self::Regular(args) = self {
+            args.default_value()
+        } else {
+            "...".to_string()
+        }
+    }
 }
 
 fn handle_argument_error(pat: &syn::Pat) -> syn::Error {
@@ -77,16 +240,26 @@ fn handle_argument_error(pat: &syn::Pat) -> syn::Error {
     syn::Error::new(span, msg)
 }
 
+/// Represents what kind of a function a pyfunction or pymethod is
 #[derive(Clone, Debug)]
 pub enum FnType {
+    /// Represents a pymethod annotated with `#[getter]`
     Getter(SelfType),
+    /// Represents a pymethod annotated with `#[setter]`
     Setter(SelfType),
+    /// Represents a regular pymethod
     Fn(SelfType),
+    /// Represents a pymethod annotated with `#[new]`, i.e. the `__new__` dunder.
     FnNew,
+    /// Represents a pymethod annotated with both `#[new]` and `#[classmethod]` (in either order)
     FnNewClass(Span),
+    /// Represents a pymethod annotated with `#[classmethod]`, like a `@classmethod`
     FnClass(Span),
+    /// Represents a pyfunction or a pymethod annotated with `#[staticmethod]`, like a `@staticmethod`
     FnStatic,
+    /// Represents a pyfunction annotated with `#[pyo3(pass_module)]
     FnModule(Span),
+    /// Represents a pymethod or associated constant annotated with `#[classattr]`
     ClassAttribute,
 }
 
@@ -103,47 +276,66 @@ impl FnType {
         }
     }
 
+    pub fn signature_attribute_allowed(&self) -> bool {
+        match self {
+            FnType::Fn(_)
+            | FnType::FnNew
+            | FnType::FnStatic
+            | FnType::FnClass(_)
+            | FnType::FnNewClass(_)
+            | FnType::FnModule(_) => true,
+            // Setter, Getter and ClassAttribute all have fixed signatures (either take 0 or 1
+            // arguments) so cannot have a `signature = (...)` attribute.
+            FnType::Getter(_) | FnType::Setter(_) | FnType::ClassAttribute => false,
+        }
+    }
+
     pub fn self_arg(
         &self,
         cls: Option<&syn::Type>,
         error_mode: ExtractErrorMode,
-        holders: &mut Vec<TokenStream>,
-    ) -> TokenStream {
+        holders: &mut Holders,
+        ctx: &Ctx,
+    ) -> Option<TokenStream> {
+        let Ctx { pyo3_path, .. } = ctx;
         match self {
             FnType::Getter(st) | FnType::Setter(st) | FnType::Fn(st) => {
                 let mut receiver = st.receiver(
                     cls.expect("no class given for Fn with a \"self\" receiver"),
                     error_mode,
                     holders,
+                    ctx,
                 );
                 syn::Token![,](Span::call_site()).to_tokens(&mut receiver);
-                receiver
-            }
-            FnType::FnNew | FnType::FnStatic | FnType::ClassAttribute => {
-                quote!()
+                Some(receiver)
             }
             FnType::FnClass(span) | FnType::FnNewClass(span) => {
                 let py = syn::Ident::new("py", Span::call_site());
                 let slf: Ident = syn::Ident::new("_slf", Span::call_site());
-                quote_spanned! { *span =>
+                let pyo3_path = pyo3_path.to_tokens_spanned(*span);
+                let ret = quote_spanned! { *span =>
                     #[allow(clippy::useless_conversion)]
                     ::std::convert::Into::into(
-                        _pyo3::impl_::pymethods::BoundRef::ref_from_ptr(#py, &#slf.cast())
-                            .downcast_unchecked::<_pyo3::types::PyType>()
-                    ),
-                }
+                        #pyo3_path::impl_::pymethods::BoundRef::ref_from_ptr(#py, &*(&#slf as *const _ as *const *mut _))
+                            .cast_unchecked::<#pyo3_path::types::PyType>()
+                    )
+                };
+                Some(quote! { unsafe { #ret }, })
             }
             FnType::FnModule(span) => {
                 let py = syn::Ident::new("py", Span::call_site());
                 let slf: Ident = syn::Ident::new("_slf", Span::call_site());
-                quote_spanned! { *span =>
+                let pyo3_path = pyo3_path.to_tokens_spanned(*span);
+                let ret = quote_spanned! { *span =>
                     #[allow(clippy::useless_conversion)]
                     ::std::convert::Into::into(
-                        _pyo3::impl_::pymethods::BoundRef::ref_from_ptr(#py, &#slf.cast())
-                            .downcast_unchecked::<_pyo3::types::PyModule>()
-                    ),
-                }
+                        #pyo3_path::impl_::pymethods::BoundRef::ref_from_ptr(#py, &*(&#slf as *const _ as *const *mut _))
+                            .cast_unchecked::<#pyo3_path::types::PyModule>()
+                    )
+                };
+                Some(quote! { unsafe { #ret }, })
             }
+            FnType::FnNew | FnType::FnStatic | FnType::ClassAttribute => None,
         }
     }
 }
@@ -151,7 +343,7 @@ impl FnType {
 #[derive(Clone, Debug)]
 pub enum SelfType {
     Receiver { mutable: bool, span: Span },
-    TryFromPyCell(Span),
+    TryFromBoundRef(Span),
 }
 
 #[derive(Clone, Copy)]
@@ -161,13 +353,14 @@ pub enum ExtractErrorMode {
 }
 
 impl ExtractErrorMode {
-    pub fn handle_error(self, extract: TokenStream) -> TokenStream {
+    pub fn handle_error(self, extract: TokenStream, ctx: &Ctx) -> TokenStream {
+        let Ctx { pyo3_path, .. } = ctx;
         match self {
             ExtractErrorMode::Raise => quote! { #extract? },
             ExtractErrorMode::NotImplemented => quote! {
                 match #extract {
                     ::std::result::Result::Ok(value) => value,
-                    ::std::result::Result::Err(_) => { return _pyo3::callback::convert(py, py.NotImplemented()); },
+                    ::std::result::Result::Err(_) => { return #pyo3_path::impl_::callback::convert(py, py.NotImplemented()); },
                 }
             },
         }
@@ -179,12 +372,16 @@ impl SelfType {
         &self,
         cls: &syn::Type,
         error_mode: ExtractErrorMode,
-        holders: &mut Vec<TokenStream>,
+        holders: &mut Holders,
+        ctx: &Ctx,
     ) -> TokenStream {
         // Due to use of quote_spanned in this function, need to bind these idents to the
         // main macro callsite.
         let py = syn::Ident::new("py", Span::call_site());
         let slf = syn::Ident::new("_slf", Span::call_site());
+        let Ctx { pyo3_path, .. } = ctx;
+        let bound_ref =
+            quote! { unsafe { #pyo3_path::impl_::pymethods::BoundRef::ref_from_ptr(#py, &#slf) } };
         match self {
             SelfType::Receiver { span, mutable } => {
                 let method = if *mutable {
@@ -192,30 +389,31 @@ impl SelfType {
                 } else {
                     syn::Ident::new("extract_pyclass_ref", *span)
                 };
-                let holder = syn::Ident::new(&format!("holder_{}", holders.len()), *span);
-                holders.push(quote_spanned! { *span =>
-                    #[allow(clippy::let_unit_value)]
-                    let mut #holder = _pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
-                });
-                error_mode.handle_error(quote_spanned! { *span =>
-                    _pyo3::impl_::extract_argument::#method::<#cls>(
-                        #py.from_borrowed_ptr::<_pyo3::PyAny>(#slf),
-                        &mut #holder,
-                    )
-                })
+                let holder = holders.push_holder(*span);
+                let pyo3_path = pyo3_path.to_tokens_spanned(*span);
+                error_mode.handle_error(
+                    quote_spanned! { *span =>
+                        #pyo3_path::impl_::extract_argument::#method::<#cls>(
+                            #bound_ref.0,
+                            &mut #holder,
+                        )
+                    },
+                    ctx,
+                )
             }
-            SelfType::TryFromPyCell(span) => {
+            SelfType::TryFromBoundRef(span) => {
+                let pyo3_path = pyo3_path.to_tokens_spanned(*span);
                 error_mode.handle_error(
                     quote_spanned! { *span =>
-                        #py.from_borrowed_ptr::<_pyo3::PyAny>(#slf).downcast::<_pyo3::PyCell<#cls>>()
-                            .map_err(::std::convert::Into::<_pyo3::PyErr>::into)
+                        #bound_ref.cast::<#cls>()
+                            .map_err(::std::convert::Into::<#pyo3_path::PyErr>::into)
                             .and_then(
-                                #[allow(clippy::useless_conversion)]  // In case slf is PyCell<Self>
-                                #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]  // In case slf is Py<Self> (unknown_lints can be removed when MSRV is 1.75+)
-                                |cell| ::std::convert::TryFrom::try_from(cell).map_err(::std::convert::Into::into)
+                                #[allow(clippy::unnecessary_fallible_conversions)]  // In case slf is Py<Self>
+                                |bound| ::std::convert::TryFrom::try_from(bound).map_err(::std::convert::Into::into)
                             )
 
-                    }
+                    },
+                    ctx
                 )
             }
         }
@@ -227,7 +425,7 @@ impl SelfType {
 pub enum CallingConvention {
     Noargs,   // METH_NOARGS
     Varargs,  // METH_VARARGS | METH_KEYWORDS
-    Fastcall, // METH_FASTCALL | METH_KEYWORDS (not compatible with `abi3` feature)
+    Fastcall, // METH_FASTCALL | METH_KEYWORDS (not compatible with `abi3` feature before 3.10)
     TpNew,    // special convention for tp_new
 }
 
@@ -239,11 +437,11 @@ impl CallingConvention {
     pub fn from_signature(signature: &FunctionSignature<'_>) -> Self {
         if signature.python_signature.has_no_args() {
             Self::Noargs
-        } else if signature.python_signature.kwargs.is_some() {
-            // for functions that accept **kwargs, always prefer varargs
-            Self::Varargs
-        } else if !is_abi3() {
-            // FIXME: available in the stable ABI since 3.10
+        } else if signature.python_signature.kwargs.is_none() && !is_abi3_before(3, 10) {
+            // For functions that accept **kwargs, always prefer varargs for now based on
+            // historical performance testing.
+            //
+            // FASTCALL not compatible with `abi3` before 3.10
             Self::Fastcall
         } else {
             Self::Varargs
@@ -251,6 +449,7 @@ impl CallingConvention {
     }
 }
 
+#[derive(Clone)]
 pub struct FnSpec<'a> {
     pub tp: FnType,
     // Rust function name
@@ -259,19 +458,13 @@ pub struct FnSpec<'a> {
     // r# can be removed by syn::ext::IdentExt::unraw()
     pub python_name: syn::Ident,
     pub signature: FunctionSignature<'a>,
-    pub output: syn::Type,
     pub convention: CallingConvention,
     pub text_signature: Option<TextSignatureAttribute>,
     pub asyncness: Option<syn::Token![async]>,
     pub unsafety: Option<syn::Token![unsafe]>,
-    pub deprecations: Deprecations,
-}
-
-pub fn get_return_info(output: &syn::ReturnType) -> syn::Type {
-    match output {
-        syn::ReturnType::Default => syn::Type::Infer(syn::parse_quote! {_}),
-        syn::ReturnType::Type(_, ty) => *ty.clone(),
-    }
+    pub warnings: Vec<PyFunctionWarning>,
+    #[cfg(feature = "experimental-inspect")]
+    pub output: syn::ReturnType,
 }
 
 pub fn parse_method_receiver(arg: &syn::FnArg) -> Result<SelfType> {
@@ -291,7 +484,7 @@ pub fn parse_method_receiver(arg: &syn::FnArg) -> Result<SelfType> {
             if let syn::Type::ImplTrait(_) = &**ty {
                 bail_spanned!(ty.span() => IMPL_TRAIT_ERR);
             }
-            Ok(SelfType::TryFromPyCell(ty.span()))
+            Ok(SelfType::TryFromBoundRef(ty.span()))
         }
     }
 }
@@ -308,17 +501,16 @@ impl<'a> FnSpec<'a> {
             text_signature,
             name,
             signature,
+            warnings,
             ..
         } = options;
 
         let mut python_name = name.map(|name| name.value.0);
-        let mut deprecations = Deprecations::new();
 
-        let fn_type = Self::parse_fn_type(sig, meth_attrs, &mut python_name, &mut deprecations)?;
+        let fn_type = Self::parse_fn_type(sig, meth_attrs, &mut python_name)?;
         ensure_signatures_on_valid_method(&fn_type, signature.as_ref(), text_signature.as_ref())?;
 
         let name = &sig.ident;
-        let ty = get_return_info(&sig.output);
         let python_name = python_name.as_ref().unwrap_or(name).unraw();
 
         let arguments: Vec<_> = sig
@@ -335,7 +527,7 @@ impl<'a> FnSpec<'a> {
         let signature = if let Some(signature) = signature {
             FunctionSignature::from_arguments_and_attribute(arguments, signature)?
         } else {
-            FunctionSignature::from_arguments(arguments)?
+            FunctionSignature::from_arguments(arguments)
         };
 
         let convention = if matches!(fn_type, FnType::FnNew | FnType::FnNewClass(_)) {
@@ -350,25 +542,27 @@ impl<'a> FnSpec<'a> {
             convention,
             python_name,
             signature,
-            output: ty,
             text_signature,
             asyncness: sig.asyncness,
             unsafety: sig.unsafety,
-            deprecations,
+            warnings,
+            #[cfg(feature = "experimental-inspect")]
+            output: sig.output.clone(),
         })
     }
 
-    pub fn null_terminated_python_name(&self) -> syn::LitStr {
-        syn::LitStr::new(&format!("{}\0", self.python_name), self.python_name.span())
+    pub fn null_terminated_python_name(&self) -> LitCStr {
+        let name = self.python_name.to_string();
+        let name = CString::new(name).unwrap();
+        LitCStr::new(&name, self.python_name.span())
     }
 
     fn parse_fn_type(
         sig: &syn::Signature,
         meth_attrs: &mut Vec<syn::Attribute>,
         python_name: &mut Option<syn::Ident>,
-        deprecations: &mut Deprecations,
     ) -> Result<FnType> {
-        let mut method_attributes = parse_method_attributes(meth_attrs, deprecations)?;
+        let mut method_attributes = parse_method_attributes(meth_attrs)?;
 
         let name = &sig.ident;
         let parse_receiver = |msg: &'static str| {
@@ -455,10 +649,10 @@ impl<'a> FnSpec<'a> {
                     .fold(first.span(), |s, next| s.join(next.span()).unwrap_or(s));
                 let span = span.join(last.span()).unwrap_or(span);
                 // List all the attributes in the error message
-                let mut msg = format!("`{}` may not be combined with", first);
+                let mut msg = format!("`{first}` may not be combined with");
                 let mut is_first = true;
                 for attr in &*rest {
-                    msg.push_str(&format!(" `{}`", attr));
+                    msg.push_str(&format!(" `{attr}`"));
                     if is_first {
                         is_first = false;
                     } else {
@@ -468,7 +662,7 @@ impl<'a> FnSpec<'a> {
                 if !rest.is_empty() {
                     msg.push_str(" and");
                 }
-                msg.push_str(&format!(" `{}`", last));
+                msg.push_str(&format!(" `{last}`"));
                 bail_spanned!(span => msg)
             }
         };
@@ -480,22 +674,29 @@ impl<'a> FnSpec<'a> {
         &self,
         ident: &proc_macro2::Ident,
         cls: Option<&syn::Type>,
+        ctx: &Ctx,
     ) -> Result<TokenStream> {
+        let Ctx {
+            pyo3_path,
+            output_span,
+        } = ctx;
         let mut cancel_handle_iter = self
             .signature
             .arguments
             .iter()
-            .filter(|arg| arg.is_cancel_handle);
+            .filter(|arg| matches!(arg, FnArg::CancelHandle(..)));
         let cancel_handle = cancel_handle_iter.next();
-        if let Some(arg) = cancel_handle {
-            ensure_spanned!(self.asyncness.is_some(), arg.name.span() => "`cancel_handle` attribute can only be used with `async fn`");
-            if let Some(arg2) = cancel_handle_iter.next() {
-                bail_spanned!(arg2.name.span() => "`cancel_handle` may only be specified once");
+        if let Some(FnArg::CancelHandle(CancelHandleArg { name, .. })) = cancel_handle {
+            ensure_spanned!(self.asyncness.is_some(), name.span() => "`cancel_handle` attribute can only be used with `async fn`");
+            if let Some(FnArg::CancelHandle(CancelHandleArg { name, .. })) =
+                cancel_handle_iter.next()
+            {
+                bail_spanned!(name.span() => "`cancel_handle` may only be specified once");
             }
         }
 
-        let rust_call = |args: Vec<TokenStream>, holders: &mut Vec<TokenStream>| {
-            let self_arg = self.tp.self_arg(cls, ExtractErrorMode::Raise, holders);
+        let rust_call = |args: Vec<TokenStream>, holders: &mut Holders| {
+            let mut self_arg = || self.tp.self_arg(cls, ExtractErrorMode::Raise, holders, ctx);
 
             let call = if self.asyncness.is_some() {
                 let throw_callback = if cancel_handle.is_some() {
@@ -505,49 +706,85 @@ impl<'a> FnSpec<'a> {
                 };
                 let python_name = &self.python_name;
                 let qualname_prefix = match cls {
-                    Some(cls) => quote!(Some(<#cls as _pyo3::PyTypeInfo>::NAME)),
+                    Some(cls) => quote!(Some(<#cls as #pyo3_path::PyTypeInfo>::NAME)),
                     None => quote!(None),
                 };
+                let arg_names = (0..args.len())
+                    .map(|i| format_ident!("arg_{}", i))
+                    .collect::<Vec<_>>();
                 let future = match self.tp {
                     FnType::Fn(SelfType::Receiver { mutable: false, .. }) => {
-                        holders.pop().unwrap(); // does not actually use holder created by `self_arg`
-
                         quote! {{
-                            let __guard = _pyo3::impl_::coroutine::RefGuard::<#cls>::new(py.from_borrowed_ptr::<_pyo3::types::PyAny>(_slf))?;
-                            async move { function(&__guard, #(#args),*).await }
+                            #(let #arg_names = #args;)*
+                            let __guard = unsafe { #pyo3_path::impl_::coroutine::RefGuard::<#cls>::new(&#pyo3_path::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf))? };
+                            async move { function(&__guard, #(#arg_names),*).await }
                         }}
                     }
                     FnType::Fn(SelfType::Receiver { mutable: true, .. }) => {
-                        holders.pop().unwrap(); // does not actually use holder created by `self_arg`
-
                         quote! {{
-                            let mut __guard = _pyo3::impl_::coroutine::RefMutGuard::<#cls>::new(py.from_borrowed_ptr::<_pyo3::types::PyAny>(_slf))?;
-                            async move { function(&mut __guard, #(#args),*).await }
+                            #(let #arg_names = #args;)*
+                            let mut __guard = unsafe { #pyo3_path::impl_::coroutine::RefMutGuard::<#cls>::new(&#pyo3_path::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf))? };
+                            async move { function(&mut __guard, #(#arg_names),*).await }
                         }}
                     }
-                    _ => quote! { function(#self_arg #(#args),*) },
+                    _ => {
+                        if let Some(self_arg) = self_arg() {
+                            quote! {
+                                function(
+                                    // NB #self_arg includes a comma, so none inserted here
+                                    #self_arg
+                                    #(#args),*
+                                )
+                            }
+                        } else {
+                            quote! { function(#(#args),*) }
+                        }
+                    }
                 };
                 let mut call = quote! {{
                     let future = #future;
-                    _pyo3::impl_::coroutine::new_coroutine(
-                        _pyo3::intern!(py, stringify!(#python_name)),
+                    #pyo3_path::impl_::coroutine::new_coroutine(
+                        #pyo3_path::intern!(py, stringify!(#python_name)),
                         #qualname_prefix,
                         #throw_callback,
-                        async move { _pyo3::impl_::wrap::OkWrap::wrap(future.await) },
+                        async move {
+                            let fut = future.await;
+                            #pyo3_path::impl_::wrap::converter(&fut).wrap(fut)
+                        },
                     )
                 }};
                 if cancel_handle.is_some() {
                     call = quote! {{
-                        let __cancel_handle = _pyo3::coroutine::CancelHandle::new();
+                        let __cancel_handle = #pyo3_path::coroutine::CancelHandle::new();
                         let __throw_callback = __cancel_handle.throw_callback();
                         #call
                     }};
                 }
                 call
+            } else if let Some(self_arg) = self_arg() {
+                quote! {
+                    function(
+                        // NB #self_arg includes a comma, so none inserted here
+                        #self_arg
+                        #(#args),*
+                    )
+                }
             } else {
-                quote! { function(#self_arg #(#args),*) }
+                quote! { function(#(#args),*) }
             };
-            quotes::map_result_into_ptr(quotes::ok_wrap(call))
+
+            // We must assign the output_span to the return value of the call,
+            // but *not* of the call itself otherwise the spans get really weird
+            let ret_ident = Ident::new("ret", *output_span);
+            let ret_expr = quote! { let #ret_ident = #call; };
+            let return_conversion =
+                quotes::map_result_into_ptr(quotes::ok_wrap(ret_ident.to_token_stream(), ctx), ctx);
+            quote! {
+                {
+                    #ret_expr
+                    #return_conversion
+                }
+            }
         };
 
         let func_name = &self.name;
@@ -557,93 +794,104 @@ impl<'a> FnSpec<'a> {
             quote!(#func_name)
         };
 
+        let warnings = self.warnings.build_py_warning(ctx);
+
         Ok(match self.convention {
             CallingConvention::Noargs => {
-                let mut holders = Vec::new();
+                let mut holders = Holders::new();
                 let args = self
                     .signature
                     .arguments
                     .iter()
-                    .map(|arg| {
-                        if arg.py {
-                            quote!(py)
-                        } else if arg.is_cancel_handle {
-                            quote!(__cancel_handle)
-                        } else {
-                            unreachable!()
-                        }
+                    .map(|arg| match arg {
+                        FnArg::Py(..) => quote!(py),
+                        FnArg::CancelHandle(..) => quote!(__cancel_handle),
+                        _ => unreachable!("`CallingConvention::Noargs` should not contain any arguments (reaching Python) except for `self`, which is handled below."),
                     })
                     .collect();
                 let call = rust_call(args, &mut holders);
-
+                let init_holders = holders.init_holders(ctx);
                 quote! {
                     unsafe fn #ident<'py>(
-                        py: _pyo3::Python<'py>,
-                        _slf: *mut _pyo3::ffi::PyObject,
-                    ) -> _pyo3::PyResult<*mut _pyo3::ffi::PyObject> {
+                        py: #pyo3_path::Python<'py>,
+                        _slf: *mut #pyo3_path::ffi::PyObject,
+                    ) -> #pyo3_path::PyResult<*mut #pyo3_path::ffi::PyObject> {
                         let function = #rust_name; // Shadow the function name to avoid #3017
-                        #( #holders )*
-                        #call
+                        #init_holders
+                        #warnings
+                        let result = #call;
+                        result
                     }
                 }
             }
             CallingConvention::Fastcall => {
-                let mut holders = Vec::new();
-                let (arg_convert, args) = impl_arg_params(self, cls, true, &mut holders)?;
+                let mut holders = Holders::new();
+                let (arg_convert, args) = impl_arg_params(self, cls, true, &mut holders, ctx);
                 let call = rust_call(args, &mut holders);
+                let init_holders = holders.init_holders(ctx);
+
                 quote! {
                     unsafe fn #ident<'py>(
-                        py: _pyo3::Python<'py>,
-                        _slf: *mut _pyo3::ffi::PyObject,
-                        _args: *const *mut _pyo3::ffi::PyObject,
-                        _nargs: _pyo3::ffi::Py_ssize_t,
-                        _kwnames: *mut _pyo3::ffi::PyObject
-                    ) -> _pyo3::PyResult<*mut _pyo3::ffi::PyObject> {
+                        py: #pyo3_path::Python<'py>,
+                        _slf: *mut #pyo3_path::ffi::PyObject,
+                        _args: *const *mut #pyo3_path::ffi::PyObject,
+                        _nargs: #pyo3_path::ffi::Py_ssize_t,
+                        _kwnames: *mut #pyo3_path::ffi::PyObject
+                    ) -> #pyo3_path::PyResult<*mut #pyo3_path::ffi::PyObject> {
                         let function = #rust_name; // Shadow the function name to avoid #3017
                         #arg_convert
-                        #( #holders )*
-                        #call
+                        #init_holders
+                        #warnings
+                        let result = #call;
+                        result
                     }
                 }
             }
             CallingConvention::Varargs => {
-                let mut holders = Vec::new();
-                let (arg_convert, args) = impl_arg_params(self, cls, false, &mut holders)?;
+                let mut holders = Holders::new();
+                let (arg_convert, args) = impl_arg_params(self, cls, false, &mut holders, ctx);
                 let call = rust_call(args, &mut holders);
+                let init_holders = holders.init_holders(ctx);
+
                 quote! {
                     unsafe fn #ident<'py>(
-                        py: _pyo3::Python<'py>,
-                        _slf: *mut _pyo3::ffi::PyObject,
-                        _args: *mut _pyo3::ffi::PyObject,
-                        _kwargs: *mut _pyo3::ffi::PyObject
-                    ) -> _pyo3::PyResult<*mut _pyo3::ffi::PyObject> {
+                        py: #pyo3_path::Python<'py>,
+                        _slf: *mut #pyo3_path::ffi::PyObject,
+                        _args: *mut #pyo3_path::ffi::PyObject,
+                        _kwargs: *mut #pyo3_path::ffi::PyObject
+                    ) -> #pyo3_path::PyResult<*mut #pyo3_path::ffi::PyObject> {
                         let function = #rust_name; // Shadow the function name to avoid #3017
                         #arg_convert
-                        #( #holders )*
-                        #call
+                        #init_holders
+                        #warnings
+                        let result = #call;
+                        result
                     }
                 }
             }
             CallingConvention::TpNew => {
-                let mut holders = Vec::new();
-                let (arg_convert, args) = impl_arg_params(self, cls, false, &mut holders)?;
-                let self_arg = self.tp.self_arg(cls, ExtractErrorMode::Raise, &mut holders);
-                let call = quote! { #rust_name(#self_arg #(#args),*) };
+                let mut holders = Holders::new();
+                let (arg_convert, args) = impl_arg_params(self, cls, false, &mut holders, ctx);
+                let self_arg = self
+                    .tp
+                    .self_arg(cls, ExtractErrorMode::Raise, &mut holders, ctx);
+                let call = quote_spanned! {*output_span=> #rust_name(#self_arg #(#args),*) };
+                let init_holders = holders.init_holders(ctx);
                 quote! {
                     unsafe fn #ident(
-                        py: _pyo3::Python<'_>,
-                        _slf: *mut _pyo3::ffi::PyTypeObject,
-                        _args: *mut _pyo3::ffi::PyObject,
-                        _kwargs: *mut _pyo3::ffi::PyObject
-                    ) -> _pyo3::PyResult<*mut _pyo3::ffi::PyObject> {
-                        use _pyo3::callback::IntoPyCallbackOutput;
+                        py: #pyo3_path::Python<'_>,
+                        _slf: *mut #pyo3_path::ffi::PyTypeObject,
+                        _args: *mut #pyo3_path::ffi::PyObject,
+                        _kwargs: *mut #pyo3_path::ffi::PyObject
+                    ) -> #pyo3_path::PyResult<*mut #pyo3_path::ffi::PyObject> {
+                        use #pyo3_path::impl_::callback::IntoPyCallbackOutput;
                         let function = #rust_name; // Shadow the function name to avoid #3017
                         #arg_convert
-                        #( #holders )*
+                        #init_holders
+                        #warnings
                         let result = #call;
-                        let initializer: _pyo3::PyClassInitializer::<#cls> = result.convert(py)?;
-                        let cell = initializer.create_cell_from_subtype(py, _slf)?;
-                        ::std::result::Result::Ok(cell as *mut _pyo3::ffi::PyObject)
+                        let initializer: #pyo3_path::PyClassInitializer::<#cls> = result.convert(py)?;
+                        #pyo3_path::impl_::pymethods::tp_new_impl(py, initializer, _slf)
                     }
                 }
             }
@@ -652,41 +900,44 @@ impl<'a> FnSpec<'a> {
 
     /// Return a `PyMethodDef` constructor for this function, matching the selected
     /// calling convention.
-    pub fn get_methoddef(&self, wrapper: impl ToTokens, doc: &PythonDoc) -> TokenStream {
+    pub fn get_methoddef(&self, wrapper: impl ToTokens, doc: &PythonDoc, ctx: &Ctx) -> TokenStream {
+        let Ctx { pyo3_path, .. } = ctx;
         let python_name = self.null_terminated_python_name();
         match self.convention {
             CallingConvention::Noargs => quote! {
-                _pyo3::impl_::pymethods::PyMethodDef::noargs(
+                #pyo3_path::impl_::pymethods::PyMethodDef::noargs(
                     #python_name,
-                    _pyo3::impl_::pymethods::PyCFunction({
+                    {
                         unsafe extern "C" fn trampoline(
-                            _slf: *mut _pyo3::ffi::PyObject,
-                            _args: *mut _pyo3::ffi::PyObject,
-                        ) -> *mut _pyo3::ffi::PyObject
+                            _slf: *mut #pyo3_path::ffi::PyObject,
+                            _args: *mut #pyo3_path::ffi::PyObject,
+                        ) -> *mut #pyo3_path::ffi::PyObject
                         {
-                            _pyo3::impl_::trampoline::noargs(
-                                _slf,
-                                _args,
-                                #wrapper
-                            )
+                            unsafe {
+                                #pyo3_path::impl_::trampoline::noargs(
+                                    _slf,
+                                    _args,
+                                    #wrapper
+                                )
+                            }
                         }
                         trampoline
-                    }),
+                    },
                     #doc,
                 )
             },
             CallingConvention::Fastcall => quote! {
-                _pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
+                #pyo3_path::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                     #python_name,
-                    _pyo3::impl_::pymethods::PyCFunctionFastWithKeywords({
+                    {
                         unsafe extern "C" fn trampoline(
-                            _slf: *mut _pyo3::ffi::PyObject,
-                            _args: *const *mut _pyo3::ffi::PyObject,
-                            _nargs: _pyo3::ffi::Py_ssize_t,
-                            _kwnames: *mut _pyo3::ffi::PyObject
-                        ) -> *mut _pyo3::ffi::PyObject
+                            _slf: *mut #pyo3_path::ffi::PyObject,
+                            _args: *const *mut #pyo3_path::ffi::PyObject,
+                            _nargs: #pyo3_path::ffi::Py_ssize_t,
+                            _kwnames: *mut #pyo3_path::ffi::PyObject
+                        ) -> *mut #pyo3_path::ffi::PyObject
                         {
-                            _pyo3::impl_::trampoline::fastcall_with_keywords(
+                            #pyo3_path::impl_::trampoline::fastcall_with_keywords(
                                 _slf,
                                 _args,
                                 _nargs,
@@ -695,21 +946,21 @@ impl<'a> FnSpec<'a> {
                             )
                         }
                         trampoline
-                    }),
+                    },
                     #doc,
                 )
             },
             CallingConvention::Varargs => quote! {
-                _pyo3::impl_::pymethods::PyMethodDef::cfunction_with_keywords(
+                #pyo3_path::impl_::pymethods::PyMethodDef::cfunction_with_keywords(
                     #python_name,
-                    _pyo3::impl_::pymethods::PyCFunctionWithKeywords({
+                    {
                         unsafe extern "C" fn trampoline(
-                            _slf: *mut _pyo3::ffi::PyObject,
-                            _args: *mut _pyo3::ffi::PyObject,
-                            _kwargs: *mut _pyo3::ffi::PyObject,
-                        ) -> *mut _pyo3::ffi::PyObject
+                            _slf: *mut #pyo3_path::ffi::PyObject,
+                            _args: *mut #pyo3_path::ffi::PyObject,
+                            _kwargs: *mut #pyo3_path::ffi::PyObject,
+                        ) -> *mut #pyo3_path::ffi::PyObject
                         {
-                            _pyo3::impl_::trampoline::cfunction_with_keywords(
+                            #pyo3_path::impl_::trampoline::cfunction_with_keywords(
                                 _slf,
                                 _args,
                                 _kwargs,
@@ -717,7 +968,7 @@ impl<'a> FnSpec<'a> {
                             )
                         }
                         trampoline
-                    }),
+                    },
                     #doc,
                 )
             },
@@ -726,11 +977,11 @@ impl<'a> FnSpec<'a> {
     }
 
     /// Forwards to [utils::get_doc] with the text signature of this spec.
-    pub fn get_doc(&self, attrs: &[syn::Attribute]) -> PythonDoc {
+    pub fn get_doc(&self, attrs: &[syn::Attribute], ctx: &Ctx) -> syn::Result<PythonDoc> {
         let text_signature = self
             .text_signature_call_signature()
             .map(|sig| format!("{}{}", self.python_name, sig));
-        utils::get_doc(attrs, text_signature)
+        utils::get_doc(attrs, text_signature, ctx)
     }
 
     /// Creates the parenthesised arguments list for `__text_signature__` snippet based on this spec's signature
@@ -779,10 +1030,7 @@ impl MethodTypeAttribute {
     /// If the attribute does not match one of the attribute names, returns `Ok(None)`.
     ///
     /// Otherwise will either return a parse error or the attribute.
-    fn parse_if_matching_attribute(
-        attr: &syn::Attribute,
-        deprecations: &mut Deprecations,
-    ) -> Result<Option<Self>> {
+    fn parse_if_matching_attribute(attr: &syn::Attribute) -> Result<Option<Self>> {
         fn ensure_no_arguments(meta: &syn::Meta, ident: &str) -> syn::Result<()> {
             match meta {
                 syn::Meta::Path(_) => Ok(()),
@@ -826,11 +1074,6 @@ impl MethodTypeAttribute {
         if path.is_ident("new") {
             ensure_no_arguments(meta, "new")?;
             Ok(Some(MethodTypeAttribute::New(path.span())))
-        } else if path.is_ident("__new__") {
-            let span = path.span();
-            deprecations.push(Deprecation::PyMethodsNewDeprecatedForm, span);
-            ensure_no_arguments(meta, "__new__")?;
-            Ok(Some(MethodTypeAttribute::New(span)))
         } else if path.is_ident("classmethod") {
             ensure_no_arguments(meta, "classmethod")?;
             Ok(Some(MethodTypeAttribute::ClassMethod(path.span())))
@@ -865,15 +1108,12 @@ impl Display for MethodTypeAttribute {
     }
 }
 
-fn parse_method_attributes(
-    attrs: &mut Vec<syn::Attribute>,
-    deprecations: &mut Deprecations,
-) -> Result<Vec<MethodTypeAttribute>> {
+fn parse_method_attributes(attrs: &mut Vec<syn::Attribute>) -> Result<Vec<MethodTypeAttribute>> {
     let mut new_attrs = Vec::new();
     let mut found_attrs = Vec::new();
 
     for attr in attrs.drain(..) {
-        match MethodTypeAttribute::parse_if_matching_attribute(&attr, deprecations)? {
+        match MethodTypeAttribute::parse_if_matching_attribute(&attr)? {
             Some(attr) => found_attrs.push(attr),
             None => new_attrs.push(attr),
         }
@@ -887,7 +1127,7 @@ fn parse_method_attributes(
 const IMPL_TRAIT_ERR: &str = "Python functions cannot have `impl Trait` arguments";
 const RECEIVER_BY_VALUE_ERR: &str =
     "Python objects are shared, so 'self' cannot be moved out of the Python interpreter.
-Try `&self`, `&mut self, `slf: PyRef<'_, Self>` or `slf: PyRefMut<'_, Self>`.";
+Try `&self`, `&mut self, `slf: PyClassGuard<'_, Self>` or `slf: PyClassGuardMut<'_, Self>`.";
 
 fn ensure_signatures_on_valid_method(
     fn_type: &FnType,
@@ -897,15 +1137,18 @@ fn ensure_signatures_on_valid_method(
     if let Some(signature) = signature {
         match fn_type {
             FnType::Getter(_) => {
+                debug_assert!(!fn_type.signature_attribute_allowed());
                 bail_spanned!(signature.kw.span() => "`signature` not allowed with `getter`")
             }
             FnType::Setter(_) => {
+                debug_assert!(!fn_type.signature_attribute_allowed());
                 bail_spanned!(signature.kw.span() => "`signature` not allowed with `setter`")
             }
             FnType::ClassAttribute => {
+                debug_assert!(!fn_type.signature_attribute_allowed());
                 bail_spanned!(signature.kw.span() => "`signature` not allowed with `classattr`")
             }
-            _ => {}
+            _ => debug_assert!(fn_type.signature_attribute_allowed()),
         }
     }
     if let Some(text_signature) = text_signature {
diff --git a/pyo3-macros-backend/src/module.rs b/pyo3-macros-backend/src/module.rs
index ccd84bb363a..831bd677b92 100644
--- a/pyo3-macros-backend/src/module.rs
+++ b/pyo3-macros-backend/src/module.rs
@@ -1,125 +1,579 @@
 //! Code generation for the function that initializes a python module and adds classes and function.
 
+#[cfg(feature = "experimental-inspect")]
+use crate::introspection::{
+    attribute_introspection_code, introspection_id_const, module_introspection_code,
+};
+#[cfg(feature = "experimental-inspect")]
+use crate::utils::expr_to_python;
 use crate::{
-    attributes::{self, take_attributes, take_pyo3_options, CrateAttribute, NameAttribute},
+    attributes::{
+        self, kw, take_attributes, take_pyo3_options, CrateAttribute, GILUsedAttribute,
+        ModuleAttribute, NameAttribute, SubmoduleAttribute,
+    },
+    combine_errors::CombineErrors,
+    get_doc,
+    pyclass::PyClassPyO3Option,
     pyfunction::{impl_wrap_pyfunction, PyFunctionOptions},
-    utils::{get_pyo3_crate, PythonDoc},
+    utils::{has_attribute, has_attribute_with_namespace, Ctx, IdentOrStr},
 };
-use proc_macro2::TokenStream;
+use proc_macro2::{Span, TokenStream};
 use quote::quote;
+use std::ffi::CString;
+use syn::LitCStr;
 use syn::{
     ext::IdentExt,
     parse::{Parse, ParseStream},
+    parse_quote, parse_quote_spanned,
+    punctuated::Punctuated,
     spanned::Spanned,
     token::Comma,
-    Ident, Path, Result, Visibility,
+    Item, Meta, Path, Result,
 };
 
 #[derive(Default)]
 pub struct PyModuleOptions {
     krate: Option<CrateAttribute>,
-    name: Option<syn::Ident>,
+    name: Option<NameAttribute>,
+    module: Option<ModuleAttribute>,
+    submodule: Option<kw::submodule>,
+    gil_used: Option<GILUsedAttribute>,
 }
 
-impl PyModuleOptions {
-    pub fn from_attrs(attrs: &mut Vec<syn::Attribute>) -> Result<Self> {
+impl Parse for PyModuleOptions {
+    fn parse(input: ParseStream<'_>) -> syn::Result<Self> {
         let mut options: PyModuleOptions = Default::default();
 
-        for option in take_pyo3_options(attrs)? {
-            match option {
-                PyModulePyO3Option::Name(name) => options.set_name(name.value.0)?,
-                PyModulePyO3Option::Crate(path) => options.set_crate(path)?,
-            }
-        }
+        options.add_attributes(
+            Punctuated::<PyModulePyO3Option, syn::Token![,]>::parse_terminated(input)?,
+        )?;
 
         Ok(options)
     }
+}
+
+impl PyModuleOptions {
+    fn take_pyo3_options(&mut self, attrs: &mut Vec<syn::Attribute>) -> Result<()> {
+        self.add_attributes(take_pyo3_options(attrs)?)
+    }
 
-    fn set_name(&mut self, name: syn::Ident) -> Result<()> {
-        ensure_spanned!(
-            self.name.is_none(),
-            name.span() => "`name` may only be specified once"
-        );
+    fn add_attributes(
+        &mut self,
+        attrs: impl IntoIterator<Item = PyModulePyO3Option>,
+    ) -> Result<()> {
+        macro_rules! set_option {
+            ($key:ident $(, $extra:literal)?) => {
+                {
+                    ensure_spanned!(
+                        self.$key.is_none(),
+                        $key.span() => concat!("`", stringify!($key), "` may only be specified once" $(, $extra)?)
+                    );
+                    self.$key = Some($key);
+                }
+            };
+        }
+        attrs
+            .into_iter()
+            .map(|attr| {
+                match attr {
+                    PyModulePyO3Option::Crate(krate) => set_option!(krate),
+                    PyModulePyO3Option::Name(name) => set_option!(name),
+                    PyModulePyO3Option::Module(module) => set_option!(module),
+                    PyModulePyO3Option::Submodule(submodule) => set_option!(
+                        submodule,
+                        " (it is implicitly always specified for nested modules)"
+                    ),
+                    PyModulePyO3Option::GILUsed(gil_used) => {
+                        set_option!(gil_used)
+                    }
+                }
 
-        self.name = Some(name);
+                Ok(())
+            })
+            .try_combine_syn_errors()?;
         Ok(())
     }
+}
 
-    fn set_crate(&mut self, path: CrateAttribute) -> Result<()> {
-        ensure_spanned!(
-            self.krate.is_none(),
-            path.span() => "`crate` may only be specified once"
-        );
+pub fn pymodule_module_impl(
+    module: &mut syn::ItemMod,
+    mut options: PyModuleOptions,
+) -> Result<TokenStream> {
+    let syn::ItemMod {
+        attrs,
+        vis,
+        unsafety: _,
+        ident,
+        mod_token,
+        content,
+        semi: _,
+    } = module;
+    let items = if let Some((_, items)) = content {
+        items
+    } else {
+        bail_spanned!(mod_token.span() => "`#[pymodule]` can only be used on inline modules")
+    };
+    options.take_pyo3_options(attrs)?;
+    let ctx = &Ctx::new(&options.krate, None);
+    let Ctx { pyo3_path, .. } = ctx;
+    let doc = get_doc(attrs, None, ctx)?;
+    let name = options
+        .name
+        .map_or_else(|| ident.unraw(), |name| name.value.0);
+    let full_name = if let Some(module) = &options.module {
+        format!("{}.{}", module.value.value(), name)
+    } else {
+        name.to_string()
+    };
 
-        self.krate = Some(path);
+    let mut module_items = Vec::new();
+    let mut module_items_cfg_attrs = Vec::new();
+    #[cfg(feature = "experimental-inspect")]
+    let mut introspection_chunks = Vec::new();
+    #[cfg(not(feature = "experimental-inspect"))]
+    let introspection_chunks = Vec::<TokenStream>::new();
+
+    fn extract_use_items(
+        source: &syn::UseTree,
+        cfg_attrs: &[syn::Attribute],
+        target_items: &mut Vec<syn::Ident>,
+        target_cfg_attrs: &mut Vec<Vec<syn::Attribute>>,
+    ) -> Result<()> {
+        match source {
+            syn::UseTree::Name(name) => {
+                target_items.push(name.ident.clone());
+                target_cfg_attrs.push(cfg_attrs.to_vec());
+            }
+            syn::UseTree::Path(path) => {
+                extract_use_items(&path.tree, cfg_attrs, target_items, target_cfg_attrs)?
+            }
+            syn::UseTree::Group(group) => {
+                for tree in &group.items {
+                    extract_use_items(tree, cfg_attrs, target_items, target_cfg_attrs)?
+                }
+            }
+            syn::UseTree::Glob(glob) => {
+                bail_spanned!(glob.span() => "#[pymodule] cannot import glob statements")
+            }
+            syn::UseTree::Rename(rename) => {
+                target_items.push(rename.rename.clone());
+                target_cfg_attrs.push(cfg_attrs.to_vec());
+            }
+        }
         Ok(())
     }
+
+    let mut pymodule_init = None;
+    let mut module_consts = Vec::new();
+    let mut module_consts_cfg_attrs = Vec::new();
+
+    let _: Vec<()> = (*items).iter_mut().map(|item|{
+        match item {
+            Item::Use(item_use) => {
+                let is_pymodule_export =
+                    find_and_remove_attribute(&mut item_use.attrs, "pymodule_export");
+                if is_pymodule_export {
+                    let cfg_attrs = get_cfg_attributes(&item_use.attrs);
+                    extract_use_items(
+                        &item_use.tree,
+                        &cfg_attrs,
+                        &mut module_items,
+                        &mut module_items_cfg_attrs,
+                    )?;
+                }
+            }
+            Item::Fn(item_fn) => {
+                ensure_spanned!(
+                    !has_attribute(&item_fn.attrs, "pymodule_export"),
+                    item.span() => "`#[pymodule_export]` may only be used on `use` or `const` statements"
+                );
+                let is_pymodule_init =
+                    find_and_remove_attribute(&mut item_fn.attrs, "pymodule_init");
+                let ident = &item_fn.sig.ident;
+                if is_pymodule_init {
+                    ensure_spanned!(
+                        !has_attribute(&item_fn.attrs, "pyfunction"),
+                        item_fn.span() => "`#[pyfunction]` cannot be used alongside `#[pymodule_init]`"
+                    );
+                    ensure_spanned!(pymodule_init.is_none(), item_fn.span() => "only one `#[pymodule_init]` may be specified");
+                    pymodule_init = Some(quote! { #ident(module)?; });
+                } else if has_attribute(&item_fn.attrs, "pyfunction")
+                    || has_attribute_with_namespace(
+                        &item_fn.attrs,
+                        Some(pyo3_path),
+                        &["pyfunction"],
+                    )
+                    || has_attribute_with_namespace(
+                        &item_fn.attrs,
+                        Some(pyo3_path),
+                        &["prelude", "pyfunction"],
+                    )
+                {
+                    module_items.push(ident.clone());
+                    module_items_cfg_attrs.push(get_cfg_attributes(&item_fn.attrs));
+                }
+            }
+            Item::Struct(item_struct) => {
+                ensure_spanned!(
+                    !has_attribute(&item_struct.attrs, "pymodule_export"),
+                    item.span() => "`#[pymodule_export]` may only be used on `use` or `const` statements"
+                );
+                if has_attribute(&item_struct.attrs, "pyclass")
+                    || has_attribute_with_namespace(
+                        &item_struct.attrs,
+                        Some(pyo3_path),
+                        &["pyclass"],
+                    )
+                    || has_attribute_with_namespace(
+                        &item_struct.attrs,
+                        Some(pyo3_path),
+                        &["prelude", "pyclass"],
+                    )
+                {
+                    module_items.push(item_struct.ident.clone());
+                    module_items_cfg_attrs.push(get_cfg_attributes(&item_struct.attrs));
+                    if !has_pyo3_module_declared::<PyClassPyO3Option>(
+                        &item_struct.attrs,
+                        "pyclass",
+                        |option| matches!(option, PyClassPyO3Option::Module(_)),
+                    )? {
+                        set_module_attribute(&mut item_struct.attrs, &full_name);
+                    }
+                }
+            }
+            Item::Enum(item_enum) => {
+                ensure_spanned!(
+                    !has_attribute(&item_enum.attrs, "pymodule_export"),
+                    item.span() => "`#[pymodule_export]` may only be used on `use` or `const` statements"
+                );
+                if has_attribute(&item_enum.attrs, "pyclass")
+                    || has_attribute_with_namespace(&item_enum.attrs, Some(pyo3_path), &["pyclass"])
+                    || has_attribute_with_namespace(
+                        &item_enum.attrs,
+                        Some(pyo3_path),
+                        &["prelude", "pyclass"],
+                    )
+                {
+                    module_items.push(item_enum.ident.clone());
+                    module_items_cfg_attrs.push(get_cfg_attributes(&item_enum.attrs));
+                    if !has_pyo3_module_declared::<PyClassPyO3Option>(
+                        &item_enum.attrs,
+                        "pyclass",
+                        |option| matches!(option, PyClassPyO3Option::Module(_)),
+                    )? {
+                        set_module_attribute(&mut item_enum.attrs, &full_name);
+                    }
+                }
+            }
+            Item::Mod(item_mod) => {
+                ensure_spanned!(
+                    !has_attribute(&item_mod.attrs, "pymodule_export"),
+                    item.span() => "`#[pymodule_export]` may only be used on `use` or `const` statements"
+                );
+                if has_attribute(&item_mod.attrs, "pymodule")
+                    || has_attribute_with_namespace(&item_mod.attrs, Some(pyo3_path), &["pymodule"])
+                    || has_attribute_with_namespace(
+                        &item_mod.attrs,
+                        Some(pyo3_path),
+                        &["prelude", "pymodule"],
+                    )
+                {
+                    module_items.push(item_mod.ident.clone());
+                    module_items_cfg_attrs.push(get_cfg_attributes(&item_mod.attrs));
+                    if !has_pyo3_module_declared::<PyModulePyO3Option>(
+                        &item_mod.attrs,
+                        "pymodule",
+                        |option| matches!(option, PyModulePyO3Option::Module(_)),
+                    )? {
+                        set_module_attribute(&mut item_mod.attrs, &full_name);
+                    }
+                    item_mod
+                        .attrs
+                        .push(parse_quote_spanned!(item_mod.mod_token.span()=> #[pyo3(submodule)]));
+                }
+            }
+            Item::ForeignMod(item) => {
+                ensure_spanned!(
+                    !has_attribute(&item.attrs, "pymodule_export"),
+                    item.span() => "`#[pymodule_export]` may only be used on `use` or `const` statements"
+                );
+            }
+            Item::Trait(item) => {
+                ensure_spanned!(
+                    !has_attribute(&item.attrs, "pymodule_export"),
+                    item.span() => "`#[pymodule_export]` may only be used on `use` or `const` statements"
+                );
+            }
+            Item::Const(item) => {
+                if !find_and_remove_attribute(&mut item.attrs, "pymodule_export") {
+                    return Ok(());
+                }
+                module_consts.push(item.ident.clone());
+                module_consts_cfg_attrs.push(get_cfg_attributes(&item.attrs));
+                #[cfg(feature = "experimental-inspect")]
+                {
+                    let cfg_attrs = get_cfg_attributes(&item.attrs);
+                    let chunk = attribute_introspection_code(
+                        pyo3_path,
+                        None,
+                        item.ident.unraw().to_string(),
+                        expr_to_python(&item.expr),
+                        (*item.ty).clone(),
+                        true,
+                    );
+                    introspection_chunks.push(quote! {
+                        #(#cfg_attrs)*
+                        #chunk
+                    });
+                }
+            }
+            Item::Static(item) => {
+                ensure_spanned!(
+                    !has_attribute(&item.attrs, "pymodule_export"),
+                    item.span() => "`#[pymodule_export]` may only be used on `use` or `const` statements"
+                );
+            }
+            Item::Macro(item) => {
+                ensure_spanned!(
+                    !has_attribute(&item.attrs, "pymodule_export"),
+                    item.span() => "`#[pymodule_export]` may only be used on `use` or `const` statements"
+                );
+            }
+            Item::ExternCrate(item) => {
+                ensure_spanned!(
+                    !has_attribute(&item.attrs, "pymodule_export"),
+                    item.span() => "`#[pymodule_export]` may only be used on `use` or `const` statements"
+                );
+            }
+            Item::Impl(item) => {
+                ensure_spanned!(
+                    !has_attribute(&item.attrs, "pymodule_export"),
+                    item.span() => "`#[pymodule_export]` may only be used on `use` or `const` statements"
+                );
+            }
+            Item::TraitAlias(item) => {
+                ensure_spanned!(
+                    !has_attribute(&item.attrs, "pymodule_export"),
+                    item.span() => "`#[pymodule_export]` may only be used on `use` or `const` statements"
+                );
+            }
+            Item::Type(item) => {
+                ensure_spanned!(
+                    !has_attribute(&item.attrs, "pymodule_export"),
+                    item.span() => "`#[pymodule_export]` may only be used on `use` or `const` statements"
+                );
+            }
+            Item::Union(item) => {
+                ensure_spanned!(
+                    !has_attribute(&item.attrs, "pymodule_export"),
+                    item.span() => "`#[pymodule_export]` may only be used on `use` or `const` statements"
+                );
+            }
+            _ => (),
+        }
+        Ok(())
+    }).try_combine_syn_errors()?;
+
+    #[cfg(feature = "experimental-inspect")]
+    let introspection = module_introspection_code(
+        pyo3_path,
+        &name.to_string(),
+        &module_items,
+        &module_items_cfg_attrs,
+        pymodule_init.is_some(),
+    );
+    #[cfg(not(feature = "experimental-inspect"))]
+    let introspection = quote! {};
+    #[cfg(feature = "experimental-inspect")]
+    let introspection_id = introspection_id_const();
+    #[cfg(not(feature = "experimental-inspect"))]
+    let introspection_id = quote! {};
+
+    let module_def = quote! {{
+        use #pyo3_path::impl_::pymodule as impl_;
+        const INITIALIZER: impl_::ModuleInitializer = impl_::ModuleInitializer(__pyo3_pymodule);
+        unsafe {
+           impl_::ModuleDef::new(
+                __PYO3_NAME,
+                #doc,
+                INITIALIZER
+            )
+        }
+    }};
+    let initialization = module_initialization(
+        &name,
+        ctx,
+        module_def,
+        options.submodule.is_some(),
+        options.gil_used.is_none_or(|op| op.value.value),
+    );
+
+    let module_consts_names = module_consts.iter().map(|i| i.unraw().to_string());
+
+    Ok(quote!(
+        #(#attrs)*
+        #vis #mod_token #ident {
+            #(#items)*
+
+            #initialization
+            #introspection
+            #introspection_id
+            #(#introspection_chunks)*
+
+            fn __pyo3_pymodule(module: &#pyo3_path::Bound<'_, #pyo3_path::types::PyModule>) -> #pyo3_path::PyResult<()> {
+                use #pyo3_path::impl_::pymodule::PyAddToModule;
+                #(
+                    #(#module_items_cfg_attrs)*
+                    #module_items::_PYO3_DEF.add_to_module(module)?;
+                )*
+
+                #(
+                    #(#module_consts_cfg_attrs)*
+                    #pyo3_path::types::PyModuleMethods::add(module, #module_consts_names, #module_consts)?;
+                )*
+
+                #pymodule_init
+                ::std::result::Result::Ok(())
+            }
+        }
+    ))
 }
 
 /// Generates the function that is called by the python interpreter to initialize the native
 /// module
-pub fn pymodule_impl(
-    fnname: &Ident,
-    options: PyModuleOptions,
-    doc: PythonDoc,
-    visibility: &Visibility,
-) -> TokenStream {
-    let name = options.name.unwrap_or_else(|| fnname.unraw());
-    let krate = get_pyo3_crate(&options.krate);
-    let pyinit_symbol = format!("PyInit_{}", name);
+pub fn pymodule_function_impl(
+    function: &mut syn::ItemFn,
+    mut options: PyModuleOptions,
+) -> Result<TokenStream> {
+    options.take_pyo3_options(&mut function.attrs)?;
+    process_functions_in_module(&options, function)?;
+    let ctx = &Ctx::new(&options.krate, None);
+    let Ctx { pyo3_path, .. } = ctx;
+    let ident = &function.sig.ident;
+    let name = options
+        .name
+        .map_or_else(|| ident.unraw(), |name| name.value.0);
+    let vis = &function.vis;
+    let doc = get_doc(&function.attrs, None, ctx)?;
 
-    quote! {
-        // Create a module with the same name as the `#[pymodule]` - this way `use <the module>`
-        // will actually bring both the module and the function into scope.
-        #[doc(hidden)]
-        #visibility mod #fnname {
-            pub(crate) struct MakeDef;
-            pub static DEF: #krate::impl_::pymodule::ModuleDef = MakeDef::make_def();
-            pub const NAME: &'static str = concat!(stringify!(#name), "\0");
+    let initialization = module_initialization(
+        &name,
+        ctx,
+        quote! { MakeDef::make_def() },
+        false,
+        options.gil_used.is_none_or(|op| op.value.value),
+    );
 
-            /// This autogenerated function is called by the python interpreter when importing
-            /// the module.
-            #[export_name = #pyinit_symbol]
-            pub unsafe extern "C" fn init() -> *mut #krate::ffi::PyObject {
-                #krate::impl_::trampoline::module_init(|py| DEF.make_module(py))
-            }
+    #[cfg(feature = "experimental-inspect")]
+    let introspection =
+        module_introspection_code(pyo3_path, &name.unraw().to_string(), &[], &[], true);
+    #[cfg(not(feature = "experimental-inspect"))]
+    let introspection = quote! {};
+    #[cfg(feature = "experimental-inspect")]
+    let introspection_id = introspection_id_const();
+    #[cfg(not(feature = "experimental-inspect"))]
+    let introspection_id = quote! {};
+
+    // Module function called with optional Python<'_> marker as first arg, followed by the module.
+    let mut module_args = Vec::new();
+    if function.sig.inputs.len() == 2 {
+        module_args.push(quote!(module.py()));
+    }
+    module_args
+        .push(quote!(::std::convert::Into::into(#pyo3_path::impl_::pymethods::BoundRef(module))));
+
+    Ok(quote! {
+        #[doc(hidden)]
+        #vis mod #ident {
+            #initialization
+            #introspection
+            #introspection_id
         }
 
         // Generate the definition inside an anonymous function in the same scope as the original function -
         // this avoids complications around the fact that the generated module has a different scope
         // (and `super` doesn't always refer to the outer scope, e.g. if the `#[pymodule] is
         // inside a function body)
-        const _: () = {
-            use #krate::impl_::pymodule as impl_;
-            impl #fnname::MakeDef {
-                const fn make_def() -> impl_::ModuleDef {
-                    const INITIALIZER: impl_::ModuleInitializer = impl_::ModuleInitializer(#fnname);
-                    unsafe {
-                        impl_::ModuleDef::new(#fnname::NAME, #doc, INITIALIZER)
-                    }
+        #[allow(unknown_lints, non_local_definitions)]
+        impl #ident::MakeDef {
+            const fn make_def() -> #pyo3_path::impl_::pymodule::ModuleDef {
+                fn __pyo3_pymodule(module: &#pyo3_path::Bound<'_, #pyo3_path::types::PyModule>) -> #pyo3_path::PyResult<()> {
+                    #ident(#(#module_args),*)
+                }
+
+                const INITIALIZER: #pyo3_path::impl_::pymodule::ModuleInitializer = #pyo3_path::impl_::pymodule::ModuleInitializer(__pyo3_pymodule);
+                unsafe {
+                    #pyo3_path::impl_::pymodule::ModuleDef::new(
+                        #ident::__PYO3_NAME,
+                        #doc,
+                        INITIALIZER
+                    )
                 }
             }
-        };
+        }
+    })
+}
+
+fn module_initialization(
+    name: &syn::Ident,
+    ctx: &Ctx,
+    module_def: TokenStream,
+    is_submodule: bool,
+    gil_used: bool,
+) -> TokenStream {
+    let Ctx { pyo3_path, .. } = ctx;
+    let pyinit_symbol = format!("PyInit_{name}");
+    let name = name.to_string();
+    let pyo3_name = LitCStr::new(&CString::new(name).unwrap(), Span::call_site());
+
+    let mut result = quote! {
+        #[doc(hidden)]
+        pub const __PYO3_NAME: &'static ::std::ffi::CStr = #pyo3_name;
+
+        pub(super) struct MakeDef;
+        #[doc(hidden)]
+        pub static _PYO3_DEF: #pyo3_path::impl_::pymodule::ModuleDef = #module_def;
+        #[doc(hidden)]
+        // so wrapped submodules can see what gil_used is
+        pub static __PYO3_GIL_USED: bool = #gil_used;
+    };
+    if !is_submodule {
+        result.extend(quote! {
+            /// This autogenerated function is called by the python interpreter when importing
+            /// the module.
+            #[doc(hidden)]
+            #[export_name = #pyinit_symbol]
+            pub unsafe extern "C" fn __pyo3_init() -> *mut #pyo3_path::ffi::PyObject {
+                unsafe { #pyo3_path::impl_::trampoline::module_init(|py| _PYO3_DEF.make_module(py, #gil_used)) }
+            }
+        });
     }
+    result
 }
 
 /// Finds and takes care of the #[pyfn(...)] in `#[pymodule]`
-pub fn process_functions_in_module(
-    options: &PyModuleOptions,
-    func: &mut syn::ItemFn,
-) -> syn::Result<()> {
+fn process_functions_in_module(options: &PyModuleOptions, func: &mut syn::ItemFn) -> Result<()> {
+    let ctx = &Ctx::new(&options.krate, None);
+    let Ctx { pyo3_path, .. } = ctx;
     let mut stmts: Vec<syn::Stmt> = Vec::new();
-    let krate = get_pyo3_crate(&options.krate);
 
     for mut stmt in func.block.stmts.drain(..) {
-        if let syn::Stmt::Item(syn::Item::Fn(func)) = &mut stmt {
-            if let Some(pyfn_args) = get_pyfn_attr(&mut func.attrs)? {
+        if let syn::Stmt::Item(Item::Fn(func)) = &mut stmt {
+            if let Some((pyfn_span, pyfn_args)) = get_pyfn_attr(&mut func.attrs)? {
                 let module_name = pyfn_args.modname;
                 let wrapped_function = impl_wrap_pyfunction(func, pyfn_args.options)?;
                 let name = &func.sig.ident;
-                let statements: Vec<syn::Stmt> = syn::parse_quote! {
+                let statements: Vec<syn::Stmt> = syn::parse_quote_spanned! {
+                    pyfn_span =>
                     #wrapped_function
-                    #module_name.add_function(#krate::impl_::pyfunction::_wrap_pyfunction(&#name::DEF, #module_name)?)?;
+                    {
+                        use #pyo3_path::types::PyModuleMethods;
+                        #module_name.add_function(#pyo3_path::wrap_pyfunction!(#name, #module_name.as_borrowed())?)?;
+                        #[deprecated(note = "`pyfn` will be removed in a future PyO3 version, use declarative `#[pymodule]` with `mod` instead")]
+                        #[allow(dead_code)]
+                        const PYFN_ATTRIBUTE: () = ();
+                        const _: () = PYFN_ATTRIBUTE;
+                    }
                 };
                 stmts.extend(statements);
             }
@@ -159,8 +613,8 @@ impl Parse for PyFnArgs {
 }
 
 /// Extracts the data from the #[pyfn(...)] attribute of a function
-fn get_pyfn_attr(attrs: &mut Vec<syn::Attribute>) -> syn::Result<Option<PyFnArgs>> {
-    let mut pyfn_args: Option<PyFnArgs> = None;
+fn get_pyfn_attr(attrs: &mut Vec<syn::Attribute>) -> syn::Result<Option<(Span, PyFnArgs)>> {
+    let mut pyfn_args: Option<(Span, PyFnArgs)> = None;
 
     take_attributes(attrs, |attr| {
         if attr.path().is_ident("pyfn") {
@@ -168,14 +622,14 @@ fn get_pyfn_attr(attrs: &mut Vec<syn::Attribute>) -> syn::Result<Option<PyFnArgs
                 pyfn_args.is_none(),
                 attr.span() => "`#[pyfn] may only be specified once"
             );
-            pyfn_args = Some(attr.parse_args()?);
+            pyfn_args = Some((attr.path().span(), attr.parse_args()?));
             Ok(true)
         } else {
             Ok(false)
         }
     })?;
 
-    if let Some(pyfn_args) = &mut pyfn_args {
+    if let Some((_, pyfn_args)) = &mut pyfn_args {
         pyfn_args
             .options
             .add_attributes(take_pyo3_options(attrs)?)?;
@@ -184,9 +638,65 @@ fn get_pyfn_attr(attrs: &mut Vec<syn::Attribute>) -> syn::Result<Option<PyFnArgs
     Ok(pyfn_args)
 }
 
+fn get_cfg_attributes(attrs: &[syn::Attribute]) -> Vec<syn::Attribute> {
+    attrs
+        .iter()
+        .filter(|attr| attr.path().is_ident("cfg"))
+        .cloned()
+        .collect()
+}
+
+fn find_and_remove_attribute(attrs: &mut Vec<syn::Attribute>, ident: &str) -> bool {
+    let mut found = false;
+    attrs.retain(|attr| {
+        if attr.path().is_ident(ident) {
+            found = true;
+            false
+        } else {
+            true
+        }
+    });
+    found
+}
+
+impl PartialEq<syn::Ident> for IdentOrStr<'_> {
+    fn eq(&self, other: &syn::Ident) -> bool {
+        match self {
+            IdentOrStr::Str(s) => other == s,
+            IdentOrStr::Ident(i) => other == i,
+        }
+    }
+}
+
+fn set_module_attribute(attrs: &mut Vec<syn::Attribute>, module_name: &str) {
+    attrs.push(parse_quote!(#[pyo3(module = #module_name)]));
+}
+
+fn has_pyo3_module_declared<T: Parse>(
+    attrs: &[syn::Attribute],
+    root_attribute_name: &str,
+    is_module_option: impl Fn(&T) -> bool + Copy,
+) -> Result<bool> {
+    for attr in attrs {
+        if (attr.path().is_ident("pyo3") || attr.path().is_ident(root_attribute_name))
+            && matches!(attr.meta, Meta::List(_))
+        {
+            for option in &attr.parse_args_with(Punctuated::<T, Comma>::parse_terminated)? {
+                if is_module_option(option) {
+                    return Ok(true);
+                }
+            }
+        }
+    }
+    Ok(false)
+}
+
 enum PyModulePyO3Option {
+    Submodule(SubmoduleAttribute),
     Crate(CrateAttribute),
     Name(NameAttribute),
+    Module(ModuleAttribute),
+    GILUsed(GILUsedAttribute),
 }
 
 impl Parse for PyModulePyO3Option {
@@ -196,6 +706,12 @@ impl Parse for PyModulePyO3Option {
             input.parse().map(PyModulePyO3Option::Name)
         } else if lookahead.peek(syn::Token![crate]) {
             input.parse().map(PyModulePyO3Option::Crate)
+        } else if lookahead.peek(attributes::kw::module) {
+            input.parse().map(PyModulePyO3Option::Module)
+        } else if lookahead.peek(attributes::kw::submodule) {
+            input.parse().map(PyModulePyO3Option::Submodule)
+        } else if lookahead.peek(attributes::kw::gil_used) {
+            input.parse().map(PyModulePyO3Option::GILUsed)
         } else {
             Err(lookahead.error())
         }
diff --git a/pyo3-macros-backend/src/params.rs b/pyo3-macros-backend/src/params.rs
index 3781b41b765..9e71630346b 100644
--- a/pyo3-macros-backend/src/params.rs
+++ b/pyo3-macros-backend/src/params.rs
@@ -1,27 +1,46 @@
+use crate::utils::Ctx;
 use crate::{
-    method::{FnArg, FnSpec},
+    attributes::FromPyWithAttribute,
+    method::{FnArg, FnSpec, RegularArg},
     pyfunction::FunctionSignature,
     quotes::some_wrap,
 };
 use proc_macro2::{Span, TokenStream};
-use quote::{quote, quote_spanned};
+use quote::{format_ident, quote, quote_spanned};
 use syn::spanned::Spanned;
-use syn::Result;
+
+pub struct Holders {
+    holders: Vec<syn::Ident>,
+}
+
+impl Holders {
+    pub fn new() -> Self {
+        Holders {
+            holders: Vec::new(),
+        }
+    }
+
+    pub fn push_holder(&mut self, span: Span) -> syn::Ident {
+        let holder = syn::Ident::new(&format!("holder_{}", self.holders.len()), span);
+        self.holders.push(holder.clone());
+        holder
+    }
+
+    pub fn init_holders(&self, ctx: &Ctx) -> TokenStream {
+        let Ctx { pyo3_path, .. } = ctx;
+        let holders = &self.holders;
+        quote! {
+            #[allow(clippy::let_unit_value)]
+            #(let mut #holders = #pyo3_path::impl_::extract_argument::FunctionArgumentHolder::INIT;)*
+        }
+    }
+}
 
 /// Return true if the argument list is simply (*args, **kwds).
 pub fn is_forwarded_args(signature: &FunctionSignature<'_>) -> bool {
     matches!(
         signature.arguments.as_slice(),
-        [
-            FnArg {
-                is_varargs: true,
-                ..
-            },
-            FnArg {
-                is_kwargs: true,
-                ..
-            },
-        ]
+        [FnArg::VarArgs(..), FnArg::KwArgs(..),]
     )
 }
 
@@ -29,9 +48,25 @@ pub fn impl_arg_params(
     spec: &FnSpec<'_>,
     self_: Option<&syn::Type>,
     fastcall: bool,
-    holders: &mut Vec<TokenStream>,
-) -> Result<(TokenStream, Vec<TokenStream>)> {
+    holders: &mut Holders,
+    ctx: &Ctx,
+) -> (TokenStream, Vec<TokenStream>) {
     let args_array = syn::Ident::new("output", Span::call_site());
+    let Ctx { pyo3_path, .. } = ctx;
+
+    let from_py_with = spec
+        .signature
+        .arguments
+        .iter()
+        .enumerate()
+        .filter_map(|(i, arg)| {
+            let from_py_with = &arg.from_py_with()?.value;
+            let from_py_with_holder = format_ident!("from_py_with_{}", i);
+            Some(quote_spanned! { from_py_with.span() =>
+                let #from_py_with_holder = #from_py_with;
+            })
+        })
+        .collect::<TokenStream>();
 
     if !fastcall && is_forwarded_args(&spec.signature) {
         // In the varargs convention, we can just pass though if the signature
@@ -40,15 +75,17 @@ pub fn impl_arg_params(
             .signature
             .arguments
             .iter()
-            .map(|arg| impl_arg_param(arg, &mut 0, &args_array, holders))
-            .collect::<Result<_>>()?;
-        return Ok((
+            .enumerate()
+            .map(|(i, arg)| impl_arg_param(arg, i, &mut 0, holders, ctx))
+            .collect();
+        return (
             quote! {
-                let _args = py.from_borrowed_ptr::<_pyo3::types::PyTuple>(_args);
-                let _kwargs: ::std::option::Option<&_pyo3::types::PyDict> = py.from_borrowed_ptr_or_opt(_kwargs);
+                let _args = unsafe { #pyo3_path::impl_::pymethods::BoundRef::ref_from_ptr(py, &_args) };
+                let _kwargs = #pyo3_path::impl_::pymethods::BoundRef::ref_from_ptr_or_opt(py, &_kwargs);
+                #from_py_with
             },
             arg_convert,
-        ));
+        );
     };
 
     let positional_parameter_names = &spec.signature.python_signature.positional_parameters;
@@ -64,7 +101,7 @@ pub fn impl_arg_params(
         .iter()
         .map(|(name, required)| {
             quote! {
-                _pyo3::impl_::extract_argument::KeywordOnlyParameterDescription {
+                #pyo3_path::impl_::extract_argument::KeywordOnlyParameterDescription {
                     name: #name,
                     required: #required,
                 }
@@ -73,27 +110,28 @@ pub fn impl_arg_params(
 
     let num_params = positional_parameter_names.len() + keyword_only_parameters.len();
 
-    let mut option_pos = 0;
+    let mut option_pos = 0usize;
     let param_conversion = spec
         .signature
         .arguments
         .iter()
-        .map(|arg| impl_arg_param(arg, &mut option_pos, &args_array, holders))
-        .collect::<Result<_>>()?;
+        .enumerate()
+        .map(|(i, arg)| impl_arg_param(arg, i, &mut option_pos, holders, ctx))
+        .collect();
 
     let args_handler = if spec.signature.python_signature.varargs.is_some() {
-        quote! { _pyo3::impl_::extract_argument::TupleVarargs }
+        quote! { #pyo3_path::impl_::extract_argument::TupleVarargs }
     } else {
-        quote! { _pyo3::impl_::extract_argument::NoVarargs }
+        quote! { #pyo3_path::impl_::extract_argument::NoVarargs }
     };
     let kwargs_handler = if spec.signature.python_signature.kwargs.is_some() {
-        quote! { _pyo3::impl_::extract_argument::DictVarkeywords }
+        quote! { #pyo3_path::impl_::extract_argument::DictVarkeywords }
     } else {
-        quote! { _pyo3::impl_::extract_argument::NoVarkeywords }
+        quote! { #pyo3_path::impl_::extract_argument::NoVarkeywords }
     };
 
     let cls_name = if let Some(cls) = self_ {
-        quote! { ::std::option::Option::Some(<#cls as _pyo3::type_object::PyTypeInfo>::NAME) }
+        quote! { ::std::option::Option::Some(<#cls as #pyo3_path::type_object::PyTypeInfo>::NAME) }
     } else {
         quote! { ::std::option::Option::None }
     };
@@ -121,9 +159,9 @@ pub fn impl_arg_params(
     };
 
     // create array of arguments, and then parse
-    Ok((
+    (
         quote! {
-                const DESCRIPTION: _pyo3::impl_::extract_argument::FunctionDescription = _pyo3::impl_::extract_argument::FunctionDescription {
+                const DESCRIPTION: #pyo3_path::impl_::extract_argument::FunctionDescription = #pyo3_path::impl_::extract_argument::FunctionDescription {
                     cls_name: #cls_name,
                     func_name: stringify!(#python_name),
                     positional_parameter_names: &[#(#positional_parameter_names),*],
@@ -133,136 +171,136 @@ pub fn impl_arg_params(
                 };
                 let mut #args_array = [::std::option::Option::None; #num_params];
                 let (_args, _kwargs) = #extract_expression;
+                #from_py_with
         },
         param_conversion,
-    ))
+    )
 }
 
-/// Re option_pos: The option slice doesn't contain the py: Python argument, so the argument
-/// index and the index in option diverge when using py: Python
 fn impl_arg_param(
     arg: &FnArg<'_>,
+    pos: usize,
     option_pos: &mut usize,
-    args_array: &syn::Ident,
-    holders: &mut Vec<TokenStream>,
-) -> Result<TokenStream> {
-    // Use this macro inside this function, to ensure that all code generated here is associated
-    // with the function argument
-    macro_rules! quote_arg_span {
-        ($($tokens:tt)*) => { quote_spanned!(arg.ty.span() => $($tokens)*) }
-    }
-
-    if arg.py {
-        return Ok(quote! { py });
-    }
+    holders: &mut Holders,
+    ctx: &Ctx,
+) -> TokenStream {
+    let Ctx { pyo3_path, .. } = ctx;
+    let args_array = syn::Ident::new("output", Span::call_site());
 
-    if arg.is_cancel_handle {
-        return Ok(quote! { __cancel_handle });
+    match arg {
+        FnArg::Regular(arg) => {
+            let from_py_with = format_ident!("from_py_with_{}", pos);
+            let arg_value = quote!(#args_array[#option_pos].as_deref());
+            *option_pos += 1;
+            impl_regular_arg_param(arg, from_py_with, arg_value, holders, ctx)
+        }
+        FnArg::VarArgs(arg) => {
+            let holder = holders.push_holder(arg.name.span());
+            let name_str = arg.name.to_string();
+            quote_spanned! { arg.name.span() =>
+                #pyo3_path::impl_::extract_argument::extract_argument(
+                    &_args,
+                    &mut #holder,
+                    #name_str
+                )?
+            }
+        }
+        FnArg::KwArgs(arg) => {
+            let holder = holders.push_holder(arg.name.span());
+            let name_str = arg.name.to_string();
+            quote_spanned! { arg.name.span() =>
+                #pyo3_path::impl_::extract_argument::extract_argument_with_default(
+                    _kwargs.as_deref(),
+                    &mut #holder,
+                    #name_str,
+                    || ::std::option::Option::None
+                )?
+            }
+        }
+        FnArg::Py(..) => quote! { py },
+        FnArg::CancelHandle(..) => quote! { __cancel_handle },
     }
+}
 
-    let name = arg.name;
-    let name_str = name.to_string();
+/// Re option_pos: The option slice doesn't contain the py: Python argument, so the argument
+/// index and the index in option diverge when using py: Python
+pub(crate) fn impl_regular_arg_param(
+    arg: &RegularArg<'_>,
+    from_py_with: syn::Ident,
+    arg_value: TokenStream, // expected type: Option<&'a Bound<'py, PyAny>>
+    holders: &mut Holders,
+    ctx: &Ctx,
+) -> TokenStream {
+    let Ctx { pyo3_path, .. } = ctx;
+    let pyo3_path = pyo3_path.to_tokens_spanned(arg.ty.span());
 
-    let mut push_holder = || {
-        let holder = syn::Ident::new(&format!("holder_{}", holders.len()), arg.ty.span());
-        holders.push(quote_arg_span! {
-            #[allow(clippy::let_unit_value)]
-            let mut #holder = _pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
-        });
-        holder
+    // Use this macro inside this function, to ensure that all code generated here is associated
+    // with the function argument
+    let use_probe = quote! {
+        #[allow(unused_imports)]
+        use #pyo3_path::impl_::pyclass::Probe as _;
     };
-
-    if arg.is_varargs {
-        ensure_spanned!(
-            arg.optional.is_none(),
-            arg.name.span() => "args cannot be optional"
-        );
-        let holder = push_holder();
-        return Ok(quote_arg_span! {
-            _pyo3::impl_::extract_argument::extract_argument(
-                _args,
-                &mut #holder,
-                #name_str
-            )?
-        });
-    } else if arg.is_kwargs {
-        ensure_spanned!(
-            arg.optional.is_some(),
-            arg.name.span() => "kwargs must be Option<_>"
-        );
-        let holder = push_holder();
-        return Ok(quote_arg_span! {
-            _pyo3::impl_::extract_argument::extract_optional_argument(
-                _kwargs.map(::std::convert::AsRef::as_ref),
-                &mut #holder,
-                #name_str,
-                || ::std::option::Option::None
-            )?
-        });
+    macro_rules! quote_arg_span {
+        ($($tokens:tt)*) => { quote_spanned!(arg.ty.span() => { #use_probe $($tokens)* }) }
     }
 
-    let arg_value = quote_arg_span!(#args_array[#option_pos]);
-    *option_pos += 1;
-
-    let mut default = arg.default.as_ref().map(|expr| quote!(#expr));
+    let name_str = arg.name.to_string();
+    let mut default = arg.default_value.as_ref().map(|expr| quote!(#expr));
 
     // Option<T> arguments have special treatment: the default should be specified _without_ the
     // Some() wrapper. Maybe this should be changed in future?!
-    if arg.optional.is_some() {
-        default = Some(default.map_or_else(|| quote!(::std::option::Option::None), some_wrap));
+    if arg.option_wrapped_type.is_some() {
+        default = default.map(|tokens| some_wrap(tokens, ctx));
     }
 
-    let tokens = if let Some(expr_path) = arg.attrs.from_py_with.as_ref().map(|attr| &attr.value) {
+    if let Some(FromPyWithAttribute { kw, .. }) = arg.from_py_with {
+        let extractor = quote_spanned! { kw.span =>
+            { let from_py_with: fn(_) -> _ = #from_py_with; from_py_with }
+        };
         if let Some(default) = default {
             quote_arg_span! {
-                #[allow(clippy::redundant_closure)]
-                _pyo3::impl_::extract_argument::from_py_with_with_default(
-                    #arg_value.map(_pyo3::PyNativeType::as_borrowed).as_deref(),
+                #pyo3_path::impl_::extract_argument::from_py_with_with_default(
+                    #arg_value,
                     #name_str,
-                    #expr_path as fn(_) -> _,
-                    || #default
+                    #extractor,
+                    #[allow(clippy::redundant_closure)]
+                    {
+                        || #default
+                    }
                 )?
             }
         } else {
+            let unwrap = quote! {unsafe { #pyo3_path::impl_::extract_argument::unwrap_required_argument(#arg_value) }};
             quote_arg_span! {
-                _pyo3::impl_::extract_argument::from_py_with(
-                    &_pyo3::impl_::extract_argument::unwrap_required_argument(#arg_value).as_borrowed(),
+                #pyo3_path::impl_::extract_argument::from_py_with(
+                    #unwrap,
                     #name_str,
-                    #expr_path as fn(_) -> _,
+                    #extractor,
                 )?
             }
         }
-    } else if arg.optional.is_some() {
-        let holder = push_holder();
-        quote_arg_span! {
-            #[allow(clippy::redundant_closure)]
-            _pyo3::impl_::extract_argument::extract_optional_argument(
-                #arg_value,
-                &mut #holder,
-                #name_str,
-                || #default
-            )?
-        }
     } else if let Some(default) = default {
-        let holder = push_holder();
+        let holder = holders.push_holder(arg.name.span());
         quote_arg_span! {
-            #[allow(clippy::redundant_closure)]
-            _pyo3::impl_::extract_argument::extract_argument_with_default(
+            #pyo3_path::impl_::extract_argument::extract_argument_with_default(
                 #arg_value,
                 &mut #holder,
                 #name_str,
-                || #default
+                #[allow(clippy::redundant_closure)]
+                {
+                    || #default
+                }
             )?
         }
     } else {
-        let holder = push_holder();
+        let holder = holders.push_holder(arg.name.span());
+        let unwrap = quote! {unsafe { #pyo3_path::impl_::extract_argument::unwrap_required_argument(#arg_value) }};
         quote_arg_span! {
-            _pyo3::impl_::extract_argument::extract_argument(
-                _pyo3::impl_::extract_argument::unwrap_required_argument(#arg_value),
+            #pyo3_path::impl_::extract_argument::extract_argument(
+                #unwrap,
                 &mut #holder,
                 #name_str
             )?
         }
-    };
-    Ok(tokens)
+    }
 }
diff --git a/pyo3-macros-backend/src/pyclass.rs b/pyo3-macros-backend/src/pyclass.rs
index 02024011366..07fccf3d655 100644
--- a/pyo3-macros-backend/src/pyclass.rs
+++ b/pyo3-macros-backend/src/pyclass.rs
@@ -1,26 +1,39 @@
 use std::borrow::Cow;
+use std::fmt::Debug;
+
+use proc_macro2::{Ident, Span, TokenStream};
+use quote::{format_ident, quote, quote_spanned, ToTokens};
+use syn::ext::IdentExt;
+use syn::parse::{Parse, ParseStream};
+use syn::punctuated::Punctuated;
+use syn::{parse_quote, parse_quote_spanned, spanned::Spanned, ImplItemFn, Result, Token};
 
 use crate::attributes::kw::frozen;
 use crate::attributes::{
     self, kw, take_pyo3_options, CrateAttribute, ExtendsAttribute, FreelistAttribute,
-    ModuleAttribute, NameAttribute, NameLitStr, RenameAllAttribute,
+    ModuleAttribute, NameAttribute, NameLitStr, RenameAllAttribute, StrFormatterAttribute,
+};
+use crate::combine_errors::CombineErrors;
+#[cfg(feature = "experimental-inspect")]
+use crate::introspection::{
+    class_introspection_code, function_introspection_code, introspection_id_const,
 };
-use crate::deprecations::Deprecations;
 use crate::konst::{ConstAttributes, ConstSpec};
-use crate::method::{FnArg, FnSpec};
-use crate::pyimpl::{gen_py_const, PyClassMethodsType};
+use crate::method::{FnArg, FnSpec, PyArg, RegularArg};
+use crate::pyfunction::ConstructorAttribute;
+#[cfg(feature = "experimental-inspect")]
+use crate::pyfunction::FunctionSignature;
+use crate::pyimpl::{gen_py_const, get_cfg_attributes, PyClassMethodsType};
+#[cfg(feature = "experimental-inspect")]
+use crate::pymethod::field_python_name;
 use crate::pymethod::{
-    impl_py_getter_def, impl_py_setter_def, MethodAndMethodDef, MethodAndSlotDef, PropertyType,
-    SlotDef, __INT__, __REPR__, __RICHCMP__,
+    impl_py_class_attribute, impl_py_getter_def, impl_py_setter_def, MethodAndMethodDef,
+    MethodAndSlotDef, PropertyType, SlotDef, __GETITEM__, __HASH__, __INT__, __LEN__, __REPR__,
+    __RICHCMP__, __STR__,
 };
-use crate::utils::{self, apply_renaming_rule, get_pyo3_crate, PythonDoc};
+use crate::pyversions::{is_abi3_before, is_py_before};
+use crate::utils::{self, apply_renaming_rule, Ctx, PythonDoc};
 use crate::PyFunctionOptions;
-use proc_macro2::{Ident, Span, TokenStream};
-use quote::{format_ident, quote};
-use syn::ext::IdentExt;
-use syn::parse::{Parse, ParseStream};
-use syn::punctuated::Punctuated;
-use syn::{parse_quote, spanned::Spanned, Result, Token};
 
 /// If the class is derived from a Rust `struct` or `enum`.
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
@@ -44,7 +57,7 @@ impl PyClassArgs {
         })
     }
 
-    pub fn parse_stuct_args(input: ParseStream<'_>) -> syn::Result<Self> {
+    pub fn parse_struct_args(input: ParseStream<'_>) -> syn::Result<Self> {
         Self::parse(input, PyClassKind::Struct)
     }
 
@@ -57,37 +70,55 @@ impl PyClassArgs {
 pub struct PyClassPyO3Options {
     pub krate: Option<CrateAttribute>,
     pub dict: Option<kw::dict>,
+    pub eq: Option<kw::eq>,
+    pub eq_int: Option<kw::eq_int>,
     pub extends: Option<ExtendsAttribute>,
     pub get_all: Option<kw::get_all>,
     pub freelist: Option<FreelistAttribute>,
     pub frozen: Option<kw::frozen>,
+    pub hash: Option<kw::hash>,
+    pub immutable_type: Option<kw::immutable_type>,
     pub mapping: Option<kw::mapping>,
     pub module: Option<ModuleAttribute>,
     pub name: Option<NameAttribute>,
+    pub ord: Option<kw::ord>,
     pub rename_all: Option<RenameAllAttribute>,
     pub sequence: Option<kw::sequence>,
     pub set_all: Option<kw::set_all>,
+    pub str: Option<StrFormatterAttribute>,
     pub subclass: Option<kw::subclass>,
     pub unsendable: Option<kw::unsendable>,
     pub weakref: Option<kw::weakref>,
+    pub generic: Option<kw::generic>,
+    pub from_py_object: Option<kw::from_py_object>,
+    pub skip_from_py_object: Option<kw::skip_from_py_object>,
 }
 
-enum PyClassPyO3Option {
+pub enum PyClassPyO3Option {
     Crate(CrateAttribute),
     Dict(kw::dict),
+    Eq(kw::eq),
+    EqInt(kw::eq_int),
     Extends(ExtendsAttribute),
     Freelist(FreelistAttribute),
     Frozen(kw::frozen),
     GetAll(kw::get_all),
+    Hash(kw::hash),
+    ImmutableType(kw::immutable_type),
     Mapping(kw::mapping),
     Module(ModuleAttribute),
     Name(NameAttribute),
+    Ord(kw::ord),
     RenameAll(RenameAllAttribute),
     Sequence(kw::sequence),
     SetAll(kw::set_all),
+    Str(StrFormatterAttribute),
     Subclass(kw::subclass),
     Unsendable(kw::unsendable),
     Weakref(kw::weakref),
+    Generic(kw::generic),
+    FromPyObject(kw::from_py_object),
+    SkipFromPyObject(kw::skip_from_py_object),
 }
 
 impl Parse for PyClassPyO3Option {
@@ -97,6 +128,10 @@ impl Parse for PyClassPyO3Option {
             input.parse().map(PyClassPyO3Option::Crate)
         } else if lookahead.peek(kw::dict) {
             input.parse().map(PyClassPyO3Option::Dict)
+        } else if lookahead.peek(kw::eq) {
+            input.parse().map(PyClassPyO3Option::Eq)
+        } else if lookahead.peek(kw::eq_int) {
+            input.parse().map(PyClassPyO3Option::EqInt)
         } else if lookahead.peek(kw::extends) {
             input.parse().map(PyClassPyO3Option::Extends)
         } else if lookahead.peek(attributes::kw::freelist) {
@@ -105,24 +140,38 @@ impl Parse for PyClassPyO3Option {
             input.parse().map(PyClassPyO3Option::Frozen)
         } else if lookahead.peek(attributes::kw::get_all) {
             input.parse().map(PyClassPyO3Option::GetAll)
+        } else if lookahead.peek(attributes::kw::hash) {
+            input.parse().map(PyClassPyO3Option::Hash)
+        } else if lookahead.peek(attributes::kw::immutable_type) {
+            input.parse().map(PyClassPyO3Option::ImmutableType)
         } else if lookahead.peek(attributes::kw::mapping) {
             input.parse().map(PyClassPyO3Option::Mapping)
         } else if lookahead.peek(attributes::kw::module) {
             input.parse().map(PyClassPyO3Option::Module)
         } else if lookahead.peek(kw::name) {
             input.parse().map(PyClassPyO3Option::Name)
+        } else if lookahead.peek(attributes::kw::ord) {
+            input.parse().map(PyClassPyO3Option::Ord)
         } else if lookahead.peek(kw::rename_all) {
             input.parse().map(PyClassPyO3Option::RenameAll)
         } else if lookahead.peek(attributes::kw::sequence) {
             input.parse().map(PyClassPyO3Option::Sequence)
         } else if lookahead.peek(attributes::kw::set_all) {
             input.parse().map(PyClassPyO3Option::SetAll)
+        } else if lookahead.peek(attributes::kw::str) {
+            input.parse().map(PyClassPyO3Option::Str)
         } else if lookahead.peek(attributes::kw::subclass) {
             input.parse().map(PyClassPyO3Option::Subclass)
         } else if lookahead.peek(attributes::kw::unsendable) {
             input.parse().map(PyClassPyO3Option::Unsendable)
         } else if lookahead.peek(attributes::kw::weakref) {
             input.parse().map(PyClassPyO3Option::Weakref)
+        } else if lookahead.peek(attributes::kw::generic) {
+            input.parse().map(PyClassPyO3Option::Generic)
+        } else if lookahead.peek(attributes::kw::from_py_object) {
+            input.parse().map(PyClassPyO3Option::FromPyObject)
+        } else if lookahead.peek(attributes::kw::skip_from_py_object) {
+            input.parse().map(PyClassPyO3Option::SkipFromPyObject)
         } else {
             Err(lookahead.error())
         }
@@ -163,20 +212,59 @@ impl PyClassPyO3Options {
 
         match option {
             PyClassPyO3Option::Crate(krate) => set_option!(krate),
-            PyClassPyO3Option::Dict(dict) => set_option!(dict),
+            PyClassPyO3Option::Dict(dict) => {
+                ensure_spanned!(
+                    !is_abi3_before(3, 9),
+                    dict.span() => "`dict` requires Python >= 3.9 when using the `abi3` feature"
+                );
+                set_option!(dict);
+            }
+            PyClassPyO3Option::Eq(eq) => set_option!(eq),
+            PyClassPyO3Option::EqInt(eq_int) => set_option!(eq_int),
             PyClassPyO3Option::Extends(extends) => set_option!(extends),
             PyClassPyO3Option::Freelist(freelist) => set_option!(freelist),
             PyClassPyO3Option::Frozen(frozen) => set_option!(frozen),
             PyClassPyO3Option::GetAll(get_all) => set_option!(get_all),
+            PyClassPyO3Option::ImmutableType(immutable_type) => {
+                ensure_spanned!(
+                    !(is_py_before(3, 10) || is_abi3_before(3, 14)),
+                    immutable_type.span() => "`immutable_type` requires Python >= 3.10 or >= 3.14 (ABI3)"
+                );
+                set_option!(immutable_type)
+            }
+            PyClassPyO3Option::Hash(hash) => set_option!(hash),
             PyClassPyO3Option::Mapping(mapping) => set_option!(mapping),
             PyClassPyO3Option::Module(module) => set_option!(module),
             PyClassPyO3Option::Name(name) => set_option!(name),
+            PyClassPyO3Option::Ord(ord) => set_option!(ord),
             PyClassPyO3Option::RenameAll(rename_all) => set_option!(rename_all),
             PyClassPyO3Option::Sequence(sequence) => set_option!(sequence),
             PyClassPyO3Option::SetAll(set_all) => set_option!(set_all),
+            PyClassPyO3Option::Str(str) => set_option!(str),
             PyClassPyO3Option::Subclass(subclass) => set_option!(subclass),
             PyClassPyO3Option::Unsendable(unsendable) => set_option!(unsendable),
-            PyClassPyO3Option::Weakref(weakref) => set_option!(weakref),
+            PyClassPyO3Option::Weakref(weakref) => {
+                ensure_spanned!(
+                    !is_abi3_before(3, 9),
+                    weakref.span() => "`weakref` requires Python >= 3.9 when using the `abi3` feature"
+                );
+                set_option!(weakref);
+            }
+            PyClassPyO3Option::Generic(generic) => set_option!(generic),
+            PyClassPyO3Option::SkipFromPyObject(skip_from_py_object) => {
+                ensure_spanned!(
+                    self.from_py_object.is_none(),
+                    skip_from_py_object.span() => "`skip_from_py_object` and `from_py_object` are mutually exclusive"
+                );
+                set_option!(skip_from_py_object)
+            }
+            PyClassPyO3Option::FromPyObject(from_py_object) => {
+                ensure_spanned!(
+                    self.skip_from_py_object.is_none(),
+                    from_py_object.span() => "`skip_from_py_object` and `from_py_object` are mutually exclusive"
+                );
+                set_option!(from_py_object)
+            }
         }
         Ok(())
     }
@@ -188,52 +276,63 @@ pub fn build_py_class(
     methods_type: PyClassMethodsType,
 ) -> syn::Result<TokenStream> {
     args.options.take_pyo3_options(&mut class.attrs)?;
-    let doc = utils::get_doc(&class.attrs, None);
-    let krate = get_pyo3_crate(&args.options.krate);
+
+    let ctx = &Ctx::new(&args.options.krate, None);
+    let doc = utils::get_doc(&class.attrs, None, ctx)?;
 
     if let Some(lt) = class.generics.lifetimes().next() {
         bail_spanned!(
-            lt.span() =>
-            "#[pyclass] cannot have lifetime parameters. \
-            For an explanation, see https://pyo3.rs/latest/class.html#no-lifetime-parameters"
+            lt.span() => concat!(
+                "#[pyclass] cannot have lifetime parameters. For an explanation, see \
+                https://pyo3.rs/v", env!("CARGO_PKG_VERSION"), "/class.html#no-lifetime-parameters"
+            )
         );
     }
 
     ensure_spanned!(
         class.generics.params.is_empty(),
-        class.generics.span() =>
-            "#[pyclass] cannot have generic parameters. \
-            For an explanation, see https://pyo3.rs/latest/class.html#no-generic-parameters"
+        class.generics.span() => concat!(
+            "#[pyclass] cannot have generic parameters. For an explanation, see \
+            https://pyo3.rs/v", env!("CARGO_PKG_VERSION"), "/class.html#no-generic-parameters"
+        )
     );
 
     let mut field_options: Vec<(&syn::Field, FieldPyO3Options)> = match &mut class.fields {
         syn::Fields::Named(fields) => fields
             .named
             .iter_mut()
-            .map(|field| {
-                FieldPyO3Options::take_pyo3_options(&mut field.attrs)
-                    .map(move |options| (&*field, options))
-            })
-            .collect::<Result<_>>()?,
+            .map(
+                |field| match FieldPyO3Options::take_pyo3_options(&mut field.attrs) {
+                    Ok(options) => Ok((&*field, options)),
+                    Err(e) => Err(e),
+                },
+            )
+            .collect::<Vec<_>>(),
         syn::Fields::Unnamed(fields) => fields
             .unnamed
             .iter_mut()
-            .map(|field| {
-                FieldPyO3Options::take_pyo3_options(&mut field.attrs)
-                    .map(move |options| (&*field, options))
-            })
-            .collect::<Result<_>>()?,
+            .map(
+                |field| match FieldPyO3Options::take_pyo3_options(&mut field.attrs) {
+                    Ok(options) => Ok((&*field, options)),
+                    Err(e) => Err(e),
+                },
+            )
+            .collect::<Vec<_>>(),
         syn::Fields::Unit => {
+            let mut results = Vec::new();
+
             if let Some(attr) = args.options.set_all {
-                return Err(syn::Error::new_spanned(attr, UNIT_SET));
+                results.push(Err(syn::Error::new_spanned(attr, UNIT_SET)));
             };
             if let Some(attr) = args.options.get_all {
-                return Err(syn::Error::new_spanned(attr, UNIT_GET));
+                results.push(Err(syn::Error::new_spanned(attr, UNIT_GET)));
             };
-            // No fields for unit struct
-            Vec::new()
+
+            results
         }
-    };
+    }
+    .into_iter()
+    .try_combine_syn_errors()?;
 
     if let Some(attr) = args.options.get_all {
         for (_, FieldPyO3Options { get, .. }) in &mut field_options {
@@ -251,7 +350,7 @@ pub fn build_py_class(
         }
     }
 
-    impl_class(&class.ident, &args, doc, field_options, methods_type, krate)
+    impl_class(&class.ident, &args, doc, field_options, methods_type, ctx)
 }
 
 enum Annotated<X, Y> {
@@ -336,39 +435,87 @@ fn get_class_python_name<'a>(cls: &'a syn::Ident, args: &'a PyClassArgs) -> Cow<
         .unwrap_or_else(|| Cow::Owned(cls.unraw()))
 }
 
+#[cfg(feature = "experimental-inspect")]
+fn get_class_type_hint(cls: &Ident, args: &PyClassArgs, ctx: &Ctx) -> TokenStream {
+    let pyo3_path = &ctx.pyo3_path;
+    let name = get_class_python_name(cls, args).to_string();
+    if let Some(module) = &args.options.module {
+        let module = module.value.value();
+        quote! { #pyo3_path::inspect::TypeHint::module_attr(#module, #name) }
+    } else {
+        quote! { #pyo3_path::inspect::TypeHint::builtin(#name) }
+    }
+}
+
 fn impl_class(
     cls: &syn::Ident,
     args: &PyClassArgs,
     doc: PythonDoc,
     field_options: Vec<(&syn::Field, FieldPyO3Options)>,
     methods_type: PyClassMethodsType,
-    krate: syn::Path,
+    ctx: &Ctx,
 ) -> syn::Result<TokenStream> {
-    let pytypeinfo_impl = impl_pytypeinfo(cls, args, None);
+    let Ctx { pyo3_path, .. } = ctx;
+    let pytypeinfo_impl = impl_pytypeinfo(cls, args, ctx);
+
+    if let Some(str) = &args.options.str {
+        if str.value.is_some() {
+            // check if any renaming is present
+            let no_naming_conflict = field_options.iter().all(|x| x.1.name.is_none())
+                & args.options.name.is_none()
+                & args.options.rename_all.is_none();
+            ensure_spanned!(no_naming_conflict, str.value.span() => "The format string syntax is incompatible with any renaming via `name` or `rename_all`");
+        }
+    }
 
-    let py_class_impl = PyClassImplsBuilder::new(
+    let mut default_methods = descriptors_to_items(
         cls,
-        args,
-        methods_type,
-        descriptors_to_items(
-            cls,
-            args.options.rename_all.as_ref(),
-            args.options.frozen,
-            field_options,
-        )?,
-        vec![],
-    )
-    .doc(doc)
-    .impl_all()?;
+        args.options.rename_all.as_ref(),
+        args.options.frozen,
+        field_options,
+        ctx,
+    )?;
+
+    let (default_class_geitem, default_class_geitem_method) =
+        pyclass_class_geitem(&args.options, &syn::parse_quote!(#cls), ctx)?;
+
+    if let Some(default_class_geitem_method) = default_class_geitem_method {
+        default_methods.push(default_class_geitem_method);
+    }
+
+    let (default_str, default_str_slot) =
+        implement_pyclass_str(&args.options, &syn::parse_quote!(#cls), ctx);
+
+    let (default_richcmp, default_richcmp_slot) =
+        pyclass_richcmp(&args.options, &syn::parse_quote!(#cls), ctx)?;
+
+    let (default_hash, default_hash_slot) =
+        pyclass_hash(&args.options, &syn::parse_quote!(#cls), ctx)?;
+
+    let mut slots = Vec::new();
+    slots.extend(default_richcmp_slot);
+    slots.extend(default_hash_slot);
+    slots.extend(default_str_slot);
+
+    let py_class_impl = PyClassImplsBuilder::new(cls, args, methods_type, default_methods, slots)
+        .doc(doc)
+        .impl_all(ctx)?;
 
     Ok(quote! {
-        const _: () = {
-            use #krate as _pyo3;
+        impl #pyo3_path::types::DerefToPyAny for #cls {}
 
-            #pytypeinfo_impl
+        #pytypeinfo_impl
 
-            #py_class_impl
-        };
+        #py_class_impl
+
+        #[doc(hidden)]
+        #[allow(non_snake_case)]
+        impl #cls {
+            #default_richcmp
+            #default_hash
+            #default_str
+            #default_class_geitem
+        }
     })
 }
 
@@ -401,6 +548,7 @@ pub fn build_py_enum(
 ) -> syn::Result<TokenStream> {
     args.options.take_pyo3_options(&mut enum_.attrs)?;
 
+    let ctx = &Ctx::new(&args.options.krate, None);
     if let Some(extends) = &args.options.extends {
         bail_spanned!(extends.span() => "enums can't extend from other classes");
     } else if let Some(subclass) = &args.options.subclass {
@@ -409,9 +557,13 @@ pub fn build_py_enum(
         bail_spanned!(enum_.brace_token.span.join() => "#[pyclass] can't be used on enums without any variants");
     }
 
-    let doc = utils::get_doc(&enum_.attrs, None);
+    if let Some(generic) = &args.options.generic {
+        bail_spanned!(generic.span() => "enums do not support #[pyclass(generic)]");
+    }
+
+    let doc = utils::get_doc(&enum_.attrs, None, ctx)?;
     let enum_ = PyClassEnum::new(enum_)?;
-    impl_enum(enum_, &args, doc, method_type)
+    impl_enum(enum_, &args, doc, method_type, ctx)
 }
 
 struct PyClassSimpleEnum<'a> {
@@ -442,7 +594,12 @@ impl<'a> PyClassSimpleEnum<'a> {
                 _ => bail_spanned!(variant.span() => "Must be a unit variant."),
             };
             let options = EnumVariantPyO3Options::take_pyo3_options(&mut variant.attrs)?;
-            Ok(PyClassEnumUnitVariant { ident, options })
+            let cfg_attrs = get_cfg_attributes(&variant.attrs);
+            Ok(PyClassEnumUnitVariant {
+                ident,
+                options,
+                cfg_attrs,
+            })
         }
 
         let ident = &enum_.ident;
@@ -500,10 +657,10 @@ impl<'a> PyClassComplexEnum<'a> {
                 let variant = match &variant.fields {
                     Fields::Unit => {
                         bail_spanned!(variant.span() => format!(
-                        "Unit variant `{ident}` is not yet supported in a complex enum\n\
-                        = help: change to a struct variant with no fields: `{ident} {{ }}`\n\
-                        = note: the enum is complex because of non-unit variant `{witness}`",
-                        ident=ident, witness=witness))
+                            "Unit variant `{ident}` is not yet supported in a complex enum\n\
+                            = help: change to an empty tuple variant instead: `{ident}()`\n\
+                            = note: the enum is complex because of non-unit variant `{witness}`",
+                            ident=ident, witness=witness))
                     }
                     Fields::Named(fields) => {
                         let fields = fields
@@ -522,12 +679,21 @@ impl<'a> PyClassComplexEnum<'a> {
                             options,
                         })
                     }
-                    Fields::Unnamed(_) => {
-                        bail_spanned!(variant.span() => format!(
-                        "Tuple variant `{ident}` is not yet supported in a complex enum\n\
-                        = help: change to a struct variant with named fields: `{ident} {{ /* fields */ }}`\n\
-                        = note: the enum is complex because of non-unit variant `{witness}`",
-                        ident=ident, witness=witness))
+                    Fields::Unnamed(types) => {
+                        let fields = types
+                            .unnamed
+                            .iter()
+                            .map(|field| PyClassEnumVariantUnnamedField {
+                                ty: &field.ty,
+                                span: field.span(),
+                            })
+                            .collect();
+
+                        PyClassEnumVariant::Tuple(PyClassEnumTupleVariant {
+                            ident,
+                            fields,
+                            options,
+                        })
                     }
                 };
 
@@ -549,7 +715,7 @@ impl<'a> PyClassComplexEnum<'a> {
 enum PyClassEnumVariant<'a> {
     // TODO(mkovaxx): Unit(PyClassEnumUnitVariant<'a>),
     Struct(PyClassEnumStructVariant<'a>),
-    // TODO(mkovaxx): Tuple(PyClassEnumTupleVariant<'a>),
+    Tuple(PyClassEnumTupleVariant<'a>),
 }
 
 trait EnumVariant {
@@ -573,16 +739,18 @@ trait EnumVariant {
     }
 }
 
-impl<'a> EnumVariant for PyClassEnumVariant<'a> {
+impl EnumVariant for PyClassEnumVariant<'_> {
     fn get_ident(&self) -> &syn::Ident {
         match self {
             PyClassEnumVariant::Struct(struct_variant) => struct_variant.ident,
+            PyClassEnumVariant::Tuple(tuple_variant) => tuple_variant.ident,
         }
     }
 
     fn get_options(&self) -> &EnumVariantPyO3Options {
         match self {
             PyClassEnumVariant::Struct(struct_variant) => &struct_variant.options,
+            PyClassEnumVariant::Tuple(tuple_variant) => &tuple_variant.options,
         }
     }
 }
@@ -591,9 +759,10 @@ impl<'a> EnumVariant for PyClassEnumVariant<'a> {
 struct PyClassEnumUnitVariant<'a> {
     ident: &'a syn::Ident,
     options: EnumVariantPyO3Options,
+    cfg_attrs: Vec<&'a syn::Attribute>,
 }
 
-impl<'a> EnumVariant for PyClassEnumUnitVariant<'a> {
+impl EnumVariant for PyClassEnumUnitVariant<'_> {
     fn get_ident(&self) -> &syn::Ident {
         self.ident
     }
@@ -610,19 +779,33 @@ struct PyClassEnumStructVariant<'a> {
     options: EnumVariantPyO3Options,
 }
 
+struct PyClassEnumTupleVariant<'a> {
+    ident: &'a syn::Ident,
+    fields: Vec<PyClassEnumVariantUnnamedField<'a>>,
+    options: EnumVariantPyO3Options,
+}
+
 struct PyClassEnumVariantNamedField<'a> {
     ident: &'a syn::Ident,
     ty: &'a syn::Type,
     span: Span,
 }
 
+struct PyClassEnumVariantUnnamedField<'a> {
+    ty: &'a syn::Type,
+    span: Span,
+}
+
 /// `#[pyo3()]` options for pyclass enum variants
+#[derive(Clone, Default)]
 struct EnumVariantPyO3Options {
     name: Option<NameAttribute>,
+    constructor: Option<ConstructorAttribute>,
 }
 
 enum EnumVariantPyO3Option {
     Name(NameAttribute),
+    Constructor(ConstructorAttribute),
 }
 
 impl Parse for EnumVariantPyO3Option {
@@ -630,6 +813,8 @@ impl Parse for EnumVariantPyO3Option {
         let lookahead = input.lookahead1();
         if lookahead.peek(attributes::kw::name) {
             input.parse().map(EnumVariantPyO3Option::Name)
+        } else if lookahead.peek(attributes::kw::constructor) {
+            input.parse().map(EnumVariantPyO3Option::Constructor)
         } else {
             Err(lookahead.error())
         }
@@ -638,21 +823,100 @@ impl Parse for EnumVariantPyO3Option {
 
 impl EnumVariantPyO3Options {
     fn take_pyo3_options(attrs: &mut Vec<syn::Attribute>) -> Result<Self> {
-        let mut options = EnumVariantPyO3Options { name: None };
+        let mut options = EnumVariantPyO3Options::default();
 
-        for option in take_pyo3_options(attrs)? {
-            match option {
-                EnumVariantPyO3Option::Name(name) => {
+        take_pyo3_options(attrs)?
+            .into_iter()
+            .try_for_each(|option| options.set_option(option))?;
+
+        Ok(options)
+    }
+
+    fn set_option(&mut self, option: EnumVariantPyO3Option) -> syn::Result<()> {
+        macro_rules! set_option {
+            ($key:ident) => {
+                {
                     ensure_spanned!(
-                        options.name.is_none(),
-                        name.span() => "`name` may only be specified once"
+                        self.$key.is_none(),
+                        $key.span() => concat!("`", stringify!($key), "` may only be specified once")
                     );
-                    options.name = Some(name);
+                    self.$key = Some($key);
                 }
-            }
+            };
         }
 
-        Ok(options)
+        match option {
+            EnumVariantPyO3Option::Constructor(constructor) => set_option!(constructor),
+            EnumVariantPyO3Option::Name(name) => set_option!(name),
+        }
+        Ok(())
+    }
+}
+
+// todo(remove this dead code allowance once __repr__ is implemented
+#[allow(dead_code)]
+pub enum PyFmtName {
+    Str,
+    Repr,
+}
+
+fn implement_py_formatting(
+    ty: &syn::Type,
+    ctx: &Ctx,
+    option: &StrFormatterAttribute,
+) -> (ImplItemFn, MethodAndSlotDef) {
+    let mut fmt_impl = match &option.value {
+        Some(opt) => {
+            let fmt = &opt.fmt;
+            let args = &opt
+                .args
+                .iter()
+                .map(|member| quote! {self.#member})
+                .collect::<Vec<TokenStream>>();
+            let fmt_impl: ImplItemFn = syn::parse_quote! {
+                fn __pyo3__generated____str__(&self) -> ::std::string::String {
+                    ::std::format!(#fmt, #(#args, )*)
+                }
+            };
+            fmt_impl
+        }
+        None => {
+            let fmt_impl: syn::ImplItemFn = syn::parse_quote! {
+                fn __pyo3__generated____str__(&self) -> ::std::string::String {
+                    ::std::format!("{}", &self)
+                }
+            };
+            fmt_impl
+        }
+    };
+    let fmt_slot = generate_protocol_slot(
+        ty,
+        &mut fmt_impl,
+        &__STR__,
+        "__str__",
+        #[cfg(feature = "experimental-inspect")]
+        FunctionIntrospectionData {
+            names: &["__str__"],
+            arguments: Vec::new(),
+            returns: parse_quote! { ::std::string::String },
+        },
+        ctx,
+    )
+    .unwrap();
+    (fmt_impl, fmt_slot)
+}
+
+fn implement_pyclass_str(
+    options: &PyClassPyO3Options,
+    ty: &syn::Type,
+    ctx: &Ctx,
+) -> (Option<ImplItemFn>, Option<MethodAndSlotDef>) {
+    match &options.str {
+        Some(option) => {
+            let (default_str, default_str_slot) = implement_py_formatting(ty, ctx, option);
+            (Some(default_str), Some(default_str_slot))
+        }
+        _ => (None, None),
     }
 }
 
@@ -661,11 +925,18 @@ fn impl_enum(
     args: &PyClassArgs,
     doc: PythonDoc,
     methods_type: PyClassMethodsType,
+    ctx: &Ctx,
 ) -> Result<TokenStream> {
+    if let Some(str_fmt) = &args.options.str {
+        ensure_spanned!(str_fmt.value.is_none(), str_fmt.value.span() => "The format string syntax cannot be used with enums")
+    }
+
     match enum_ {
-        PyClassEnum::Simple(simple_enum) => impl_simple_enum(simple_enum, args, doc, methods_type),
+        PyClassEnum::Simple(simple_enum) => {
+            impl_simple_enum(simple_enum, args, doc, methods_type, ctx)
+        }
         PyClassEnum::Complex(complex_enum) => {
-            impl_complex_enum(complex_enum, args, doc, methods_type)
+            impl_complex_enum(complex_enum, args, doc, methods_type, ctx)
         }
     }
 }
@@ -675,97 +946,78 @@ fn impl_simple_enum(
     args: &PyClassArgs,
     doc: PythonDoc,
     methods_type: PyClassMethodsType,
+    ctx: &Ctx,
 ) -> Result<TokenStream> {
-    let krate = get_pyo3_crate(&args.options.krate);
     let cls = simple_enum.ident;
     let ty: syn::Type = syn::parse_quote!(#cls);
     let variants = simple_enum.variants;
-    let pytypeinfo = impl_pytypeinfo(cls, args, None);
+    let pytypeinfo = impl_pytypeinfo(cls, args, ctx);
+
+    for variant in &variants {
+        ensure_spanned!(variant.options.constructor.is_none(), variant.options.constructor.span() => "`constructor` can't be used on a simple enum variant");
+    }
+
+    let variant_cfg_check = generate_cfg_check(&variants, cls);
 
     let (default_repr, default_repr_slot) = {
         let variants_repr = variants.iter().map(|variant| {
             let variant_name = variant.ident;
+            let cfg_attrs = &variant.cfg_attrs;
             // Assuming all variants are unit variants because they are the only type we support.
             let repr = format!(
                 "{}.{}",
                 get_class_python_name(cls, args),
                 variant.get_python_name(args),
             );
-            quote! { #cls::#variant_name => #repr, }
+            quote! { #(#cfg_attrs)* #cls::#variant_name => #repr, }
         });
         let mut repr_impl: syn::ImplItemFn = syn::parse_quote! {
             fn __pyo3__repr__(&self) -> &'static str {
-                match self {
+                match *self {
                     #(#variants_repr)*
                 }
             }
         };
-        let repr_slot = generate_default_protocol_slot(&ty, &mut repr_impl, &__REPR__).unwrap();
+        let repr_slot = generate_default_protocol_slot(&ty, &mut repr_impl, &__REPR__, ctx)?;
         (repr_impl, repr_slot)
     };
 
+    let (default_str, default_str_slot) = implement_pyclass_str(&args.options, &ty, ctx);
+
     let repr_type = &simple_enum.repr_type;
 
     let (default_int, default_int_slot) = {
         // This implementation allows us to convert &T to #repr_type without implementing `Copy`
         let variants_to_int = variants.iter().map(|variant| {
             let variant_name = variant.ident;
-            quote! { #cls::#variant_name => #cls::#variant_name as #repr_type, }
+            let cfg_attrs = &variant.cfg_attrs;
+            quote! { #(#cfg_attrs)* #cls::#variant_name => #cls::#variant_name as #repr_type, }
         });
         let mut int_impl: syn::ImplItemFn = syn::parse_quote! {
             fn __pyo3__int__(&self) -> #repr_type {
-                match self {
+                match *self {
                     #(#variants_to_int)*
                 }
             }
         };
-        let int_slot = generate_default_protocol_slot(&ty, &mut int_impl, &__INT__).unwrap();
+        let int_slot = generate_default_protocol_slot(&ty, &mut int_impl, &__INT__, ctx)?;
         (int_impl, int_slot)
     };
 
-    let (default_richcmp, default_richcmp_slot) = {
-        let mut richcmp_impl: syn::ImplItemFn = syn::parse_quote! {
-            fn __pyo3__richcmp__(
-                &self,
-                py: _pyo3::Python,
-                other: &_pyo3::PyAny,
-                op: _pyo3::basic::CompareOp
-            ) -> _pyo3::PyResult<_pyo3::PyObject> {
-                use _pyo3::conversion::ToPyObject;
-                use ::core::result::Result::*;
-                match op {
-                    _pyo3::basic::CompareOp::Eq => {
-                        let self_val = self.__pyo3__int__();
-                        if let Ok(i) = other.extract::<#repr_type>() {
-                            return Ok((self_val == i).to_object(py));
-                        }
-                        if let Ok(other) = other.extract::<_pyo3::PyRef<Self>>() {
-                            return Ok((self_val == other.__pyo3__int__()).to_object(py));
-                        }
-
-                        return Ok(py.NotImplemented());
-                    }
-                    _pyo3::basic::CompareOp::Ne => {
-                        let self_val = self.__pyo3__int__();
-                        if let Ok(i) = other.extract::<#repr_type>() {
-                            return Ok((self_val != i).to_object(py));
-                        }
-                        if let Ok(other) = other.extract::<_pyo3::PyRef<Self>>() {
-                            return Ok((self_val != other.__pyo3__int__()).to_object(py));
-                        }
-
-                        return Ok(py.NotImplemented());
-                    }
-                    _ => Ok(py.NotImplemented()),
-                }
-            }
-        };
-        let richcmp_slot =
-            generate_default_protocol_slot(&ty, &mut richcmp_impl, &__RICHCMP__).unwrap();
-        (richcmp_impl, richcmp_slot)
-    };
-
-    let default_slots = vec![default_repr_slot, default_int_slot, default_richcmp_slot];
+    let (default_richcmp, default_richcmp_slot) = pyclass_richcmp_simple_enum(
+        &args.options,
+        &ty,
+        repr_type,
+        #[cfg(feature = "experimental-inspect")]
+        &get_class_python_name(cls, args).to_string(),
+        ctx,
+    )?;
+    let (default_hash, default_hash_slot) = pyclass_hash(&args.options, &ty, ctx)?;
+
+    let mut default_slots = vec![default_repr_slot, default_int_slot];
+    default_slots.extend(default_richcmp_slot);
+    default_slots.extend(default_hash_slot);
+    default_slots.extend(default_str_slot);
 
     let pyclass_impls = PyClassImplsBuilder::new(
         cls,
@@ -773,29 +1025,32 @@ fn impl_simple_enum(
         methods_type,
         simple_enum_default_methods(
             cls,
-            variants.iter().map(|v| (v.ident, v.get_python_name(args))),
+            variants
+                .iter()
+                .map(|v| (v.ident, v.get_python_name(args), &v.cfg_attrs)),
+            ctx,
         ),
         default_slots,
     )
     .doc(doc)
-    .impl_all()?;
+    .impl_all(ctx)?;
 
     Ok(quote! {
-        const _: () = {
-            use #krate as _pyo3;
+        #variant_cfg_check
 
-            #pytypeinfo
+        #pytypeinfo
 
-            #pyclass_impls
+        #pyclass_impls
 
-            #[doc(hidden)]
-            #[allow(non_snake_case)]
-            impl #cls {
-                #default_repr
-                #default_int
-                #default_richcmp
-            }
-        };
+        #[doc(hidden)]
+        #[allow(non_snake_case)]
+        impl #cls {
+            #default_repr
+            #default_int
+            #default_richcmp
+            #default_hash
+            #default_str
+        }
     })
 }
 
@@ -804,7 +1059,12 @@ fn impl_complex_enum(
     args: &PyClassArgs,
     doc: PythonDoc,
     methods_type: PyClassMethodsType,
+    ctx: &Ctx,
 ) -> Result<TokenStream> {
+    let Ctx { pyo3_path, .. } = ctx;
+    let cls = complex_enum.ident;
+    let ty: syn::Type = syn::parse_quote!(#cls);
+
     // Need to rig the enum PyClass options
     let args = {
         let mut rigged_args = args.clone();
@@ -815,12 +1075,20 @@ fn impl_complex_enum(
         rigged_args
     };
 
-    let krate = get_pyo3_crate(&args.options.krate);
+    let ctx = &Ctx::new(&args.options.krate, None);
     let cls = complex_enum.ident;
     let variants = complex_enum.variants;
-    let pytypeinfo = impl_pytypeinfo(cls, &args, None);
+    let pytypeinfo = impl_pytypeinfo(cls, &args, ctx);
+
+    let (default_richcmp, default_richcmp_slot) = pyclass_richcmp(&args.options, &ty, ctx)?;
+    let (default_hash, default_hash_slot) = pyclass_hash(&args.options, &ty, ctx)?;
 
-    let default_slots = vec![];
+    let (default_str, default_str_slot) = implement_pyclass_str(&args.options, &ty, ctx);
+
+    let mut default_slots = vec![];
+    default_slots.extend(default_richcmp_slot);
+    default_slots.extend(default_hash_slot);
+    default_slots.extend(default_str_slot);
 
     let impl_builder = PyClassImplsBuilder::new(
         cls,
@@ -831,31 +1099,41 @@ fn impl_complex_enum(
             variants
                 .iter()
                 .map(|v| (v.get_ident(), v.get_python_name(&args))),
+            ctx,
         ),
         default_slots,
     )
     .doc(doc);
 
-    // Need to customize the into_py impl so that it returns the variant PyClass
-    let enum_into_py_impl = {
-        let match_arms: Vec<TokenStream> = variants
+    let enum_into_pyobject_impl = {
+        let match_arms = variants
             .iter()
             .map(|variant| {
                 let variant_ident = variant.get_ident();
                 let variant_cls = gen_complex_enum_variant_class_ident(cls, variant.get_ident());
                 quote! {
                     #cls::#variant_ident { .. } => {
-                        let pyclass_init = _pyo3::PyClassInitializer::from(self).add_subclass(#variant_cls);
-                        let variant_value = _pyo3::Py::new(py, pyclass_init).unwrap();
-                        _pyo3::IntoPy::into_py(variant_value, py)
+                        let pyclass_init = <#pyo3_path::PyClassInitializer<Self> as ::std::convert::From<Self>>::from(self).add_subclass(#variant_cls);
+                        unsafe { #pyo3_path::Bound::new(py, pyclass_init).map(|b| b.cast_into_unchecked()) }
                     }
                 }
-            })
-            .collect();
-
+            });
+        let output_type = if cfg!(feature = "experimental-inspect") {
+            quote!(const OUTPUT_TYPE: #pyo3_path::inspect::TypeHint = <#cls as #pyo3_path::PyTypeInfo>::TYPE_HINT;)
+        } else {
+            TokenStream::new()
+        };
         quote! {
-            impl _pyo3::IntoPy<_pyo3::PyObject> for #cls {
-                fn into_py(self, py: _pyo3::Python) -> _pyo3::PyObject {
+            impl<'py> #pyo3_path::conversion::IntoPyObject<'py> for #cls {
+                type Target = Self;
+                type Output = #pyo3_path::Bound<'py, <Self as #pyo3_path::conversion::IntoPyObject<'py>>::Target>;
+                type Error = #pyo3_path::PyErr;
+                #output_type
+
+                fn into_pyobject(self, py: #pyo3_path::Python<'py>) -> ::std::result::Result<
+                    <Self as #pyo3_path::conversion::IntoPyObject>::Output,
+                    <Self as #pyo3_path::conversion::IntoPyObject>::Error,
+                > {
                     match self {
                         #(#match_arms)*
                     }
@@ -864,12 +1142,13 @@ fn impl_complex_enum(
         }
     };
 
-    let pyclass_impls: TokenStream = vec![
-        impl_builder.impl_pyclass(),
-        impl_builder.impl_extractext(),
-        enum_into_py_impl,
-        impl_builder.impl_pyclassimpl()?,
-        impl_builder.impl_freelist(),
+    let pyclass_impls: TokenStream = [
+        impl_builder.impl_pyclass(ctx),
+        enum_into_pyobject_impl,
+        impl_builder.impl_pyclassimpl(ctx)?,
+        impl_builder.impl_add_to_module(ctx),
+        impl_builder.impl_freelist(ctx),
+        impl_builder.impl_introspection(ctx),
     ]
     .into_iter()
     .collect();
@@ -878,7 +1157,7 @@ fn impl_complex_enum(
     let mut variant_cls_pytypeinfos = vec![];
     let mut variant_cls_pyclass_impls = vec![];
     let mut variant_cls_impls = vec![];
-    for variant in &variants {
+    for variant in variants {
         let variant_cls = gen_complex_enum_variant_class_ident(cls, variant.get_ident());
 
         let variant_cls_zst = quote! {
@@ -891,67 +1170,108 @@ fn impl_complex_enum(
         let variant_args = PyClassArgs {
             class_kind: PyClassKind::Struct,
             // TODO(mkovaxx): propagate variant.options
-            options: parse_quote!(extends = #cls, frozen),
+            options: {
+                let mut rigged_options: PyClassPyO3Options = parse_quote!(extends = #cls, frozen);
+                // If a specific module was given to the base class, use it for all variants.
+                rigged_options.module.clone_from(&args.options.module);
+                rigged_options
+            },
         };
 
-        let variant_cls_pytypeinfo = impl_pytypeinfo(&variant_cls, &variant_args, None);
+        let variant_cls_pytypeinfo = impl_pytypeinfo(&variant_cls, &variant_args, ctx);
         variant_cls_pytypeinfos.push(variant_cls_pytypeinfo);
 
-        let variant_new = complex_enum_variant_new(cls, variant)?;
-
-        let (variant_cls_impl, field_getters) = impl_complex_enum_variant_cls(cls, variant)?;
+        let (variant_cls_impl, field_getters, mut slots) =
+            impl_complex_enum_variant_cls(cls, &variant, ctx)?;
         variant_cls_impls.push(variant_cls_impl);
 
+        let variant_new = complex_enum_variant_new(cls, variant, ctx)?;
+        slots.push(variant_new);
+
         let pyclass_impl = PyClassImplsBuilder::new(
             &variant_cls,
             &variant_args,
             methods_type,
             field_getters,
-            vec![variant_new],
+            slots,
         )
-        .impl_all()?;
+        .impl_all(ctx)?;
 
         variant_cls_pyclass_impls.push(pyclass_impl);
     }
 
     Ok(quote! {
-        const _: () = {
-            use #krate as _pyo3;
+        #pytypeinfo
 
-            #pytypeinfo
+        #pyclass_impls
 
-            #pyclass_impls
-
-            #[doc(hidden)]
-            #[allow(non_snake_case)]
-            impl #cls {}
+        #[doc(hidden)]
+        #[allow(non_snake_case)]
+        impl #cls {
+            #default_richcmp
+            #default_hash
+            #default_str
+        }
 
-            #(#variant_cls_zsts)*
+        #(#variant_cls_zsts)*
 
-            #(#variant_cls_pytypeinfos)*
+        #(#variant_cls_pytypeinfos)*
 
-            #(#variant_cls_pyclass_impls)*
+        #(#variant_cls_pyclass_impls)*
 
-            #(#variant_cls_impls)*
-        };
+        #(#variant_cls_impls)*
     })
 }
 
 fn impl_complex_enum_variant_cls(
     enum_name: &syn::Ident,
     variant: &PyClassEnumVariant<'_>,
-) -> Result<(TokenStream, Vec<MethodAndMethodDef>)> {
+    ctx: &Ctx,
+) -> Result<(TokenStream, Vec<MethodAndMethodDef>, Vec<MethodAndSlotDef>)> {
     match variant {
         PyClassEnumVariant::Struct(struct_variant) => {
-            impl_complex_enum_struct_variant_cls(enum_name, struct_variant)
+            impl_complex_enum_struct_variant_cls(enum_name, struct_variant, ctx)
+        }
+        PyClassEnumVariant::Tuple(tuple_variant) => {
+            impl_complex_enum_tuple_variant_cls(enum_name, tuple_variant, ctx)
         }
     }
 }
 
+fn impl_complex_enum_variant_match_args(
+    ctx @ Ctx { pyo3_path, .. }: &Ctx,
+    variant_cls_type: &syn::Type,
+    field_names: &[Ident],
+) -> syn::Result<(MethodAndMethodDef, syn::ImplItemFn)> {
+    let ident = format_ident!("__match_args__");
+    let field_names_unraw = field_names.iter().map(|name| name.unraw());
+    let mut match_args_impl: syn::ImplItemFn = {
+        parse_quote! {
+            #[classattr]
+            fn #ident(py: #pyo3_path::Python<'_>) -> #pyo3_path::PyResult<#pyo3_path::Bound<'_, #pyo3_path::types::PyTuple>> {
+                #pyo3_path::types::PyTuple::new::<&str, _>(py, [
+                    #(stringify!(#field_names_unraw),)*
+                ])
+            }
+        }
+    };
+
+    let spec = FnSpec::parse(
+        &mut match_args_impl.sig,
+        &mut match_args_impl.attrs,
+        Default::default(),
+    )?;
+    let variant_match_args = impl_py_class_attribute(variant_cls_type, &spec, ctx)?;
+
+    Ok((variant_match_args, match_args_impl))
+}
+
 fn impl_complex_enum_struct_variant_cls(
     enum_name: &syn::Ident,
     variant: &PyClassEnumStructVariant<'_>,
-) -> Result<(TokenStream, Vec<MethodAndMethodDef>)> {
+    ctx: &Ctx,
+) -> Result<(TokenStream, Vec<MethodAndMethodDef>, Vec<MethodAndSlotDef>)> {
+    let Ctx { pyo3_path, .. } = ctx;
     let variant_ident = &variant.ident;
     let variant_cls = gen_complex_enum_variant_class_ident(enum_name, variant.ident);
     let variant_cls_type = parse_quote!(#variant_cls);
@@ -965,18 +1285,20 @@ fn impl_complex_enum_struct_variant_cls(
         let field_type = field.ty;
         let field_with_type = quote! { #field_name: #field_type };
 
-        let field_getter = complex_enum_variant_field_getter(
-            &variant_cls_type,
-            field_name,
-            field_type,
-            field.span,
-        )?;
+        let field_getter =
+            complex_enum_variant_field_getter(&variant_cls_type, field_name, field.span, ctx)?;
 
         let field_getter_impl = quote! {
-            fn #field_name(slf: _pyo3::PyRef<Self>) -> _pyo3::PyResult<#field_type> {
+            fn #field_name(slf: #pyo3_path::PyClassGuard<'_, Self>, py: #pyo3_path::Python<'_>) -> #pyo3_path::PyResult<#pyo3_path::Py<#pyo3_path::PyAny>> {
+                #[allow(unused_imports)]
+                use #pyo3_path::impl_::pyclass::Probe as _;
                 match &*slf.into_super() {
-                    #enum_name::#variant_ident { #field_name, .. } => Ok(#field_name.clone()),
-                    _ => unreachable!("Wrong complex enum variant found in variant wrapper PyClass"),
+                    #enum_name::#variant_ident { #field_name, .. } =>
+                        #pyo3_path::impl_::pyclass::ConvertField::<
+                            { #pyo3_path::impl_::pyclass::IsIntoPyObjectRef::<#field_type>::VALUE },
+                            { #pyo3_path::impl_::pyclass::IsIntoPyObject::<#field_type>::VALUE },
+                        >::convert_field::<#field_type>(#field_name, py),
+                    _ => ::core::unreachable!("Wrong complex enum variant found in variant wrapper PyClass"),
                 }
             }
         };
@@ -987,48 +1309,290 @@ fn impl_complex_enum_struct_variant_cls(
         field_getter_impls.push(field_getter_impl);
     }
 
+    let (variant_match_args, match_args_const_impl) =
+        impl_complex_enum_variant_match_args(ctx, &variant_cls_type, &field_names)?;
+
+    field_getters.push(variant_match_args);
+
     let cls_impl = quote! {
         #[doc(hidden)]
         #[allow(non_snake_case)]
         impl #variant_cls {
-            fn __pymethod_constructor__(py: _pyo3::Python<'_>, #(#fields_with_types,)*) -> _pyo3::PyClassInitializer<#variant_cls> {
+            #[allow(clippy::too_many_arguments)]
+            fn __pymethod_constructor__(py: #pyo3_path::Python<'_>, #(#fields_with_types,)*) -> #pyo3_path::PyClassInitializer<#variant_cls> {
                 let base_value = #enum_name::#variant_ident { #(#field_names,)* };
-                _pyo3::PyClassInitializer::from(base_value).add_subclass(#variant_cls)
+                <#pyo3_path::PyClassInitializer<#enum_name> as ::std::convert::From<#enum_name>>::from(base_value).add_subclass(#variant_cls)
+            }
+
+            #match_args_const_impl
+
+            #(#field_getter_impls)*
+        }
+    };
+
+    Ok((cls_impl, field_getters, Vec::new()))
+}
+
+fn impl_complex_enum_tuple_variant_field_getters(
+    ctx: &Ctx,
+    variant: &PyClassEnumTupleVariant<'_>,
+    enum_name: &syn::Ident,
+    variant_cls_type: &syn::Type,
+    variant_ident: &&Ident,
+    field_names: &mut Vec<Ident>,
+    fields_types: &mut Vec<syn::Type>,
+) -> Result<(Vec<MethodAndMethodDef>, Vec<syn::ImplItemFn>)> {
+    let Ctx { pyo3_path, .. } = ctx;
+
+    let mut field_getters = vec![];
+    let mut field_getter_impls = vec![];
+
+    for (index, field) in variant.fields.iter().enumerate() {
+        let field_name = format_ident!("_{}", index);
+        let field_type = field.ty;
+
+        let field_getter =
+            complex_enum_variant_field_getter(variant_cls_type, &field_name, field.span, ctx)?;
+
+        // Generate the match arms needed to destructure the tuple and access the specific field
+        let field_access_tokens: Vec<_> = (0..variant.fields.len())
+            .map(|i| {
+                if i == index {
+                    quote! { val }
+                } else {
+                    quote! { _ }
+                }
+            })
+            .collect();
+        let field_getter_impl: syn::ImplItemFn = parse_quote! {
+            fn #field_name(slf: #pyo3_path::PyClassGuard<'_, Self>, py: #pyo3_path::Python<'_>) -> #pyo3_path::PyResult<#pyo3_path::Py<#pyo3_path::PyAny>> {
+                #[allow(unused_imports)]
+                use #pyo3_path::impl_::pyclass::Probe as _;
+                match &*slf.into_super() {
+                    #enum_name::#variant_ident ( #(#field_access_tokens), *) =>
+                        #pyo3_path::impl_::pyclass::ConvertField::<
+                            { #pyo3_path::impl_::pyclass::IsIntoPyObjectRef::<#field_type>::VALUE },
+                            { #pyo3_path::impl_::pyclass::IsIntoPyObject::<#field_type>::VALUE },
+                        >::convert_field::<#field_type>(val, py),
+                    _ => ::core::unreachable!("Wrong complex enum variant found in variant wrapper PyClass"),
+                }
+            }
+        };
+
+        field_names.push(field_name);
+        fields_types.push(field_type.clone());
+        field_getters.push(field_getter);
+        field_getter_impls.push(field_getter_impl);
+    }
+
+    Ok((field_getters, field_getter_impls))
+}
+
+fn impl_complex_enum_tuple_variant_len(
+    ctx: &Ctx,
+
+    variant_cls_type: &syn::Type,
+    num_fields: usize,
+) -> Result<(MethodAndSlotDef, syn::ImplItemFn)> {
+    let Ctx { pyo3_path, .. } = ctx;
+
+    let mut len_method_impl: syn::ImplItemFn = parse_quote! {
+        fn __len__(slf: #pyo3_path::PyClassGuard<'_, Self>) -> #pyo3_path::PyResult<usize> {
+            ::std::result::Result::Ok(#num_fields)
+        }
+    };
+
+    let variant_len =
+        generate_default_protocol_slot(variant_cls_type, &mut len_method_impl, &__LEN__, ctx)?;
+
+    Ok((variant_len, len_method_impl))
+}
+
+fn impl_complex_enum_tuple_variant_getitem(
+    ctx: &Ctx,
+    variant_cls: &syn::Ident,
+    variant_cls_type: &syn::Type,
+    num_fields: usize,
+) -> Result<(MethodAndSlotDef, syn::ImplItemFn)> {
+    let Ctx { pyo3_path, .. } = ctx;
+
+    let match_arms: Vec<_> = (0..num_fields)
+        .map(|i| {
+            let field_access = format_ident!("_{}", i);
+            quote! { #i =>
+                #pyo3_path::IntoPyObjectExt::into_py_any(#variant_cls::#field_access(slf, py)?, py)
+            }
+        })
+        .collect();
+
+    let mut get_item_method_impl: syn::ImplItemFn = parse_quote! {
+        fn __getitem__(slf: #pyo3_path::PyClassGuard<'_, Self>, py: #pyo3_path::Python<'_>, idx: usize) -> #pyo3_path::PyResult< #pyo3_path::Py<#pyo3_path::PyAny>> {
+            match idx {
+                #( #match_arms, )*
+                _ => ::std::result::Result::Err(#pyo3_path::exceptions::PyIndexError::new_err("tuple index out of range")),
+            }
+        }
+    };
+
+    let variant_getitem = generate_default_protocol_slot(
+        variant_cls_type,
+        &mut get_item_method_impl,
+        &__GETITEM__,
+        ctx,
+    )?;
+
+    Ok((variant_getitem, get_item_method_impl))
+}
+
+fn impl_complex_enum_tuple_variant_cls(
+    enum_name: &syn::Ident,
+    variant: &PyClassEnumTupleVariant<'_>,
+    ctx: &Ctx,
+) -> Result<(TokenStream, Vec<MethodAndMethodDef>, Vec<MethodAndSlotDef>)> {
+    let Ctx { pyo3_path, .. } = ctx;
+    let variant_ident = &variant.ident;
+    let variant_cls = gen_complex_enum_variant_class_ident(enum_name, variant.ident);
+    let variant_cls_type = parse_quote!(#variant_cls);
+
+    let mut slots = vec![];
+
+    // represents the index of the field
+    let mut field_names: Vec<Ident> = vec![];
+    let mut field_types: Vec<syn::Type> = vec![];
+
+    let (mut field_getters, field_getter_impls) = impl_complex_enum_tuple_variant_field_getters(
+        ctx,
+        variant,
+        enum_name,
+        &variant_cls_type,
+        variant_ident,
+        &mut field_names,
+        &mut field_types,
+    )?;
+
+    let num_fields = variant.fields.len();
+
+    let (variant_len, len_method_impl) =
+        impl_complex_enum_tuple_variant_len(ctx, &variant_cls_type, num_fields)?;
+
+    slots.push(variant_len);
+
+    let (variant_getitem, getitem_method_impl) =
+        impl_complex_enum_tuple_variant_getitem(ctx, &variant_cls, &variant_cls_type, num_fields)?;
+
+    slots.push(variant_getitem);
+
+    let (variant_match_args, match_args_method_impl) =
+        impl_complex_enum_variant_match_args(ctx, &variant_cls_type, &field_names)?;
+
+    field_getters.push(variant_match_args);
+
+    let cls_impl = quote! {
+        #[doc(hidden)]
+        #[allow(non_snake_case)]
+        impl #variant_cls {
+            #[allow(clippy::too_many_arguments)]
+            fn __pymethod_constructor__(py: #pyo3_path::Python<'_>, #(#field_names : #field_types,)*) -> #pyo3_path::PyClassInitializer<#variant_cls> {
+                let base_value = #enum_name::#variant_ident ( #(#field_names,)* );
+                <#pyo3_path::PyClassInitializer<#enum_name> as ::std::convert::From<#enum_name>>::from(base_value).add_subclass(#variant_cls)
             }
 
+            #len_method_impl
+
+            #getitem_method_impl
+
+            #match_args_method_impl
+
             #(#field_getter_impls)*
         }
     };
 
-    Ok((cls_impl, field_getters))
+    Ok((cls_impl, field_getters, slots))
 }
 
 fn gen_complex_enum_variant_class_ident(enum_: &syn::Ident, variant: &syn::Ident) -> syn::Ident {
     format_ident!("{}_{}", enum_, variant)
 }
 
+#[cfg(feature = "experimental-inspect")]
+struct FunctionIntrospectionData<'a> {
+    names: &'a [&'a str],
+    arguments: Vec<FnArg<'a>>,
+    returns: syn::Type,
+}
+
+fn generate_protocol_slot(
+    cls: &syn::Type,
+    method: &mut syn::ImplItemFn,
+    slot: &SlotDef,
+    name: &str,
+    #[cfg(feature = "experimental-inspect")] introspection_data: FunctionIntrospectionData<'_>,
+    ctx: &Ctx,
+) -> syn::Result<MethodAndSlotDef> {
+    let spec = FnSpec::parse(
+        &mut method.sig,
+        &mut Vec::new(),
+        PyFunctionOptions::default(),
+    )?;
+    #[cfg_attr(not(feature = "experimental-inspect"), allow(unused_mut))]
+    let mut def = slot.generate_type_slot(&syn::parse_quote!(#cls), &spec, name, ctx)?;
+    #[cfg(feature = "experimental-inspect")]
+    {
+        // We generate introspection data
+        let signature = FunctionSignature::from_arguments(introspection_data.arguments);
+        let returns = introspection_data.returns;
+        def.add_introspection(
+            introspection_data
+                .names
+                .iter()
+                .flat_map(|name| {
+                    function_introspection_code(
+                        &ctx.pyo3_path,
+                        None,
+                        name,
+                        &signature,
+                        Some("self"),
+                        parse_quote!(-> #returns),
+                        [],
+                        Some(cls),
+                    )
+                })
+                .collect(),
+        );
+    }
+    Ok(def)
+}
+
 fn generate_default_protocol_slot(
     cls: &syn::Type,
     method: &mut syn::ImplItemFn,
     slot: &SlotDef,
+    ctx: &Ctx,
 ) -> syn::Result<MethodAndSlotDef> {
     let spec = FnSpec::parse(
         &mut method.sig,
         &mut Vec::new(),
         PyFunctionOptions::default(),
-    )
-    .unwrap();
+    )?;
     let name = spec.name.to_string();
     slot.generate_type_slot(
         &syn::parse_quote!(#cls),
         &spec,
-        &format!("__default_{}__", name),
+        &format!("__default_{name}__"),
+        ctx,
     )
 }
 
 fn simple_enum_default_methods<'a>(
     cls: &'a syn::Ident,
-    unit_variant_names: impl IntoIterator<Item = (&'a syn::Ident, Cow<'a, syn::Ident>)>,
+    unit_variant_names: impl IntoIterator<
+        Item = (
+            &'a syn::Ident,
+            Cow<'a, syn::Ident>,
+            &'a Vec<&'a syn::Attribute>,
+        ),
+    >,
+    ctx: &Ctx,
 ) -> Vec<MethodAndMethodDef> {
     let cls_type = syn::parse_quote!(#cls);
     let variant_to_attribute = |var_ident: &syn::Ident, py_ident: &syn::Ident| ConstSpec {
@@ -1039,18 +1603,36 @@ fn simple_enum_default_methods<'a>(
                 kw: syn::parse_quote! { name },
                 value: NameLitStr(py_ident.clone()),
             }),
-            deprecations: Default::default(),
         },
     };
     unit_variant_names
         .into_iter()
-        .map(|(var, py_name)| gen_py_const(&cls_type, &variant_to_attribute(var, &py_name)))
+        .map(|(var, py_name, attrs)| {
+            let method = gen_py_const(&cls_type, &variant_to_attribute(var, &py_name), ctx);
+            let associated_method_tokens = method.associated_method;
+            let method_def_tokens = method.method_def;
+
+            let associated_method = quote! {
+                #(#attrs)*
+                #associated_method_tokens
+            };
+            let method_def = quote! {
+                #(#attrs)*
+                #method_def_tokens
+            };
+
+            MethodAndMethodDef {
+                associated_method,
+                method_def,
+            }
+        })
         .collect()
 }
 
 fn complex_enum_default_methods<'a>(
     cls: &'a syn::Ident,
     variant_names: impl IntoIterator<Item = (&'a syn::Ident, Cow<'a, syn::Ident>)>,
+    ctx: &Ctx,
 ) -> Vec<MethodAndMethodDef> {
     let cls_type = syn::parse_quote!(#cls);
     let variant_to_attribute = |var_ident: &syn::Ident, py_ident: &syn::Ident| ConstSpec {
@@ -1061,13 +1643,12 @@ fn complex_enum_default_methods<'a>(
                 kw: syn::parse_quote! { name },
                 value: NameLitStr(py_ident.clone()),
             }),
-            deprecations: Default::default(),
         },
     };
     variant_names
         .into_iter()
         .map(|(var, py_name)| {
-            gen_complex_enum_variant_attr(cls, &cls_type, &variant_to_attribute(var, &py_name))
+            gen_complex_enum_variant_attr(cls, &cls_type, &variant_to_attribute(var, &py_name), ctx)
         })
         .collect()
 }
@@ -1076,25 +1657,25 @@ pub fn gen_complex_enum_variant_attr(
     cls: &syn::Ident,
     cls_type: &syn::Type,
     spec: &ConstSpec,
+    ctx: &Ctx,
 ) -> MethodAndMethodDef {
+    let Ctx { pyo3_path, .. } = ctx;
     let member = &spec.rust_ident;
     let wrapper_ident = format_ident!("__pymethod_variant_cls_{}__", member);
-    let deprecations = &spec.attributes.deprecations;
-    let python_name = &spec.null_terminated_python_name();
+    let python_name = spec.null_terminated_python_name();
 
     let variant_cls = format_ident!("{}_{}", cls, member);
     let associated_method = quote! {
-        fn #wrapper_ident(py: _pyo3::Python<'_>) -> _pyo3::PyResult<_pyo3::PyObject> {
-            #deprecations
-            ::std::result::Result::Ok(py.get_type::<#variant_cls>().into())
+        fn #wrapper_ident(py: #pyo3_path::Python<'_>) -> #pyo3_path::PyResult<#pyo3_path::Py<#pyo3_path::PyAny>> {
+            ::std::result::Result::Ok(py.get_type::<#variant_cls>().into_any().unbind())
         }
     };
 
     let method_def = quote! {
-        _pyo3::class::PyMethodDefType::ClassAttribute({
-            _pyo3::class::PyClassAttributeDef::new(
+        #pyo3_path::impl_::pymethods::PyMethodDefType::ClassAttribute({
+            #pyo3_path::impl_::pymethods::PyClassAttributeDef::new(
                 #python_name,
-                _pyo3::impl_::pymethods::PyClassAttributeFactory(#cls_type::#wrapper_ident)
+                #cls_type::#wrapper_ident
             )
         })
     };
@@ -1107,107 +1688,172 @@ pub fn gen_complex_enum_variant_attr(
 
 fn complex_enum_variant_new<'a>(
     cls: &'a syn::Ident,
-    variant: &'a PyClassEnumVariant<'a>,
+    variant: PyClassEnumVariant<'a>,
+    ctx: &Ctx,
 ) -> Result<MethodAndSlotDef> {
     match variant {
         PyClassEnumVariant::Struct(struct_variant) => {
-            complex_enum_struct_variant_new(cls, struct_variant)
+            complex_enum_struct_variant_new(cls, struct_variant, ctx)
+        }
+        PyClassEnumVariant::Tuple(tuple_variant) => {
+            complex_enum_tuple_variant_new(cls, tuple_variant, ctx)
         }
     }
 }
 
 fn complex_enum_struct_variant_new<'a>(
     cls: &'a syn::Ident,
-    variant: &'a PyClassEnumStructVariant<'a>,
+    variant: PyClassEnumStructVariant<'a>,
+    ctx: &Ctx,
 ) -> Result<MethodAndSlotDef> {
+    let Ctx { pyo3_path, .. } = ctx;
     let variant_cls = format_ident!("{}_{}", cls, variant.ident);
     let variant_cls_type: syn::Type = parse_quote!(#variant_cls);
 
     let arg_py_ident: syn::Ident = parse_quote!(py);
-    let arg_py_type: syn::Type = parse_quote!(_pyo3::Python<'_>);
+    let arg_py_type: syn::Type = parse_quote!(#pyo3_path::Python<'_>);
 
     let args = {
-        let mut no_pyo3_attrs = vec![];
-        let attrs = crate::pyfunction::PyFunctionArgPyO3Attributes::from_attrs(&mut no_pyo3_attrs)?;
-
         let mut args = vec![
             // py: Python<'_>
-            FnArg {
+            FnArg::Py(PyArg {
                 name: &arg_py_ident,
                 ty: &arg_py_type,
-                optional: None,
-                default: None,
-                py: true,
-                attrs: attrs.clone(),
-                is_varargs: false,
-                is_kwargs: false,
-                is_cancel_handle: false,
-            },
+            }),
         ];
 
         for field in &variant.fields {
-            args.push(FnArg {
-                name: field.ident,
+            args.push(FnArg::Regular(RegularArg {
+                name: Cow::Borrowed(field.ident),
                 ty: field.ty,
-                optional: None,
-                default: None,
-                py: false,
-                attrs: attrs.clone(),
-                is_varargs: false,
-                is_kwargs: false,
-                is_cancel_handle: false,
-            });
+                from_py_with: None,
+                default_value: None,
+                option_wrapped_type: None,
+                #[cfg(feature = "experimental-inspect")]
+                annotation: None,
+            }));
+        }
+        args
+    };
+
+    let signature = if let Some(constructor) = variant.options.constructor {
+        crate::pyfunction::FunctionSignature::from_arguments_and_attribute(
+            args,
+            constructor.into_signature(),
+        )?
+    } else {
+        crate::pyfunction::FunctionSignature::from_arguments(args)
+    };
+
+    let spec = FnSpec {
+        tp: crate::method::FnType::FnNew,
+        name: &format_ident!("__pymethod_constructor__"),
+        python_name: format_ident!("__new__"),
+        signature,
+        convention: crate::method::CallingConvention::TpNew,
+        text_signature: None,
+        asyncness: None,
+        unsafety: None,
+        warnings: vec![],
+        #[cfg(feature = "experimental-inspect")]
+        output: syn::ReturnType::Default,
+    };
+
+    crate::pymethod::impl_py_method_def_new(&variant_cls_type, &spec, ctx)
+}
+
+fn complex_enum_tuple_variant_new<'a>(
+    cls: &'a syn::Ident,
+    variant: PyClassEnumTupleVariant<'a>,
+    ctx: &Ctx,
+) -> Result<MethodAndSlotDef> {
+    let Ctx { pyo3_path, .. } = ctx;
+
+    let variant_cls: Ident = format_ident!("{}_{}", cls, variant.ident);
+    let variant_cls_type: syn::Type = parse_quote!(#variant_cls);
+
+    let arg_py_ident: syn::Ident = parse_quote!(py);
+    let arg_py_type: syn::Type = parse_quote!(#pyo3_path::Python<'_>);
+
+    let args = {
+        let mut args = vec![FnArg::Py(PyArg {
+            name: &arg_py_ident,
+            ty: &arg_py_type,
+        })];
+
+        for (i, field) in variant.fields.iter().enumerate() {
+            args.push(FnArg::Regular(RegularArg {
+                name: std::borrow::Cow::Owned(format_ident!("_{}", i)),
+                ty: field.ty,
+                from_py_with: None,
+                default_value: None,
+                option_wrapped_type: None,
+                #[cfg(feature = "experimental-inspect")]
+                annotation: None,
+            }));
         }
         args
     };
-    let signature = crate::pyfunction::FunctionSignature::from_arguments(args)?;
+
+    let signature = if let Some(constructor) = variant.options.constructor {
+        crate::pyfunction::FunctionSignature::from_arguments_and_attribute(
+            args,
+            constructor.into_signature(),
+        )?
+    } else {
+        crate::pyfunction::FunctionSignature::from_arguments(args)
+    };
 
     let spec = FnSpec {
         tp: crate::method::FnType::FnNew,
         name: &format_ident!("__pymethod_constructor__"),
         python_name: format_ident!("__new__"),
         signature,
-        output: variant_cls_type.clone(),
         convention: crate::method::CallingConvention::TpNew,
         text_signature: None,
         asyncness: None,
         unsafety: None,
-        deprecations: Deprecations::default(),
+        warnings: vec![],
+        #[cfg(feature = "experimental-inspect")]
+        output: syn::ReturnType::Default,
     };
 
-    crate::pymethod::impl_py_method_def_new(&variant_cls_type, &spec)
+    crate::pymethod::impl_py_method_def_new(&variant_cls_type, &spec, ctx)
 }
 
 fn complex_enum_variant_field_getter<'a>(
     variant_cls_type: &'a syn::Type,
     field_name: &'a syn::Ident,
-    field_type: &'a syn::Type,
     field_span: Span,
+    ctx: &Ctx,
 ) -> Result<MethodAndMethodDef> {
-    let signature = crate::pyfunction::FunctionSignature::from_arguments(vec![])?;
+    let mut arg = parse_quote!(py: Python<'_>);
+    let py = FnArg::parse(&mut arg)?;
+    let signature = crate::pyfunction::FunctionSignature::from_arguments(vec![py]);
 
-    let self_type = crate::method::SelfType::TryFromPyCell(field_span);
+    let self_type = crate::method::SelfType::TryFromBoundRef(field_span);
 
     let spec = FnSpec {
         tp: crate::method::FnType::Getter(self_type.clone()),
         name: field_name,
-        python_name: field_name.clone(),
+        python_name: field_name.unraw(),
         signature,
-        output: field_type.clone(),
         convention: crate::method::CallingConvention::Noargs,
         text_signature: None,
         asyncness: None,
         unsafety: None,
-        deprecations: Deprecations::default(),
+        warnings: vec![],
+        #[cfg(feature = "experimental-inspect")]
+        output: parse_quote!(-> #variant_cls_type),
     };
 
     let property_type = crate::pymethod::PropertyType::Function {
         self_type: &self_type,
         spec: &spec,
-        doc: crate::get_doc(&[], None),
+        doc: crate::get_doc(&[], None, ctx)?,
     };
 
-    let getter = crate::pymethod::impl_py_getter_def(variant_cls_type, property_type)?;
+    let getter = crate::pymethod::impl_py_getter_def(variant_cls_type, property_type, ctx)?;
     Ok(getter)
 }
 
@@ -1216,6 +1862,7 @@ fn descriptors_to_items(
     rename_all: Option<&RenameAllAttribute>,
     frozen: Option<frozen>,
     field_options: Vec<(&syn::Field, FieldPyO3Options)>,
+    ctx: &Ctx,
 ) -> syn::Result<Vec<MethodAndMethodDef>> {
     let ty = syn::parse_quote!(#cls);
     let mut items = Vec::new();
@@ -1230,40 +1877,80 @@ fn descriptors_to_items(
         }
 
         if options.get.is_some() {
-            let getter = impl_py_getter_def(
+            let renaming_rule = rename_all.map(|rename_all| rename_all.value.rule);
+            #[cfg_attr(not(feature = "experimental-inspect"), allow(unused_mut))]
+            let mut getter = impl_py_getter_def(
                 &ty,
                 PropertyType::Descriptor {
                     field_index,
                     field,
                     python_name: options.name.as_ref(),
-                    renaming_rule: rename_all.map(|rename_all| rename_all.value.rule),
+                    renaming_rule,
                 },
+                ctx,
             )?;
+            #[cfg(feature = "experimental-inspect")]
+            {
+                // We generate introspection data
+                let return_type = &field.ty;
+                getter.add_introspection(function_introspection_code(
+                    &ctx.pyo3_path,
+                    None,
+                    &field_python_name(field, options.name.as_ref(), renaming_rule)?,
+                    &FunctionSignature::from_arguments(vec![]),
+                    Some("self"),
+                    parse_quote!(-> #return_type),
+                    vec!["property".into()],
+                    Some(&parse_quote!(#cls)),
+                ));
+            }
             items.push(getter);
         }
 
         if let Some(set) = options.set {
             ensure_spanned!(frozen.is_none(), set.span() => "cannot use `#[pyo3(set)]` on a `frozen` class");
-            let setter = impl_py_setter_def(
+            let renaming_rule = rename_all.map(|rename_all| rename_all.value.rule);
+            #[cfg_attr(not(feature = "experimental-inspect"), allow(unused_mut))]
+            let mut setter = impl_py_setter_def(
                 &ty,
                 PropertyType::Descriptor {
                     field_index,
                     field,
                     python_name: options.name.as_ref(),
-                    renaming_rule: rename_all.map(|rename_all| rename_all.value.rule),
+                    renaming_rule,
                 },
+                ctx,
             )?;
+            #[cfg(feature = "experimental-inspect")]
+            {
+                // We generate introspection data
+                let name = field_python_name(field, options.name.as_ref(), renaming_rule)?;
+                setter.add_introspection(function_introspection_code(
+                    &ctx.pyo3_path,
+                    None,
+                    &name,
+                    &FunctionSignature::from_arguments(vec![FnArg::Regular(RegularArg {
+                        name: Cow::Owned(format_ident!("value")),
+                        ty: &field.ty,
+                        from_py_with: None,
+                        default_value: None,
+                        option_wrapped_type: None,
+                        annotation: None,
+                    })]),
+                    Some("self"),
+                    syn::ReturnType::Default,
+                    vec![format!("{name}.setter")],
+                    Some(&parse_quote!(#cls)),
+                ));
+            }
             items.push(setter);
         };
     }
     Ok(items)
 }
 
-fn impl_pytypeinfo(
-    cls: &syn::Ident,
-    attr: &PyClassArgs,
-    deprecations: Option<&Deprecations>,
-) -> TokenStream {
+fn impl_pytypeinfo(cls: &syn::Ident, attr: &PyClassArgs, ctx: &Ctx) -> TokenStream {
+    let Ctx { pyo3_path, .. } = ctx;
     let cls_name = get_class_python_name(cls, attr).to_string();
 
     let module = if let Some(ModuleAttribute { value, .. }) = &attr.options.module {
@@ -1272,27 +1959,320 @@ fn impl_pytypeinfo(
         quote! { ::core::option::Option::None }
     };
 
-    quote! {
-        unsafe impl _pyo3::type_object::HasPyGilRef for #cls {
-            type AsRefTarget = _pyo3::PyCell<Self>;
-        }
+    #[cfg(feature = "experimental-inspect")]
+    let type_hint = {
+        let type_hint = get_class_type_hint(cls, attr, ctx);
+        quote! { const TYPE_HINT: #pyo3_path::inspect::TypeHint = #type_hint; }
+    };
+    #[cfg(not(feature = "experimental-inspect"))]
+    let type_hint = quote! {};
 
-        unsafe impl _pyo3::type_object::PyTypeInfo for #cls {
+    quote! {
+        unsafe impl #pyo3_path::type_object::PyTypeInfo for #cls {
             const NAME: &'static str = #cls_name;
             const MODULE: ::std::option::Option<&'static str> = #module;
 
-            #[inline]
-            fn type_object_raw(py: _pyo3::Python<'_>) -> *mut _pyo3::ffi::PyTypeObject {
-                #deprecations
+            #type_hint
 
-                <#cls as _pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
-                    .get_or_init(py)
+            #[inline]
+            fn type_object_raw(py: #pyo3_path::Python<'_>) -> *mut #pyo3_path::ffi::PyTypeObject {
+                use #pyo3_path::prelude::PyTypeMethods;
+                <#cls as #pyo3_path::impl_::pyclass::PyClassImpl>::lazy_type_object()
+                    .get_or_try_init(py)
+                    .unwrap_or_else(|e| #pyo3_path::impl_::pyclass::type_object_init_failed(
+                        py,
+                        e,
+                        <Self as #pyo3_path::type_object::PyTypeInfo>::NAME
+                    ))
                     .as_type_ptr()
             }
         }
     }
 }
 
+fn pyclass_richcmp_arms(
+    options: &PyClassPyO3Options,
+    ctx: &Ctx,
+) -> std::result::Result<TokenStream, syn::Error> {
+    let Ctx { pyo3_path, .. } = ctx;
+
+    let eq_arms = options
+        .eq
+        .map(|eq| eq.span)
+        .or(options.eq_int.map(|eq_int| eq_int.span))
+        .map(|span| {
+            quote_spanned! { span =>
+                #pyo3_path::pyclass::CompareOp::Eq => {
+                    #pyo3_path::IntoPyObjectExt::into_py_any(self_val == other, py)
+                },
+                #pyo3_path::pyclass::CompareOp::Ne => {
+                    #pyo3_path::IntoPyObjectExt::into_py_any(self_val != other, py)
+                },
+            }
+        })
+        .unwrap_or_default();
+
+    if let Some(ord) = options.ord {
+        ensure_spanned!(options.eq.is_some(), ord.span() => "The `ord` option requires the `eq` option.");
+    }
+
+    let ord_arms = options
+        .ord
+        .map(|ord| {
+            quote_spanned! { ord.span() =>
+                #pyo3_path::pyclass::CompareOp::Gt => {
+                    #pyo3_path::IntoPyObjectExt::into_py_any(self_val > other, py)
+                },
+                #pyo3_path::pyclass::CompareOp::Lt => {
+                    #pyo3_path::IntoPyObjectExt::into_py_any(self_val < other, py)
+                 },
+                #pyo3_path::pyclass::CompareOp::Le => {
+                    #pyo3_path::IntoPyObjectExt::into_py_any(self_val <= other, py)
+                 },
+                #pyo3_path::pyclass::CompareOp::Ge => {
+                    #pyo3_path::IntoPyObjectExt::into_py_any(self_val >= other, py)
+                 },
+            }
+        })
+        .unwrap_or_else(|| quote! { _ => ::std::result::Result::Ok(py.NotImplemented()) });
+
+    Ok(quote! {
+        #eq_arms
+        #ord_arms
+    })
+}
+
+fn pyclass_richcmp_simple_enum(
+    options: &PyClassPyO3Options,
+    cls: &syn::Type,
+    repr_type: &syn::Ident,
+    #[cfg(feature = "experimental-inspect")] class_name: &str,
+    ctx: &Ctx,
+) -> Result<(Option<syn::ImplItemFn>, Option<MethodAndSlotDef>)> {
+    let Ctx { pyo3_path, .. } = ctx;
+    if let Some(eq_int) = options.eq_int {
+        ensure_spanned!(options.eq.is_some(), eq_int.span() => "The `eq_int` option requires the `eq` option.");
+    }
+
+    if options.eq.is_none() && options.eq_int.is_none() {
+        return Ok((None, None));
+    }
+
+    let arms = pyclass_richcmp_arms(options, ctx)?;
+
+    let eq = options.eq.map(|eq| {
+        quote_spanned! { eq.span() =>
+            let self_val = self;
+            if let ::std::result::Result::Ok(other) = other.cast::<Self>() {
+                let other = &*other.borrow();
+                return match op {
+                    #arms
+                }
+            }
+        }
+    });
+
+    let eq_int = options.eq_int.map(|eq_int| {
+        quote_spanned! { eq_int.span() =>
+            let self_val = self.__pyo3__int__();
+            if let ::std::result::Result::Ok(other) = #pyo3_path::types::PyAnyMethods::extract::<#repr_type>(other).or_else(|_| {
+                other.cast::<Self>().map(|o| o.borrow().__pyo3__int__())
+            }) {
+                return match op {
+                    #arms
+                }
+            }
+        }
+    });
+
+    let mut richcmp_impl = parse_quote! {
+        fn __pyo3__generated____richcmp__(
+            &self,
+            py: #pyo3_path::Python,
+            other: &#pyo3_path::Bound<'_, #pyo3_path::PyAny>,
+            op: #pyo3_path::pyclass::CompareOp
+        ) -> #pyo3_path::PyResult<#pyo3_path::Py<#pyo3_path::PyAny>> {
+            #eq
+
+            #eq_int
+
+            ::std::result::Result::Ok(py.NotImplemented())
+        }
+    };
+    let richcmp_slot = if options.eq.is_some() {
+        generate_protocol_slot(
+            cls,
+            &mut richcmp_impl,
+            &__RICHCMP__,
+            "__richcmp__",
+            #[cfg(feature = "experimental-inspect")]
+            FunctionIntrospectionData {
+                names: &["__eq__", "__ne__"],
+                arguments: vec![FnArg::Regular(RegularArg {
+                    name: Cow::Owned(format_ident!("other")),
+                    // we need to set a type, let's pick something small, it is overridden by annotation anyway
+                    ty: &parse_quote!(!),
+                    from_py_with: None,
+                    default_value: None,
+                    option_wrapped_type: None,
+                    annotation: Some(match (options.eq.is_some(), options.eq_int.is_some()) {
+                        (true, true) => {
+                            format!("{class_name} | int")
+                        }
+                        (true, false) => class_name.into(),
+                        (false, true) => "int".into(),
+                        (false, false) => unreachable!(),
+                    }),
+                })],
+                returns: parse_quote! { ::std::primitive::bool },
+            },
+            ctx,
+        )?
+    } else {
+        generate_default_protocol_slot(cls, &mut richcmp_impl, &__RICHCMP__, ctx)?
+    };
+    Ok((Some(richcmp_impl), Some(richcmp_slot)))
+}
+
+fn pyclass_richcmp(
+    options: &PyClassPyO3Options,
+    cls: &syn::Type,
+    ctx: &Ctx,
+) -> Result<(Option<syn::ImplItemFn>, Option<MethodAndSlotDef>)> {
+    let Ctx { pyo3_path, .. } = ctx;
+    if let Some(eq_int) = options.eq_int {
+        bail_spanned!(eq_int.span() => "`eq_int` can only be used on simple enums.")
+    }
+
+    let arms = pyclass_richcmp_arms(options, ctx)?;
+    if options.eq.is_some() {
+        let mut richcmp_impl = parse_quote! {
+            fn __pyo3__generated____richcmp__(
+                &self,
+                py: #pyo3_path::Python,
+                other: &#pyo3_path::Bound<'_, #pyo3_path::PyAny>,
+                op: #pyo3_path::pyclass::CompareOp
+            ) -> #pyo3_path::PyResult<#pyo3_path::Py<#pyo3_path::PyAny>> {
+                let self_val = self;
+                if let ::std::result::Result::Ok(other) = other.cast::<Self>() {
+                    let other = &*other.borrow();
+                    match op {
+                        #arms
+                    }
+                } else {
+                    ::std::result::Result::Ok(py.NotImplemented())
+                }
+            }
+        };
+        let richcmp_slot = generate_protocol_slot(
+            cls,
+            &mut richcmp_impl,
+            &__RICHCMP__,
+            "__richcmp__",
+            #[cfg(feature = "experimental-inspect")]
+            FunctionIntrospectionData {
+                names: if options.ord.is_some() {
+                    &["__eq__", "__ne__", "__lt__", "__le__", "__gt__", "__ge__"]
+                } else {
+                    &["__eq__", "__ne__"]
+                },
+                arguments: vec![FnArg::Regular(RegularArg {
+                    name: Cow::Owned(format_ident!("other")),
+                    ty: &parse_quote!(&#cls),
+                    from_py_with: None,
+                    default_value: None,
+                    option_wrapped_type: None,
+                    annotation: None,
+                })],
+                returns: parse_quote! { ::std::primitive::bool },
+            },
+            ctx,
+        )?;
+        Ok((Some(richcmp_impl), Some(richcmp_slot)))
+    } else {
+        Ok((None, None))
+    }
+}
+
+fn pyclass_hash(
+    options: &PyClassPyO3Options,
+    cls: &syn::Type,
+    ctx: &Ctx,
+) -> Result<(Option<syn::ImplItemFn>, Option<MethodAndSlotDef>)> {
+    if options.hash.is_some() {
+        ensure_spanned!(
+            options.frozen.is_some(), options.hash.span() => "The `hash` option requires the `frozen` option.";
+            options.eq.is_some(), options.hash.span() => "The `hash` option requires the `eq` option.";
+        );
+    }
+    match options.hash {
+        Some(opt) => {
+            let mut hash_impl = parse_quote_spanned! { opt.span() =>
+                fn __pyo3__generated____hash__(&self) -> u64 {
+                    let mut s = ::std::collections::hash_map::DefaultHasher::new();
+                    ::std::hash::Hash::hash(self, &mut s);
+                    ::std::hash::Hasher::finish(&s)
+                }
+            };
+            let hash_slot = generate_protocol_slot(
+                cls,
+                &mut hash_impl,
+                &__HASH__,
+                "__hash__",
+                #[cfg(feature = "experimental-inspect")]
+                FunctionIntrospectionData {
+                    names: &["__hash__"],
+                    arguments: Vec::new(),
+                    returns: parse_quote! { ::std::primitive::u64 },
+                },
+                ctx,
+            )?;
+            Ok((Some(hash_impl), Some(hash_slot)))
+        }
+        None => Ok((None, None)),
+    }
+}
+
+fn pyclass_class_geitem(
+    options: &PyClassPyO3Options,
+    cls: &syn::Type,
+    ctx: &Ctx,
+) -> Result<(Option<syn::ImplItemFn>, Option<MethodAndMethodDef>)> {
+    let Ctx { pyo3_path, .. } = ctx;
+    match options.generic {
+        Some(_) => {
+            let ident = format_ident!("__class_getitem__");
+            let mut class_geitem_impl: syn::ImplItemFn = {
+                parse_quote! {
+                    #[classmethod]
+                    fn #ident<'py>(
+                        cls: &#pyo3_path::Bound<'py, #pyo3_path::types::PyType>,
+                        key: &#pyo3_path::Bound<'py, #pyo3_path::types::PyAny>
+                    ) -> #pyo3_path::PyResult<#pyo3_path::Bound<'py, #pyo3_path::types::PyGenericAlias>> {
+                        #pyo3_path::types::PyGenericAlias::new(cls.py(), cls.as_any(), key)
+                    }
+                }
+            };
+
+            let spec = FnSpec::parse(
+                &mut class_geitem_impl.sig,
+                &mut class_geitem_impl.attrs,
+                Default::default(),
+            )?;
+
+            let class_geitem_method = crate::pymethod::impl_py_method_def(
+                cls,
+                &spec,
+                &spec.get_doc(&class_geitem_impl.attrs, ctx)?,
+                Some(quote!(#pyo3_path::ffi::METH_CLASS)),
+                ctx,
+            )?;
+            Ok((Some(class_geitem_impl), Some(class_geitem_method)))
+        }
+        None => Ok((None, None)),
+    }
+}
+
 /// Implements most traits used by `#[pyclass]`.
 ///
 /// Specifically, it implements traits that only depend on class name,
@@ -1332,82 +2312,59 @@ impl<'a> PyClassImplsBuilder<'a> {
         }
     }
 
-    fn impl_all(&self) -> Result<TokenStream> {
-        let tokens = vec![
-            self.impl_pyclass(),
-            self.impl_extractext(),
-            self.impl_into_py(),
-            self.impl_pyclassimpl()?,
-            self.impl_freelist(),
+    fn impl_all(&self, ctx: &Ctx) -> Result<TokenStream> {
+        Ok([
+            self.impl_pyclass(ctx),
+            self.impl_into_py(ctx),
+            self.impl_pyclassimpl(ctx)?,
+            self.impl_add_to_module(ctx),
+            self.impl_freelist(ctx),
+            self.impl_introspection(ctx),
         ]
         .into_iter()
-        .collect();
-        Ok(tokens)
+        .collect())
     }
 
-    fn impl_pyclass(&self) -> TokenStream {
+    fn impl_pyclass(&self, ctx: &Ctx) -> TokenStream {
+        let Ctx { pyo3_path, .. } = ctx;
         let cls = self.cls;
 
         let frozen = if self.attr.options.frozen.is_some() {
-            quote! { _pyo3::pyclass::boolean_struct::True }
+            quote! { #pyo3_path::pyclass::boolean_struct::True }
         } else {
-            quote! { _pyo3::pyclass::boolean_struct::False }
+            quote! { #pyo3_path::pyclass::boolean_struct::False }
         };
 
         quote! {
-            impl _pyo3::PyClass for #cls {
+            impl #pyo3_path::PyClass for #cls {
                 type Frozen = #frozen;
             }
         }
     }
-    fn impl_extractext(&self) -> TokenStream {
-        let cls = self.cls;
-        if self.attr.options.frozen.is_some() {
-            quote! {
-                impl<'a, 'py> _pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py> for &'a #cls
-                {
-                    type Holder = ::std::option::Option<_pyo3::PyRef<'py, #cls>>;
-
-                    #[inline]
-                    fn extract(obj: &'py _pyo3::PyAny, holder: &'a mut Self::Holder) -> _pyo3::PyResult<Self> {
-                        _pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
-                    }
-                }
-            }
-        } else {
-            quote! {
-                impl<'a, 'py> _pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py> for &'a #cls
-                {
-                    type Holder = ::std::option::Option<_pyo3::PyRef<'py, #cls>>;
-
-                    #[inline]
-                    fn extract(obj: &'py _pyo3::PyAny, holder: &'a mut Self::Holder) -> _pyo3::PyResult<Self> {
-                        _pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
-                    }
-                }
-
-                impl<'a, 'py> _pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py> for &'a mut #cls
-                {
-                    type Holder = ::std::option::Option<_pyo3::PyRefMut<'py, #cls>>;
-
-                    #[inline]
-                    fn extract(obj: &'py _pyo3::PyAny, holder: &'a mut Self::Holder) -> _pyo3::PyResult<Self> {
-                        _pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
-                    }
-                }
-            }
-        }
-    }
 
-    fn impl_into_py(&self) -> TokenStream {
+    fn impl_into_py(&self, ctx: &Ctx) -> TokenStream {
+        let Ctx { pyo3_path, .. } = ctx;
         let cls = self.cls;
         let attr = self.attr;
         // If #cls is not extended type, we allow Self->PyObject conversion
         if attr.options.extends.is_none() {
+            let output_type = if cfg!(feature = "experimental-inspect") {
+                quote!(const OUTPUT_TYPE: #pyo3_path::inspect::TypeHint = <#cls as #pyo3_path::PyTypeInfo>::TYPE_HINT;)
+            } else {
+                TokenStream::new()
+            };
             quote! {
-                impl _pyo3::IntoPy<_pyo3::PyObject> for #cls {
-                    fn into_py(self, py: _pyo3::Python) -> _pyo3::PyObject {
-                        _pyo3::IntoPy::into_py(_pyo3::Py::new(py, self).unwrap(), py)
+                impl<'py> #pyo3_path::conversion::IntoPyObject<'py> for #cls {
+                    type Target = Self;
+                    type Output = #pyo3_path::Bound<'py, <Self as #pyo3_path::conversion::IntoPyObject<'py>>::Target>;
+                    type Error = #pyo3_path::PyErr;
+                    #output_type
+
+                    fn into_pyobject(self, py: #pyo3_path::Python<'py>) -> ::std::result::Result<
+                        <Self as #pyo3_path::conversion::IntoPyObject>::Output,
+                        <Self as #pyo3_path::conversion::IntoPyObject>::Error,
+                    > {
+                        #pyo3_path::Bound::new(py, self)
                     }
                 }
             }
@@ -1415,17 +2372,22 @@ impl<'a> PyClassImplsBuilder<'a> {
             quote! {}
         }
     }
-    fn impl_pyclassimpl(&self) -> Result<TokenStream> {
+    fn impl_pyclassimpl(&self, ctx: &Ctx) -> Result<TokenStream> {
+        let Ctx { pyo3_path, .. } = ctx;
         let cls = self.cls;
-        let doc = self.doc.as_ref().map_or(quote! {"\0"}, |doc| quote! {#doc});
+        let doc = self
+            .doc
+            .as_ref()
+            .map_or(c"".to_token_stream(), PythonDoc::to_token_stream);
         let is_basetype = self.attr.options.subclass.is_some();
         let base = match &self.attr.options.extends {
             Some(extends_attr) => extends_attr.value.clone(),
-            None => parse_quote! { _pyo3::PyAny },
+            None => parse_quote! { #pyo3_path::PyAny },
         };
         let is_subclass = self.attr.options.extends.is_some();
         let is_mapping: bool = self.attr.options.mapping.is_some();
         let is_sequence: bool = self.attr.options.sequence.is_some();
+        let is_immutable_type = self.attr.options.immutable_type.is_some();
 
         ensure_spanned!(
             !(is_mapping && is_sequence),
@@ -1434,8 +2396,8 @@ impl<'a> PyClassImplsBuilder<'a> {
 
         let dict_offset = if self.attr.options.dict.is_some() {
             quote! {
-                fn dict_offset() -> ::std::option::Option<_pyo3::ffi::Py_ssize_t> {
-                    ::std::option::Option::Some(_pyo3::impl_::pyclass::dict_offset::<Self>())
+                fn dict_offset() -> ::std::option::Option<#pyo3_path::ffi::Py_ssize_t> {
+                    ::std::option::Option::Some(#pyo3_path::impl_::pyclass::dict_offset::<Self>())
                 }
             }
         } else {
@@ -1445,8 +2407,8 @@ impl<'a> PyClassImplsBuilder<'a> {
         // insert space for weak ref
         let weaklist_offset = if self.attr.options.weakref.is_some() {
             quote! {
-                fn weaklist_offset() -> ::std::option::Option<_pyo3::ffi::Py_ssize_t> {
-                    ::std::option::Option::Some(_pyo3::impl_::pyclass::weaklist_offset::<Self>())
+                fn weaklist_offset() -> ::std::option::Option<#pyo3_path::ffi::Py_ssize_t> {
+                    ::std::option::Option::Some(#pyo3_path::impl_::pyclass::weaklist_offset::<Self>())
                 }
             }
         } else {
@@ -1454,9 +2416,9 @@ impl<'a> PyClassImplsBuilder<'a> {
         };
 
         let thread_checker = if self.attr.options.unsendable.is_some() {
-            quote! { _pyo3::impl_::pyclass::ThreadCheckerImpl }
+            quote! { #pyo3_path::impl_::pyclass::ThreadCheckerImpl }
         } else {
-            quote! { _pyo3::impl_::pyclass::SendablePyClass<#cls> }
+            quote! { #pyo3_path::impl_::pyclass::SendablePyClass<#cls> }
         };
 
         let (pymethods_items, inventory, inventory_class) = match self.methods_type {
@@ -1471,13 +2433,13 @@ impl<'a> PyClassImplsBuilder<'a> {
                     quote! {
                         ::std::boxed::Box::new(
                             ::std::iter::Iterator::map(
-                                _pyo3::inventory::iter::<<Self as _pyo3::impl_::pyclass::PyClassImpl>::Inventory>(),
-                                _pyo3::impl_::pyclass::PyClassInventory::items
+                                #pyo3_path::inventory::iter::<<Self as #pyo3_path::impl_::pyclass::PyClassImpl>::Inventory>(),
+                                #pyo3_path::impl_::pyclass::PyClassInventory::items
                             )
                         )
                     },
                     Some(quote! { type Inventory = #inventory_class_name; }),
-                    Some(define_inventory_class(&inventory_class_name)),
+                    Some(define_inventory_class(&inventory_class_name, ctx)),
                 )
             }
         };
@@ -1494,7 +2456,7 @@ impl<'a> PyClassImplsBuilder<'a> {
 
         let default_method_defs = self.default_methods.iter().map(|meth| &meth.method_def);
         let default_slot_defs = self.default_slots.iter().map(|slot| &slot.slot_def);
-        let freelist_slots = self.freelist_slots();
+        let freelist_slots = self.freelist_slots(ctx);
 
         let class_mutability = if self.attr.options.frozen.is_some() {
             quote! {
@@ -1509,41 +2471,98 @@ impl<'a> PyClassImplsBuilder<'a> {
         let cls = self.cls;
         let attr = self.attr;
         let dict = if attr.options.dict.is_some() {
-            quote! { _pyo3::impl_::pyclass::PyClassDictSlot }
+            quote! { #pyo3_path::impl_::pyclass::PyClassDictSlot }
         } else {
-            quote! { _pyo3::impl_::pyclass::PyClassDummySlot }
+            quote! { #pyo3_path::impl_::pyclass::PyClassDummySlot }
         };
 
         // insert space for weak ref
         let weakref = if attr.options.weakref.is_some() {
-            quote! { _pyo3::impl_::pyclass::PyClassWeakRefSlot }
+            quote! { #pyo3_path::impl_::pyclass::PyClassWeakRefSlot }
         } else {
-            quote! { _pyo3::impl_::pyclass::PyClassDummySlot }
+            quote! { #pyo3_path::impl_::pyclass::PyClassDummySlot }
         };
 
         let base_nativetype = if attr.options.extends.is_some() {
-            quote! { <Self::BaseType as _pyo3::impl_::pyclass::PyClassBaseType>::BaseNativeType }
+            quote! { <Self::BaseType as #pyo3_path::impl_::pyclass::PyClassBaseType>::BaseNativeType }
         } else {
-            quote! { _pyo3::PyAny }
+            quote! { #pyo3_path::PyAny }
+        };
+
+        let pyclass_base_type_impl = attr.options.subclass.map(|subclass| {
+            quote_spanned! { subclass.span() =>
+                impl #pyo3_path::impl_::pyclass::PyClassBaseType for #cls {
+                    type LayoutAsBase = #pyo3_path::impl_::pycell::PyClassObject<Self>;
+                    type BaseNativeType = <Self as #pyo3_path::impl_::pyclass::PyClassImpl>::BaseNativeType;
+                    type Initializer = #pyo3_path::pyclass_init::PyClassInitializer<Self>;
+                    type PyClassMutability = <Self as #pyo3_path::impl_::pyclass::PyClassImpl>::PyClassMutability;
+                }
+            }
+        });
+
+        let assertions = if attr.options.unsendable.is_some() {
+            TokenStream::new()
+        } else {
+            let assert = quote_spanned! { cls.span() => #pyo3_path::impl_::pyclass::assert_pyclass_sync::<#cls>(); };
+            quote! {
+                const _: () = {
+                    #assert
+                };
+            }
+        };
+
+        let extract_pyclass_with_clone = if let Some(from_py_object) =
+            self.attr.options.from_py_object
+        {
+            let input_type = if cfg!(feature = "experimental-inspect") {
+                quote!(const INPUT_TYPE: #pyo3_path::inspect::TypeHint = <#cls as #pyo3_path::PyTypeInfo>::TYPE_HINT;)
+            } else {
+                TokenStream::new()
+            };
+            quote_spanned! { from_py_object.span() =>
+                impl<'a, 'py> #pyo3_path::FromPyObject<'a, 'py> for #cls
+                where
+                    Self: ::std::clone::Clone,
+                {
+                    type Error = #pyo3_path::pyclass::PyClassGuardError<'a, 'py>;
+
+                    #input_type
+
+                    fn extract(obj: #pyo3_path::Borrowed<'a, 'py, #pyo3_path::PyAny>) -> ::std::result::Result<Self, Self::Error> {
+                        ::std::result::Result::Ok(::std::clone::Clone::clone(&*obj.extract::<#pyo3_path::PyClassGuard<'_, #cls>>()?))
+                    }
+                }
+            }
+        } else if self.attr.options.skip_from_py_object.is_none() {
+            quote!( impl #pyo3_path::impl_::pyclass::ExtractPyClassWithClone for #cls {} )
+        } else {
+            TokenStream::new()
         };
 
         Ok(quote! {
-            impl _pyo3::impl_::pyclass::PyClassImpl for #cls {
+            #extract_pyclass_with_clone
+
+            #assertions
+
+            #pyclass_base_type_impl
+
+            impl #pyo3_path::impl_::pyclass::PyClassImpl for #cls {
                 const IS_BASETYPE: bool = #is_basetype;
                 const IS_SUBCLASS: bool = #is_subclass;
                 const IS_MAPPING: bool = #is_mapping;
                 const IS_SEQUENCE: bool = #is_sequence;
+                const IS_IMMUTABLE_TYPE: bool = #is_immutable_type;
 
                 type BaseType = #base;
                 type ThreadChecker = #thread_checker;
                 #inventory
-                type PyClassMutability = <<#base as _pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as _pyo3::impl_::pycell::PyClassMutability>::#class_mutability;
+                type PyClassMutability = <<#base as #pyo3_path::impl_::pyclass::PyClassBaseType>::PyClassMutability as #pyo3_path::impl_::pycell::PyClassMutability>::#class_mutability;
                 type Dict = #dict;
                 type WeakRef = #weakref;
                 type BaseNativeType = #base_nativetype;
 
-                fn items_iter() -> _pyo3::impl_::pyclass::PyClassItemsIter {
-                    use _pyo3::impl_::pyclass::*;
+                fn items_iter() -> #pyo3_path::impl_::pyclass::PyClassItemsIter {
+                    use #pyo3_path::impl_::pyclass::*;
                     let collector = PyClassImplCollector::<Self>::new();
                     static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                         methods: &[#(#default_method_defs),*],
@@ -1552,21 +2571,26 @@ impl<'a> PyClassImplsBuilder<'a> {
                     PyClassItemsIter::new(&INTRINSIC_ITEMS, #pymethods_items)
                 }
 
-                fn doc(py: _pyo3::Python<'_>) -> _pyo3::PyResult<&'static ::std::ffi::CStr>  {
-                    use _pyo3::impl_::pyclass::*;
-                    static DOC: _pyo3::sync::GILOnceCell<::std::borrow::Cow<'static, ::std::ffi::CStr>> = _pyo3::sync::GILOnceCell::new();
-                    DOC.get_or_try_init(py, || {
-                        let collector = PyClassImplCollector::<Self>::new();
-                        build_pyclass_doc(<#cls as _pyo3::PyTypeInfo>::NAME, #doc, collector.new_text_signature())
-                    }).map(::std::ops::Deref::deref)
-                }
+                const RAW_DOC: &'static ::std::ffi::CStr = #doc;
+
+                const DOC: &'static ::std::ffi::CStr = {
+                    use #pyo3_path::impl_ as impl_;
+                    use impl_::pyclass::Probe as _;
+                    const DOC_PIECES: &'static [&'static [u8]] = impl_::pyclass::doc::PyClassDocGenerator::<
+                        #cls,
+                        { impl_::pyclass::HasNewTextSignature::<#cls>::VALUE }
+                    >::DOC_PIECES;
+                    const LEN: usize = impl_::concat::combined_len(DOC_PIECES);
+                    const DOC: &'static [u8] = &impl_::concat::combine_to_array::<LEN>(DOC_PIECES);
+                    impl_::pyclass::doc::doc_bytes_as_cstr(DOC)
+                };
 
                 #dict_offset
 
                 #weaklist_offset
 
-                fn lazy_type_object() -> &'static _pyo3::impl_::pyclass::LazyTypeObject<Self> {
-                    use _pyo3::impl_::pyclass::LazyTypeObject;
+                fn lazy_type_object() -> &'static #pyo3_path::impl_::pyclass::LazyTypeObject<Self> {
+                    use #pyo3_path::impl_::pyclass::LazyTypeObject;
                     static TYPE_OBJECT: LazyTypeObject<#cls> = LazyTypeObject::new();
                     &TYPE_OBJECT
                 }
@@ -1582,44 +2606,51 @@ impl<'a> PyClassImplsBuilder<'a> {
         })
     }
 
-    fn impl_freelist(&self) -> TokenStream {
+    fn impl_add_to_module(&self, ctx: &Ctx) -> TokenStream {
+        let Ctx { pyo3_path, .. } = ctx;
+        let cls = self.cls;
+        quote! {
+            impl #cls {
+                #[doc(hidden)]
+                pub const _PYO3_DEF: #pyo3_path::impl_::pymodule::AddClassToModule<Self> = #pyo3_path::impl_::pymodule::AddClassToModule::new();
+            }
+        }
+    }
+
+    fn impl_freelist(&self, ctx: &Ctx) -> TokenStream {
         let cls = self.cls;
+        let Ctx { pyo3_path, .. } = ctx;
 
-        self.attr.options.freelist.as_ref().map_or(quote!{}, |freelist| {
+        self.attr.options.freelist.as_ref().map_or(quote! {}, |freelist| {
             let freelist = &freelist.value;
             quote! {
-                impl _pyo3::impl_::pyclass::PyClassWithFreeList for #cls {
+                impl #pyo3_path::impl_::pyclass::PyClassWithFreeList for #cls {
                     #[inline]
-                    fn get_free_list(py: _pyo3::Python<'_>) -> &mut _pyo3::impl_::freelist::FreeList<*mut _pyo3::ffi::PyObject> {
-                        static mut FREELIST: *mut _pyo3::impl_::freelist::FreeList<*mut _pyo3::ffi::PyObject> = 0 as *mut _;
-                        unsafe {
-                            if FREELIST.is_null() {
-                                FREELIST = ::std::boxed::Box::into_raw(::std::boxed::Box::new(
-                                    _pyo3::impl_::freelist::FreeList::with_capacity(#freelist)));
-                            }
-                            &mut *FREELIST
-                        }
+                    fn get_free_list(py: #pyo3_path::Python<'_>) -> &'static ::std::sync::Mutex<#pyo3_path::impl_::freelist::PyObjectFreeList> {
+                        static FREELIST: #pyo3_path::sync::PyOnceLock<::std::sync::Mutex<#pyo3_path::impl_::freelist::PyObjectFreeList>> = #pyo3_path::sync::PyOnceLock::new();
+                        &FREELIST.get_or_init(py, || ::std::sync::Mutex::new(#pyo3_path::impl_::freelist::PyObjectFreeList::with_capacity(#freelist)))
                     }
                 }
             }
         })
     }
 
-    fn freelist_slots(&self) -> Vec<TokenStream> {
+    fn freelist_slots(&self, ctx: &Ctx) -> Vec<TokenStream> {
+        let Ctx { pyo3_path, .. } = ctx;
         let cls = self.cls;
 
         if self.attr.options.freelist.is_some() {
             vec![
                 quote! {
-                    _pyo3::ffi::PyType_Slot {
-                        slot: _pyo3::ffi::Py_tp_alloc,
-                        pfunc: _pyo3::impl_::pyclass::alloc_with_freelist::<#cls> as *mut _,
+                    #pyo3_path::ffi::PyType_Slot {
+                        slot: #pyo3_path::ffi::Py_tp_alloc,
+                        pfunc: #pyo3_path::impl_::pyclass::alloc_with_freelist::<#cls> as *mut _,
                     }
                 },
                 quote! {
-                    _pyo3::ffi::PyType_Slot {
-                        slot: _pyo3::ffi::Py_tp_free,
-                        pfunc: _pyo3::impl_::pyclass::free_with_freelist::<#cls> as *mut _,
+                    #pyo3_path::ffi::PyType_Slot {
+                        slot: #pyo3_path::ffi::Py_tp_free,
+                        pfunc: #pyo3_path::impl_::pyclass::free_with_freelist::<#cls> as *mut _,
                     }
                 },
             ]
@@ -1627,27 +2658,79 @@ impl<'a> PyClassImplsBuilder<'a> {
             Vec::new()
         }
     }
+
+    #[cfg(feature = "experimental-inspect")]
+    fn impl_introspection(&self, ctx: &Ctx) -> TokenStream {
+        let Ctx { pyo3_path, .. } = ctx;
+        let name = get_class_python_name(self.cls, self.attr).to_string();
+        let ident = self.cls;
+        let static_introspection = class_introspection_code(pyo3_path, ident, &name);
+        let introspection_id = introspection_id_const();
+        quote! {
+            #static_introspection
+            impl #ident {
+                #introspection_id
+            }
+        }
+    }
+
+    #[cfg(not(feature = "experimental-inspect"))]
+    fn impl_introspection(&self, _ctx: &Ctx) -> TokenStream {
+        quote! {}
+    }
 }
 
-fn define_inventory_class(inventory_class_name: &syn::Ident) -> TokenStream {
+fn define_inventory_class(inventory_class_name: &syn::Ident, ctx: &Ctx) -> TokenStream {
+    let Ctx { pyo3_path, .. } = ctx;
     quote! {
         #[doc(hidden)]
         pub struct #inventory_class_name {
-            items: _pyo3::impl_::pyclass::PyClassItems,
+            items: #pyo3_path::impl_::pyclass::PyClassItems,
         }
         impl #inventory_class_name {
-            pub const fn new(items: _pyo3::impl_::pyclass::PyClassItems) -> Self {
+            pub const fn new(items: #pyo3_path::impl_::pyclass::PyClassItems) -> Self {
                 Self { items }
             }
         }
 
-        impl _pyo3::impl_::pyclass::PyClassInventory for #inventory_class_name {
-            fn items(&self) -> &_pyo3::impl_::pyclass::PyClassItems {
+        impl #pyo3_path::impl_::pyclass::PyClassInventory for #inventory_class_name {
+            fn items(&self) -> &#pyo3_path::impl_::pyclass::PyClassItems {
                 &self.items
             }
         }
 
-        _pyo3::inventory::collect!(#inventory_class_name);
+        #pyo3_path::inventory::collect!(#inventory_class_name);
+    }
+}
+
+fn generate_cfg_check(variants: &[PyClassEnumUnitVariant<'_>], cls: &syn::Ident) -> TokenStream {
+    if variants.is_empty() {
+        return quote! {};
+    }
+
+    let mut conditions = Vec::new();
+
+    for variant in variants {
+        let cfg_attrs = &variant.cfg_attrs;
+
+        if cfg_attrs.is_empty() {
+            // There's at least one variant of the enum without cfg attributes,
+            // so the check is not necessary
+            return quote! {};
+        }
+
+        for attr in cfg_attrs {
+            if let syn::Meta::List(meta) = &attr.meta {
+                let cfg_tokens = &meta.tokens;
+                conditions.push(quote! { not(#cfg_tokens) });
+            }
+        }
+    }
+
+    quote_spanned! {
+        cls.span() =>
+        #[cfg(all(#(#conditions),*))]
+        ::core::compile_error!(concat!("#[pyclass] can't be used on enums without any variants - all variants of enum `", stringify!(#cls), "` have been configured out by cfg attributes"));
     }
 }
 
diff --git a/pyo3-macros-backend/src/pyfunction.rs b/pyo3-macros-backend/src/pyfunction.rs
index b265a34d39f..1333e6d2bcd 100644
--- a/pyo3-macros-backend/src/pyfunction.rs
+++ b/pyo3-macros-backend/src/pyfunction.rs
@@ -1,24 +1,28 @@
+use crate::attributes::KeywordAttribute;
+use crate::combine_errors::CombineErrors;
+#[cfg(feature = "experimental-inspect")]
+use crate::introspection::{function_introspection_code, introspection_id_const};
+use crate::utils::Ctx;
 use crate::{
     attributes::{
         self, get_pyo3_options, take_attributes, take_pyo3_options, CrateAttribute,
         FromPyWithAttribute, NameAttribute, TextSignatureAttribute,
     },
-    deprecations::Deprecations,
     method::{self, CallingConvention, FnArg},
     pymethod::check_generic,
-    utils::get_pyo3_crate,
-};
-use proc_macro2::TokenStream;
-use quote::{format_ident, quote};
-use syn::{ext::IdentExt, spanned::Spanned, Result};
-use syn::{
-    parse::{Parse, ParseStream},
-    token::Comma,
 };
+use proc_macro2::{Span, TokenStream};
+use quote::{format_ident, quote, ToTokens};
+use std::cmp::PartialEq;
+use std::ffi::CString;
+use syn::parse::{Parse, ParseStream};
+use syn::punctuated::Punctuated;
+use syn::LitCStr;
+use syn::{ext::IdentExt, spanned::Spanned, LitStr, Path, Result, Token};
 
 mod signature;
 
-pub use self::signature::{FunctionSignature, SignatureAttribute};
+pub use self::signature::{ConstructorAttribute, FunctionSignature, SignatureAttribute};
 
 #[derive(Clone, Debug)]
 pub struct PyFunctionArgPyO3Attributes {
@@ -84,6 +88,149 @@ impl PyFunctionArgPyO3Attributes {
     }
 }
 
+type PyFunctionWarningMessageAttribute = KeywordAttribute<attributes::kw::message, LitStr>;
+type PyFunctionWarningCategoryAttribute = KeywordAttribute<attributes::kw::category, Path>;
+
+pub struct PyFunctionWarningAttribute {
+    pub message: PyFunctionWarningMessageAttribute,
+    pub category: Option<PyFunctionWarningCategoryAttribute>,
+    pub span: Span,
+}
+
+#[derive(PartialEq, Clone)]
+pub enum PyFunctionWarningCategory {
+    Path(Path),
+    UserWarning,
+    DeprecationWarning, // TODO: unused for now, intended for pyo3(deprecated) special-case
+}
+
+#[derive(Clone)]
+pub struct PyFunctionWarning {
+    pub message: LitStr,
+    pub category: PyFunctionWarningCategory,
+    pub span: Span,
+}
+
+impl From<PyFunctionWarningAttribute> for PyFunctionWarning {
+    fn from(value: PyFunctionWarningAttribute) -> Self {
+        Self {
+            message: value.message.value,
+            category: value
+                .category
+                .map_or(PyFunctionWarningCategory::UserWarning, |cat| {
+                    PyFunctionWarningCategory::Path(cat.value)
+                }),
+            span: value.span,
+        }
+    }
+}
+
+pub trait WarningFactory {
+    fn build_py_warning(&self, ctx: &Ctx) -> TokenStream;
+    fn span(&self) -> Span;
+}
+
+impl WarningFactory for PyFunctionWarning {
+    fn build_py_warning(&self, ctx: &Ctx) -> TokenStream {
+        let message = &self.message.value();
+        let c_message = LitCStr::new(
+            &CString::new(message.clone()).unwrap(),
+            Spanned::span(&message),
+        );
+        let pyo3_path = &ctx.pyo3_path;
+        let category = match &self.category {
+            PyFunctionWarningCategory::Path(path) => quote! {#path},
+            PyFunctionWarningCategory::UserWarning => {
+                quote! {#pyo3_path::exceptions::PyUserWarning}
+            }
+            PyFunctionWarningCategory::DeprecationWarning => {
+                quote! {#pyo3_path::exceptions::PyDeprecationWarning}
+            }
+        };
+        quote! {
+            #pyo3_path::PyErr::warn(py, &<#category as #pyo3_path::PyTypeInfo>::type_object(py), #c_message, 1)?;
+        }
+    }
+
+    fn span(&self) -> Span {
+        self.span
+    }
+}
+
+impl<T: WarningFactory> WarningFactory for Vec<T> {
+    fn build_py_warning(&self, ctx: &Ctx) -> TokenStream {
+        let warnings = self.iter().map(|warning| warning.build_py_warning(ctx));
+
+        quote! {
+            #(#warnings)*
+        }
+    }
+
+    fn span(&self) -> Span {
+        self.iter()
+            .map(|val| val.span())
+            .reduce(|acc, span| acc.join(span).unwrap_or(acc))
+            .unwrap()
+    }
+}
+
+impl Parse for PyFunctionWarningAttribute {
+    fn parse(input: ParseStream<'_>) -> Result<Self> {
+        let mut message: Option<PyFunctionWarningMessageAttribute> = None;
+        let mut category: Option<PyFunctionWarningCategoryAttribute> = None;
+
+        let span = input.parse::<attributes::kw::warn>()?.span();
+
+        let content;
+        syn::parenthesized!(content in input);
+
+        while !content.is_empty() {
+            let lookahead = content.lookahead1();
+
+            if lookahead.peek(attributes::kw::message) {
+                message = content
+                    .parse::<PyFunctionWarningMessageAttribute>()
+                    .map(Some)?;
+            } else if lookahead.peek(attributes::kw::category) {
+                category = content
+                    .parse::<PyFunctionWarningCategoryAttribute>()
+                    .map(Some)?;
+            } else {
+                return Err(lookahead.error());
+            }
+
+            if content.peek(Token![,]) {
+                content.parse::<Token![,]>()?;
+            }
+        }
+
+        Ok(PyFunctionWarningAttribute {
+            message: message.ok_or(syn::Error::new(
+                content.span(),
+                "missing `message` in `warn` attribute",
+            ))?,
+            category,
+            span,
+        })
+    }
+}
+
+impl ToTokens for PyFunctionWarningAttribute {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
+        let message_tokens = self.message.to_token_stream();
+        let category_tokens = self
+            .category
+            .as_ref()
+            .map_or(quote! {}, |cat| cat.to_token_stream());
+
+        let token_stream = quote! {
+            warn(#message_tokens, #category_tokens)
+        };
+
+        tokens.extend(token_stream);
+    }
+}
+
 #[derive(Default)]
 pub struct PyFunctionOptions {
     pub pass_module: Option<attributes::kw::pass_module>,
@@ -91,30 +238,15 @@ pub struct PyFunctionOptions {
     pub signature: Option<SignatureAttribute>,
     pub text_signature: Option<TextSignatureAttribute>,
     pub krate: Option<CrateAttribute>,
+    pub warnings: Vec<PyFunctionWarning>,
 }
 
 impl Parse for PyFunctionOptions {
     fn parse(input: ParseStream<'_>) -> Result<Self> {
         let mut options = PyFunctionOptions::default();
 
-        while !input.is_empty() {
-            let lookahead = input.lookahead1();
-            if lookahead.peek(attributes::kw::name)
-                || lookahead.peek(attributes::kw::pass_module)
-                || lookahead.peek(attributes::kw::signature)
-                || lookahead.peek(attributes::kw::text_signature)
-            {
-                options.add_attributes(std::iter::once(input.parse()?))?;
-                if !input.is_empty() {
-                    let _: Comma = input.parse()?;
-                }
-            } else if lookahead.peek(syn::Token![crate]) {
-                // TODO needs duplicate check?
-                options.krate = Some(input.parse()?);
-            } else {
-                return Err(lookahead.error());
-            }
-        }
+        let attrs = Punctuated::<PyFunctionOption, syn::Token![,]>::parse_terminated(input)?;
+        options.add_attributes(attrs)?;
 
         Ok(options)
     }
@@ -126,6 +258,7 @@ pub enum PyFunctionOption {
     Signature(SignatureAttribute),
     TextSignature(TextSignatureAttribute),
     Crate(CrateAttribute),
+    Warning(PyFunctionWarningAttribute),
 }
 
 impl Parse for PyFunctionOption {
@@ -141,6 +274,8 @@ impl Parse for PyFunctionOption {
             input.parse().map(PyFunctionOption::TextSignature)
         } else if lookahead.peek(syn::Token![crate]) {
             input.parse().map(PyFunctionOption::Crate)
+        } else if lookahead.peek(attributes::kw::warn) {
+            input.parse().map(PyFunctionOption::Warning)
         } else {
             Err(lookahead.error())
         }
@@ -176,6 +311,9 @@ impl PyFunctionOptions {
                 PyFunctionOption::Signature(signature) => set_option!(signature),
                 PyFunctionOption::TextSignature(text_signature) => set_option!(text_signature),
                 PyFunctionOption::Crate(krate) => set_option!(krate),
+                PyFunctionOption::Warning(warning) => {
+                    self.warnings.push(warning.into());
+                }
             }
         }
         Ok(())
@@ -203,9 +341,16 @@ pub fn impl_wrap_pyfunction(
         signature,
         text_signature,
         krate,
+        warnings,
     } = options;
 
-    let python_name = name.map_or_else(|| func.sig.ident.unraw(), |name| name.value.0);
+    let ctx = &Ctx::new(&krate, Some(&func.sig));
+    let Ctx { pyo3_path, .. } = &ctx;
+
+    let python_name = name
+        .as_ref()
+        .map_or_else(|| &func.sig.ident, |name| &name.value.0)
+        .unraw();
 
     let tp = if pass_module.is_some() {
         let span = match func.sig.inputs.first() {
@@ -229,15 +374,34 @@ pub fn impl_wrap_pyfunction(
             0
         })
         .map(FnArg::parse)
-        .collect::<syn::Result<Vec<_>>>()?;
+        .try_combine_syn_errors()?;
 
     let signature = if let Some(signature) = signature {
         FunctionSignature::from_arguments_and_attribute(arguments, signature)?
     } else {
-        FunctionSignature::from_arguments(arguments)?
+        FunctionSignature::from_arguments(arguments)
     };
 
-    let ty = method::get_return_info(&func.sig.output);
+    let vis = &func.vis;
+    let name = &func.sig.ident;
+
+    #[cfg(feature = "experimental-inspect")]
+    let introspection = function_introspection_code(
+        pyo3_path,
+        Some(name),
+        &name.to_string(),
+        &signature,
+        None,
+        func.sig.output.clone(),
+        [] as [String; 0],
+        None,
+    );
+    #[cfg(not(feature = "experimental-inspect"))]
+    let introspection = quote! {};
+    #[cfg(feature = "experimental-inspect")]
+    let introspection_id = introspection_id_const();
+    #[cfg(not(feature = "experimental-inspect"))]
+    let introspection_id = quote! {};
 
     let spec = method::FnSpec {
         tp,
@@ -245,45 +409,50 @@ pub fn impl_wrap_pyfunction(
         convention: CallingConvention::from_signature(&signature),
         python_name,
         signature,
-        output: ty,
         text_signature,
         asyncness: func.sig.asyncness,
         unsafety: func.sig.unsafety,
-        deprecations: Deprecations::new(),
+        warnings,
+        #[cfg(feature = "experimental-inspect")]
+        output: func.sig.output.clone(),
     };
 
-    let krate = get_pyo3_crate(&krate);
-
-    let vis = &func.vis;
-    let name = &func.sig.ident;
-
     let wrapper_ident = format_ident!("__pyfunction_{}", spec.name);
-    let wrapper = spec.get_wrapper_function(&wrapper_ident, None)?;
-    let methoddef = spec.get_methoddef(wrapper_ident, &spec.get_doc(&func.attrs));
+    if spec.asyncness.is_some() {
+        ensure_spanned!(
+            cfg!(feature = "experimental-async"),
+            spec.asyncness.span() => "async functions are only supported with the `experimental-async` feature"
+        );
+    }
+    let wrapper = spec.get_wrapper_function(&wrapper_ident, None, ctx)?;
+    let methoddef = spec.get_methoddef(wrapper_ident, &spec.get_doc(&func.attrs, ctx)?, ctx);
 
     let wrapped_pyfunction = quote! {
-
         // Create a module with the same name as the `#[pyfunction]` - this way `use <the function>`
         // will actually bring both the module and the function into scope.
         #[doc(hidden)]
         #vis mod #name {
             pub(crate) struct MakeDef;
-            pub const DEF: #krate::impl_::pyfunction::PyMethodDef = MakeDef::DEF;
+            pub static _PYO3_DEF: #pyo3_path::impl_::pyfunction::PyFunctionDef = MakeDef::_PYO3_DEF;
+            #introspection_id
         }
 
-        // Generate the definition inside an anonymous function in the same scope as the original function -
+        // Generate the definition in the same scope as the original function -
         // this avoids complications around the fact that the generated module has a different scope
         // (and `super` doesn't always refer to the outer scope, e.g. if the `#[pyfunction] is
         // inside a function body)
-        const _: () = {
-            use #krate as _pyo3;
-            impl #name::MakeDef {
-                const DEF: #krate::impl_::pyfunction::PyMethodDef = #methoddef;
-            }
+        #[allow(unknown_lints, non_local_definitions)]
+        impl #name::MakeDef {
+            // We're using this to initialize a static, so it's fine.
+            #[allow(clippy::declare_interior_mutable_const)]
+            const _PYO3_DEF: #pyo3_path::impl_::pyfunction::PyFunctionDef =
+                #pyo3_path::impl_::pyfunction::PyFunctionDef::from_method_def(#methoddef);
+        }
 
-            #[allow(non_snake_case)]
-            #wrapper
-        };
+        #[allow(non_snake_case)]
+        #wrapper
+
+        #introspection
     };
     Ok(wrapped_pyfunction)
 }
diff --git a/pyo3-macros-backend/src/pyfunction/signature.rs b/pyo3-macros-backend/src/pyfunction/signature.rs
index baf01285658..306c42f791a 100644
--- a/pyo3-macros-backend/src/pyfunction/signature.rs
+++ b/pyo3-macros-backend/src/pyfunction/signature.rs
@@ -1,3 +1,7 @@
+use crate::{
+    attributes::{kw, KeywordAttribute},
+    method::{FnArg, RegularArg},
+};
 use proc_macro2::{Span, TokenStream};
 use quote::ToTokens;
 use syn::{
@@ -8,63 +12,74 @@ use syn::{
     Token,
 };
 
-use crate::{
-    attributes::{kw, KeywordAttribute},
-    method::FnArg,
-};
-
+#[derive(Clone)]
 pub struct Signature {
     paren_token: syn::token::Paren,
     pub items: Punctuated<SignatureItem, Token![,]>,
+    pub returns: Option<(Token![->], PyTypeAnnotation)>,
 }
 
 impl Parse for Signature {
     fn parse(input: ParseStream<'_>) -> syn::Result<Self> {
         let content;
         let paren_token = syn::parenthesized!(content in input);
-
         let items = content.parse_terminated(SignatureItem::parse, Token![,])?;
-
-        Ok(Signature { paren_token, items })
+        let returns = if input.peek(Token![->]) {
+            Some((input.parse()?, input.parse()?))
+        } else {
+            None
+        };
+        Ok(Signature {
+            paren_token,
+            items,
+            returns,
+        })
     }
 }
 
 impl ToTokens for Signature {
     fn to_tokens(&self, tokens: &mut TokenStream) {
         self.paren_token
-            .surround(tokens, |tokens| self.items.to_tokens(tokens))
+            .surround(tokens, |tokens| self.items.to_tokens(tokens));
+        if let Some((arrow, returns)) = &self.returns {
+            arrow.to_tokens(tokens);
+            returns.to_tokens(tokens);
+        }
     }
 }
 
-#[derive(Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq)]
 pub struct SignatureItemArgument {
     pub ident: syn::Ident,
+    pub colon_and_annotation: Option<(Token![:], PyTypeAnnotation)>,
     pub eq_and_default: Option<(Token![=], syn::Expr)>,
 }
 
-#[derive(Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq)]
 pub struct SignatureItemPosargsSep {
     pub slash: Token![/],
 }
 
-#[derive(Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq)]
 pub struct SignatureItemVarargsSep {
     pub asterisk: Token![*],
 }
 
-#[derive(Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq)]
 pub struct SignatureItemVarargs {
     pub sep: SignatureItemVarargsSep,
     pub ident: syn::Ident,
+    pub colon_and_annotation: Option<(Token![:], PyTypeAnnotation)>,
 }
 
-#[derive(Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq)]
 pub struct SignatureItemKwargs {
     pub asterisks: (Token![*], Token![*]),
     pub ident: syn::Ident,
+    pub colon_and_annotation: Option<(Token![:], PyTypeAnnotation)>,
 }
 
-#[derive(Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq)]
 pub enum SignatureItem {
     Argument(Box<SignatureItemArgument>),
     PosargsSep(SignatureItemPosargsSep),
@@ -87,6 +102,11 @@ impl Parse for SignatureItem {
                     Ok(SignatureItem::Varargs(SignatureItemVarargs {
                         sep,
                         ident: input.parse()?,
+                        colon_and_annotation: if input.peek(Token![:]) {
+                            Some((input.parse()?, input.parse()?))
+                        } else {
+                            None
+                        },
                     }))
                 }
             }
@@ -114,6 +134,11 @@ impl Parse for SignatureItemArgument {
     fn parse(input: ParseStream<'_>) -> syn::Result<Self> {
         Ok(Self {
             ident: input.parse()?,
+            colon_and_annotation: if input.peek(Token![:]) {
+                Some((input.parse()?, input.parse()?))
+            } else {
+                None
+            },
             eq_and_default: if input.peek(Token![=]) {
                 Some((input.parse()?, input.parse()?))
             } else {
@@ -126,6 +151,10 @@ impl Parse for SignatureItemArgument {
 impl ToTokens for SignatureItemArgument {
     fn to_tokens(&self, tokens: &mut TokenStream) {
         self.ident.to_tokens(tokens);
+        if let Some((colon, annotation)) = &self.colon_and_annotation {
+            colon.to_tokens(tokens);
+            annotation.to_tokens(tokens);
+        }
         if let Some((eq, default)) = &self.eq_and_default {
             eq.to_tokens(tokens);
             default.to_tokens(tokens);
@@ -152,6 +181,11 @@ impl Parse for SignatureItemVarargs {
         Ok(Self {
             sep: input.parse()?,
             ident: input.parse()?,
+            colon_and_annotation: if input.peek(Token![:]) {
+                Some((input.parse()?, input.parse()?))
+            } else {
+                None
+            },
         })
     }
 }
@@ -168,6 +202,11 @@ impl Parse for SignatureItemKwargs {
         Ok(Self {
             asterisks: (input.parse()?, input.parse()?),
             ident: input.parse()?,
+            colon_and_annotation: if input.peek(Token![:]) {
+                Some((input.parse()?, input.parse()?))
+            } else {
+                None
+            },
         })
     }
 }
@@ -194,9 +233,40 @@ impl ToTokens for SignatureItemPosargsSep {
     }
 }
 
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct PyTypeAnnotation(syn::LitStr);
+
+impl Parse for PyTypeAnnotation {
+    fn parse(input: ParseStream<'_>) -> syn::Result<Self> {
+        Ok(Self(input.parse()?))
+    }
+}
+
+impl ToTokens for PyTypeAnnotation {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
+        self.0.to_tokens(tokens);
+    }
+}
+
+impl PyTypeAnnotation {
+    pub fn to_python(&self) -> String {
+        self.0.value()
+    }
+}
+
 pub type SignatureAttribute = KeywordAttribute<kw::signature, Signature>;
+pub type ConstructorAttribute = KeywordAttribute<kw::constructor, Signature>;
 
-#[derive(Default)]
+impl ConstructorAttribute {
+    pub fn into_signature(self) -> SignatureAttribute {
+        SignatureAttribute {
+            kw: kw::signature(self.kw.span),
+            value: self.value,
+        }
+    }
+}
+
+#[derive(Default, Clone)]
 pub struct PythonSignature {
     pub positional_parameters: Vec<String>,
     pub positional_only_parameters: usize,
@@ -216,6 +286,7 @@ impl PythonSignature {
     }
 }
 
+#[derive(Clone)]
 pub struct FunctionSignature<'a> {
     pub arguments: Vec<FnArg<'a>>,
     pub python_signature: PythonSignature,
@@ -351,42 +422,52 @@ impl<'a> FunctionSignature<'a> {
 
         let mut next_non_py_argument_checked = |name: &syn::Ident| {
             for fn_arg in args_iter.by_ref() {
-                if fn_arg.py {
-                    // If the user incorrectly tried to include py: Python in the
-                    // signature, give a useful error as a hint.
-                    ensure_spanned!(
-                        name != fn_arg.name,
-                        name.span() => "arguments of type `Python` must not be part of the signature"
-                    );
-                    // Otherwise try next argument.
-                    continue;
-                }
-                if fn_arg.is_cancel_handle {
-                    // If the user incorrectly tried to include cancel: CoroutineCancel in the
-                    // signature, give a useful error as a hint.
-                    ensure_spanned!(
-                        name != fn_arg.name,
-                        name.span() => "`cancel_handle` argument must not be part of the signature"
-                    );
-                    // Otherwise try next argument.
-                    continue;
+                match fn_arg {
+                    FnArg::Py(..) => {
+                        // If the user incorrectly tried to include py: Python in the
+                        // signature, give a useful error as a hint.
+                        ensure_spanned!(
+                            name != fn_arg.name(),
+                            name.span() => "arguments of type `Python` must not be part of the signature"
+                        );
+                        // Otherwise try next argument.
+                        continue;
+                    }
+                    FnArg::CancelHandle(..) => {
+                        // If the user incorrectly tried to include cancel: CoroutineCancel in the
+                        // signature, give a useful error as a hint.
+                        ensure_spanned!(
+                            name != fn_arg.name(),
+                            name.span() => "`cancel_handle` argument must not be part of the signature"
+                        );
+                        // Otherwise try next argument.
+                        continue;
+                    }
+                    _ => {
+                        ensure_spanned!(
+                            name == fn_arg.name(),
+                            name.span() => format!(
+                                "expected argument from function definition `{}` but got argument `{}`",
+                                fn_arg.name().unraw(),
+                                name.unraw(),
+                            )
+                        );
+                        return Ok(fn_arg);
+                    }
                 }
-
-                ensure_spanned!(
-                    name == fn_arg.name,
-                    name.span() => format!(
-                        "expected argument from function definition `{}` but got argument `{}`",
-                        fn_arg.name.unraw(),
-                        name.unraw(),
-                    )
-                );
-                return Ok(fn_arg);
             }
             bail_spanned!(
                 name.span() => "signature entry does not have a corresponding function argument"
             )
         };
 
+        if let Some(returns) = &attribute.value.returns {
+            ensure_spanned!(
+                cfg!(feature = "experimental-inspect"),
+                returns.1.span() => "Return type annotation in the signature is only supported with the `experimental-inspect` feature"
+            );
+        }
+
         for item in &attribute.value.items {
             match item {
                 SignatureItem::Argument(arg) => {
@@ -397,8 +478,25 @@ impl<'a> FunctionSignature<'a> {
                         arg.eq_and_default.is_none(),
                         arg.span(),
                     )?;
+                    let FnArg::Regular(fn_arg) = fn_arg else {
+                        unreachable!(
+                            "`Python` and `CancelHandle` are already handled above and `*args`/`**kwargs` are \
+                                parsed and transformed below. Because the have to come last and are only allowed \
+                                once, this has to be a regular argument."
+                        );
+                    };
                     if let Some((_, default)) = &arg.eq_and_default {
-                        fn_arg.default = Some(default.clone());
+                        fn_arg.default_value = Some(default.clone());
+                    }
+                    if let Some((_, annotation)) = &arg.colon_and_annotation {
+                        ensure_spanned!(
+                            cfg!(feature = "experimental-inspect"),
+                            annotation.span() => "Type annotations in the signature is only supported with the `experimental-inspect` feature"
+                        );
+                        #[cfg(feature = "experimental-inspect")]
+                        {
+                            fn_arg.annotation = Some(annotation.to_python());
+                        }
                     }
                 }
                 SignatureItem::VarargsSep(sep) => {
@@ -406,13 +504,47 @@ impl<'a> FunctionSignature<'a> {
                 }
                 SignatureItem::Varargs(varargs) => {
                     let fn_arg = next_non_py_argument_checked(&varargs.ident)?;
-                    fn_arg.is_varargs = true;
+                    fn_arg.to_varargs_mut()?;
                     parse_state.add_varargs(&mut python_signature, varargs)?;
+                    if let Some((_, annotation)) = &varargs.colon_and_annotation {
+                        ensure_spanned!(
+                            cfg!(feature = "experimental-inspect"),
+                            annotation.span() => "Type annotations in the signature is only supported with the `experimental-inspect` feature"
+                        );
+                        #[cfg(feature = "experimental-inspect")]
+                        {
+                            let FnArg::VarArgs(fn_arg) = fn_arg else {
+                                unreachable!(
+                                    "`Python` and `CancelHandle` are already handled above and `*args`/`**kwargs` are \
+                                parsed and transformed below. Because the have to come last and are only allowed \
+                                once, this has to be a regular argument."
+                                );
+                            };
+                            fn_arg.annotation = Some(annotation.to_python());
+                        }
+                    }
                 }
                 SignatureItem::Kwargs(kwargs) => {
                     let fn_arg = next_non_py_argument_checked(&kwargs.ident)?;
-                    fn_arg.is_kwargs = true;
+                    fn_arg.to_kwargs_mut()?;
                     parse_state.add_kwargs(&mut python_signature, kwargs)?;
+                    if let Some((_, annotation)) = &kwargs.colon_and_annotation {
+                        ensure_spanned!(
+                            cfg!(feature = "experimental-inspect"),
+                            annotation.span() => "Type annotations in the signature is only supported with the `experimental-inspect` feature"
+                        );
+                        #[cfg(feature = "experimental-inspect")]
+                        {
+                            let FnArg::KwArgs(fn_arg) = fn_arg else {
+                                unreachable!(
+                                    "`Python` and `CancelHandle` are already handled above and `*args`/`**kwargs` are \
+                                parsed and transformed below. Because the have to come last and are only allowed \
+                                once, this has to be a regular argument."
+                                );
+                            };
+                            fn_arg.annotation = Some(annotation.to_python());
+                        }
+                    }
                 }
                 SignatureItem::PosargsSep(sep) => {
                     parse_state.finish_pos_only_args(&mut python_signature, sep.span())?
@@ -421,9 +553,11 @@ impl<'a> FunctionSignature<'a> {
         }
 
         // Ensure no non-py arguments remain
-        if let Some(arg) = args_iter.find(|arg| !arg.py && !arg.is_cancel_handle) {
+        if let Some(arg) =
+            args_iter.find(|arg| !matches!(arg, FnArg::Py(..) | FnArg::CancelHandle(..)))
+        {
             bail_spanned!(
-                attribute.kw.span() => format!("missing signature entry for argument `{}`", arg.name)
+                attribute.kw.span() => format!("missing signature entry for argument `{}`", arg.name())
             );
         }
 
@@ -435,20 +569,19 @@ impl<'a> FunctionSignature<'a> {
     }
 
     /// Without `#[pyo3(signature)]` or `#[args]` - just take the Rust function arguments as positional.
-    pub fn from_arguments(arguments: Vec<FnArg<'a>>) -> syn::Result<Self> {
+    pub fn from_arguments(arguments: Vec<FnArg<'a>>) -> Self {
         let mut python_signature = PythonSignature::default();
         for arg in &arguments {
             // Python<'_> arguments don't show in Python signature
-            if arg.py || arg.is_cancel_handle {
+            if matches!(arg, FnArg::Py(..) | FnArg::CancelHandle(..)) {
                 continue;
             }
 
-            if arg.optional.is_none() {
+            if let FnArg::Regular(RegularArg { .. }) = arg {
                 // This argument is required, all previous arguments must also have been required
-                ensure_spanned!(
-                    python_signature.required_positional_parameters == python_signature.positional_parameters.len(),
-                    arg.ty.span() => "required arguments after an `Option<_>` argument are ambiguous\n\
-                    = help: add a `#[pyo3(signature)]` annotation on this function to unambiguously specify the default values for all optional parameters"
+                assert_eq!(
+                    python_signature.required_positional_parameters,
+                    python_signature.positional_parameters.len(),
                 );
 
                 python_signature.required_positional_parameters =
@@ -457,52 +590,22 @@ impl<'a> FunctionSignature<'a> {
 
             python_signature
                 .positional_parameters
-                .push(arg.name.unraw().to_string());
+                .push(arg.name().unraw().to_string());
         }
 
-        Ok(Self {
+        Self {
             arguments,
             python_signature,
             attribute: None,
-        })
+        }
     }
 
     fn default_value_for_parameter(&self, parameter: &str) -> String {
-        let mut default = "...".to_string();
-        if let Some(fn_arg) = self.arguments.iter().find(|arg| arg.name == parameter) {
-            if let Some(arg_default) = fn_arg.default.as_ref() {
-                match arg_default {
-                    // literal values
-                    syn::Expr::Lit(syn::ExprLit { lit, .. }) => match lit {
-                        syn::Lit::Str(s) => default = s.token().to_string(),
-                        syn::Lit::Char(c) => default = c.token().to_string(),
-                        syn::Lit::Int(i) => default = i.base10_digits().to_string(),
-                        syn::Lit::Float(f) => default = f.base10_digits().to_string(),
-                        syn::Lit::Bool(b) => {
-                            default = if b.value() {
-                                "True".to_string()
-                            } else {
-                                "False".to_string()
-                            }
-                        }
-                        _ => {}
-                    },
-                    // None
-                    syn::Expr::Path(syn::ExprPath {
-                        qself: None, path, ..
-                    }) if path.is_ident("None") => {
-                        default = "None".to_string();
-                    }
-                    // others, unsupported yet so defaults to `...`
-                    _ => {}
-                }
-            } else if fn_arg.optional.is_some() {
-                // functions without a `#[pyo3(signature = (...))]` option
-                // will treat trailing `Option<T>` arguments as having a default of `None`
-                default = "None".to_string();
-            }
+        if let Some(fn_arg) = self.arguments.iter().find(|arg| arg.name() == parameter) {
+            fn_arg.default_value()
+        } else {
+            "...".to_string()
         }
-        default
     }
 
     pub fn text_signature(&self, self_argument: Option<&str>) -> String {
diff --git a/pyo3-macros-backend/src/pyimpl.rs b/pyo3-macros-backend/src/pyimpl.rs
index f5ae111bf48..36d413d21b9 100644
--- a/pyo3-macros-backend/src/pyimpl.rs
+++ b/pyo3-macros-backend/src/pyimpl.rs
@@ -1,19 +1,29 @@
 use std::collections::HashSet;
 
+use crate::combine_errors::CombineErrors;
+#[cfg(feature = "experimental-inspect")]
+use crate::introspection::{attribute_introspection_code, function_introspection_code};
+#[cfg(feature = "experimental-inspect")]
+use crate::method::{FnSpec, FnType};
+#[cfg(feature = "experimental-inspect")]
+use crate::utils::expr_to_python;
+use crate::utils::{has_attribute, has_attribute_with_namespace, Ctx, PyO3CratePath};
 use crate::{
     attributes::{take_pyo3_options, CrateAttribute},
     konst::{ConstAttributes, ConstSpec},
     pyfunction::PyFunctionOptions,
-    pymethod::{self, is_proto_method, MethodAndMethodDef, MethodAndSlotDef},
-    utils::get_pyo3_crate,
+    pymethod::{
+        self, is_proto_method, GeneratedPyMethod, MethodAndMethodDef, MethodAndSlotDef, PyMethod,
+    },
 };
 use proc_macro2::TokenStream;
-use pymethod::GeneratedPyMethod;
 use quote::{format_ident, quote};
+#[cfg(feature = "experimental-inspect")]
+use syn::Ident;
 use syn::{
     parse::{Parse, ParseStream},
     spanned::Spanned,
-    Result,
+    ImplItemFn, Result,
 };
 
 /// The mechanism used to collect `#[pymethods]` into the type object
@@ -84,124 +94,158 @@ pub fn build_py_methods(
     }
 }
 
+fn check_pyfunction(pyo3_path: &PyO3CratePath, meth: &mut ImplItemFn) -> syn::Result<()> {
+    let mut error = None;
+
+    meth.attrs.retain(|attr| {
+        let attrs = [attr.clone()];
+
+        if has_attribute(&attrs, "pyfunction")
+            || has_attribute_with_namespace(&attrs, Some(pyo3_path),  &["pyfunction"])
+            || has_attribute_with_namespace(&attrs, Some(pyo3_path),  &["prelude", "pyfunction"]) {
+                error = Some(err_spanned!(meth.sig.span() => "functions inside #[pymethods] do not need to be annotated with #[pyfunction]"));
+                false
+        } else {
+            true
+        }
+    });
+
+    error.map_or(Ok(()), Err)
+}
+
 pub fn impl_methods(
     ty: &syn::Type,
     impls: &mut [syn::ImplItem],
     methods_type: PyClassMethodsType,
     options: PyImplOptions,
 ) -> syn::Result<TokenStream> {
-    let mut trait_impls = Vec::new();
+    let mut extra_fragments = Vec::new();
     let mut proto_impls = Vec::new();
     let mut methods = Vec::new();
     let mut associated_methods = Vec::new();
 
     let mut implemented_proto_fragments = HashSet::new();
 
-    for iimpl in impls {
-        match iimpl {
-            syn::ImplItem::Fn(meth) => {
-                let mut fun_options = PyFunctionOptions::from_attrs(&mut meth.attrs)?;
-                fun_options.krate = fun_options.krate.or_else(|| options.krate.clone());
-                match pymethod::gen_py_method(ty, &mut meth.sig, &mut meth.attrs, fun_options)? {
-                    GeneratedPyMethod::Method(MethodAndMethodDef {
-                        associated_method,
-                        method_def,
-                    }) => {
-                        let attrs = get_cfg_attributes(&meth.attrs);
-                        associated_methods.push(quote!(#(#attrs)* #associated_method));
-                        methods.push(quote!(#(#attrs)* #method_def));
-                    }
-                    GeneratedPyMethod::SlotTraitImpl(method_name, token_stream) => {
-                        implemented_proto_fragments.insert(method_name);
-                        let attrs = get_cfg_attributes(&meth.attrs);
-                        trait_impls.push(quote!(#(#attrs)* #token_stream));
-                    }
-                    GeneratedPyMethod::Proto(MethodAndSlotDef {
-                        associated_method,
-                        slot_def,
-                    }) => {
-                        let attrs = get_cfg_attributes(&meth.attrs);
-                        proto_impls.push(quote!(#(#attrs)* #slot_def));
-                        associated_methods.push(quote!(#(#attrs)* #associated_method));
+    let _: Vec<()> = impls
+        .iter_mut()
+        .map(|iimpl| {
+            match iimpl {
+                syn::ImplItem::Fn(meth) => {
+                    let ctx = &Ctx::new(&options.krate, Some(&meth.sig));
+                    let mut fun_options = PyFunctionOptions::from_attrs(&mut meth.attrs)?;
+                    fun_options.krate = fun_options.krate.or_else(|| options.krate.clone());
+
+                    check_pyfunction(&ctx.pyo3_path, meth)?;
+                    let method = PyMethod::parse(&mut meth.sig, &mut meth.attrs, fun_options)?;
+                    #[cfg(feature = "experimental-inspect")]
+                    extra_fragments.push(method_introspection_code(&method.spec, ty, ctx));
+                    match pymethod::gen_py_method(ty, method, &meth.attrs, ctx)? {
+                        GeneratedPyMethod::Method(MethodAndMethodDef {
+                            associated_method,
+                            method_def,
+                        }) => {
+                            let attrs = get_cfg_attributes(&meth.attrs);
+                            associated_methods.push(quote!(#(#attrs)* #associated_method));
+                            methods.push(quote!(#(#attrs)* #method_def));
+                        }
+                        GeneratedPyMethod::SlotTraitImpl(method_name, token_stream) => {
+                            implemented_proto_fragments.insert(method_name);
+                            let attrs = get_cfg_attributes(&meth.attrs);
+                            extra_fragments.push(quote!(#(#attrs)* #token_stream));
+                        }
+                        GeneratedPyMethod::Proto(MethodAndSlotDef {
+                            associated_method,
+                            slot_def,
+                        }) => {
+                            let attrs = get_cfg_attributes(&meth.attrs);
+                            proto_impls.push(quote!(#(#attrs)* #slot_def));
+                            associated_methods.push(quote!(#(#attrs)* #associated_method));
+                        }
                     }
                 }
-            }
-            syn::ImplItem::Const(konst) => {
-                let attributes = ConstAttributes::from_attrs(&mut konst.attrs)?;
-                if attributes.is_class_attr {
-                    let spec = ConstSpec {
-                        rust_ident: konst.ident.clone(),
-                        attributes,
-                    };
-                    let attrs = get_cfg_attributes(&konst.attrs);
-                    let MethodAndMethodDef {
-                        associated_method,
-                        method_def,
-                    } = gen_py_const(ty, &spec);
-                    methods.push(quote!(#(#attrs)* #method_def));
-                    associated_methods.push(quote!(#(#attrs)* #associated_method));
-                    if is_proto_method(&spec.python_name().to_string()) {
-                        // If this is a known protocol method e.g. __contains__, then allow this
-                        // symbol even though it's not an uppercase constant.
-                        konst
-                            .attrs
-                            .push(syn::parse_quote!(#[allow(non_upper_case_globals)]));
+                syn::ImplItem::Const(konst) => {
+                    let ctx = &Ctx::new(&options.krate, None);
+                    let attributes = ConstAttributes::from_attrs(&mut konst.attrs)?;
+                    if attributes.is_class_attr {
+                        let spec = ConstSpec {
+                            rust_ident: konst.ident.clone(),
+                            attributes,
+                        };
+                        let attrs = get_cfg_attributes(&konst.attrs);
+                        let MethodAndMethodDef {
+                            associated_method,
+                            method_def,
+                        } = gen_py_const(ty, &spec, ctx);
+                        methods.push(quote!(#(#attrs)* #method_def));
+                        associated_methods.push(quote!(#(#attrs)* #associated_method));
+                        if is_proto_method(&spec.python_name().to_string()) {
+                            // If this is a known protocol method e.g. __contains__, then allow this
+                            // symbol even though it's not an uppercase constant.
+                            konst
+                                .attrs
+                                .push(syn::parse_quote!(#[allow(non_upper_case_globals)]));
+                        }
+                        #[cfg(feature = "experimental-inspect")]
+                        extra_fragments.push(attribute_introspection_code(
+                            &ctx.pyo3_path,
+                            Some(ty),
+                            spec.python_name().to_string(),
+                            expr_to_python(&konst.expr),
+                            konst.ty.clone(),
+                            true,
+                        ));
                     }
                 }
+                syn::ImplItem::Macro(m) => bail_spanned!(
+                    m.span() =>
+                    "macros cannot be used as items in `#[pymethods]` impl blocks\n\
+                    = note: this was previously accepted and ignored"
+                ),
+                _ => {}
             }
-            syn::ImplItem::Macro(m) => bail_spanned!(
-                m.span() =>
-                "macros cannot be used as items in `#[pymethods]` impl blocks\n\
-                 = note: this was previously accepted and ignored"
-            ),
-            _ => {}
-        }
-    }
+            Ok(())
+        })
+        .try_combine_syn_errors()?;
 
-    add_shared_proto_slots(ty, &mut proto_impls, implemented_proto_fragments);
+    let ctx = &Ctx::new(&options.krate, None);
 
-    let krate = get_pyo3_crate(&options.krate);
+    add_shared_proto_slots(ty, &mut proto_impls, implemented_proto_fragments, ctx);
 
     let items = match methods_type {
-        PyClassMethodsType::Specialization => impl_py_methods(ty, methods, proto_impls),
-        PyClassMethodsType::Inventory => submit_methods_inventory(ty, methods, proto_impls),
+        PyClassMethodsType::Specialization => impl_py_methods(ty, methods, proto_impls, ctx),
+        PyClassMethodsType::Inventory => submit_methods_inventory(ty, methods, proto_impls, ctx),
     };
 
     Ok(quote! {
-        const _: () = {
-            use #krate as _pyo3;
+        #(#extra_fragments)*
 
-            #(#trait_impls)*
+        #items
 
-            #items
-
-            #[doc(hidden)]
-            #[allow(non_snake_case)]
-            impl #ty {
-                #(#associated_methods)*
-            }
-        };
+        #[doc(hidden)]
+        #[allow(non_snake_case)]
+        impl #ty {
+            #(#associated_methods)*
+        }
     })
 }
 
-pub fn gen_py_const(cls: &syn::Type, spec: &ConstSpec) -> MethodAndMethodDef {
+pub fn gen_py_const(cls: &syn::Type, spec: &ConstSpec, ctx: &Ctx) -> MethodAndMethodDef {
     let member = &spec.rust_ident;
     let wrapper_ident = format_ident!("__pymethod_{}__", member);
-    let deprecations = &spec.attributes.deprecations;
-    let python_name = &spec.null_terminated_python_name();
+    let python_name = spec.null_terminated_python_name();
+    let Ctx { pyo3_path, .. } = ctx;
 
     let associated_method = quote! {
-        fn #wrapper_ident(py: _pyo3::Python<'_>) -> _pyo3::PyResult<_pyo3::PyObject> {
-            #deprecations
-            ::std::result::Result::Ok(_pyo3::IntoPy::into_py(#cls::#member, py))
+        fn #wrapper_ident(py: #pyo3_path::Python<'_>) -> #pyo3_path::PyResult<#pyo3_path::Py<#pyo3_path::PyAny>> {
+            #pyo3_path::IntoPyObjectExt::into_py_any(#cls::#member, py)
         }
     };
 
     let method_def = quote! {
-        _pyo3::class::PyMethodDefType::ClassAttribute({
-            _pyo3::class::PyClassAttributeDef::new(
+        #pyo3_path::impl_::pymethods::PyMethodDefType::ClassAttribute({
+            #pyo3_path::impl_::pymethods::PyClassAttributeDef::new(
                 #python_name,
-                _pyo3::impl_::pymethods::PyClassAttributeFactory(#cls::#wrapper_ident)
+                #cls::#wrapper_ident
             )
         })
     };
@@ -216,13 +260,16 @@ fn impl_py_methods(
     ty: &syn::Type,
     methods: Vec<TokenStream>,
     proto_impls: Vec<TokenStream>,
+    ctx: &Ctx,
 ) -> TokenStream {
+    let Ctx { pyo3_path, .. } = ctx;
     quote! {
-        impl _pyo3::impl_::pyclass::PyMethods<#ty>
-            for _pyo3::impl_::pyclass::PyClassImplCollector<#ty>
+        #[allow(unknown_lints, non_local_definitions)]
+        impl #pyo3_path::impl_::pyclass::PyMethods<#ty>
+            for #pyo3_path::impl_::pyclass::PyClassImplCollector<#ty>
         {
-            fn py_methods(self) -> &'static _pyo3::impl_::pyclass::PyClassItems {
-                static ITEMS: _pyo3::impl_::pyclass::PyClassItems = _pyo3::impl_::pyclass::PyClassItems {
+            fn py_methods(self) -> &'static #pyo3_path::impl_::pyclass::PyClassItems {
+                static ITEMS: #pyo3_path::impl_::pyclass::PyClassItems = #pyo3_path::impl_::pyclass::PyClassItems {
                     methods: &[#(#methods),*],
                     slots: &[#(#proto_impls),*]
                 };
@@ -236,13 +283,15 @@ fn add_shared_proto_slots(
     ty: &syn::Type,
     proto_impls: &mut Vec<TokenStream>,
     mut implemented_proto_fragments: HashSet<String>,
+    ctx: &Ctx,
 ) {
+    let Ctx { pyo3_path, .. } = ctx;
     macro_rules! try_add_shared_slot {
         ($slot:ident, $($fragments:literal),*) => {{
             let mut implemented = false;
             $(implemented |= implemented_proto_fragments.remove($fragments));*;
             if implemented {
-                proto_impls.push(quote! { _pyo3::impl_::pyclass::$slot!(#ty) })
+                proto_impls.push(quote! { #pyo3_path::impl_::pyclass::$slot!(#ty) })
             }
         }};
     }
@@ -292,18 +341,101 @@ fn submit_methods_inventory(
     ty: &syn::Type,
     methods: Vec<TokenStream>,
     proto_impls: Vec<TokenStream>,
+    ctx: &Ctx,
 ) -> TokenStream {
+    let Ctx { pyo3_path, .. } = ctx;
     quote! {
-        _pyo3::inventory::submit! {
-            type Inventory = <#ty as _pyo3::impl_::pyclass::PyClassImpl>::Inventory;
-            Inventory::new(_pyo3::impl_::pyclass::PyClassItems { methods: &[#(#methods),*], slots: &[#(#proto_impls),*] })
+        #pyo3_path::inventory::submit! {
+            type Inventory = <#ty as #pyo3_path::impl_::pyclass::PyClassImpl>::Inventory;
+            Inventory::new(#pyo3_path::impl_::pyclass::PyClassItems { methods: &[#(#methods),*], slots: &[#(#proto_impls),*] })
         }
     }
 }
 
-fn get_cfg_attributes(attrs: &[syn::Attribute]) -> Vec<&syn::Attribute> {
+pub(crate) fn get_cfg_attributes(attrs: &[syn::Attribute]) -> Vec<&syn::Attribute> {
     attrs
         .iter()
         .filter(|attr| attr.path().is_ident("cfg"))
         .collect()
 }
+
+#[cfg(feature = "experimental-inspect")]
+fn method_introspection_code(spec: &FnSpec<'_>, parent: &syn::Type, ctx: &Ctx) -> TokenStream {
+    let Ctx { pyo3_path, .. } = ctx;
+
+    let name = spec.python_name.to_string();
+
+    // __richcmp__ special case
+    if name == "__richcmp__" {
+        // We expend into each individual method
+        return ["__eq__", "__ne__", "__lt__", "__le__", "__gt__", "__ge__"]
+            .into_iter()
+            .map(|method_name| {
+                let mut spec = (*spec).clone();
+                spec.python_name = Ident::new(method_name, spec.python_name.span());
+                // We remove the CompareOp arg, this is safe because the signature is always the same
+                // First the other value to compare with then the CompareOp
+                // We cant to keep the first argument type, hence this hack
+                spec.signature.arguments.pop();
+                spec.signature.python_signature.positional_parameters.pop();
+                method_introspection_code(&spec, parent, ctx)
+            })
+            .collect();
+    }
+    // We map or ignore some magic methods
+    // TODO: this might create a naming conflict
+    let name = match name.as_str() {
+        "__concat__" => "__add__".into(),
+        "__repeat__" => "__mul__".into(),
+        "__inplace_concat__" => "__iadd__".into(),
+        "__inplace_repeat__" => "__imul__".into(),
+        "__getbuffer__" | "__releasebuffer__" | "__traverse__" | "__clear__" => return quote! {},
+        _ => name,
+    };
+
+    // We introduce self/cls argument and setup decorators
+    let mut first_argument = None;
+    let mut output = spec.output.clone();
+    let mut decorators = Vec::new();
+    match &spec.tp {
+        FnType::Getter(_) => {
+            first_argument = Some("self");
+            decorators.push("property".into());
+        }
+        FnType::Setter(_) => {
+            first_argument = Some("self");
+            decorators.push(format!("{name}.setter"));
+        }
+        FnType::Fn(_) => {
+            first_argument = Some("self");
+        }
+        FnType::FnNew | FnType::FnNewClass(_) => {
+            first_argument = Some("cls");
+            output = syn::ReturnType::Default; // The __new__ Python function return type is None
+        }
+        FnType::FnClass(_) => {
+            first_argument = Some("cls");
+            decorators.push("classmethod".into());
+        }
+        FnType::FnStatic => {
+            decorators.push("staticmethod".into());
+        }
+        FnType::FnModule(_) => (), // TODO: not sure this can happen
+        FnType::ClassAttribute => {
+            first_argument = Some("cls");
+            // TODO: this combination only works with Python 3.9-3.11 https://docs.python.org/3.11/library/functions.html#classmethod
+            decorators.push("classmethod".into());
+            decorators.push("property".into());
+        }
+    }
+    function_introspection_code(
+        pyo3_path,
+        None,
+        &name,
+        &spec.signature,
+        first_argument,
+        output,
+        decorators,
+        Some(parent),
+    )
+}
diff --git a/pyo3-macros-backend/src/pymethod.rs b/pyo3-macros-backend/src/pymethod.rs
index d45d2e12f26..755bd367f27 100644
--- a/pyo3-macros-backend/src/pymethod.rs
+++ b/pyo3-macros-backend/src/pymethod.rs
@@ -1,7 +1,13 @@
 use std::borrow::Cow;
-
-use crate::attributes::{NameAttribute, RenamingRule};
-use crate::method::{CallingConvention, ExtractErrorMode};
+use std::ffi::CString;
+
+use crate::attributes::{FromPyWithAttribute, NameAttribute, RenamingRule};
+#[cfg(feature = "experimental-inspect")]
+use crate::introspection::unique_element_id;
+use crate::method::{CallingConvention, ExtractErrorMode, PyArg};
+use crate::params::{impl_regular_arg_param, Holders};
+use crate::pyfunction::WarningFactory;
+use crate::utils::Ctx;
 use crate::utils::PythonDoc;
 use crate::{
     method::{FnArg, FnSpec, FnType, SelfType},
@@ -9,8 +15,9 @@ use crate::{
 };
 use crate::{quotes, utils};
 use proc_macro2::{Span, TokenStream};
-use quote::{format_ident, quote, ToTokens};
-use syn::{ext::IdentExt, spanned::Spanned, Result};
+use quote::{format_ident, quote, quote_spanned, ToTokens};
+use syn::LitCStr;
+use syn::{ext::IdentExt, spanned::Spanned, Field, Ident, Result};
 
 /// Generated code for a single pymethod item.
 pub struct MethodAndMethodDef {
@@ -20,6 +27,18 @@ pub struct MethodAndMethodDef {
     pub method_def: TokenStream,
 }
 
+#[cfg(feature = "experimental-inspect")]
+impl MethodAndMethodDef {
+    pub fn add_introspection(&mut self, data: TokenStream) {
+        let const_name = format_ident!("_{}", unique_element_id()); // We need an explicit name here
+        self.associated_method.extend(quote! {
+            const #const_name: () = {
+                #data
+            };
+        });
+    }
+}
+
 /// Generated code for a single pymethod item which is registered by a slot.
 pub struct MethodAndSlotDef {
     /// The implementation of the Python wrapper for the pymethod
@@ -28,6 +47,18 @@ pub struct MethodAndSlotDef {
     pub slot_def: TokenStream,
 }
 
+#[cfg(feature = "experimental-inspect")]
+impl MethodAndSlotDef {
+    pub fn add_introspection(&mut self, data: TokenStream) {
+        let const_name = format_ident!("_{}", unique_element_id()); // We need an explicit name here
+        self.associated_method.extend(quote! {
+            const #const_name: () = {
+                #data
+            };
+        });
+    }
+}
+
 pub enum GeneratedPyMethod {
     Method(MethodAndMethodDef),
     Proto(MethodAndSlotDef),
@@ -37,7 +68,7 @@ pub enum GeneratedPyMethod {
 pub struct PyMethod<'a> {
     kind: PyMethodKind,
     method_name: String,
-    spec: FnSpec<'a>,
+    pub spec: FnSpec<'a>,
 }
 
 enum PyMethodKind {
@@ -93,7 +124,6 @@ impl PyMethodKind {
             "__ior__" => PyMethodKind::Proto(PyMethodProtoKind::Slot(&__IOR__)),
             "__getbuffer__" => PyMethodKind::Proto(PyMethodProtoKind::Slot(&__GETBUFFER__)),
             "__releasebuffer__" => PyMethodKind::Proto(PyMethodProtoKind::Slot(&__RELEASEBUFFER__)),
-            "__clear__" => PyMethodKind::Proto(PyMethodProtoKind::Slot(&__CLEAR__)),
             // Protocols implemented through traits
             "__getattribute__" => {
                 PyMethodKind::Proto(PyMethodProtoKind::SlotFragment(&__GETATTRIBUTE__))
@@ -142,6 +172,7 @@ impl PyMethodKind {
             // Some tricky protocols which don't fit the pattern of the rest
             "__call__" => PyMethodKind::Proto(PyMethodProtoKind::Call),
             "__traverse__" => PyMethodKind::Proto(PyMethodProtoKind::Traverse),
+            "__clear__" => PyMethodKind::Proto(PyMethodProtoKind::Clear),
             // Not a proto
             _ => PyMethodKind::Fn,
         }
@@ -152,15 +183,18 @@ enum PyMethodProtoKind {
     Slot(&'static SlotDef),
     Call,
     Traverse,
+    Clear,
     SlotFragment(&'static SlotFragmentDef),
 }
 
 impl<'a> PyMethod<'a> {
-    fn parse(
+    pub fn parse(
         sig: &'a mut syn::Signature,
         meth_attrs: &mut Vec<syn::Attribute>,
         options: PyFunctionOptions,
     ) -> Result<Self> {
+        check_generic(sig)?;
+        ensure_function_options_valid(&options)?;
         let spec = FnSpec::parse(sig, meth_attrs, options)?;
 
         let method_name = spec.python_name.to_string();
@@ -183,36 +217,44 @@ pub fn is_proto_method(name: &str) -> bool {
 
 pub fn gen_py_method(
     cls: &syn::Type,
-    sig: &mut syn::Signature,
-    meth_attrs: &mut Vec<syn::Attribute>,
-    options: PyFunctionOptions,
+    method: PyMethod<'_>,
+    meth_attrs: &[syn::Attribute],
+    ctx: &Ctx,
 ) -> Result<GeneratedPyMethod> {
-    check_generic(sig)?;
-    ensure_function_options_valid(&options)?;
-    let method = PyMethod::parse(sig, meth_attrs, options)?;
     let spec = &method.spec;
+    let Ctx { pyo3_path, .. } = ctx;
+
+    if spec.asyncness.is_some() {
+        ensure_spanned!(
+            cfg!(feature = "experimental-async"),
+            spec.asyncness.span() => "async functions are only supported with the `experimental-async` feature"
+        );
+    }
 
     Ok(match (method.kind, &spec.tp) {
         // Class attributes go before protos so that class attributes can be used to set proto
         // method to None.
         (_, FnType::ClassAttribute) => {
-            GeneratedPyMethod::Method(impl_py_class_attribute(cls, spec)?)
+            GeneratedPyMethod::Method(impl_py_class_attribute(cls, spec, ctx)?)
         }
         (PyMethodKind::Proto(proto_kind), _) => {
             ensure_no_forbidden_protocol_attributes(&proto_kind, spec, &method.method_name)?;
             match proto_kind {
                 PyMethodProtoKind::Slot(slot_def) => {
-                    let slot = slot_def.generate_type_slot(cls, spec, &method.method_name)?;
+                    let slot = slot_def.generate_type_slot(cls, spec, &method.method_name, ctx)?;
                     GeneratedPyMethod::Proto(slot)
                 }
                 PyMethodProtoKind::Call => {
-                    GeneratedPyMethod::Proto(impl_call_slot(cls, method.spec)?)
+                    GeneratedPyMethod::Proto(impl_call_slot(cls, method.spec, ctx)?)
                 }
                 PyMethodProtoKind::Traverse => {
-                    GeneratedPyMethod::Proto(impl_traverse_slot(cls, spec)?)
+                    GeneratedPyMethod::Proto(impl_traverse_slot(cls, spec, ctx)?)
+                }
+                PyMethodProtoKind::Clear => {
+                    GeneratedPyMethod::Proto(impl_clear_slot(cls, spec, ctx)?)
                 }
                 PyMethodProtoKind::SlotFragment(slot_fragment_def) => {
-                    let proto = slot_fragment_def.generate_pyproto_fragment(cls, spec)?;
+                    let proto = slot_fragment_def.generate_pyproto_fragment(cls, spec, ctx)?;
                     GeneratedPyMethod::SlotTraitImpl(method.method_name, proto)
                 }
             }
@@ -221,24 +263,27 @@ pub fn gen_py_method(
         (_, FnType::Fn(_)) => GeneratedPyMethod::Method(impl_py_method_def(
             cls,
             spec,
-            &spec.get_doc(meth_attrs),
+            &spec.get_doc(meth_attrs, ctx)?,
             None,
+            ctx,
         )?),
         (_, FnType::FnClass(_)) => GeneratedPyMethod::Method(impl_py_method_def(
             cls,
             spec,
-            &spec.get_doc(meth_attrs),
-            Some(quote!(_pyo3::ffi::METH_CLASS)),
+            &spec.get_doc(meth_attrs, ctx)?,
+            Some(quote!(#pyo3_path::ffi::METH_CLASS)),
+            ctx,
         )?),
         (_, FnType::FnStatic) => GeneratedPyMethod::Method(impl_py_method_def(
             cls,
             spec,
-            &spec.get_doc(meth_attrs),
-            Some(quote!(_pyo3::ffi::METH_STATIC)),
+            &spec.get_doc(meth_attrs, ctx)?,
+            Some(quote!(#pyo3_path::ffi::METH_STATIC)),
+            ctx,
         )?),
         // special prototypes
         (_, FnType::FnNew) | (_, FnType::FnNewClass(_)) => {
-            GeneratedPyMethod::Proto(impl_py_method_def_new(cls, spec)?)
+            GeneratedPyMethod::Proto(impl_py_method_def_new(cls, spec, ctx)?)
         }
 
         (_, FnType::Getter(self_type)) => GeneratedPyMethod::Method(impl_py_getter_def(
@@ -246,16 +291,18 @@ pub fn gen_py_method(
             PropertyType::Function {
                 self_type,
                 spec,
-                doc: spec.get_doc(meth_attrs),
+                doc: spec.get_doc(meth_attrs, ctx)?,
             },
+            ctx,
         )?),
         (_, FnType::Setter(self_type)) => GeneratedPyMethod::Method(impl_py_setter_def(
             cls,
             PropertyType::Function {
                 self_type,
                 spec,
-                doc: spec.get_doc(meth_attrs),
+                doc: spec.get_doc(meth_attrs, ctx)?,
             },
+            ctx,
         )?),
         (_, FnType::FnModule(_)) => {
             unreachable!("methods cannot be FnModule")
@@ -264,7 +311,7 @@ pub fn gen_py_method(
 }
 
 pub fn check_generic(sig: &syn::Signature) -> syn::Result<()> {
-    let err_msg = |typ| format!("Python functions cannot have generic {} parameters", typ);
+    let err_msg = |typ| format!("Python functions cannot have generic {typ} parameters");
     for param in &sig.generics.params {
         match param {
             syn::GenericParam::Lifetime(_) => {}
@@ -305,18 +352,20 @@ pub fn impl_py_method_def(
     spec: &FnSpec<'_>,
     doc: &PythonDoc,
     flags: Option<TokenStream>,
+    ctx: &Ctx,
 ) -> Result<MethodAndMethodDef> {
+    let Ctx { pyo3_path, .. } = ctx;
     let wrapper_ident = format_ident!("__pymethod_{}__", spec.python_name);
-    let associated_method = spec.get_wrapper_function(&wrapper_ident, Some(cls))?;
+    let associated_method = spec.get_wrapper_function(&wrapper_ident, Some(cls), ctx)?;
     let add_flags = flags.map(|flags| quote!(.flags(#flags)));
     let methoddef_type = match spec.tp {
         FnType::FnStatic => quote!(Static),
         FnType::FnClass(_) => quote!(Class),
         _ => quote!(Method),
     };
-    let methoddef = spec.get_methoddef(quote! { #cls::#wrapper_ident }, doc);
+    let methoddef = spec.get_methoddef(quote! { #cls::#wrapper_ident }, doc, ctx);
     let method_def = quote! {
-        _pyo3::class::PyMethodDefType::#methoddef_type(#methoddef #add_flags)
+        #pyo3_path::impl_::pymethods::PyMethodDefType::#methoddef_type(#methoddef #add_flags)
     };
     Ok(MethodAndMethodDef {
         associated_method,
@@ -325,38 +374,38 @@ pub fn impl_py_method_def(
 }
 
 /// Also used by pyclass.
-pub fn impl_py_method_def_new(cls: &syn::Type, spec: &FnSpec<'_>) -> Result<MethodAndSlotDef> {
+pub fn impl_py_method_def_new(
+    cls: &syn::Type,
+    spec: &FnSpec<'_>,
+    ctx: &Ctx,
+) -> Result<MethodAndSlotDef> {
+    let Ctx { pyo3_path, .. } = ctx;
     let wrapper_ident = syn::Ident::new("__pymethod___new____", Span::call_site());
-    let associated_method = spec.get_wrapper_function(&wrapper_ident, Some(cls))?;
+    let associated_method = spec.get_wrapper_function(&wrapper_ident, Some(cls), ctx)?;
     // Use just the text_signature_call_signature() because the class' Python name
     // isn't known to `#[pymethods]` - that has to be attached at runtime from the PyClassImpl
     // trait implementation created by `#[pyclass]`.
-    let text_signature_body = spec.text_signature_call_signature().map_or_else(
-        || quote!(::std::option::Option::None),
-        |text_signature| quote!(::std::option::Option::Some(#text_signature)),
-    );
-    let deprecations = &spec.deprecations;
+    let text_signature_impl = spec.text_signature_call_signature().map(|text_signature| {
+        quote! {
+            #[allow(unknown_lints, non_local_definitions)]
+            impl #pyo3_path::impl_::pyclass::doc::PyClassNewTextSignature for #cls {
+                const TEXT_SIGNATURE: &'static str = #text_signature;
+            }
+        }
+    });
     let slot_def = quote! {
-        _pyo3::ffi::PyType_Slot {
-            slot: _pyo3::ffi::Py_tp_new,
+        #pyo3_path::ffi::PyType_Slot {
+            slot: #pyo3_path::ffi::Py_tp_new,
             pfunc: {
                 unsafe extern "C" fn trampoline(
-                    subtype: *mut _pyo3::ffi::PyTypeObject,
-                    args: *mut _pyo3::ffi::PyObject,
-                    kwargs: *mut _pyo3::ffi::PyObject,
-                ) -> *mut _pyo3::ffi::PyObject
-                {
-                    #deprecations
-
-                    use _pyo3::impl_::pyclass::*;
-                    impl PyClassNewTextSignature<#cls> for PyClassImplCollector<#cls> {
-                        #[inline]
-                        fn new_text_signature(self) -> ::std::option::Option<&'static str> {
-                            #text_signature_body
-                        }
-                    }
+                    subtype: *mut #pyo3_path::ffi::PyTypeObject,
+                    args: *mut #pyo3_path::ffi::PyObject,
+                    kwargs: *mut #pyo3_path::ffi::PyObject,
+                ) -> *mut #pyo3_path::ffi::PyObject {
+
+                    #text_signature_impl
 
-                    _pyo3::impl_::trampoline::newfunc(
+                    #pyo3_path::impl_::trampoline::newfunc(
                         subtype,
                         args,
                         kwargs,
@@ -364,7 +413,7 @@ pub fn impl_py_method_def_new(cls: &syn::Type, spec: &FnSpec<'_>) -> Result<Meth
                     )
                 }
                 trampoline
-            } as _pyo3::ffi::newfunc as _
+            } as #pyo3_path::ffi::newfunc as _
         }
     };
     Ok(MethodAndSlotDef {
@@ -373,24 +422,26 @@ pub fn impl_py_method_def_new(cls: &syn::Type, spec: &FnSpec<'_>) -> Result<Meth
     })
 }
 
-fn impl_call_slot(cls: &syn::Type, mut spec: FnSpec<'_>) -> Result<MethodAndSlotDef> {
+fn impl_call_slot(cls: &syn::Type, mut spec: FnSpec<'_>, ctx: &Ctx) -> Result<MethodAndSlotDef> {
+    let Ctx { pyo3_path, .. } = ctx;
+
     // HACK: __call__ proto slot must always use varargs calling convention, so change the spec.
     // Probably indicates there's a refactoring opportunity somewhere.
     spec.convention = CallingConvention::Varargs;
 
     let wrapper_ident = syn::Ident::new("__pymethod___call____", Span::call_site());
-    let associated_method = spec.get_wrapper_function(&wrapper_ident, Some(cls))?;
+    let associated_method = spec.get_wrapper_function(&wrapper_ident, Some(cls), ctx)?;
     let slot_def = quote! {
-        _pyo3::ffi::PyType_Slot {
-            slot: _pyo3::ffi::Py_tp_call,
+        #pyo3_path::ffi::PyType_Slot {
+            slot: #pyo3_path::ffi::Py_tp_call,
             pfunc: {
                 unsafe extern "C" fn trampoline(
-                    slf: *mut _pyo3::ffi::PyObject,
-                    args: *mut _pyo3::ffi::PyObject,
-                    kwargs: *mut _pyo3::ffi::PyObject,
-                ) -> *mut _pyo3::ffi::PyObject
+                    slf: *mut #pyo3_path::ffi::PyObject,
+                    args: *mut #pyo3_path::ffi::PyObject,
+                    kwargs: *mut #pyo3_path::ffi::PyObject,
+                ) -> *mut #pyo3_path::ffi::PyObject
                 {
-                    _pyo3::impl_::trampoline::ternaryfunc(
+                    #pyo3_path::impl_::trampoline::ternaryfunc(
                         slf,
                         args,
                         kwargs,
@@ -398,7 +449,7 @@ fn impl_call_slot(cls: &syn::Type, mut spec: FnSpec<'_>) -> Result<MethodAndSlot
                     )
                 }
                 trampoline
-            } as _pyo3::ffi::ternaryfunc as _
+            } as #pyo3_path::ffi::ternaryfunc as _
         }
     };
     Ok(MethodAndSlotDef {
@@ -407,29 +458,54 @@ fn impl_call_slot(cls: &syn::Type, mut spec: FnSpec<'_>) -> Result<MethodAndSlot
     })
 }
 
-fn impl_traverse_slot(cls: &syn::Type, spec: &FnSpec<'_>) -> syn::Result<MethodAndSlotDef> {
+fn impl_traverse_slot(
+    cls: &syn::Type,
+    spec: &FnSpec<'_>,
+    ctx: &Ctx,
+) -> syn::Result<MethodAndSlotDef> {
+    let Ctx { pyo3_path, .. } = ctx;
     if let (Some(py_arg), _) = split_off_python_arg(&spec.signature.arguments) {
         return Err(syn::Error::new_spanned(py_arg.ty, "__traverse__ may not take `Python`. \
-            Usually, an implementation of `__traverse__` should do nothing but calls to `visit.call`. \
-            Most importantly, safe access to the GIL is prohibited inside implementations of `__traverse__`, \
-            i.e. `Python::with_gil` will panic."));
+            Usually, an implementation of `__traverse__(&self, visit: PyVisit<'_>) -> Result<(), PyTraverseError>` \
+            should do nothing but calls to `visit.call`. Most importantly, safe access to the Python interpreter is \
+            prohibited inside implementations of `__traverse__`, i.e. `Python::attach` will panic."));
     }
 
+    // check that the receiver does not try to smuggle an (implicit) `Python` token into here
+    if let FnType::Fn(SelfType::TryFromBoundRef(span))
+    | FnType::Fn(SelfType::Receiver {
+        mutable: true,
+        span,
+    }) = spec.tp
+    {
+        bail_spanned! { span =>
+            "__traverse__ may not take a receiver other than `&self`. Usually, an implementation of \
+            `__traverse__(&self, visit: PyVisit<'_>) -> Result<(), PyTraverseError>` \
+            should do nothing but calls to `visit.call`. Most importantly, safe access to the Python interpreter is \
+            prohibited inside implementations of `__traverse__`, i.e. `Python::attach` will panic."
+        }
+    }
+
+    ensure_spanned!(
+        spec.warnings.is_empty(),
+        spec.warnings.span() => "__traverse__ cannot be used with #[pyo3(warn)]"
+    );
+
     let rust_fn_ident = spec.name;
 
     let associated_method = quote! {
         pub unsafe extern "C" fn __pymethod_traverse__(
-            slf: *mut _pyo3::ffi::PyObject,
-            visit: _pyo3::ffi::visitproc,
-            arg: *mut ::std::os::raw::c_void,
-        ) -> ::std::os::raw::c_int {
-            _pyo3::impl_::pymethods::_call_traverse::<#cls>(slf, #cls::#rust_fn_ident, visit, arg)
+            slf: *mut #pyo3_path::ffi::PyObject,
+            visit: #pyo3_path::ffi::visitproc,
+            arg: *mut ::std::ffi::c_void,
+        ) -> ::std::ffi::c_int {
+            #pyo3_path::impl_::pymethods::_call_traverse::<#cls>(slf, #cls::#rust_fn_ident, visit, arg, #cls::__pymethod_traverse__)
         }
     };
     let slot_def = quote! {
-        _pyo3::ffi::PyType_Slot {
-            slot: _pyo3::ffi::Py_tp_traverse,
-            pfunc: #cls::__pymethod_traverse__ as _pyo3::ffi::traverseproc as _
+        #pyo3_path::ffi::PyType_Slot {
+            slot: #pyo3_path::ffi::Py_tp_traverse,
+            pfunc: #cls::__pymethod_traverse__ as #pyo3_path::ffi::traverseproc as _
         }
     };
     Ok(MethodAndSlotDef {
@@ -438,11 +514,68 @@ fn impl_traverse_slot(cls: &syn::Type, spec: &FnSpec<'_>) -> syn::Result<MethodA
     })
 }
 
-fn impl_py_class_attribute(cls: &syn::Type, spec: &FnSpec<'_>) -> syn::Result<MethodAndMethodDef> {
+fn impl_clear_slot(cls: &syn::Type, spec: &FnSpec<'_>, ctx: &Ctx) -> syn::Result<MethodAndSlotDef> {
+    let Ctx { pyo3_path, .. } = ctx;
+    let (py_arg, args) = split_off_python_arg(&spec.signature.arguments);
+    let self_type = match &spec.tp {
+        FnType::Fn(self_type) => self_type,
+        _ => bail_spanned!(spec.name.span() => "expected instance method for `__clear__` function"),
+    };
+    let mut holders = Holders::new();
+    let slf = self_type.receiver(cls, ExtractErrorMode::Raise, &mut holders, ctx);
+
+    if let [arg, ..] = args {
+        bail_spanned!(arg.ty().span() => "`__clear__` function expected to have no arguments");
+    }
+
+    let name = &spec.name;
+    let holders = holders.init_holders(ctx);
+    let fncall = if py_arg.is_some() {
+        quote!(#cls::#name(#slf, py))
+    } else {
+        quote!(#cls::#name(#slf))
+    };
+
+    let associated_method = quote! {
+        pub unsafe extern "C" fn __pymethod___clear____(
+            _slf: *mut #pyo3_path::ffi::PyObject,
+        ) -> ::std::ffi::c_int {
+            #pyo3_path::impl_::pymethods::_call_clear(_slf, |py, _slf| {
+                #holders
+                let result = #fncall;
+                let result = #pyo3_path::impl_::wrap::converter(&result).wrap(result)?;
+                ::std::result::Result::Ok(result)
+            }, #cls::__pymethod___clear____)
+        }
+    };
+    let slot_def = quote! {
+        #pyo3_path::ffi::PyType_Slot {
+            slot: #pyo3_path::ffi::Py_tp_clear,
+            pfunc: #cls::__pymethod___clear____ as #pyo3_path::ffi::inquiry as _
+        }
+    };
+    Ok(MethodAndSlotDef {
+        associated_method,
+        slot_def,
+    })
+}
+
+pub(crate) fn impl_py_class_attribute(
+    cls: &syn::Type,
+    spec: &FnSpec<'_>,
+    ctx: &Ctx,
+) -> syn::Result<MethodAndMethodDef> {
+    let Ctx { pyo3_path, .. } = ctx;
     let (py_arg, args) = split_off_python_arg(&spec.signature.arguments);
     ensure_spanned!(
         args.is_empty(),
-        args[0].ty.span() => "#[classattr] can only have one argument (of type pyo3::Python)"
+        args[0].ty().span() => "#[classattr] can only have one argument (of type pyo3::Python)"
+    );
+
+    ensure_spanned!(
+        spec.warnings.is_empty(),
+        spec.warnings.span()
+        => "#[classattr] cannot be used with #[pyo3(warn)]"
     );
 
     let name = &spec.name;
@@ -454,20 +587,21 @@ fn impl_py_class_attribute(cls: &syn::Type, spec: &FnSpec<'_>) -> syn::Result<Me
 
     let wrapper_ident = format_ident!("__pymethod_{}__", name);
     let python_name = spec.null_terminated_python_name();
-    let body = quotes::ok_wrap(fncall);
+    let body = quotes::ok_wrap(fncall, ctx);
 
     let associated_method = quote! {
-        fn #wrapper_ident(py: _pyo3::Python<'_>) -> _pyo3::PyResult<_pyo3::PyObject> {
+        fn #wrapper_ident(py: #pyo3_path::Python<'_>) -> #pyo3_path::PyResult<#pyo3_path::Py<#pyo3_path::PyAny>> {
             let function = #cls::#name; // Shadow the method name to avoid #3017
-            _pyo3::impl_::wrap::map_result_into_py(py, #body)
+            let result = #body;
+            #pyo3_path::impl_::wrap::converter(&result).map_into_pyobject(py, result)
         }
     };
 
     let method_def = quote! {
-        _pyo3::class::PyMethodDefType::ClassAttribute({
-            _pyo3::class::PyClassAttributeDef::new(
+        #pyo3_path::impl_::pymethods::PyMethodDefType::ClassAttribute({
+            #pyo3_path::impl_::pymethods::PyClassAttributeDef::new(
                 #python_name,
-                _pyo3::impl_::pymethods::PyClassAttributeFactory(#cls::#wrapper_ident)
+                #cls::#wrapper_ident
             )
         })
     };
@@ -482,16 +616,17 @@ fn impl_call_setter(
     cls: &syn::Type,
     spec: &FnSpec<'_>,
     self_type: &SelfType,
-    holders: &mut Vec<TokenStream>,
+    holders: &mut Holders,
+    ctx: &Ctx,
 ) -> syn::Result<TokenStream> {
     let (py_arg, args) = split_off_python_arg(&spec.signature.arguments);
-    let slf = self_type.receiver(cls, ExtractErrorMode::Raise, holders);
+    let slf = self_type.receiver(cls, ExtractErrorMode::Raise, holders, ctx);
 
     if args.is_empty() {
         bail_spanned!(spec.name.span() => "setter function expected to have one argument");
     } else if args.len() > 1 {
         bail_spanned!(
-            args[1].ty.span() =>
+            args[1].ty().span() =>
             "setter function can have at most two arguments ([pyo3::Python,] and value)"
         );
     }
@@ -510,10 +645,12 @@ fn impl_call_setter(
 pub fn impl_py_setter_def(
     cls: &syn::Type,
     property_type: PropertyType<'_>,
+    ctx: &Ctx,
 ) -> Result<MethodAndMethodDef> {
+    let Ctx { pyo3_path, .. } = ctx;
     let python_name = property_type.null_terminated_python_name()?;
-    let doc = property_type.doc();
-    let mut holders = Vec::new();
+    let doc = property_type.doc(ctx)?;
+    let mut holders = Holders::new();
     let setter_impl = match property_type {
         PropertyType::Descriptor {
             field_index, field, ..
@@ -522,7 +659,7 @@ pub fn impl_py_setter_def(
                 mutable: true,
                 span: Span::call_site(),
             }
-            .receiver(cls, ExtractErrorMode::Raise, &mut holders);
+            .receiver(cls, ExtractErrorMode::Raise, &mut holders, ctx);
             if let Some(ident) = &field.ident {
                 // named struct field
                 quote!({ #slf.#ident = _val; })
@@ -534,7 +671,7 @@ pub fn impl_py_setter_def(
         }
         PropertyType::Function {
             spec, self_type, ..
-        } => impl_call_setter(cls, spec, self_type, &mut holders)?,
+        } => impl_call_setter(cls, spec, self_type, &mut holders, ctx)?,
     };
 
     let wrapper_ident = match property_type {
@@ -554,6 +691,59 @@ pub fn impl_py_setter_def(
         }
     };
 
+    let extract = match &property_type {
+        PropertyType::Function { spec, .. } => {
+            let (_, args) = split_off_python_arg(&spec.signature.arguments);
+            let value_arg = &args[0];
+            let (from_py_with, ident) =
+                if let Some(from_py_with) = &value_arg.from_py_with().as_ref().map(|f| &f.value) {
+                    let ident = syn::Ident::new("from_py_with", from_py_with.span());
+                    (
+                        quote_spanned! { from_py_with.span() =>
+                            let #ident = #from_py_with;
+                        },
+                        ident,
+                    )
+                } else {
+                    (quote!(), syn::Ident::new("dummy", Span::call_site()))
+                };
+
+            let arg = if let FnArg::Regular(arg) = &value_arg {
+                arg
+            } else {
+                bail_spanned!(value_arg.name().span() => "The #[setter] value argument can't be *args, **kwargs or `cancel_handle`.");
+            };
+
+            let extract = impl_regular_arg_param(
+                arg,
+                ident,
+                quote!(::std::option::Option::Some(_value.into())),
+                &mut holders,
+                ctx,
+            );
+
+            quote! {
+                #from_py_with
+                let _val = #extract;
+            }
+        }
+        PropertyType::Descriptor { field, .. } => {
+            let span = field.ty.span();
+            let name = field
+                .ident
+                .as_ref()
+                .map(|i| i.to_string())
+                .unwrap_or_default();
+
+            let holder = holders.push_holder(span);
+            quote! {
+                #[allow(unused_imports)]
+                use #pyo3_path::impl_::pyclass::Probe as _;
+                let _val = #pyo3_path::impl_::extract_argument::extract_argument(_value.into(), &mut #holder, #name)?;
+            }
+        }
+    };
+
     let mut cfg_attrs = TokenStream::new();
     if let PropertyType::Descriptor { field, .. } = &property_type {
         for attr in field
@@ -565,30 +755,39 @@ pub fn impl_py_setter_def(
         }
     }
 
+    let warnings = if let PropertyType::Function { spec, .. } = &property_type {
+        spec.warnings.build_py_warning(ctx)
+    } else {
+        quote!()
+    };
+
+    let init_holders = holders.init_holders(ctx);
     let associated_method = quote! {
         #cfg_attrs
         unsafe fn #wrapper_ident(
-            py: _pyo3::Python<'_>,
-            _slf: *mut _pyo3::ffi::PyObject,
-            _value: *mut _pyo3::ffi::PyObject,
-        ) -> _pyo3::PyResult<::std::os::raw::c_int> {
-            let _value = py
-                .from_borrowed_ptr_or_opt(_value)
+            py: #pyo3_path::Python<'_>,
+            _slf: *mut #pyo3_path::ffi::PyObject,
+            _value: *mut #pyo3_path::ffi::PyObject,
+        ) -> #pyo3_path::PyResult<::std::ffi::c_int> {
+            use ::std::convert::Into;
+            let _value = #pyo3_path::impl_::pymethods::BoundRef::ref_from_ptr_or_opt(py, &_value)
                 .ok_or_else(|| {
-                    _pyo3::exceptions::PyAttributeError::new_err("can't delete attribute")
+                    #pyo3_path::exceptions::PyAttributeError::new_err("can't delete attribute")
                 })?;
-            let _val = _pyo3::FromPyObject::extract(_value)?;
-            #( #holders )*
-            _pyo3::callback::convert(py, #setter_impl)
+            #init_holders
+            #extract
+            #warnings
+            let result = #setter_impl;
+            #pyo3_path::impl_::callback::convert(py, result)
         }
     };
 
     let method_def = quote! {
         #cfg_attrs
-        _pyo3::class::PyMethodDefType::Setter(
-            _pyo3::class::PySetterDef::new(
+        #pyo3_path::impl_::pymethods::PyMethodDefType::Setter(
+            #pyo3_path::impl_::pymethods::PySetterDef::new(
                 #python_name,
-                _pyo3::impl_::pymethods::PySetter(#cls::#wrapper_ident),
+                #cls::#wrapper_ident,
                 #doc
             )
         )
@@ -604,13 +803,14 @@ fn impl_call_getter(
     cls: &syn::Type,
     spec: &FnSpec<'_>,
     self_type: &SelfType,
-    holders: &mut Vec<TokenStream>,
+    holders: &mut Holders,
+    ctx: &Ctx,
 ) -> syn::Result<TokenStream> {
     let (py_arg, args) = split_off_python_arg(&spec.signature.arguments);
-    let slf = self_type.receiver(cls, ExtractErrorMode::Raise, holders);
+    let slf = self_type.receiver(cls, ExtractErrorMode::Raise, holders, ctx);
     ensure_spanned!(
         args.is_empty(),
-        args[0].ty.span() => "getter function can only have one argument (of type pyo3::Python)"
+        args[0].ty().span() => "getter function can only have one argument (of type pyo3::Python)"
     );
 
     let name = &spec.name;
@@ -627,102 +827,112 @@ fn impl_call_getter(
 pub fn impl_py_getter_def(
     cls: &syn::Type,
     property_type: PropertyType<'_>,
+    ctx: &Ctx,
 ) -> Result<MethodAndMethodDef> {
+    let Ctx { pyo3_path, .. } = ctx;
     let python_name = property_type.null_terminated_python_name()?;
-    let doc = property_type.doc();
+    let doc = property_type.doc(ctx)?;
 
-    let mut holders = Vec::new();
-    let body = match property_type {
+    let mut cfg_attrs = TokenStream::new();
+    if let PropertyType::Descriptor { field, .. } = &property_type {
+        for attr in field
+            .attrs
+            .iter()
+            .filter(|attr| attr.path().is_ident("cfg"))
+        {
+            attr.to_tokens(&mut cfg_attrs);
+        }
+    }
+
+    let mut holders = Holders::new();
+    match property_type {
         PropertyType::Descriptor {
             field_index, field, ..
         } => {
-            let slf = SelfType::Receiver {
-                mutable: false,
-                span: Span::call_site(),
-            }
-            .receiver(cls, ExtractErrorMode::Raise, &mut holders);
-            let field_token = if let Some(ident) = &field.ident {
-                // named struct field
+            let ty = &field.ty;
+            let field = if let Some(ident) = &field.ident {
                 ident.to_token_stream()
             } else {
-                // tuple struct field
                 syn::Index::from(field_index).to_token_stream()
             };
-            quotes::map_result_into_ptr(quotes::ok_wrap(quote! {
-                ::std::clone::Clone::clone(&(#slf.#field_token))
-            }))
+
+            let generator = quote_spanned! { ty.span() =>
+                GENERATOR.generate(#python_name, #doc)
+            };
+            // This is separate from `generator` so that the unsafe below does not inherit the span and thus does not
+            // trigger the `unsafe_code` lint
+            let method_def = quote! {
+                #cfg_attrs
+                {
+                    #[allow(unused_imports)]  // might not be used if all probes are positive
+                    use #pyo3_path::impl_::pyclass::Probe as _;
+
+                    const GENERATOR: #pyo3_path::impl_::pyclass::PyClassGetterGenerator::<
+                        #cls,
+                        #ty,
+                        { ::std::mem::offset_of!(#cls, #field) },
+                        { #pyo3_path::impl_::pyclass::IsPyT::<#ty>::VALUE },
+                        { #pyo3_path::impl_::pyclass::IsIntoPyObjectRef::<#ty>::VALUE },
+                        { #pyo3_path::impl_::pyclass::IsIntoPyObject::<#ty>::VALUE },
+                    > = unsafe { #pyo3_path::impl_::pyclass::PyClassGetterGenerator::new() };
+                    #generator
+                }
+            };
+
+            Ok(MethodAndMethodDef {
+                associated_method: quote! {},
+                method_def,
+            })
         }
         // Forward to `IntoPyCallbackOutput`, to handle `#[getter]`s returning results.
         PropertyType::Function {
             spec, self_type, ..
         } => {
-            let call = impl_call_getter(cls, spec, self_type, &mut holders)?;
-            quote! {
-                _pyo3::callback::convert(py, #call)
-            }
-        }
-    };
+            let wrapper_ident = format_ident!("__pymethod_get_{}__", spec.name);
+            let call = impl_call_getter(cls, spec, self_type, &mut holders, ctx)?;
+            let body = quote! {
+                #pyo3_path::impl_::callback::convert(py, #call)
+            };
 
-    let wrapper_ident = match property_type {
-        PropertyType::Descriptor {
-            field: syn::Field {
-                ident: Some(ident), ..
-            },
-            ..
-        } => {
-            format_ident!("__pymethod_get_{}__", ident)
-        }
-        PropertyType::Descriptor { field_index, .. } => {
-            format_ident!("__pymethod_get_field_{}__", field_index)
-        }
-        PropertyType::Function { spec, .. } => {
-            format_ident!("__pymethod_get_{}__", spec.name)
-        }
-    };
+            let init_holders = holders.init_holders(ctx);
+            let warnings = spec.warnings.build_py_warning(ctx);
+
+            let associated_method = quote! {
+                #cfg_attrs
+                unsafe fn #wrapper_ident(
+                    py: #pyo3_path::Python<'_>,
+                    _slf: *mut #pyo3_path::ffi::PyObject
+                ) -> #pyo3_path::PyResult<*mut #pyo3_path::ffi::PyObject> {
+                    #init_holders
+                    #warnings
+                    let result = #body;
+                    result
+                }
+            };
 
-    let mut cfg_attrs = TokenStream::new();
-    if let PropertyType::Descriptor { field, .. } = &property_type {
-        for attr in field
-            .attrs
-            .iter()
-            .filter(|attr| attr.path().is_ident("cfg"))
-        {
-            attr.to_tokens(&mut cfg_attrs);
-        }
-    }
+            let method_def = quote! {
+                #cfg_attrs
+                #pyo3_path::impl_::pymethods::PyMethodDefType::Getter(
+                    #pyo3_path::impl_::pymethods::PyGetterDef::new(
+                        #python_name,
+                        #cls::#wrapper_ident,
+                        #doc
+                    )
+                )
+            };
 
-    let associated_method = quote! {
-        #cfg_attrs
-        unsafe fn #wrapper_ident(
-            py: _pyo3::Python<'_>,
-            _slf: *mut _pyo3::ffi::PyObject
-        ) -> _pyo3::PyResult<*mut _pyo3::ffi::PyObject> {
-            #( #holders )*
-            #body
+            Ok(MethodAndMethodDef {
+                associated_method,
+                method_def,
+            })
         }
-    };
-
-    let method_def = quote! {
-        #cfg_attrs
-        _pyo3::class::PyMethodDefType::Getter(
-            _pyo3::class::PyGetterDef::new(
-                #python_name,
-                _pyo3::impl_::pymethods::PyGetter(#cls::#wrapper_ident),
-                #doc
-            )
-        )
-    };
-
-    Ok(MethodAndMethodDef {
-        associated_method,
-        method_def,
-    })
+    }
 }
 
 /// Split an argument of pyo3::Python from the front of the arg list, if present
-fn split_off_python_arg<'a>(args: &'a [FnArg<'a>]) -> (Option<&FnArg<'_>>, &[FnArg<'_>]) {
+fn split_off_python_arg<'a, 'b>(args: &'a [FnArg<'b>]) -> (Option<&'a PyArg<'b>>, &'a [FnArg<'b>]) {
     match args {
-        [py, args @ ..] if utils::is_python(py.ty) => (Some(py), args),
+        [FnArg::Py(py), args @ ..] => (Some(py), args),
         args => (None, args),
     }
 }
@@ -742,7 +952,7 @@ pub enum PropertyType<'a> {
 }
 
 impl PropertyType<'_> {
-    fn null_terminated_python_name(&self) -> Result<syn::LitStr> {
+    fn null_terminated_python_name(&self) -> Result<LitCStr> {
         match self {
             PropertyType::Descriptor {
                 field,
@@ -750,42 +960,30 @@ impl PropertyType<'_> {
                 renaming_rule,
                 ..
             } => {
-                let name = match (python_name, &field.ident) {
-                    (Some(name), _) => name.value.0.to_string(),
-                    (None, Some(field_name)) => {
-                        let mut name = field_name.unraw().to_string();
-                        if let Some(rule) = renaming_rule {
-                            name = utils::apply_renaming_rule(*rule, &name);
-                        }
-                        name.push('\0');
-                        name
-                    }
-                    (None, None) => {
-                        bail_spanned!(field.span() => "`get` and `set` with tuple struct fields require `name`");
-                    }
-                };
-                Ok(syn::LitStr::new(&name, field.span()))
+                let name = field_python_name(field, *python_name, *renaming_rule)?;
+                let name = CString::new(name).unwrap();
+                Ok(LitCStr::new(&name, field.span()))
             }
             PropertyType::Function { spec, .. } => Ok(spec.null_terminated_python_name()),
         }
     }
 
-    fn doc(&self) -> Cow<'_, PythonDoc> {
+    fn doc(&self, ctx: &Ctx) -> Result<Cow<'_, PythonDoc>> {
         match self {
             PropertyType::Descriptor { field, .. } => {
-                Cow::Owned(utils::get_doc(&field.attrs, None))
+                utils::get_doc(&field.attrs, None, ctx).map(Cow::Owned)
             }
-            PropertyType::Function { doc, .. } => Cow::Borrowed(doc),
+            PropertyType::Function { doc, .. } => Ok(Cow::Borrowed(doc)),
         }
     }
 }
 
-const __STR__: SlotDef = SlotDef::new("Py_tp_str", "reprfunc");
+pub const __STR__: SlotDef = SlotDef::new("Py_tp_str", "reprfunc");
 pub const __REPR__: SlotDef = SlotDef::new("Py_tp_repr", "reprfunc");
-const __HASH__: SlotDef = SlotDef::new("Py_tp_hash", "hashfunc")
+pub const __HASH__: SlotDef = SlotDef::new("Py_tp_hash", "hashfunc")
     .ret_ty(Ty::PyHashT)
     .return_conversion(TokenGenerator(
-        || quote! { _pyo3::callback::HashCallbackOutput },
+        |Ctx { pyo3_path, .. }: &Ctx| quote! { #pyo3_path::impl_::callback::HashCallbackOutput },
     ));
 pub const __RICHCMP__: SlotDef = SlotDef::new("Py_tp_richcompare", "richcmpfunc")
     .extract_error_mode(ExtractErrorMode::NotImplemented)
@@ -795,16 +993,18 @@ const __GET__: SlotDef = SlotDef::new("Py_tp_descr_get", "descrgetfunc")
 const __ITER__: SlotDef = SlotDef::new("Py_tp_iter", "getiterfunc");
 const __NEXT__: SlotDef = SlotDef::new("Py_tp_iternext", "iternextfunc")
     .return_specialized_conversion(
-        TokenGenerator(|| quote! { IterBaseKind, IterOptionKind, IterResultOptionKind }),
-        TokenGenerator(|| quote! { iter_tag }),
+        TokenGenerator(|_| quote! { IterBaseKind, IterOptionKind, IterResultOptionKind }),
+        TokenGenerator(|_| quote! { iter_tag }),
     );
 const __AWAIT__: SlotDef = SlotDef::new("Py_am_await", "unaryfunc");
 const __AITER__: SlotDef = SlotDef::new("Py_am_aiter", "unaryfunc");
 const __ANEXT__: SlotDef = SlotDef::new("Py_am_anext", "unaryfunc").return_specialized_conversion(
-    TokenGenerator(|| quote! { AsyncIterBaseKind, AsyncIterOptionKind, AsyncIterResultOptionKind }),
-    TokenGenerator(|| quote! { async_iter_tag }),
+    TokenGenerator(
+        |_| quote! { AsyncIterBaseKind, AsyncIterOptionKind, AsyncIterResultOptionKind },
+    ),
+    TokenGenerator(|_| quote! { async_iter_tag }),
 );
-const __LEN__: SlotDef = SlotDef::new("Py_mp_length", "lenfunc").ret_ty(Ty::PySsizeT);
+pub const __LEN__: SlotDef = SlotDef::new("Py_mp_length", "lenfunc").ret_ty(Ty::PySsizeT);
 const __CONTAINS__: SlotDef = SlotDef::new("Py_sq_contains", "objobjproc")
     .arguments(&[Ty::Object])
     .ret_ty(Ty::Int);
@@ -814,7 +1014,8 @@ const __INPLACE_CONCAT__: SlotDef =
     SlotDef::new("Py_sq_concat", "binaryfunc").arguments(&[Ty::Object]);
 const __INPLACE_REPEAT__: SlotDef =
     SlotDef::new("Py_sq_repeat", "ssizeargfunc").arguments(&[Ty::PySsizeT]);
-const __GETITEM__: SlotDef = SlotDef::new("Py_mp_subscript", "binaryfunc").arguments(&[Ty::Object]);
+pub const __GETITEM__: SlotDef =
+    SlotDef::new("Py_mp_subscript", "binaryfunc").arguments(&[Ty::Object]);
 
 const __POS__: SlotDef = SlotDef::new("Py_nb_positive", "unaryfunc");
 const __NEG__: SlotDef = SlotDef::new("Py_nb_negative", "unaryfunc");
@@ -904,16 +1105,21 @@ enum Ty {
 }
 
 impl Ty {
-    fn ffi_type(self) -> TokenStream {
+    fn ffi_type(self, ctx: &Ctx) -> TokenStream {
+        let Ctx {
+            pyo3_path,
+            output_span,
+        } = ctx;
+        let pyo3_path = pyo3_path.to_tokens_spanned(*output_span);
         match self {
-            Ty::Object | Ty::MaybeNullObject => quote! { *mut _pyo3::ffi::PyObject },
-            Ty::NonNullObject => quote! { ::std::ptr::NonNull<_pyo3::ffi::PyObject> },
-            Ty::IPowModulo => quote! { _pyo3::impl_::pymethods::IPowModulo },
-            Ty::Int | Ty::CompareOp => quote! { ::std::os::raw::c_int },
-            Ty::PyHashT => quote! { _pyo3::ffi::Py_hash_t },
-            Ty::PySsizeT => quote! { _pyo3::ffi::Py_ssize_t },
+            Ty::Object | Ty::MaybeNullObject => quote! { *mut #pyo3_path::ffi::PyObject },
+            Ty::NonNullObject => quote! { ::std::ptr::NonNull<#pyo3_path::ffi::PyObject> },
+            Ty::IPowModulo => quote! { #pyo3_path::impl_::pymethods::IPowModulo },
+            Ty::Int | Ty::CompareOp => quote! { ::std::ffi::c_int },
+            Ty::PyHashT => quote! { #pyo3_path::ffi::Py_hash_t },
+            Ty::PySsizeT => quote! { #pyo3_path::ffi::Py_ssize_t },
             Ty::Void => quote! { () },
-            Ty::PyBuffer => quote! { *mut _pyo3::ffi::Py_buffer },
+            Ty::PyBuffer => quote! { *mut #pyo3_path::ffi::Py_buffer },
         }
     }
 
@@ -922,60 +1128,63 @@ impl Ty {
         ident: &syn::Ident,
         arg: &FnArg<'_>,
         extract_error_mode: ExtractErrorMode,
-        holders: &mut Vec<TokenStream>,
+        holders: &mut Holders,
+        ctx: &Ctx,
     ) -> TokenStream {
-        let name_str = arg.name.unraw().to_string();
+        let Ctx { pyo3_path, .. } = ctx;
         match self {
             Ty::Object => extract_object(
                 extract_error_mode,
                 holders,
-                &name_str,
-                quote! {
-                    py.from_borrowed_ptr::<_pyo3::PyAny>(#ident)
-                },
+                arg,
+                format_ident!("ref_from_ptr"),
+                quote! { #ident },
+                ctx
             ),
             Ty::MaybeNullObject => extract_object(
                 extract_error_mode,
                 holders,
-                &name_str,
+                arg,
+                format_ident!("ref_from_ptr"),
                 quote! {
-                    py.from_borrowed_ptr::<_pyo3::PyAny>(
-                        if #ident.is_null() {
-                            _pyo3::ffi::Py_None()
-                        } else {
-                            #ident
-                        }
-                    )
+                    if #ident.is_null() {
+                        #pyo3_path::ffi::Py_None()
+                    } else {
+                        #ident
+                    }
                 },
+                ctx
             ),
             Ty::NonNullObject => extract_object(
                 extract_error_mode,
                 holders,
-                &name_str,
-                quote! {
-                    py.from_borrowed_ptr::<_pyo3::PyAny>(#ident.as_ptr())
-                },
+                arg,
+                format_ident!("ref_from_non_null"),
+                quote! { #ident },
+                ctx
             ),
             Ty::IPowModulo => extract_object(
                 extract_error_mode,
                 holders,
-                &name_str,
-                quote! {
-                    #ident.to_borrowed_any(py)
-                },
+                arg,
+                format_ident!("ref_from_ptr"),
+                quote! { #ident.as_ptr() },
+                ctx
             ),
             Ty::CompareOp => extract_error_mode.handle_error(
                 quote! {
-                    _pyo3::class::basic::CompareOp::from_raw(#ident)
-                        .ok_or_else(|| _pyo3::exceptions::PyValueError::new_err("invalid comparison operator"))
+                    #pyo3_path::class::basic::CompareOp::from_raw(#ident)
+                        .ok_or_else(|| #pyo3_path::exceptions::PyValueError::new_err("invalid comparison operator"))
                 },
+                ctx
             ),
             Ty::PySsizeT => {
-                let ty = arg.ty;
+                let ty = arg.ty();
                 extract_error_mode.handle_error(
                     quote! {
-                            ::std::convert::TryInto::<#ty>::try_into(#ident).map_err(|e| _pyo3::exceptions::PyValueError::new_err(e.to_string()))
+                            ::std::convert::TryInto::<#ty>::try_into(#ident).map_err(|e| #pyo3_path::exceptions::PyValueError::new_err(e.to_string()))
                     },
+                    ctx
                 )
             }
             // Just pass other types through unmodified
@@ -986,22 +1195,46 @@ impl Ty {
 
 fn extract_object(
     extract_error_mode: ExtractErrorMode,
-    holders: &mut Vec<TokenStream>,
-    name: &str,
-    source: TokenStream,
+    holders: &mut Holders,
+    arg: &FnArg<'_>,
+    ref_from_method: Ident,
+    source_ptr: TokenStream,
+    ctx: &Ctx,
 ) -> TokenStream {
-    let holder = syn::Ident::new(&format!("holder_{}", holders.len()), Span::call_site());
-    holders.push(quote! {
-        #[allow(clippy::let_unit_value)]
-        let mut #holder = _pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
-    });
-    extract_error_mode.handle_error(quote! {
-        _pyo3::impl_::extract_argument::extract_argument(
-            #source,
-            &mut #holder,
-            #name
-        )
-    })
+    let Ctx { pyo3_path, .. } = ctx;
+    let name = arg.name().unraw().to_string();
+
+    let extract = if let Some(FromPyWithAttribute {
+        kw,
+        value: extractor,
+    }) = arg.from_py_with()
+    {
+        let extractor = quote_spanned! { kw.span =>
+            { let from_py_with: fn(_) -> _ = #extractor; from_py_with }
+        };
+
+        quote! {
+            #pyo3_path::impl_::extract_argument::from_py_with(
+                unsafe { #pyo3_path::impl_::pymethods::BoundRef::#ref_from_method(py, &#source_ptr).0 },
+                #name,
+                #extractor,
+            )
+        }
+    } else {
+        let holder = holders.push_holder(Span::call_site());
+        quote! {{
+            #[allow(unused_imports)]
+            use #pyo3_path::impl_::pyclass::Probe as _;
+            #pyo3_path::impl_::extract_argument::extract_argument(
+                unsafe { #pyo3_path::impl_::pymethods::BoundRef::#ref_from_method(py, &#source_ptr).0 },
+                &mut #holder,
+                #name
+            )
+        }}
+    };
+
+    let extracted = extract_error_mode.handle_error(extract, ctx);
+    quote!(#extracted)
 }
 
 enum ReturnMode {
@@ -1011,21 +1244,29 @@ enum ReturnMode {
 }
 
 impl ReturnMode {
-    fn return_call_output(&self, call: TokenStream) -> TokenStream {
+    fn return_call_output(&self, call: TokenStream, ctx: &Ctx) -> TokenStream {
+        let Ctx { pyo3_path, .. } = ctx;
         match self {
-            ReturnMode::Conversion(conversion) => quote! {
-                let _result: _pyo3::PyResult<#conversion> = _pyo3::callback::convert(py, #call);
-                _pyo3::callback::convert(py, _result)
-            },
-            ReturnMode::SpecializedConversion(traits, tag) => quote! {
-                let _result = #call;
-                use _pyo3::impl_::pymethods::{#traits};
-                (&_result).#tag().convert(py, _result)
-            },
+            ReturnMode::Conversion(conversion) => {
+                let conversion = TokenGeneratorCtx(*conversion, ctx);
+                quote! {
+                    let _result: #pyo3_path::PyResult<#conversion> = #pyo3_path::impl_::callback::convert(py, #call);
+                    #pyo3_path::impl_::callback::convert(py, _result)
+                }
+            }
+            ReturnMode::SpecializedConversion(traits, tag) => {
+                let traits = TokenGeneratorCtx(*traits, ctx);
+                let tag = TokenGeneratorCtx(*tag, ctx);
+                quote! {
+                    let _result = #call;
+                    use #pyo3_path::impl_::pymethods::{#traits};
+                    (&_result).#tag().convert(py, _result)
+                }
+            }
             ReturnMode::ReturnSelf => quote! {
-                let _result: _pyo3::PyResult<()> = _pyo3::callback::convert(py, #call);
+                let _result: #pyo3_path::PyResult<()> = #pyo3_path::impl_::callback::convert(py, #call);
                 _result?;
-                _pyo3::ffi::Py_XINCREF(_raw_slf);
+                #pyo3_path::ffi::Py_XINCREF(_raw_slf);
                 ::std::result::Result::Ok(_raw_slf)
             },
         }
@@ -1101,7 +1342,9 @@ impl SlotDef {
         cls: &syn::Type,
         spec: &FnSpec<'_>,
         method_name: &str,
+        ctx: &Ctx,
     ) -> Result<MethodAndSlotDef> {
+        let Ctx { pyo3_path, .. } = ctx;
         let SlotDef {
             slot,
             func_ty,
@@ -1117,13 +1360,13 @@ impl SlotDef {
                 spec.name.span() => format!("`{}` must be `unsafe fn`", method_name)
             );
         }
-        let arg_types: &Vec<_> = &arguments.iter().map(|arg| arg.ffi_type()).collect();
+        let arg_types: &Vec<_> = &arguments.iter().map(|arg| arg.ffi_type(ctx)).collect();
         let arg_idents: &Vec<_> = &(0..arguments.len())
             .map(|i| format_ident!("arg{}", i))
             .collect();
         let wrapper_ident = format_ident!("__pymethod_{}__", method_name);
-        let ret_ty = ret_ty.ffi_type();
-        let mut holders = Vec::new();
+        let ret_ty = ret_ty.ffi_type(ctx);
+        let mut holders = Holders::new();
         let body = generate_method_body(
             cls,
             spec,
@@ -1131,36 +1374,39 @@ impl SlotDef {
             *extract_error_mode,
             &mut holders,
             return_mode.as_ref(),
+            ctx,
         )?;
         let name = spec.name;
+        let holders = holders.init_holders(ctx);
         let associated_method = quote! {
+            #[allow(non_snake_case)]
             unsafe fn #wrapper_ident(
-                py: _pyo3::Python<'_>,
-                _raw_slf: *mut _pyo3::ffi::PyObject,
+                py: #pyo3_path::Python<'_>,
+                _raw_slf: *mut #pyo3_path::ffi::PyObject,
                 #(#arg_idents: #arg_types),*
-            ) -> _pyo3::PyResult<#ret_ty> {
+            ) -> #pyo3_path::PyResult<#ret_ty> {
                 let function = #cls::#name; // Shadow the method name to avoid #3017
                 let _slf = _raw_slf;
-                #( #holders )*
+                #holders
                 #body
             }
         };
         let slot_def = quote! {{
             unsafe extern "C" fn trampoline(
-                _slf: *mut _pyo3::ffi::PyObject,
+                _slf: *mut #pyo3_path::ffi::PyObject,
                 #(#arg_idents: #arg_types),*
             ) -> #ret_ty
             {
-                _pyo3::impl_::trampoline:: #func_ty (
+                #pyo3_path::impl_::trampoline:: #func_ty (
                     _slf,
                     #(#arg_idents,)*
                     #cls::#wrapper_ident
                 )
             }
 
-            _pyo3::ffi::PyType_Slot {
-                slot: _pyo3::ffi::#slot,
-                pfunc: trampoline as _pyo3::ffi::#func_ty as _
+            #pyo3_path::ffi::PyType_Slot {
+                slot: #pyo3_path::ffi::#slot,
+                pfunc: trampoline as #pyo3_path::ffi::#func_ty as _
             }
         }};
         Ok(MethodAndSlotDef {
@@ -1175,17 +1421,30 @@ fn generate_method_body(
     spec: &FnSpec<'_>,
     arguments: &[Ty],
     extract_error_mode: ExtractErrorMode,
-    holders: &mut Vec<TokenStream>,
+    holders: &mut Holders,
     return_mode: Option<&ReturnMode>,
+    ctx: &Ctx,
 ) -> Result<TokenStream> {
-    let self_arg = spec.tp.self_arg(Some(cls), extract_error_mode, holders);
+    let Ctx { pyo3_path, .. } = ctx;
+    let self_arg = spec
+        .tp
+        .self_arg(Some(cls), extract_error_mode, holders, ctx);
     let rust_name = spec.name;
-    let args = extract_proto_arguments(spec, arguments, extract_error_mode, holders)?;
+    let args = extract_proto_arguments(spec, arguments, extract_error_mode, holders, ctx)?;
     let call = quote! { #cls::#rust_name(#self_arg #(#args),*) };
-    Ok(if let Some(return_mode) = return_mode {
-        return_mode.return_call_output(call)
+    let body = if let Some(return_mode) = return_mode {
+        return_mode.return_call_output(call, ctx)
     } else {
-        quote! { _pyo3::callback::convert(py, #call) }
+        quote! {
+            let result = #call;
+            #pyo3_path::impl_::callback::convert(py, result)
+        }
+    };
+    let warnings = spec.warnings.build_py_warning(ctx);
+
+    Ok(quote! {
+        #warnings
+        #body
     })
 }
 
@@ -1216,7 +1475,13 @@ impl SlotFragmentDef {
         self
     }
 
-    fn generate_pyproto_fragment(&self, cls: &syn::Type, spec: &FnSpec<'_>) -> Result<TokenStream> {
+    fn generate_pyproto_fragment(
+        &self,
+        cls: &syn::Type,
+        spec: &FnSpec<'_>,
+        ctx: &Ctx,
+    ) -> Result<TokenStream> {
+        let Ctx { pyo3_path, .. } = ctx;
         let SlotFragmentDef {
             fragment,
             arguments,
@@ -1226,11 +1491,11 @@ impl SlotFragmentDef {
         let fragment_trait = format_ident!("PyClass{}SlotFragment", fragment);
         let method = syn::Ident::new(fragment, Span::call_site());
         let wrapper_ident = format_ident!("__pymethod_{}__", fragment);
-        let arg_types: &Vec<_> = &arguments.iter().map(|arg| arg.ffi_type()).collect();
+        let arg_types: &Vec<_> = &arguments.iter().map(|arg| arg.ffi_type(ctx)).collect();
         let arg_idents: &Vec<_> = &(0..arguments.len())
             .map(|i| format_ident!("arg{}", i))
             .collect();
-        let mut holders = Vec::new();
+        let mut holders = Holders::new();
         let body = generate_method_body(
             cls,
             spec,
@@ -1238,29 +1503,33 @@ impl SlotFragmentDef {
             *extract_error_mode,
             &mut holders,
             None,
+            ctx,
         )?;
-        let ret_ty = ret_ty.ffi_type();
+        let ret_ty = ret_ty.ffi_type(ctx);
+        let holders = holders.init_holders(ctx);
         Ok(quote! {
-            impl _pyo3::impl_::pyclass::#fragment_trait<#cls> for _pyo3::impl_::pyclass::PyClassImplCollector<#cls> {
+            impl #cls {
+                #[allow(non_snake_case)]
+                unsafe fn #wrapper_ident(
+                    py: #pyo3_path::Python,
+                    _raw_slf: *mut #pyo3_path::ffi::PyObject,
+                    #(#arg_idents: #arg_types),*
+                ) -> #pyo3_path::PyResult<#ret_ty> {
+                    let _slf = _raw_slf;
+                    #holders
+                    #body
+                }
+            }
+
+            impl #pyo3_path::impl_::pyclass::#fragment_trait<#cls> for #pyo3_path::impl_::pyclass::PyClassImplCollector<#cls> {
 
                 #[inline]
                 unsafe fn #method(
                     self,
-                    py: _pyo3::Python,
-                    _raw_slf: *mut _pyo3::ffi::PyObject,
+                    py: #pyo3_path::Python,
+                    _raw_slf: *mut #pyo3_path::ffi::PyObject,
                     #(#arg_idents: #arg_types),*
-                ) -> _pyo3::PyResult<#ret_ty> {
-                    impl #cls {
-                        unsafe fn #wrapper_ident(
-                            py: _pyo3::Python,
-                            _raw_slf: *mut _pyo3::ffi::PyObject,
-                            #(#arg_idents: #arg_types),*
-                        ) -> _pyo3::PyResult<#ret_ty> {
-                            let _slf = _raw_slf;
-                            #( #holders )*
-                            #body
-                        }
-                    }
+                ) -> #pyo3_path::PyResult<#ret_ty> {
                     #cls::#wrapper_ident(py, _raw_slf, #(#arg_idents),*)
                 }
             }
@@ -1346,19 +1615,20 @@ fn extract_proto_arguments(
     spec: &FnSpec<'_>,
     proto_args: &[Ty],
     extract_error_mode: ExtractErrorMode,
-    holders: &mut Vec<TokenStream>,
+    holders: &mut Holders,
+    ctx: &Ctx,
 ) -> Result<Vec<TokenStream>> {
     let mut args = Vec::with_capacity(spec.signature.arguments.len());
     let mut non_python_args = 0;
 
     for arg in &spec.signature.arguments {
-        if arg.py {
+        if let FnArg::Py(..) = arg {
             args.push(quote! { py });
         } else {
-            let ident = syn::Ident::new(&format!("arg{}", non_python_args), Span::call_site());
+            let ident = syn::Ident::new(&format!("arg{non_python_args}"), Span::call_site());
             let conversions = proto_args.get(non_python_args)
-                .ok_or_else(|| err_spanned!(arg.ty.span() => format!("Expected at most {} non-python arguments", proto_args.len())))?
-                .extract(&ident, arg, extract_error_mode, holders);
+                .ok_or_else(|| err_spanned!(arg.ty().span() => format!("Expected at most {} non-python arguments", proto_args.len())))?
+                .extract(&ident, arg, extract_error_mode, holders, ctx);
             non_python_args += 1;
             args.push(conversions);
         }
@@ -1378,10 +1648,32 @@ impl ToTokens for StaticIdent {
     }
 }
 
-struct TokenGenerator(fn() -> TokenStream);
+#[derive(Clone, Copy)]
+struct TokenGenerator(fn(&Ctx) -> TokenStream);
+
+struct TokenGeneratorCtx<'ctx>(TokenGenerator, &'ctx Ctx);
 
-impl ToTokens for TokenGenerator {
+impl ToTokens for TokenGeneratorCtx<'_> {
     fn to_tokens(&self, tokens: &mut TokenStream) {
-        self.0().to_tokens(tokens)
+        let Self(TokenGenerator(gen), ctx) = self;
+        (gen)(ctx).to_tokens(tokens)
+    }
+}
+
+pub fn field_python_name(
+    field: &Field,
+    name_attr: Option<&NameAttribute>,
+    renaming_rule: Option<RenamingRule>,
+) -> Result<String> {
+    if let Some(name_attr) = name_attr {
+        return Ok(name_attr.value.0.to_string());
+    }
+    let Some(ident) = &field.ident else {
+        bail_spanned!(field.span() => "`get` and `set` with tuple struct fields require `name`");
+    };
+    let mut name = ident.unraw().to_string();
+    if let Some(rule) = renaming_rule {
+        name = utils::apply_renaming_rule(rule, &name);
     }
+    Ok(name)
 }
diff --git a/pyo3-macros-backend/src/pyversions.rs b/pyo3-macros-backend/src/pyversions.rs
new file mode 100644
index 00000000000..3c5ac47fb84
--- /dev/null
+++ b/pyo3-macros-backend/src/pyversions.rs
@@ -0,0 +1,11 @@
+use pyo3_build_config::PythonVersion;
+
+pub fn is_abi3_before(major: u8, minor: u8) -> bool {
+    let config = pyo3_build_config::get();
+    config.abi3 && !config.is_free_threaded() && config.version < PythonVersion { major, minor }
+}
+
+pub fn is_py_before(major: u8, minor: u8) -> bool {
+    let config = pyo3_build_config::get();
+    config.version < PythonVersion { major, minor }
+}
diff --git a/pyo3-macros-backend/src/quotes.rs b/pyo3-macros-backend/src/quotes.rs
index 239036ef3ca..d961b4c0acd 100644
--- a/pyo3-macros-backend/src/quotes.rs
+++ b/pyo3-macros-backend/src/quotes.rs
@@ -1,21 +1,36 @@
+use crate::utils::Ctx;
 use proc_macro2::TokenStream;
-use quote::quote;
+use quote::{quote, quote_spanned};
 
-pub(crate) fn some_wrap(obj: TokenStream) -> TokenStream {
+pub(crate) fn some_wrap(obj: TokenStream, ctx: &Ctx) -> TokenStream {
+    let Ctx { pyo3_path, .. } = ctx;
     quote! {
-        _pyo3::impl_::wrap::SomeWrap::wrap(#obj)
+        #pyo3_path::impl_::wrap::SomeWrap::wrap(#obj)
     }
 }
 
-pub(crate) fn ok_wrap(obj: TokenStream) -> TokenStream {
-    quote! {
-        _pyo3::impl_::wrap::OkWrap::wrap(#obj)
-            .map_err(::core::convert::Into::<_pyo3::PyErr>::into)
-    }
+pub(crate) fn ok_wrap(obj: TokenStream, ctx: &Ctx) -> TokenStream {
+    let Ctx {
+        pyo3_path,
+        output_span,
+    } = ctx;
+    let pyo3_path = pyo3_path.to_tokens_spanned(*output_span);
+    quote_spanned! { *output_span => {
+        let obj = #obj;
+        #[allow(clippy::useless_conversion)]
+        #pyo3_path::impl_::wrap::converter(&obj).wrap(obj).map_err(::core::convert::Into::<#pyo3_path::PyErr>::into)
+    }}
 }
 
-pub(crate) fn map_result_into_ptr(result: TokenStream) -> TokenStream {
-    quote! {
-        _pyo3::impl_::wrap::map_result_into_ptr(py, #result)
-    }
+pub(crate) fn map_result_into_ptr(result: TokenStream, ctx: &Ctx) -> TokenStream {
+    let Ctx {
+        pyo3_path,
+        output_span,
+    } = ctx;
+    let pyo3_path = pyo3_path.to_tokens_spanned(*output_span);
+    let py = syn::Ident::new("py", proc_macro2::Span::call_site());
+    quote_spanned! { *output_span => {
+        let result = #result;
+        #pyo3_path::impl_::wrap::converter(&result).map_into_ptr(#py, result)
+    }}
 }
diff --git a/pyo3-macros-backend/src/utils.rs b/pyo3-macros-backend/src/utils.rs
index 9f0f2678476..81228cd8b69 100644
--- a/pyo3-macros-backend/src/utils.rs
+++ b/pyo3-macros-backend/src/utils.rs
@@ -1,9 +1,11 @@
+use crate::attributes::{CrateAttribute, RenamingRule};
 use proc_macro2::{Span, TokenStream};
-use quote::ToTokens;
+use quote::{quote, quote_spanned, ToTokens};
+use std::ffi::CString;
+use syn::spanned::Spanned;
+use syn::LitCStr;
 use syn::{punctuated::Punctuated, Token};
 
-use crate::attributes::{CrateAttribute, RenamingRule};
-
 /// Macro inspired by `anyhow::anyhow!` to create a compiler error with the given span.
 macro_rules! err_spanned {
     ($span:expr => $msg:expr) => {
@@ -25,7 +27,20 @@ macro_rules! ensure_spanned {
         if !($condition) {
             bail_spanned!($span => $msg);
         }
-    }
+    };
+    ($($condition:expr, $span:expr => $msg:expr;)*) => {
+        if let Some(e) = [$(
+            (!($condition)).then(|| err_spanned!($span => $msg)),
+        )*]
+            .into_iter()
+            .flatten()
+            .reduce(|mut acc, e| {
+                acc.combine(e);
+                acc
+            }) {
+                return Err(e);
+            }
+    };
 }
 
 /// Check if the given type `ty` is `pyo3::Python`.
@@ -58,17 +73,29 @@ pub fn option_type_argument(ty: &syn::Type) -> Option<&syn::Type> {
 ///
 /// Typically the tokens will just be that string, but if the original docs included macro
 /// expressions then the tokens will be a concat!("...", "\n", "\0") expression of the strings and
-/// macro parts.
-/// contents such as parse the string contents.
+/// macro parts. contents such as parse the string contents.
+#[derive(Clone)]
+pub struct PythonDoc(PythonDocKind);
+
 #[derive(Clone)]
-pub struct PythonDoc(TokenStream);
+enum PythonDocKind {
+    LitCStr(LitCStr),
+    // There is currently no way to `concat!` c-string literals, we fallback to the `c_str!` macro in
+    // this case.
+    Tokens(TokenStream),
+}
 
 /// Collects all #[doc = "..."] attributes into a TokenStream evaluating to a null-terminated string.
 ///
 /// If this doc is for a callable, the provided `text_signature` can be passed to prepend
 /// this to the documentation suitable for Python to extract this into the `__text_signature__`
 /// attribute.
-pub fn get_doc(attrs: &[syn::Attribute], mut text_signature: Option<String>) -> PythonDoc {
+pub fn get_doc(
+    attrs: &[syn::Attribute],
+    mut text_signature: Option<String>,
+    ctx: &Ctx,
+) -> syn::Result<PythonDoc> {
+    let Ctx { pyo3_path, .. } = ctx;
     // insert special divider between `__text_signature__` and doc
     // (assume text_signature is itself well-formed)
     if let Some(text_signature) = &mut text_signature {
@@ -78,10 +105,15 @@ pub fn get_doc(attrs: &[syn::Attribute], mut text_signature: Option<String>) ->
     let mut parts = Punctuated::<TokenStream, Token![,]>::new();
     let mut first = true;
     let mut current_part = text_signature.unwrap_or_default();
+    let mut current_part_span = None;
 
     for attr in attrs {
         if attr.path().is_ident("doc") {
             if let Ok(nv) = attr.meta.require_name_value() {
+                current_part_span = match current_part_span {
+                    None => Some(nv.value.span()),
+                    Some(span) => span.join(nv.value.span()),
+                };
                 if !first {
                     current_part.push('\n');
                 } else {
@@ -99,7 +131,7 @@ pub fn get_doc(attrs: &[syn::Attribute], mut text_signature: Option<String>) ->
                 } else {
                     // This is probably a macro doc from Rust 1.54, e.g. #[doc = include_str!(...)]
                     // Reset the string buffer, write that part, and then push this macro part too.
-                    parts.push(current_part.to_token_stream());
+                    parts.push(quote_spanned!(current_part_span.unwrap_or(Span::call_site()) => #current_part));
                     current_part.clear();
                     parts.push(nv.value.to_token_stream());
                 }
@@ -110,7 +142,9 @@ pub fn get_doc(attrs: &[syn::Attribute], mut text_signature: Option<String>) ->
     if !parts.is_empty() {
         // Doc contained macro pieces - return as `concat!` expression
         if !current_part.is_empty() {
-            parts.push(current_part.to_token_stream());
+            parts.push(
+                quote_spanned!(current_part_span.unwrap_or(Span::call_site()) => #current_part),
+            );
         }
 
         let mut tokens = TokenStream::new();
@@ -120,20 +154,35 @@ pub fn get_doc(attrs: &[syn::Attribute], mut text_signature: Option<String>) ->
         syn::token::Bracket(Span::call_site()).surround(&mut tokens, |tokens| {
             parts.to_tokens(tokens);
             syn::token::Comma(Span::call_site()).to_tokens(tokens);
-            syn::LitStr::new("\0", Span::call_site()).to_tokens(tokens);
         });
 
-        PythonDoc(tokens)
+        Ok(PythonDoc(PythonDocKind::Tokens(
+            quote!(#pyo3_path::ffi::c_str!(#tokens)),
+        )))
     } else {
         // Just a string doc - return directly with nul terminator
-        current_part.push('\0');
-        PythonDoc(current_part.to_token_stream())
+        let docs = CString::new(current_part).map_err(|e| {
+            syn::Error::new(
+                current_part_span.unwrap_or(Span::call_site()),
+                format!(
+                    "Python doc may not contain nul byte, found nul at position {}",
+                    e.nul_position()
+                ),
+            )
+        })?;
+        Ok(PythonDoc(PythonDocKind::LitCStr(LitCStr::new(
+            &docs,
+            current_part_span.unwrap_or(Span::call_site()),
+        ))))
     }
 }
 
 impl quote::ToTokens for PythonDoc {
     fn to_tokens(&self, tokens: &mut TokenStream) {
-        self.0.to_tokens(tokens)
+        match &self.0 {
+            PythonDocKind::LitCStr(lit) => lit.to_tokens(tokens),
+            PythonDocKind::Tokens(toks) => toks.to_tokens(tokens),
+        }
     }
 }
 
@@ -144,11 +193,60 @@ pub fn unwrap_ty_group(mut ty: &syn::Type) -> &syn::Type {
     ty
 }
 
-/// Extract the path to the pyo3 crate, or use the default (`::pyo3`).
-pub(crate) fn get_pyo3_crate(attr: &Option<CrateAttribute>) -> syn::Path {
-    match attr {
-        Some(attr) => attr.value.0.clone(),
-        None => syn::parse_str("::pyo3").unwrap(),
+pub struct Ctx {
+    /// Where we can find the pyo3 crate
+    pub pyo3_path: PyO3CratePath,
+
+    /// If we are in a pymethod or pyfunction,
+    /// this will be the span of the return type
+    pub output_span: Span,
+}
+
+impl Ctx {
+    pub(crate) fn new(attr: &Option<CrateAttribute>, signature: Option<&syn::Signature>) -> Self {
+        let pyo3_path = match attr {
+            Some(attr) => PyO3CratePath::Given(attr.value.0.clone()),
+            None => PyO3CratePath::Default,
+        };
+
+        let output_span = if let Some(syn::Signature {
+            output: syn::ReturnType::Type(_, output_type),
+            ..
+        }) = &signature
+        {
+            output_type.span()
+        } else {
+            Span::call_site()
+        };
+
+        Self {
+            pyo3_path,
+            output_span,
+        }
+    }
+}
+
+#[derive(Clone)]
+pub enum PyO3CratePath {
+    Given(syn::Path),
+    Default,
+}
+
+impl PyO3CratePath {
+    pub fn to_tokens_spanned(&self, span: Span) -> TokenStream {
+        match self {
+            Self::Given(path) => quote::quote_spanned! { span => #path },
+            Self::Default => quote::quote_spanned! {  span => ::pyo3 },
+        }
+    }
+}
+
+impl quote::ToTokens for PyO3CratePath {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
+        match self {
+            Self::Given(path) => path.to_tokens(tokens),
+            Self::Default => quote::quote! { ::pyo3 }.to_tokens(tokens),
+        }
     }
 }
 
@@ -167,6 +265,66 @@ pub fn apply_renaming_rule(rule: RenamingRule, name: &str) -> String {
     }
 }
 
-pub(crate) fn is_abi3() -> bool {
-    pyo3_build_config::get().abi3
+pub(crate) enum IdentOrStr<'a> {
+    Str(&'a str),
+    Ident(syn::Ident),
+}
+
+pub(crate) fn has_attribute(attrs: &[syn::Attribute], ident: &str) -> bool {
+    has_attribute_with_namespace(attrs, None, &[ident])
+}
+
+pub(crate) fn has_attribute_with_namespace(
+    attrs: &[syn::Attribute],
+    crate_path: Option<&PyO3CratePath>,
+    idents: &[&str],
+) -> bool {
+    let mut segments = vec![];
+    if let Some(c) = crate_path {
+        match c {
+            PyO3CratePath::Given(paths) => {
+                for p in &paths.segments {
+                    segments.push(IdentOrStr::Ident(p.ident.clone()));
+                }
+            }
+            PyO3CratePath::Default => segments.push(IdentOrStr::Str("pyo3")),
+        }
+    };
+    for i in idents {
+        segments.push(IdentOrStr::Str(i));
+    }
+
+    attrs.iter().any(|attr| {
+        segments
+            .iter()
+            .eq(attr.path().segments.iter().map(|v| &v.ident))
+    })
+}
+
+pub fn expr_to_python(expr: &syn::Expr) -> String {
+    match expr {
+        // literal values
+        syn::Expr::Lit(syn::ExprLit { lit, .. }) => match lit {
+            syn::Lit::Str(s) => s.token().to_string(),
+            syn::Lit::Char(c) => c.token().to_string(),
+            syn::Lit::Int(i) => i.base10_digits().to_string(),
+            syn::Lit::Float(f) => f.base10_digits().to_string(),
+            syn::Lit::Bool(b) => {
+                if b.value() {
+                    "True".to_string()
+                } else {
+                    "False".to_string()
+                }
+            }
+            _ => "...".to_string(),
+        },
+        // None
+        syn::Expr::Path(syn::ExprPath { qself, path, .. })
+            if qself.is_none() && path.is_ident("None") =>
+        {
+            "None".to_string()
+        }
+        // others, unsupported yet so defaults to `...`
+        _ => "...".to_string(),
+    }
 }
diff --git a/pyo3-macros/Cargo.toml b/pyo3-macros/Cargo.toml
index 576c94a2bc1..604a5bbaac7 100644
--- a/pyo3-macros/Cargo.toml
+++ b/pyo3-macros/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "pyo3-macros"
-version = "0.21.0-dev"
+version = "0.27.0"
 description = "Proc macros for PyO3 package"
 authors = ["PyO3 Project and Contributors <https://github.com/PyO3>"]
 keywords = ["pyo3", "python", "cpython", "ffi"]
@@ -9,18 +9,21 @@ repository = "https://github.com/pyo3/pyo3"
 categories = ["api-bindings", "development-tools::ffi"]
 license = "MIT OR Apache-2.0"
 edition = "2021"
+rust-version.workspace = true
 
 [lib]
 proc-macro = true
 
 [features]
 multiple-pymethods = []
+experimental-async = ["pyo3-macros-backend/experimental-async"]
+experimental-inspect = ["pyo3-macros-backend/experimental-inspect"]
 
 [dependencies]
-proc-macro2 = { version = "1", default-features = false }
+proc-macro2 = { version = "1.0.60", default-features = false }
 quote = "1"
 syn = { version = "2", features = ["full", "extra-traits"] }
-pyo3-macros-backend = { path = "../pyo3-macros-backend", version = "=0.21.0-dev" }
+pyo3-macros-backend = { path = "../pyo3-macros-backend", version = "=0.27.0" }
 
 [lints]
 workspace = true
diff --git a/pyo3-macros/src/lib.rs b/pyo3-macros/src/lib.rs
index d00ede89143..6e4a46ee95e 100644
--- a/pyo3-macros/src/lib.rs
+++ b/pyo3-macros/src/lib.rs
@@ -1,16 +1,16 @@
 //! This crate declares only the proc macro attributes, as a crate defining proc macro attributes
 //! must not contain any other public items.
 
-#![cfg_attr(docsrs, feature(doc_cfg, doc_auto_cfg))]
+#![cfg_attr(docsrs, feature(doc_cfg))]
 use proc_macro::TokenStream;
 use proc_macro2::TokenStream as TokenStream2;
 use pyo3_macros_backend::{
-    build_derive_from_pyobject, build_py_class, build_py_enum, build_py_function, build_py_methods,
-    get_doc, process_functions_in_module, pymodule_impl, PyClassArgs, PyClassMethodsType,
-    PyFunctionOptions, PyModuleOptions,
+    build_derive_from_pyobject, build_derive_into_pyobject, build_py_class, build_py_enum,
+    build_py_function, build_py_methods, pymodule_function_impl, pymodule_module_impl, PyClassArgs,
+    PyClassMethodsType, PyFunctionOptions, PyModuleOptions,
 };
 use quote::quote;
-use syn::{parse::Nothing, parse_macro_input};
+use syn::{parse_macro_input, Item};
 
 /// A proc macro used to implement Python modules.
 ///
@@ -24,6 +24,9 @@ use syn::{parse::Nothing, parse_macro_input};
 /// |  Annotation  |  Description |
 /// | :-  | :- |
 /// | `#[pyo3(name = "...")]` | Defines the name of the module in Python. |
+/// | `#[pyo3(submodule)]`    | Skips adding a `PyInit_` FFI symbol to the compiled binary. |
+/// | `#[pyo3(module = "...")]` | Defines the Python `dotted.path` to the parent module for use in introspection. |
+/// | `#[pyo3(crate = "pyo3")]` | Defines the path to PyO3 to use code generated by the macro. |
 ///
 /// For more on creating Python modules see the [module section of the guide][1].
 ///
@@ -32,24 +35,27 @@ use syn::{parse::Nothing, parse_macro_input};
 /// `#[pymodule]` implementation generates a hidden module with the same name containing
 /// metadata about the module, which is used by `wrap_pymodule!`).
 ///
-/// [1]: https://pyo3.rs/latest/module.html
+#[doc = concat!("[1]: https://pyo3.rs/v", env!("CARGO_PKG_VERSION"), "/module.html")]
 #[proc_macro_attribute]
 pub fn pymodule(args: TokenStream, input: TokenStream) -> TokenStream {
-    parse_macro_input!(args as Nothing);
-
-    let mut ast = parse_macro_input!(input as syn::ItemFn);
-    let options = match PyModuleOptions::from_attrs(&mut ast.attrs) {
-        Ok(options) => options,
-        Err(e) => return e.into_compile_error().into(),
-    };
-
-    if let Err(err) = process_functions_in_module(&options, &mut ast) {
-        return err.into_compile_error().into();
+    let options = parse_macro_input!(args as PyModuleOptions);
+
+    let mut ast = parse_macro_input!(input as Item);
+    let expanded = match &mut ast {
+        Item::Mod(module) => {
+            match pymodule_module_impl(module, options) {
+                // #[pymodule] on a module will rebuild the original ast, so we don't emit it here
+                Ok(expanded) => return expanded.into(),
+                Err(e) => Err(e),
+            }
+        }
+        Item::Fn(function) => pymodule_function_impl(function, options),
+        unsupported => Err(syn::Error::new_spanned(
+            unsupported,
+            "#[pymodule] only supports modules and functions.",
+        )),
     }
-
-    let doc = get_doc(&ast.attrs, None);
-
-    let expanded = pymodule_impl(&ast.sig.ident, options, doc, &ast.vis);
+    .unwrap_or_compile_error();
 
     quote!(
         #ast
@@ -60,7 +66,6 @@ pub fn pymodule(args: TokenStream, input: TokenStream) -> TokenStream {
 
 #[proc_macro_attribute]
 pub fn pyclass(attr: TokenStream, input: TokenStream) -> TokenStream {
-    use syn::Item;
     let item = parse_macro_input!(input as Item);
     match item {
         Item::Struct(struct_) => pyclass_impl(attr, struct_, methods_type()),
@@ -80,12 +85,12 @@ pub fn pyclass(attr: TokenStream, input: TokenStream) -> TokenStream {
 /// |  Annotation  |  Description |
 /// | :-  | :- |
 /// | [`#[new]`][4]  | Defines the class constructor, like Python's `__new__` method. |
-/// | [`#[getter]`][5] and [`#[setter]`][5] | These define getters and setters, similar to Python's `@property` decorator. This is useful for getters/setters that require computation or side effects; if that is not the case consider using [`#[pyo3(get, set)]`][11] on the struct's field(s).|
+/// | [`#[getter]`][5] and [`#[setter]`][5] | These define getters and setters, similar to Python's `@property` decorator. This is useful for getters/setters that require computation or side effects; if that is not the case consider using [`#[pyo3(get, set)]`][12] on the struct's field(s).|
 /// | [`#[staticmethod]`][6]| Defines the method as a staticmethod, like Python's `@staticmethod` decorator.|
 /// | [`#[classmethod]`][7]  | Defines the method as a classmethod, like Python's `@classmethod` decorator.|
 /// | [`#[classattr]`][9]  | Defines a class variable. |
 /// | [`#[args]`][10]  | Deprecated way to define a method's default arguments and allows the function to receive `*args` and `**kwargs`. Use `#[pyo3(signature = (...))]` instead. |
-/// | <nobr>[`#[pyo3(<option> = <value>)`][pyo3-method-options]</nobr> | Any of the `#[pyo3]` options supported on [`macro@pyfunction`]. |
+/// | <nobr>[`#[pyo3(<option> = <value>)`][11]</nobr> | Any of the `#[pyo3]` options supported on [`macro@pyfunction`]. |
 ///
 /// For more on creating class methods,
 /// see the [class section of the guide][1].
@@ -94,17 +99,18 @@ pub fn pyclass(attr: TokenStream, input: TokenStream) -> TokenStream {
 /// multiple `#[pymethods]` blocks for a single `#[pyclass]`.
 /// This will add a transitive dependency on the [`inventory`][3] crate.
 ///
-/// [1]: https://pyo3.rs/latest/class.html#instance-methods
-/// [2]: https://pyo3.rs/latest/features.html#multiple-pymethods
+#[doc = concat!("[1]: https://pyo3.rs/v", env!("CARGO_PKG_VERSION"), "/class.html#instance-methods")]
+#[doc = concat!("[2]: https://pyo3.rs/v", env!("CARGO_PKG_VERSION"), "/features.html#multiple-pymethods")]
 /// [3]: https://docs.rs/inventory/
-/// [4]: https://pyo3.rs/latest/class.html#constructor
-/// [5]: https://pyo3.rs/latest/class.html#object-properties-using-getter-and-setter
-/// [6]: https://pyo3.rs/latest/class.html#static-methods
-/// [7]: https://pyo3.rs/latest/class.html#class-methods
-/// [8]: https://pyo3.rs/latest/class.html#callable-objects
-/// [9]: https://pyo3.rs/latest/class.html#class-attributes
-/// [10]: https://pyo3.rs/latest/class.html#method-arguments
-/// [11]: https://pyo3.rs/latest/class.html#object-properties-using-pyo3get-set
+#[doc = concat!("[4]: https://pyo3.rs/v", env!("CARGO_PKG_VERSION"), "/class.html#constructor")]
+#[doc = concat!("[5]: https://pyo3.rs/v", env!("CARGO_PKG_VERSION"), "/class.html#object-properties-using-getter-and-setter")]
+#[doc = concat!("[6]: https://pyo3.rs/v", env!("CARGO_PKG_VERSION"), "/class.html#static-methods")]
+#[doc = concat!("[7]: https://pyo3.rs/v", env!("CARGO_PKG_VERSION"), "/class.html#class-methods")]
+#[doc = concat!("[8]: https://pyo3.rs/v", env!("CARGO_PKG_VERSION"), "/class.html#callable-objects")]
+#[doc = concat!("[9]: https://pyo3.rs/v", env!("CARGO_PKG_VERSION"), "/class.html#class-attributes")]
+#[doc = concat!("[10]: https://pyo3.rs/v", env!("CARGO_PKG_VERSION"), "/class.html#method-arguments")]
+#[doc = concat!("[11]: https://pyo3.rs/v", env!("CARGO_PKG_VERSION"), "/function.html#function-options")]
+#[doc = concat!("[12]: https://pyo3.rs/v", env!("CARGO_PKG_VERSION"), "/class.html#object-properties-using-pyo3get-set")]
 #[proc_macro_attribute]
 pub fn pymethods(attr: TokenStream, input: TokenStream) -> TokenStream {
     let methods_type = if cfg!(feature = "multiple-pymethods") {
@@ -125,6 +131,7 @@ pub fn pymethods(attr: TokenStream, input: TokenStream) -> TokenStream {
 /// | `#[pyo3(name = "...")]` | Defines the name of the function in Python. |
 /// | `#[pyo3(text_signature = "...")]` | Defines the `__text_signature__` attribute of the function in Python. |
 /// | `#[pyo3(pass_module)]` | Passes the module containing the function as a `&PyModule` first argument to the function. |
+/// | `#[pyo3(warn(message = "...", category = ...))]` | Generate warning given a message and a category |
 ///
 /// For more on exposing functions see the [function section of the guide][1].
 ///
@@ -133,7 +140,7 @@ pub fn pymethods(attr: TokenStream, input: TokenStream) -> TokenStream {
 /// `#[pyfunction]` implementation generates a hidden module with the same name containing
 /// metadata about the function, which is used by `wrap_pyfunction!`).
 ///
-/// [1]: https://pyo3.rs/latest/function.html
+#[doc = concat!("[1]: https://pyo3.rs/v", env!("CARGO_PKG_VERSION"), "/function.html")]
 #[proc_macro_attribute]
 pub fn pyfunction(attr: TokenStream, input: TokenStream) -> TokenStream {
     let mut ast = parse_macro_input!(input as syn::ItemFn);
@@ -148,6 +155,27 @@ pub fn pyfunction(attr: TokenStream, input: TokenStream) -> TokenStream {
     .into()
 }
 
+#[proc_macro_derive(IntoPyObject, attributes(pyo3))]
+pub fn derive_into_py_object(item: TokenStream) -> TokenStream {
+    let ast = parse_macro_input!(item as syn::DeriveInput);
+    let expanded = build_derive_into_pyobject::<false>(&ast).unwrap_or_compile_error();
+    quote!(
+        #expanded
+    )
+    .into()
+}
+
+#[proc_macro_derive(IntoPyObjectRef, attributes(pyo3))]
+pub fn derive_into_py_object_ref(item: TokenStream) -> TokenStream {
+    let ast = parse_macro_input!(item as syn::DeriveInput);
+    let expanded =
+        pyo3_macros_backend::build_derive_into_pyobject::<true>(&ast).unwrap_or_compile_error();
+    quote!(
+        #expanded
+    )
+    .into()
+}
+
 #[proc_macro_derive(FromPyObject, attributes(pyo3))]
 pub fn derive_from_py_object(item: TokenStream) -> TokenStream {
     let ast = parse_macro_input!(item as syn::DeriveInput);
@@ -163,7 +191,7 @@ fn pyclass_impl(
     mut ast: syn::ItemStruct,
     methods_type: PyClassMethodsType,
 ) -> TokenStream {
-    let args = parse_macro_input!(attrs with PyClassArgs::parse_stuct_args);
+    let args = parse_macro_input!(attrs with PyClassArgs::parse_struct_args);
     let expanded = build_py_class(&mut ast, args, methods_type).unwrap_or_compile_error();
 
     quote!(
diff --git a/pyproject.toml b/pyproject.toml
index 866645d2ffc..2b9915ffb45 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,9 +1,9 @@
-[tool.ruff.extend-per-file-ignores]
+[tool.ruff.lint.extend-per-file-ignores]
 "__init__.py" = ["F403"]
 
 [tool.towncrier]
 filename = "CHANGELOG.md"
-version = "0.21.0-dev"
+version = "0.27.0"
 start_string = "<!-- towncrier release notes start -->\n"
 template = ".towncrier.template.md"
 title_format = "## [{version}] - {project_date}"
@@ -24,3 +24,32 @@ name = "Removed"
 
 [tool.towncrier.fragment.fixed]
 name = "Fixed"
+
+[tool.rumdl]
+
+disable = [
+    # TODO: what to do about inline HTML, probably allow?
+    "MD033",
+    # TODO: {{#PYO3_DOCS_URL}} placeholder confuses rumdl, change syntax perhaps?
+    "MD051"
+]
+
+exclude = [
+    # just has an include to the top-level files
+    "guide/src/changelog.md",
+    "guide/src/contributing.md"
+]
+
+[tool.rumdl.per-file-ignores]
+"guide/pyclass-parameters.md" = ["MD041"]
+
+[tool.rumdl.MD004]
+style = "dash"
+
+[tool.rumdl.MD013]
+paragraphs = false
+code_blocks = false
+tables = false
+headings = false
+reflow = true
+reflow_mode = "sentence-per-line"
diff --git a/pytests/Cargo.toml b/pytests/Cargo.toml
index 255094a6c40..152500792df 100644
--- a/pytests/Cargo.toml
+++ b/pytests/Cargo.toml
@@ -5,9 +5,13 @@ version = "0.1.0"
 description = "Python-based tests for PyO3"
 edition = "2021"
 publish = false
+rust-version = "1.83"
+
+[features]
+experimental-inspect = ["pyo3/experimental-inspect"]
 
 [dependencies]
-pyo3 = { path = "../", features = ["extension-module"] }
+pyo3.path = "../"
 
 [build-dependencies]
 pyo3-build-config = { path = "../pyo3-build-config" }
diff --git a/pytests/README.md b/pytests/README.md
index 7ced072aa36..1016baa7209 100644
--- a/pytests/README.md
+++ b/pytests/README.md
@@ -2,6 +2,9 @@
 
 An extension module built using PyO3, used to test and benchmark PyO3 from Python.
 
+The `stubs` directory contains Python stubs used to test the automated stubs introspection.
+To test them run `nox -s test-introspection`.
+
 ## Testing
 
 This package is intended to be built using `maturin`. Once built, you can run the tests using `pytest`:
diff --git a/pytests/conftest.py b/pytests/conftest.py
new file mode 100644
index 00000000000..ce729689355
--- /dev/null
+++ b/pytests/conftest.py
@@ -0,0 +1,22 @@
+import sysconfig
+import sys
+import pytest
+
+FREE_THREADED_BUILD = bool(sysconfig.get_config_var("Py_GIL_DISABLED"))
+
+gil_enabled_at_start = True
+if FREE_THREADED_BUILD:
+    gil_enabled_at_start = sys._is_gil_enabled()
+
+
+def pytest_terminal_summary(terminalreporter, exitstatus, config):
+    if FREE_THREADED_BUILD and not gil_enabled_at_start and sys._is_gil_enabled():
+        tr = terminalreporter
+        tr.ensure_newline()
+        tr.section("GIL re-enabled", sep="=", red=True, bold=True)
+        tr.line("The GIL was re-enabled at runtime during the tests.")
+        tr.line("")
+        tr.line("Please ensure all new modules declare support for running")
+        tr.line("without the GIL. Any new tests that intentionally imports ")
+        tr.line("code that re-enables the GIL should do so in a subprocess.")
+        pytest.exit("GIL re-enabled during tests", returncode=1)
diff --git a/pytests/noxfile.py b/pytests/noxfile.py
index 7c681ab1aa8..2bc9c0366d1 100644
--- a/pytests/noxfile.py
+++ b/pytests/noxfile.py
@@ -8,12 +8,20 @@
 @nox.session
 def test(session: nox.Session):
     session.env["MATURIN_PEP517_ARGS"] = "--profile=dev"
-    session.run_always("python", "-m", "pip", "install", "-v", ".[dev]")
-    try:
-        session.install("--only-binary=numpy", "numpy>=1.16")
-    except CommandFailed:
-        # No binary wheel for numpy available on this platform
-        pass
+    session.install("-v", ".[dev]")
+
+    def try_install_binary(package: str, constraint: str):
+        try:
+            session.install("--only-binary=:all:", f"{package}{constraint}")
+        except CommandFailed:
+            # No binary wheel available on this platform
+            pass
+
+    try_install_binary("numpy", ">=1.16")
+    # https://github.com/zopefoundation/zope.interface/issues/316
+    # - is a dependency of gevent
+    try_install_binary("zope.interface", "<7")
+    try_install_binary("gevent", ">=22.10.2")
     ignored_paths = []
     if sys.version_info < (3, 10):
         # Match syntax is only available in Python >= 3.10
diff --git a/pytests/pyproject.toml b/pytests/pyproject.toml
index 126eaf77b09..32ccec55604 100644
--- a/pytests/pyproject.toml
+++ b/pytests/pyproject.toml
@@ -1,5 +1,5 @@
 [build-system]
-requires = ["maturin>=1,<2"]
+requires = ["maturin>=1.9.4,<2"]
 build-backend = "maturin"
 
 [tool.pytest.ini_options]
@@ -20,10 +20,9 @@ classifiers = [
 
 [project.optional-dependencies]
 dev = [
-    "gevent>=22.10.2; implementation_name == 'cpython'",
     "hypothesis>=3.55",
-    "pytest-asyncio>=0.21",
+    "pytest-asyncio>=0.21,<2",
     "pytest-benchmark>=3.4",
-    "pytest>=6.0",
+    "pytest>=7",
     "typing_extensions>=4.0.0"
 ]
diff --git a/pytests/src/awaitable.rs b/pytests/src/awaitable.rs
index e1a70b42bb0..8481e2f6528 100644
--- a/pytests/src/awaitable.rs
+++ b/pytests/src/awaitable.rs
@@ -2,7 +2,7 @@
 //! awaitable protocol.
 //!
 //! Both IterAwaitable and FutureAwaitable will return a value immediately
-//! when awaited, see guide examples related to pyo3-asyncio for ways
+//! when awaited, see guide examples related to pyo3-async-runtimes for ways
 //! to suspend tasks and await results.
 
 use pyo3::exceptions::PyStopIteration;
@@ -11,13 +11,13 @@ use pyo3::prelude::*;
 #[pyclass]
 #[derive(Debug)]
 pub(crate) struct IterAwaitable {
-    result: Option<PyResult<PyObject>>,
+    result: Option<PyResult<Py<PyAny>>>,
 }
 
 #[pymethods]
 impl IterAwaitable {
     #[new]
-    fn new(result: PyObject) -> Self {
+    fn new(result: Py<PyAny>) -> Self {
         IterAwaitable {
             result: Some(Ok(result)),
         }
@@ -31,7 +31,7 @@ impl IterAwaitable {
         pyself
     }
 
-    fn __next__(&mut self, py: Python<'_>) -> PyResult<PyObject> {
+    fn __next__(&mut self, py: Python<'_>) -> PyResult<Py<PyAny>> {
         match self.result.take() {
             Some(res) => match res {
                 Ok(v) => Err(PyStopIteration::new_err(v)),
@@ -46,13 +46,13 @@ impl IterAwaitable {
 pub(crate) struct FutureAwaitable {
     #[pyo3(get, set, name = "_asyncio_future_blocking")]
     py_block: bool,
-    result: Option<PyResult<PyObject>>,
+    result: Option<PyResult<Py<PyAny>>>,
 }
 
 #[pymethods]
 impl FutureAwaitable {
     #[new]
-    fn new(result: PyObject) -> Self {
+    fn new(result: Py<PyAny>) -> Self {
         FutureAwaitable {
             py_block: false,
             result: Some(Ok(result)),
@@ -78,8 +78,8 @@ impl FutureAwaitable {
     }
 }
 
-#[pymodule]
-pub fn awaitable(_py: Python<'_>, m: &PyModule) -> PyResult<()> {
+#[pymodule(gil_used = false)]
+pub fn awaitable(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_class::<IterAwaitable>()?;
     m.add_class::<FutureAwaitable>()?;
     Ok(())
diff --git a/pytests/src/buf_and_str.rs b/pytests/src/buf_and_str.rs
index 23db9f0625e..15230a5e153 100644
--- a/pytests/src/buf_and_str.rs
+++ b/pytests/src/buf_and_str.rs
@@ -17,38 +17,38 @@ impl BytesExtractor {
     }
 
     #[staticmethod]
-    pub fn from_bytes(bytes: &PyBytes) -> PyResult<usize> {
+    pub fn from_bytes(bytes: &Bound<'_, PyBytes>) -> PyResult<usize> {
         let byte_vec: Vec<u8> = bytes.extract()?;
         Ok(byte_vec.len())
     }
 
     #[staticmethod]
-    pub fn from_str(string: &PyString) -> PyResult<usize> {
+    pub fn from_str(string: &Bound<'_, PyString>) -> PyResult<usize> {
         let rust_string: String = string.extract()?;
         Ok(rust_string.len())
     }
 
     #[staticmethod]
-    pub fn from_str_lossy(string: &PyString) -> usize {
+    pub fn from_str_lossy(string: &Bound<'_, PyString>) -> usize {
         let rust_string_lossy: String = string.to_string_lossy().to_string();
         rust_string_lossy.len()
     }
 
     #[staticmethod]
     pub fn from_buffer(buf: &Bound<'_, PyAny>) -> PyResult<usize> {
-        let buf = PyBuffer::<u8>::get_bound(buf)?;
+        let buf = PyBuffer::<u8>::get(buf)?;
         Ok(buf.item_count())
     }
 }
 
 #[pyfunction]
 fn return_memoryview(py: Python<'_>) -> PyResult<Bound<'_, PyMemoryView>> {
-    let bytes = PyBytes::new_bound(py, b"hello world");
-    PyMemoryView::from_bound(&bytes)
+    let bytes = PyBytes::new(py, b"hello world");
+    PyMemoryView::from(&bytes)
 }
 
-#[pymodule]
-pub fn buf_and_str(_py: Python<'_>, m: &PyModule) -> PyResult<()> {
+#[pymodule(gil_used = false)]
+pub fn buf_and_str(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_class::<BytesExtractor>()?;
     m.add_function(wrap_pyfunction!(return_memoryview, m)?)?;
     Ok(())
diff --git a/pytests/src/comparisons.rs b/pytests/src/comparisons.rs
index d8c2f5a6a52..df28b423c3c 100644
--- a/pytests/src/comparisons.rs
+++ b/pytests/src/comparisons.rs
@@ -1,7 +1,8 @@
+use pyo3::basic::CompareOp;
 use pyo3::prelude::*;
-use pyo3::{types::PyModule, Python};
+use std::fmt;
 
-#[pyclass]
+#[pyclass(frozen)]
 struct Eq(i64);
 
 #[pymethods]
@@ -20,7 +21,7 @@ impl Eq {
     }
 }
 
-#[pyclass]
+#[pyclass(frozen)]
 struct EqDefaultNe(i64);
 
 #[pymethods]
@@ -35,7 +36,19 @@ impl EqDefaultNe {
     }
 }
 
-#[pyclass]
+#[pyclass(eq, frozen)]
+#[derive(PartialEq, Eq)]
+struct EqDerived(i64);
+
+#[pymethods]
+impl EqDerived {
+    #[new]
+    fn new(value: i64) -> Self {
+        Self(value)
+    }
+}
+
+#[pyclass(frozen)]
 struct Ordered(i64);
 
 #[pymethods]
@@ -70,7 +83,40 @@ impl Ordered {
     }
 }
 
-#[pyclass]
+#[pyclass(frozen)]
+struct OrderedRichCmp(i64);
+
+#[pymethods]
+impl OrderedRichCmp {
+    #[new]
+    fn new(value: i64) -> Self {
+        Self(value)
+    }
+
+    fn __richcmp__(&self, other: &Self, op: CompareOp) -> bool {
+        op.matches(self.0.cmp(&other.0))
+    }
+}
+
+#[pyclass(eq, ord, hash, str, frozen)]
+#[derive(PartialEq, Eq, Ord, PartialOrd, Hash)]
+struct OrderedDerived(i64);
+
+impl fmt::Display for OrderedDerived {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.0.fmt(f)
+    }
+}
+
+#[pymethods]
+impl OrderedDerived {
+    #[new]
+    fn new(value: i64) -> Self {
+        Self(value)
+    }
+}
+
+#[pyclass(frozen)]
 struct OrderedDefaultNe(i64);
 
 #[pymethods]
@@ -101,11 +147,10 @@ impl OrderedDefaultNe {
     }
 }
 
-#[pymodule]
-pub fn comparisons(_py: Python<'_>, m: &PyModule) -> PyResult<()> {
-    m.add_class::<Eq>()?;
-    m.add_class::<EqDefaultNe>()?;
-    m.add_class::<Ordered>()?;
-    m.add_class::<OrderedDefaultNe>()?;
-    Ok(())
+#[pymodule(gil_used = false)]
+pub mod comparisons {
+    #[pymodule_export]
+    use super::{
+        Eq, EqDefaultNe, EqDerived, Ordered, OrderedDefaultNe, OrderedDerived, OrderedRichCmp,
+    };
 }
diff --git a/pytests/src/consts.rs b/pytests/src/consts.rs
new file mode 100644
index 00000000000..eec09a71819
--- /dev/null
+++ b/pytests/src/consts.rs
@@ -0,0 +1,21 @@
+use pyo3::pymodule;
+
+#[pymodule]
+pub mod consts {
+    use pyo3::{pyclass, pymethods};
+
+    #[pymodule_export]
+    pub const PI: f64 = std::f64::consts::PI; // Exports PI constant as part of the module
+
+    #[pymodule_export]
+    pub const SIMPLE: &str = "SIMPLE";
+
+    #[pyclass]
+    struct ClassWithConst {}
+
+    #[pymethods]
+    impl ClassWithConst {
+        #[classattr]
+        const INSTANCE: Self = ClassWithConst {};
+    }
+}
diff --git a/pytests/src/datetime.rs b/pytests/src/datetime.rs
index 9d8f32a93c9..5162b3508a5 100644
--- a/pytests/src/datetime.rs
+++ b/pytests/src/datetime.rs
@@ -8,20 +8,24 @@ use pyo3::types::{
 
 #[pyfunction]
 fn make_date(py: Python<'_>, year: i32, month: u8, day: u8) -> PyResult<Bound<'_, PyDate>> {
-    PyDate::new_bound(py, year, month, day)
+    PyDate::new(py, year, month, day)
 }
 
 #[pyfunction]
-fn get_date_tuple<'p>(py: Python<'p>, d: &PyDate) -> Bound<'p, PyTuple> {
-    PyTuple::new_bound(py, [d.get_year(), d.get_month() as i32, d.get_day() as i32])
+fn get_date_tuple<'py>(d: &Bound<'py, PyDate>) -> PyResult<Bound<'py, PyTuple>> {
+    PyTuple::new(
+        d.py(),
+        [d.get_year(), d.get_month() as i32, d.get_day() as i32],
+    )
 }
 
 #[pyfunction]
 fn date_from_timestamp(py: Python<'_>, timestamp: i64) -> PyResult<Bound<'_, PyDate>> {
-    PyDate::from_timestamp_bound(py, timestamp)
+    PyDate::from_timestamp(py, timestamp)
 }
 
 #[pyfunction]
+#[pyo3(signature=(hour, minute, second, microsecond, tzinfo=None))]
 fn make_time<'py>(
     py: Python<'py>,
     hour: u8,
@@ -30,7 +34,7 @@ fn make_time<'py>(
     microsecond: u32,
     tzinfo: Option<&Bound<'py, PyTzInfo>>,
 ) -> PyResult<Bound<'py, PyTime>> {
-    PyTime::new_bound(py, hour, minute, second, microsecond, tzinfo)
+    PyTime::new(py, hour, minute, second, microsecond, tzinfo)
 }
 
 #[pyfunction]
@@ -44,13 +48,13 @@ fn time_with_fold<'py>(
     tzinfo: Option<&Bound<'py, PyTzInfo>>,
     fold: bool,
 ) -> PyResult<Bound<'py, PyTime>> {
-    PyTime::new_bound_with_fold(py, hour, minute, second, microsecond, tzinfo, fold)
+    PyTime::new_with_fold(py, hour, minute, second, microsecond, tzinfo, fold)
 }
 
 #[pyfunction]
-fn get_time_tuple<'p>(py: Python<'p>, dt: &PyTime) -> Bound<'p, PyTuple> {
-    PyTuple::new_bound(
-        py,
+fn get_time_tuple<'py>(dt: &Bound<'py, PyTime>) -> PyResult<Bound<'py, PyTuple>> {
+    PyTuple::new(
+        dt.py(),
         [
             dt.get_hour() as u32,
             dt.get_minute() as u32,
@@ -61,9 +65,9 @@ fn get_time_tuple<'p>(py: Python<'p>, dt: &PyTime) -> Bound<'p, PyTuple> {
 }
 
 #[pyfunction]
-fn get_time_tuple_fold<'p>(py: Python<'p>, dt: &PyTime) -> Bound<'p, PyTuple> {
-    PyTuple::new_bound(
-        py,
+fn get_time_tuple_fold<'py>(dt: &Bound<'py, PyTime>) -> PyResult<Bound<'py, PyTuple>> {
+    PyTuple::new(
+        dt.py(),
         [
             dt.get_hour() as u32,
             dt.get_minute() as u32,
@@ -81,12 +85,12 @@ fn make_delta(
     seconds: i32,
     microseconds: i32,
 ) -> PyResult<Bound<'_, PyDelta>> {
-    PyDelta::new_bound(py, days, seconds, microseconds, true)
+    PyDelta::new(py, days, seconds, microseconds, true)
 }
 
 #[pyfunction]
-fn get_delta_tuple<'py>(delta: &Bound<'py, PyDelta>) -> Bound<'py, PyTuple> {
-    PyTuple::new_bound(
+fn get_delta_tuple<'py>(delta: &Bound<'py, PyDelta>) -> PyResult<Bound<'py, PyTuple>> {
+    PyTuple::new(
         delta.py(),
         [
             delta.get_days(),
@@ -98,6 +102,7 @@ fn get_delta_tuple<'py>(delta: &Bound<'py, PyDelta>) -> Bound<'py, PyTuple> {
 
 #[allow(clippy::too_many_arguments)]
 #[pyfunction]
+#[pyo3(signature=(year, month, day, hour, minute, second, microsecond, tzinfo=None))]
 fn make_datetime<'py>(
     py: Python<'py>,
     year: i32,
@@ -109,7 +114,7 @@ fn make_datetime<'py>(
     microsecond: u32,
     tzinfo: Option<&Bound<'py, PyTzInfo>>,
 ) -> PyResult<Bound<'py, PyDateTime>> {
-    PyDateTime::new_bound(
+    PyDateTime::new(
         py,
         year,
         month,
@@ -123,9 +128,9 @@ fn make_datetime<'py>(
 }
 
 #[pyfunction]
-fn get_datetime_tuple<'py>(py: Python<'py>, dt: &Bound<'py, PyDateTime>) -> Bound<'py, PyTuple> {
-    PyTuple::new_bound(
-        py,
+fn get_datetime_tuple<'py>(dt: &Bound<'py, PyDateTime>) -> PyResult<Bound<'py, PyTuple>> {
+    PyTuple::new(
+        dt.py(),
         [
             dt.get_year(),
             dt.get_month() as i32,
@@ -139,12 +144,9 @@ fn get_datetime_tuple<'py>(py: Python<'py>, dt: &Bound<'py, PyDateTime>) -> Boun
 }
 
 #[pyfunction]
-fn get_datetime_tuple_fold<'py>(
-    py: Python<'py>,
-    dt: &Bound<'py, PyDateTime>,
-) -> Bound<'py, PyTuple> {
-    PyTuple::new_bound(
-        py,
+fn get_datetime_tuple_fold<'py>(dt: &Bound<'py, PyDateTime>) -> PyResult<Bound<'py, PyTuple>> {
+    PyTuple::new(
+        dt.py(),
         [
             dt.get_year(),
             dt.get_month() as i32,
@@ -159,22 +161,23 @@ fn get_datetime_tuple_fold<'py>(
 }
 
 #[pyfunction]
+#[pyo3(signature=(ts, tz=None))]
 fn datetime_from_timestamp<'py>(
     py: Python<'py>,
     ts: f64,
     tz: Option<&Bound<'py, PyTzInfo>>,
 ) -> PyResult<Bound<'py, PyDateTime>> {
-    PyDateTime::from_timestamp_bound(py, ts, tz)
+    PyDateTime::from_timestamp(py, ts, tz)
 }
 
 #[pyfunction]
 fn get_datetime_tzinfo<'py>(dt: &Bound<'py, PyDateTime>) -> Option<Bound<'py, PyTzInfo>> {
-    dt.get_tzinfo_bound()
+    dt.get_tzinfo()
 }
 
 #[pyfunction]
 fn get_time_tzinfo<'py>(dt: &Bound<'py, PyTime>) -> Option<Bound<'py, PyTzInfo>> {
-    dt.get_tzinfo_bound()
+    dt.get_tzinfo()
 }
 
 #[pyclass(extends=PyTzInfo)]
@@ -187,12 +190,8 @@ impl TzClass {
         TzClass {}
     }
 
-    fn utcoffset<'py>(
-        &self,
-        py: Python<'py>,
-        _dt: &Bound<'py, PyDateTime>,
-    ) -> PyResult<Bound<'py, PyDelta>> {
-        PyDelta::new_bound(py, 0, 3600, 0, true)
+    fn utcoffset<'py>(&self, dt: &Bound<'py, PyDateTime>) -> PyResult<Bound<'py, PyDelta>> {
+        PyDelta::new(dt.py(), 0, 3600, 0, true)
     }
 
     fn tzname(&self, _dt: &Bound<'_, PyDateTime>) -> String {
@@ -204,8 +203,8 @@ impl TzClass {
     }
 }
 
-#[pymodule]
-pub fn datetime(_py: Python<'_>, m: &PyModule) -> PyResult<()> {
+#[pymodule(gil_used = false)]
+pub fn datetime(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(make_date, m)?)?;
     m.add_function(wrap_pyfunction!(get_date_tuple, m)?)?;
     m.add_function(wrap_pyfunction!(date_from_timestamp, m)?)?;
diff --git a/pytests/src/dict_iter.rs b/pytests/src/dict_iter.rs
index 5f5992b6efc..c312fbb5f83 100644
--- a/pytests/src/dict_iter.rs
+++ b/pytests/src/dict_iter.rs
@@ -3,7 +3,7 @@ use pyo3::prelude::*;
 use pyo3::types::PyDict;
 
 #[pymodule]
-pub fn dict_iter(_py: Python<'_>, m: &PyModule) -> PyResult<()> {
+pub fn dict_iter(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_class::<DictSize>()?;
     Ok(())
 }
@@ -20,7 +20,7 @@ impl DictSize {
         DictSize { expected }
     }
 
-    fn iter_dict(&mut self, _py: Python<'_>, dict: &PyDict) -> PyResult<u32> {
+    fn iter_dict(&mut self, _py: Python<'_>, dict: &Bound<'_, PyDict>) -> PyResult<u32> {
         let mut seen = 0u32;
         for (sym, values) in dict {
             seen += 1;
diff --git a/pytests/src/enums.rs b/pytests/src/enums.rs
index 11b592d3563..02431fdd1e8 100644
--- a/pytests/src/enums.rs
+++ b/pytests/src/enums.rs
@@ -1,15 +1,16 @@
-use pyo3::{pyclass, pyfunction, pymodule, types::PyModule, wrap_pyfunction, PyResult, Python};
+use pyo3::{pyclass, pyfunction, pymodule};
 
-#[pymodule]
-pub fn enums(_py: Python<'_>, m: &PyModule) -> PyResult<()> {
-    m.add_class::<SimpleEnum>()?;
-    m.add_class::<ComplexEnum>()?;
-    m.add_wrapped(wrap_pyfunction!(do_simple_stuff))?;
-    m.add_wrapped(wrap_pyfunction!(do_complex_stuff))?;
-    Ok(())
+#[pymodule(gil_used = false)]
+pub mod enums {
+    #[pymodule_export]
+    use super::{
+        do_complex_stuff, do_mixed_complex_stuff, do_simple_stuff, do_tuple_stuff, ComplexEnum,
+        MixedComplexEnum, SimpleEnum, SimpleTupleEnum, TupleEnum,
+    };
 }
 
-#[pyclass]
+#[pyclass(eq, eq_int)]
+#[derive(PartialEq)]
 pub enum SimpleEnum {
     Sunday,
     Monday,
@@ -35,11 +36,26 @@ pub fn do_simple_stuff(thing: &SimpleEnum) -> SimpleEnum {
 
 #[pyclass]
 pub enum ComplexEnum {
-    Int { i: i32 },
-    Float { f: f64 },
-    Str { s: String },
+    Int {
+        i: i32,
+    },
+    Float {
+        f: f64,
+    },
+    Str {
+        s: String,
+    },
     EmptyStruct {},
-    MultiFieldStruct { a: i32, b: f64, c: bool },
+    MultiFieldStruct {
+        a: i32,
+        b: f64,
+        c: bool,
+    },
+    #[pyo3(constructor = (a = 42, b = None))]
+    VariantWithDefault {
+        a: i32,
+        b: Option<String>,
+    },
 }
 
 #[pyfunction]
@@ -54,5 +70,46 @@ pub fn do_complex_stuff(thing: &ComplexEnum) -> ComplexEnum {
             b: *b,
             c: *c,
         },
+        ComplexEnum::VariantWithDefault { a, b } => ComplexEnum::VariantWithDefault {
+            a: 2 * a,
+            b: b.as_ref().map(|s| s.to_uppercase()),
+        },
+    }
+}
+
+#[pyclass]
+enum SimpleTupleEnum {
+    Int(i32),
+    Str(String),
+}
+
+#[pyclass]
+pub enum TupleEnum {
+    #[pyo3(constructor = (_0 = 1, _1 = 1.0, _2 = true))]
+    FullWithDefault(i32, f64, bool),
+    Full(i32, f64, bool),
+    EmptyTuple(),
+}
+
+#[pyfunction]
+pub fn do_tuple_stuff(thing: &TupleEnum) -> TupleEnum {
+    match thing {
+        TupleEnum::FullWithDefault(a, b, c) => TupleEnum::FullWithDefault(*a, *b, *c),
+        TupleEnum::Full(a, b, c) => TupleEnum::Full(*a, *b, *c),
+        TupleEnum::EmptyTuple() => TupleEnum::EmptyTuple(),
+    }
+}
+
+#[pyclass]
+pub enum MixedComplexEnum {
+    Nothing {},
+    Empty(),
+}
+
+#[pyfunction]
+pub fn do_mixed_complex_stuff(thing: &MixedComplexEnum) -> MixedComplexEnum {
+    match thing {
+        MixedComplexEnum::Nothing {} => MixedComplexEnum::Empty(),
+        MixedComplexEnum::Empty() => MixedComplexEnum::Nothing {},
     }
 }
diff --git a/pytests/src/lib.rs b/pytests/src/lib.rs
index e65385bf679..76c07937eed 100644
--- a/pytests/src/lib.rs
+++ b/pytests/src/lib.rs
@@ -5,6 +5,7 @@ use pyo3::wrap_pymodule;
 pub mod awaitable;
 pub mod buf_and_str;
 pub mod comparisons;
+mod consts;
 pub mod datetime;
 pub mod dict_iter;
 pub mod enums;
@@ -17,44 +18,53 @@ pub mod pyfunctions;
 pub mod sequence;
 pub mod subclassing;
 
-#[pymodule]
-fn pyo3_pytests(py: Python<'_>, m: &PyModule) -> PyResult<()> {
-    m.add_wrapped(wrap_pymodule!(awaitable::awaitable))?;
-    #[cfg(not(Py_LIMITED_API))]
-    m.add_wrapped(wrap_pymodule!(buf_and_str::buf_and_str))?;
-    m.add_wrapped(wrap_pymodule!(comparisons::comparisons))?;
-    #[cfg(not(Py_LIMITED_API))]
-    m.add_wrapped(wrap_pymodule!(datetime::datetime))?;
-    m.add_wrapped(wrap_pymodule!(dict_iter::dict_iter))?;
-    m.add_wrapped(wrap_pymodule!(enums::enums))?;
-    m.add_wrapped(wrap_pymodule!(misc::misc))?;
-    m.add_wrapped(wrap_pymodule!(objstore::objstore))?;
-    m.add_wrapped(wrap_pymodule!(othermod::othermod))?;
-    m.add_wrapped(wrap_pymodule!(path::path))?;
-    m.add_wrapped(wrap_pymodule!(pyclasses::pyclasses))?;
-    m.add_wrapped(wrap_pymodule!(pyfunctions::pyfunctions))?;
-    m.add_wrapped(wrap_pymodule!(sequence::sequence))?;
-    m.add_wrapped(wrap_pymodule!(subclassing::subclassing))?;
+#[pymodule(gil_used = false)]
+mod pyo3_pytests {
+    use super::*;
+
+    #[pymodule_export]
+    use {
+        comparisons::comparisons, consts::consts, enums::enums, pyclasses::pyclasses,
+        pyfunctions::pyfunctions,
+    };
 
     // Inserting to sys.modules allows importing submodules nicely from Python
     // e.g. import pyo3_pytests.buf_and_str as bas
+    #[pymodule_init]
+    fn init(m: &Bound<'_, PyModule>) -> PyResult<()> {
+        m.add_wrapped(wrap_pymodule!(awaitable::awaitable))?;
+        #[cfg(not(Py_LIMITED_API))]
+        m.add_wrapped(wrap_pymodule!(buf_and_str::buf_and_str))?;
+        #[cfg(not(Py_LIMITED_API))]
+        m.add_wrapped(wrap_pymodule!(datetime::datetime))?;
+        m.add_wrapped(wrap_pymodule!(dict_iter::dict_iter))?;
+        m.add_wrapped(wrap_pymodule!(misc::misc))?;
+        m.add_wrapped(wrap_pymodule!(objstore::objstore))?;
+        m.add_wrapped(wrap_pymodule!(othermod::othermod))?;
+        m.add_wrapped(wrap_pymodule!(path::path))?;
+        m.add_wrapped(wrap_pymodule!(sequence::sequence))?;
+        m.add_wrapped(wrap_pymodule!(subclassing::subclassing))?;
+
+        // Inserting to sys.modules allows importing submodules nicely from Python
+        // e.g. import pyo3_pytests.buf_and_str as bas
 
-    let sys = PyModule::import(py, "sys")?;
-    let sys_modules: &PyDict = sys.getattr("modules")?.downcast()?;
-    sys_modules.set_item("pyo3_pytests.awaitable", m.getattr("awaitable")?)?;
-    sys_modules.set_item("pyo3_pytests.buf_and_str", m.getattr("buf_and_str")?)?;
-    sys_modules.set_item("pyo3_pytests.comparisons", m.getattr("comparisons")?)?;
-    sys_modules.set_item("pyo3_pytests.datetime", m.getattr("datetime")?)?;
-    sys_modules.set_item("pyo3_pytests.dict_iter", m.getattr("dict_iter")?)?;
-    sys_modules.set_item("pyo3_pytests.enums", m.getattr("enums")?)?;
-    sys_modules.set_item("pyo3_pytests.misc", m.getattr("misc")?)?;
-    sys_modules.set_item("pyo3_pytests.objstore", m.getattr("objstore")?)?;
-    sys_modules.set_item("pyo3_pytests.othermod", m.getattr("othermod")?)?;
-    sys_modules.set_item("pyo3_pytests.path", m.getattr("path")?)?;
-    sys_modules.set_item("pyo3_pytests.pyclasses", m.getattr("pyclasses")?)?;
-    sys_modules.set_item("pyo3_pytests.pyfunctions", m.getattr("pyfunctions")?)?;
-    sys_modules.set_item("pyo3_pytests.sequence", m.getattr("sequence")?)?;
-    sys_modules.set_item("pyo3_pytests.subclassing", m.getattr("subclassing")?)?;
+        let sys = PyModule::import(m.py(), "sys")?;
+        let sys_modules = sys.getattr("modules")?.cast_into::<PyDict>()?;
+        sys_modules.set_item("pyo3_pytests.awaitable", m.getattr("awaitable")?)?;
+        sys_modules.set_item("pyo3_pytests.buf_and_str", m.getattr("buf_and_str")?)?;
+        sys_modules.set_item("pyo3_pytests.comparisons", m.getattr("comparisons")?)?;
+        sys_modules.set_item("pyo3_pytests.datetime", m.getattr("datetime")?)?;
+        sys_modules.set_item("pyo3_pytests.dict_iter", m.getattr("dict_iter")?)?;
+        sys_modules.set_item("pyo3_pytests.enums", m.getattr("enums")?)?;
+        sys_modules.set_item("pyo3_pytests.misc", m.getattr("misc")?)?;
+        sys_modules.set_item("pyo3_pytests.objstore", m.getattr("objstore")?)?;
+        sys_modules.set_item("pyo3_pytests.othermod", m.getattr("othermod")?)?;
+        sys_modules.set_item("pyo3_pytests.path", m.getattr("path")?)?;
+        sys_modules.set_item("pyo3_pytests.pyclasses", m.getattr("pyclasses")?)?;
+        sys_modules.set_item("pyo3_pytests.pyfunctions", m.getattr("pyfunctions")?)?;
+        sys_modules.set_item("pyo3_pytests.sequence", m.getattr("sequence")?)?;
+        sys_modules.set_item("pyo3_pytests.subclassing", m.getattr("subclassing")?)?;
 
-    Ok(())
+        Ok(())
+    }
 }
diff --git a/pytests/src/misc.rs b/pytests/src/misc.rs
index bd941461e91..811923f971a 100644
--- a/pytests/src/misc.rs
+++ b/pytests/src/misc.rs
@@ -1,15 +1,39 @@
-use pyo3::{prelude::*, types::PyDict};
-use std::borrow::Cow;
+use pyo3::{
+    prelude::*,
+    types::{PyDict, PyString},
+};
 
 #[pyfunction]
 fn issue_219() {
-    // issue 219: acquiring GIL inside #[pyfunction] deadlocks.
-    Python::with_gil(|_| {});
+    // issue 219: attaching inside #[pyfunction] deadlocks.
+    Python::attach(|_| {});
+}
+
+#[pyclass]
+struct LockHolder {
+    #[allow(unused)]
+    sender: std::sync::mpsc::Sender<()>,
+}
+
+// This will repeatedly attach and detach from the Python interpreter
+// once the LockHolder is dropped.
+#[pyfunction]
+fn hammer_attaching_in_thread() -> LockHolder {
+    let (sender, receiver) = std::sync::mpsc::channel();
+    std::thread::spawn(move || {
+        receiver.recv().ok();
+        // now the interpreter has shut down, so hammer the attach API. In buggy
+        // versions of PyO3 this will cause a crash.
+        loop {
+            Python::try_attach(|_py| ());
+        }
+    });
+    LockHolder { sender }
 }
 
 #[pyfunction]
-fn get_type_full_name(obj: &PyAny) -> PyResult<Cow<'_, str>> {
-    obj.get_type().name()
+fn get_type_fully_qualified_name<'py>(obj: &Bound<'py, PyAny>) -> PyResult<Bound<'py, PyString>> {
+    obj.get_type().fully_qualified_name()
 }
 
 #[pyfunction]
@@ -30,10 +54,11 @@ fn get_item_and_run_callback(dict: Bound<'_, PyDict>, callback: Bound<'_, PyAny>
     Ok(())
 }
 
-#[pymodule]
-pub fn misc(_py: Python<'_>, m: &PyModule) -> PyResult<()> {
+#[pymodule(gil_used = false)]
+pub fn misc(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(issue_219, m)?)?;
-    m.add_function(wrap_pyfunction!(get_type_full_name, m)?)?;
+    m.add_function(wrap_pyfunction!(hammer_attaching_in_thread, m)?)?;
+    m.add_function(wrap_pyfunction!(get_type_fully_qualified_name, m)?)?;
     m.add_function(wrap_pyfunction!(accepts_bool, m)?)?;
     m.add_function(wrap_pyfunction!(get_item_and_run_callback, m)?)?;
     Ok(())
diff --git a/pytests/src/objstore.rs b/pytests/src/objstore.rs
index f7fc66edb84..89643c3967d 100644
--- a/pytests/src/objstore.rs
+++ b/pytests/src/objstore.rs
@@ -3,7 +3,7 @@ use pyo3::prelude::*;
 #[pyclass]
 #[derive(Default)]
 pub struct ObjStore {
-    obj: Vec<PyObject>,
+    obj: Vec<Py<PyAny>>,
 }
 
 #[pymethods]
@@ -13,12 +13,12 @@ impl ObjStore {
         ObjStore::default()
     }
 
-    fn push(&mut self, py: Python<'_>, obj: &PyAny) {
-        self.obj.push(obj.to_object(py));
+    fn push(&mut self, obj: &Bound<'_, PyAny>) {
+        self.obj.push(obj.clone().unbind());
     }
 }
 
-#[pymodule]
-pub fn objstore(_py: Python<'_>, m: &PyModule) -> PyResult<()> {
+#[pymodule(gil_used = false)]
+pub fn objstore(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_class::<ObjStore>()
 }
diff --git a/pytests/src/othermod.rs b/pytests/src/othermod.rs
index 763d38a878f..0de912d7d04 100644
--- a/pytests/src/othermod.rs
+++ b/pytests/src/othermod.rs
@@ -28,14 +28,14 @@ fn double(x: i32) -> i32 {
     x * 2
 }
 
-#[pymodule]
-pub fn othermod(_py: Python<'_>, m: &PyModule) -> PyResult<()> {
+#[pymodule(gil_used = false)]
+pub fn othermod(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(double, m)?)?;
 
     m.add_class::<ModClass>()?;
 
-    m.add("USIZE_MIN", usize::min_value())?;
-    m.add("USIZE_MAX", usize::max_value())?;
+    m.add("USIZE_MIN", usize::MIN)?;
+    m.add("USIZE_MAX", usize::MAX)?;
 
     Ok(())
 }
diff --git a/pytests/src/path.rs b/pytests/src/path.rs
index b3e8f92bacf..b52c038ed34 100644
--- a/pytests/src/path.rs
+++ b/pytests/src/path.rs
@@ -11,8 +11,8 @@ fn take_pathbuf(path: PathBuf) -> PathBuf {
     path
 }
 
-#[pymodule]
-pub fn path(_py: Python<'_>, m: &PyModule) -> PyResult<()> {
+#[pymodule(gil_used = false)]
+pub fn path(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(make_path, m)?)?;
     m.add_function(wrap_pyfunction!(take_pathbuf, m)?)?;
 
diff --git a/pytests/src/pyclasses.rs b/pytests/src/pyclasses.rs
index 9c7b2d250da..631ec4fa0a0 100644
--- a/pytests/src/pyclasses.rs
+++ b/pytests/src/pyclasses.rs
@@ -1,8 +1,11 @@
+use std::{thread, time};
+
 use pyo3::exceptions::{PyStopIteration, PyValueError};
 use pyo3::prelude::*;
 use pyo3::types::PyType;
 
 #[pyclass]
+#[derive(Clone, Default)]
 struct EmptyClass {}
 
 #[pymethods]
@@ -11,6 +14,12 @@ impl EmptyClass {
     fn new() -> Self {
         EmptyClass {}
     }
+
+    fn method(&self) {}
+
+    fn __len__(&self) -> usize {
+        0
+    }
 }
 
 /// This is for demonstrating how to return a value from __next__
@@ -37,6 +46,29 @@ impl PyClassIter {
     }
 }
 
+#[pyclass]
+#[derive(Default)]
+struct PyClassThreadIter {
+    count: usize,
+}
+
+#[pymethods]
+impl PyClassThreadIter {
+    #[new]
+    pub fn new() -> Self {
+        Default::default()
+    }
+
+    fn __next__(&mut self, py: Python<'_>) -> usize {
+        let current_count = self.count;
+        self.count += 1;
+        if current_count == 0 {
+            py.detach(|| thread::sleep(time::Duration::from_millis(100)));
+        }
+        self.count
+    }
+}
+
 /// Demonstrates a base class which can operate on the relevant subclass in its constructor.
 #[pyclass(subclass)]
 #[derive(Clone, Debug)]
@@ -49,42 +81,101 @@ impl AssertingBaseClass {
     fn new(cls: &Bound<'_, PyType>, expected_type: Bound<'_, PyType>) -> PyResult<Self> {
         if !cls.is(&expected_type) {
             return Err(PyValueError::new_err(format!(
-                "{:?} != {:?}",
-                cls, expected_type
+                "{cls:?} != {expected_type:?}"
             )));
         }
         Ok(Self)
     }
 }
 
-#[pyclass(subclass)]
-#[derive(Clone, Debug)]
-struct AssertingBaseClassGilRef;
+#[pyclass]
+struct ClassWithoutConstructor;
 
+#[cfg(any(Py_3_10, not(Py_LIMITED_API)))]
+#[pyclass(dict)]
+struct ClassWithDict;
+
+#[cfg(any(Py_3_10, not(Py_LIMITED_API)))]
 #[pymethods]
-impl AssertingBaseClassGilRef {
+impl ClassWithDict {
     #[new]
-    #[classmethod]
-    fn new(cls: &PyType, expected_type: &PyType) -> PyResult<Self> {
-        if !cls.is(expected_type) {
-            return Err(PyValueError::new_err(format!(
-                "{:?} != {:?}",
-                cls, expected_type
-            )));
-        }
-        Ok(Self)
+    fn new() -> Self {
+        ClassWithDict
     }
 }
 
 #[pyclass]
-struct ClassWithoutConstructor;
+#[derive(Clone)]
+struct ClassWithDecorators {
+    attr: usize,
+}
+
+#[pymethods]
+impl ClassWithDecorators {
+    #[new]
+    #[classmethod]
+    fn new(_cls: Bound<'_, PyType>) -> Self {
+        Self { attr: 0 }
+    }
+
+    #[getter]
+    fn get_attr(&self) -> usize {
+        self.attr
+    }
+
+    #[setter]
+    fn set_attr(&mut self, value: usize) {
+        self.attr = value;
+    }
+
+    #[classmethod]
+    fn cls_method(_cls: &Bound<'_, PyType>) -> usize {
+        1
+    }
+
+    #[staticmethod]
+    fn static_method() -> usize {
+        2
+    }
+
+    #[classattr]
+    fn cls_attribute() -> usize {
+        3
+    }
+}
+
+#[pyclass(get_all, set_all)]
+struct PlainObject {
+    foo: String,
+    bar: usize,
+}
+
+#[derive(FromPyObject, IntoPyObject)]
+enum AClass {
+    NewType(EmptyClass),
+    Tuple(EmptyClass, EmptyClass),
+    Struct {
+        f: EmptyClass,
+        #[pyo3(item(42))]
+        g: EmptyClass,
+        #[pyo3(default)]
+        h: EmptyClass,
+    },
+}
+
+#[pyfunction]
+fn map_a_class(cls: AClass) -> AClass {
+    cls
+}
 
-#[pymodule]
-pub fn pyclasses(_py: Python<'_>, m: &PyModule) -> PyResult<()> {
-    m.add_class::<EmptyClass>()?;
-    m.add_class::<PyClassIter>()?;
-    m.add_class::<AssertingBaseClass>()?;
-    m.add_class::<AssertingBaseClassGilRef>()?;
-    m.add_class::<ClassWithoutConstructor>()?;
-    Ok(())
+#[pymodule(gil_used = false)]
+pub mod pyclasses {
+    #[cfg(any(Py_3_10, not(Py_LIMITED_API)))]
+    #[pymodule_export]
+    use super::ClassWithDict;
+    #[pymodule_export]
+    use super::{
+        map_a_class, AssertingBaseClass, ClassWithDecorators, ClassWithoutConstructor, EmptyClass,
+        PlainObject, PyClassIter, PyClassThreadIter,
+    };
 }
diff --git a/pytests/src/pyfunctions.rs b/pytests/src/pyfunctions.rs
index 1eef970430e..5cb88f976ab 100644
--- a/pytests/src/pyfunctions.rs
+++ b/pytests/src/pyfunctions.rs
@@ -4,72 +4,144 @@ use pyo3::types::{PyDict, PyTuple};
 #[pyfunction(signature = ())]
 fn none() {}
 
+type Any<'py> = Bound<'py, PyAny>;
+type Dict<'py> = Bound<'py, PyDict>;
+type Tuple<'py> = Bound<'py, PyTuple>;
+
 #[pyfunction(signature = (a, b = None, *, c = None))]
-fn simple<'a>(
-    a: &'a PyAny,
-    b: Option<&'a PyAny>,
-    c: Option<&'a PyAny>,
-) -> (&'a PyAny, Option<&'a PyAny>, Option<&'a PyAny>) {
+fn simple<'py>(
+    a: Any<'py>,
+    b: Option<Any<'py>>,
+    c: Option<Any<'py>>,
+) -> (Any<'py>, Option<Any<'py>>, Option<Any<'py>>) {
     (a, b, c)
 }
 
 #[pyfunction(signature = (a, b = None, *args, c = None))]
-fn simple_args<'a>(
-    a: &'a PyAny,
-    b: Option<&'a PyAny>,
-    args: &'a PyTuple,
-    c: Option<&'a PyAny>,
-) -> (&'a PyAny, Option<&'a PyAny>, &'a PyTuple, Option<&'a PyAny>) {
+fn simple_args<'py>(
+    a: Any<'py>,
+    b: Option<Any<'py>>,
+    args: Tuple<'py>,
+    c: Option<Any<'py>>,
+) -> (Any<'py>, Option<Any<'py>>, Tuple<'py>, Option<Any<'py>>) {
     (a, b, args, c)
 }
 
 #[pyfunction(signature = (a, b = None, c = None, **kwargs))]
-fn simple_kwargs<'a>(
-    a: &'a PyAny,
-    b: Option<&'a PyAny>,
-    c: Option<&'a PyAny>,
-    kwargs: Option<&'a PyDict>,
+fn simple_kwargs<'py>(
+    a: Any<'py>,
+    b: Option<Any<'py>>,
+    c: Option<Any<'py>>,
+    kwargs: Option<Dict<'py>>,
 ) -> (
-    &'a PyAny,
-    Option<&'a PyAny>,
-    Option<&'a PyAny>,
-    Option<&'a PyDict>,
+    Any<'py>,
+    Option<Any<'py>>,
+    Option<Any<'py>>,
+    Option<Dict<'py>>,
 ) {
     (a, b, c, kwargs)
 }
 
 #[pyfunction(signature = (a, b = None, *args, c = None, **kwargs))]
-fn simple_args_kwargs<'a>(
-    a: &'a PyAny,
-    b: Option<&'a PyAny>,
-    args: &'a PyTuple,
-    c: Option<&'a PyAny>,
-    kwargs: Option<&'a PyDict>,
+fn simple_args_kwargs<'py>(
+    a: Any<'py>,
+    b: Option<Any<'py>>,
+    args: Tuple<'py>,
+    c: Option<Any<'py>>,
+    kwargs: Option<Dict<'py>>,
 ) -> (
-    &'a PyAny,
-    Option<&'a PyAny>,
-    &'a PyTuple,
-    Option<&'a PyAny>,
-    Option<&'a PyDict>,
+    Any<'py>,
+    Option<Any<'py>>,
+    Tuple<'py>,
+    Option<Any<'py>>,
+    Option<Dict<'py>>,
 ) {
     (a, b, args, c, kwargs)
 }
 
 #[pyfunction(signature = (*args, **kwargs))]
-fn args_kwargs<'a>(
-    args: &'a PyTuple,
-    kwargs: Option<&'a PyDict>,
-) -> (&'a PyTuple, Option<&'a PyDict>) {
+fn args_kwargs<'py>(
+    args: Tuple<'py>,
+    kwargs: Option<Dict<'py>>,
+) -> (Tuple<'py>, Option<Dict<'py>>) {
     (args, kwargs)
 }
 
+#[pyfunction(signature = (a, /, b))]
+fn positional_only<'py>(a: Any<'py>, b: Any<'py>) -> (Any<'py>, Any<'py>) {
+    (a, b)
+}
+
+#[pyfunction(signature = (a = false, b = 0, c = 0.0, d = ""))]
+fn with_typed_args(a: bool, b: u64, c: f64, d: &str) -> (bool, u64, f64, &str) {
+    (a, b, c, d)
+}
+
+#[cfg(feature = "experimental-inspect")]
+#[pyfunction(signature = (a: "int", *_args: "str", _b: "int | None" = None, **_kwargs: "bool") -> "int")]
+fn with_custom_type_annotations<'py>(
+    a: Any<'py>,
+    _args: Tuple<'py>,
+    _b: Option<Any<'py>>,
+    _kwargs: Option<Dict<'py>>,
+) -> Any<'py> {
+    a
+}
+
+#[allow(clippy::too_many_arguments)]
+#[pyfunction(
+    signature = (
+        *,
+        ant = None,
+        bear = None,
+        cat = None,
+        dog = None,
+        elephant = None,
+        fox = None,
+        goat = None,
+        horse = None,
+        iguana = None,
+        jaguar = None,
+        koala = None,
+        lion = None,
+        monkey = None,
+        newt = None,
+        owl = None,
+        penguin = None
+    )
+)]
+fn many_keyword_arguments<'py>(
+    ant: Option<&'_ Bound<'py, PyAny>>,
+    bear: Option<&'_ Bound<'py, PyAny>>,
+    cat: Option<&'_ Bound<'py, PyAny>>,
+    dog: Option<&'_ Bound<'py, PyAny>>,
+    elephant: Option<&'_ Bound<'py, PyAny>>,
+    fox: Option<&'_ Bound<'py, PyAny>>,
+    goat: Option<&'_ Bound<'py, PyAny>>,
+    horse: Option<&'_ Bound<'py, PyAny>>,
+    iguana: Option<&'_ Bound<'py, PyAny>>,
+    jaguar: Option<&'_ Bound<'py, PyAny>>,
+    koala: Option<&'_ Bound<'py, PyAny>>,
+    lion: Option<&'_ Bound<'py, PyAny>>,
+    monkey: Option<&'_ Bound<'py, PyAny>>,
+    newt: Option<&'_ Bound<'py, PyAny>>,
+    owl: Option<&'_ Bound<'py, PyAny>>,
+    penguin: Option<&'_ Bound<'py, PyAny>>,
+) {
+    std::hint::black_box((
+        ant, bear, cat, dog, elephant, fox, goat, horse, iguana, jaguar, koala, lion, monkey, newt,
+        owl, penguin,
+    ));
+}
+
 #[pymodule]
-pub fn pyfunctions(_py: Python<'_>, m: &PyModule) -> PyResult<()> {
-    m.add_function(wrap_pyfunction!(none, m)?)?;
-    m.add_function(wrap_pyfunction!(simple, m)?)?;
-    m.add_function(wrap_pyfunction!(simple_args, m)?)?;
-    m.add_function(wrap_pyfunction!(simple_kwargs, m)?)?;
-    m.add_function(wrap_pyfunction!(simple_args_kwargs, m)?)?;
-    m.add_function(wrap_pyfunction!(args_kwargs, m)?)?;
-    Ok(())
+pub mod pyfunctions {
+    #[cfg(feature = "experimental-inspect")]
+    #[pymodule_export]
+    use super::with_custom_type_annotations;
+    #[pymodule_export]
+    use super::{
+        args_kwargs, many_keyword_arguments, none, positional_only, simple, simple_args,
+        simple_args_kwargs, simple_kwargs, with_typed_args,
+    };
 }
diff --git a/pytests/src/sequence.rs b/pytests/src/sequence.rs
index 5916414ee8f..175f5fba8aa 100644
--- a/pytests/src/sequence.rs
+++ b/pytests/src/sequence.rs
@@ -12,12 +12,12 @@ fn array_to_array_i32(arr: [i32; 3]) -> [i32; 3] {
 }
 
 #[pyfunction]
-fn vec_to_vec_pystring(vec: Vec<&PyString>) -> Vec<&PyString> {
+fn vec_to_vec_pystring(vec: Vec<Bound<'_, PyString>>) -> Vec<Bound<'_, PyString>> {
     vec
 }
 
-#[pymodule]
-pub fn sequence(_py: Python<'_>, m: &PyModule) -> PyResult<()> {
+#[pymodule(gil_used = false)]
+pub fn sequence(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(vec_to_vec_i32, m)?)?;
     m.add_function(wrap_pyfunction!(array_to_array_i32, m)?)?;
     m.add_function(wrap_pyfunction!(vec_to_vec_pystring, m)?)?;
diff --git a/pytests/src/subclassing.rs b/pytests/src/subclassing.rs
index 0033114ccea..0f00e74c19d 100644
--- a/pytests/src/subclassing.rs
+++ b/pytests/src/subclassing.rs
@@ -17,8 +17,8 @@ impl Subclassable {
     }
 }
 
-#[pymodule]
-pub fn subclassing(_py: Python<'_>, m: &PyModule) -> PyResult<()> {
+#[pymodule(gil_used = false)]
+pub fn subclassing(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_class::<Subclassable>()?;
     Ok(())
 }
diff --git a/pytests/stubs/__init__.pyi b/pytests/stubs/__init__.pyi
new file mode 100644
index 00000000000..0f6820f054e
--- /dev/null
+++ b/pytests/stubs/__init__.pyi
@@ -0,0 +1,3 @@
+from _typeshed import Incomplete
+
+def __getattr__(name: str) -> Incomplete: ...
diff --git a/pytests/stubs/comparisons.pyi b/pytests/stubs/comparisons.pyi
new file mode 100644
index 00000000000..f5e44130057
--- /dev/null
+++ b/pytests/stubs/comparisons.pyi
@@ -0,0 +1,50 @@
+class Eq:
+    def __eq__(self, /, other: Eq) -> bool: ...
+    def __ne__(self, /, other: Eq) -> bool: ...
+    def __new__(cls, /, value: int) -> None: ...
+
+class EqDefaultNe:
+    def __eq__(self, /, other: EqDefaultNe) -> bool: ...
+    def __new__(cls, /, value: int) -> None: ...
+
+class EqDerived:
+    def __eq__(self, /, other: EqDerived) -> bool: ...
+    def __ne__(self, /, other: EqDerived) -> bool: ...
+    def __new__(cls, /, value: int) -> None: ...
+
+class Ordered:
+    def __eq__(self, /, other: Ordered) -> bool: ...
+    def __ge__(self, /, other: Ordered) -> bool: ...
+    def __gt__(self, /, other: Ordered) -> bool: ...
+    def __le__(self, /, other: Ordered) -> bool: ...
+    def __lt__(self, /, other: Ordered) -> bool: ...
+    def __ne__(self, /, other: Ordered) -> bool: ...
+    def __new__(cls, /, value: int) -> None: ...
+
+class OrderedDefaultNe:
+    def __eq__(self, /, other: OrderedDefaultNe) -> bool: ...
+    def __ge__(self, /, other: OrderedDefaultNe) -> bool: ...
+    def __gt__(self, /, other: OrderedDefaultNe) -> bool: ...
+    def __le__(self, /, other: OrderedDefaultNe) -> bool: ...
+    def __lt__(self, /, other: OrderedDefaultNe) -> bool: ...
+    def __new__(cls, /, value: int) -> None: ...
+
+class OrderedDerived:
+    def __eq__(self, /, other: OrderedDerived) -> bool: ...
+    def __ge__(self, /, other: OrderedDerived) -> bool: ...
+    def __gt__(self, /, other: OrderedDerived) -> bool: ...
+    def __hash__(self, /) -> int: ...
+    def __le__(self, /, other: OrderedDerived) -> bool: ...
+    def __lt__(self, /, other: OrderedDerived) -> bool: ...
+    def __ne__(self, /, other: OrderedDerived) -> bool: ...
+    def __new__(cls, /, value: int) -> None: ...
+    def __str__(self, /) -> str: ...
+
+class OrderedRichCmp:
+    def __eq__(self, /, other: OrderedRichCmp) -> bool: ...
+    def __ge__(self, /, other: OrderedRichCmp) -> bool: ...
+    def __gt__(self, /, other: OrderedRichCmp) -> bool: ...
+    def __le__(self, /, other: OrderedRichCmp) -> bool: ...
+    def __lt__(self, /, other: OrderedRichCmp) -> bool: ...
+    def __ne__(self, /, other: OrderedRichCmp) -> bool: ...
+    def __new__(cls, /, value: int) -> None: ...
diff --git a/pytests/stubs/consts.pyi b/pytests/stubs/consts.pyi
new file mode 100644
index 00000000000..66b0672c8a5
--- /dev/null
+++ b/pytests/stubs/consts.pyi
@@ -0,0 +1,7 @@
+from typing import Final
+
+PI: Final[float]
+SIMPLE: Final = "SIMPLE"
+
+class ClassWithConst:
+    INSTANCE: Final[ClassWithConst]
diff --git a/pytests/stubs/enums.pyi b/pytests/stubs/enums.pyi
new file mode 100644
index 00000000000..95eaabac451
--- /dev/null
+++ b/pytests/stubs/enums.pyi
@@ -0,0 +1,14 @@
+class ComplexEnum: ...
+class MixedComplexEnum: ...
+
+class SimpleEnum:
+    def __eq__(self, /, other: SimpleEnum | int) -> bool: ...
+    def __ne__(self, /, other: SimpleEnum | int) -> bool: ...
+
+class SimpleTupleEnum: ...
+class TupleEnum: ...
+
+def do_complex_stuff(thing: ComplexEnum) -> ComplexEnum: ...
+def do_mixed_complex_stuff(thing: MixedComplexEnum) -> MixedComplexEnum: ...
+def do_simple_stuff(thing: SimpleEnum) -> SimpleEnum: ...
+def do_tuple_stuff(thing: TupleEnum) -> TupleEnum: ...
diff --git a/pytests/stubs/pyclasses.pyi b/pytests/stubs/pyclasses.pyi
new file mode 100644
index 00000000000..e2d1f4d006b
--- /dev/null
+++ b/pytests/stubs/pyclasses.pyi
@@ -0,0 +1,51 @@
+from _typeshed import Incomplete
+from typing import Any
+
+class AssertingBaseClass:
+    def __new__(cls, /, expected_type: Any) -> None: ...
+
+class ClassWithDecorators:
+    def __new__(cls, /) -> None: ...
+    @property
+    def attr(self, /) -> int: ...
+    @attr.setter
+    def attr(self, /, value: int) -> None: ...
+    @classmethod
+    @property
+    def cls_attribute(cls, /) -> int: ...
+    @classmethod
+    def cls_method(cls, /) -> int: ...
+    @staticmethod
+    def static_method() -> int: ...
+
+class ClassWithDict:
+    def __new__(cls, /) -> None: ...
+
+class ClassWithoutConstructor: ...
+
+class EmptyClass:
+    def __len__(self, /) -> int: ...
+    def __new__(cls, /) -> None: ...
+    def method(self, /) -> None: ...
+
+class PlainObject:
+    @property
+    def bar(self, /) -> int: ...
+    @bar.setter
+    def bar(self, /, value: int) -> None: ...
+    @property
+    def foo(self, /) -> str: ...
+    @foo.setter
+    def foo(self, /, value: str) -> None: ...
+
+class PyClassIter:
+    def __new__(cls, /) -> None: ...
+    def __next__(self, /) -> int: ...
+
+class PyClassThreadIter:
+    def __new__(cls, /) -> None: ...
+    def __next__(self, /) -> int: ...
+
+def map_a_class(
+    cls: EmptyClass | tuple[EmptyClass, EmptyClass] | Incomplete,
+) -> EmptyClass | tuple[EmptyClass, EmptyClass] | Incomplete: ...
diff --git a/pytests/stubs/pyfunctions.pyi b/pytests/stubs/pyfunctions.pyi
new file mode 100644
index 00000000000..9513072d023
--- /dev/null
+++ b/pytests/stubs/pyfunctions.pyi
@@ -0,0 +1,38 @@
+from typing import Any
+
+def args_kwargs(*args, **kwargs) -> Any: ...
+def many_keyword_arguments(
+    *,
+    ant: Any | None = None,
+    bear: Any | None = None,
+    cat: Any | None = None,
+    dog: Any | None = None,
+    elephant: Any | None = None,
+    fox: Any | None = None,
+    goat: Any | None = None,
+    horse: Any | None = None,
+    iguana: Any | None = None,
+    jaguar: Any | None = None,
+    koala: Any | None = None,
+    lion: Any | None = None,
+    monkey: Any | None = None,
+    newt: Any | None = None,
+    owl: Any | None = None,
+    penguin: Any | None = None,
+) -> None: ...
+def none() -> None: ...
+def positional_only(a: Any, /, b: Any) -> Any: ...
+def simple(a: Any, b: Any | None = None, *, c: Any | None = None) -> Any: ...
+def simple_args(a: Any, b: Any | None = None, *args, c: Any | None = None) -> Any: ...
+def simple_args_kwargs(
+    a: Any, b: Any | None = None, *args, c: Any | None = None, **kwargs
+) -> Any: ...
+def simple_kwargs(
+    a: Any, b: Any | None = None, c: Any | None = None, **kwargs
+) -> Any: ...
+def with_custom_type_annotations(
+    a: int, *_args: str, _b: int | None = None, **_kwargs: bool
+) -> int: ...
+def with_typed_args(
+    a: bool = False, b: int = 0, c: float = 0.0, d: str = ""
+) -> Any: ...
diff --git a/pytests/tests/test_awaitable.py b/pytests/tests/test_awaitable.py
index 2bada317517..40f1e1cc01d 100644
--- a/pytests/tests/test_awaitable.py
+++ b/pytests/tests/test_awaitable.py
@@ -1,13 +1,22 @@
 import pytest
+import sys
 
 from pyo3_pytests.awaitable import IterAwaitable, FutureAwaitable
 
 
+@pytest.mark.skipif(
+    sys.implementation.name == "graalpy",
+    reason="GraalPy's asyncio module has a bug with native classes, see oracle/graalpython#365",
+)
 @pytest.mark.asyncio
 async def test_iter_awaitable():
     assert await IterAwaitable(5) == 5
 
 
+@pytest.mark.skipif(
+    sys.implementation.name == "graalpy",
+    reason="GraalPy's asyncio module has a bug with native classes, see oracle/graalpython#365",
+)
 @pytest.mark.asyncio
 async def test_future_awaitable():
     assert await FutureAwaitable(5) == 5
diff --git a/pytests/tests/test_comparisons.py b/pytests/tests/test_comparisons.py
index 508cdeb2465..2c889be4189 100644
--- a/pytests/tests/test_comparisons.py
+++ b/pytests/tests/test_comparisons.py
@@ -1,7 +1,16 @@
 from typing import Type, Union
 
+import sys
 import pytest
-from pyo3_pytests.comparisons import Eq, EqDefaultNe, Ordered, OrderedDefaultNe
+from pyo3_pytests.comparisons import (
+    Eq,
+    EqDefaultNe,
+    EqDerived,
+    Ordered,
+    OrderedDefaultNe,
+    OrderedDerived,
+    OrderedRichCmp,
+)
 from typing_extensions import Self
 
 
@@ -9,15 +18,28 @@ class PyEq:
     def __init__(self, x: int) -> None:
         self.x = x
 
-    def __eq__(self, other: Self) -> bool:
-        return self.x == other.x
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, self.__class__):
+            return self.x == other.x
+        else:
+            return NotImplemented
 
     def __ne__(self, other: Self) -> bool:
-        return self.x != other.x
+        if isinstance(other, self.__class__):
+            return self.x != other.x
+        else:
+            return NotImplemented
 
 
-@pytest.mark.parametrize("ty", (Eq, PyEq), ids=("rust", "python"))
-def test_eq(ty: Type[Union[Eq, PyEq]]):
+@pytest.mark.skipif(
+    sys.implementation.name == "graalpy"
+    and __graalpython__.get_graalvm_version().startswith("24.1"),  # noqa: F821
+    reason="Bug in GraalPy 24.1",
+)
+@pytest.mark.parametrize(
+    "ty", (Eq, EqDerived, PyEq), ids=("rust", "rust-derived", "python")
+)
+def test_eq(ty: Type[Union[Eq, EqDerived, PyEq]]):
     a = ty(0)
     b = ty(0)
     c = ty(1)
@@ -32,6 +54,13 @@ def test_eq(ty: Type[Union[Eq, PyEq]]):
     assert b != c
     assert not (b == c)
 
+    assert not a == 0
+    assert a != 0
+    assert not b == 0
+    assert b != 1
+    assert not c == 1
+    assert c != 1
+
     with pytest.raises(TypeError):
         assert a <= b
 
@@ -105,8 +134,12 @@ def __ge__(self, other: Self) -> bool:
         return self.x >= other.x
 
 
-@pytest.mark.parametrize("ty", (Ordered, PyOrdered), ids=("rust", "python"))
-def test_ordered(ty: Type[Union[Ordered, PyOrdered]]):
+@pytest.mark.parametrize(
+    "ty",
+    (Ordered, OrderedDerived, OrderedRichCmp, PyOrdered),
+    ids=("rust", "rust-derived", "rust-richcmp", "python"),
+)
+def test_ordered(ty: Type[Union[Ordered, OrderedDerived, OrderedRichCmp, PyOrdered]]):
     a = ty(0)
     b = ty(0)
     c = ty(1)
diff --git a/pytests/tests/test_datetime.py b/pytests/tests/test_datetime.py
index c81d13a929a..6484b926a96 100644
--- a/pytests/tests/test_datetime.py
+++ b/pytests/tests/test_datetime.py
@@ -56,11 +56,11 @@ def tzname(self, dt):
 IS_WINDOWS = sys.platform == "win32"
 
 if IS_WINDOWS:
-    MIN_DATETIME = pdt.datetime(1971, 1, 2, 0, 0)
+    MIN_DATETIME = pdt.datetime(1970, 1, 1, 0, 0, 0)
     if IS_32_BIT:
-        MAX_DATETIME = pdt.datetime(3001, 1, 19, 4, 59, 59)
+        MAX_DATETIME = pdt.datetime(2038, 1, 18, 23, 59, 59)
     else:
-        MAX_DATETIME = pdt.datetime(3001, 1, 19, 7, 59, 59)
+        MAX_DATETIME = pdt.datetime(3000, 12, 31, 23, 59, 59)
 else:
     if IS_32_BIT:
         # TS ±2147483648 (2**31)
@@ -93,11 +93,21 @@ def test_invalid_date_fails():
 
 @given(d=st.dates(MIN_DATETIME.date(), MAX_DATETIME.date()))
 def test_date_from_timestamp(d):
-    if PYPY and d < pdt.date(1900, 1, 1):
-        pytest.xfail("pdt.datetime.timestamp will raise on PyPy with dates before 1900")
-
-    ts = pdt.datetime.timestamp(pdt.datetime.combine(d, pdt.time(0)))
-    assert rdt.date_from_timestamp(int(ts)) == pdt.date.fromtimestamp(ts)
+    try:
+        ts = pdt.datetime.timestamp(d)
+    except Exception:
+        # out of range for timestamp
+        return
+
+    try:
+        expected = pdt.date.fromtimestamp(ts)
+    except Exception as pdt_fail:
+        # date from timestamp failed; expect the same from Rust binding
+        with pytest.raises(type(pdt_fail)) as exc_info:
+            rdt.date_from_timestamp(ts)
+        assert str(exc_info.value) == str(pdt_fail)
+    else:
+        assert rdt.date_from_timestamp(int(ts)) == expected
 
 
 @pytest.mark.parametrize(
@@ -229,11 +239,21 @@ def test_datetime_typeerror():
 @given(dt=st.datetimes(MIN_DATETIME, MAX_DATETIME))
 @example(dt=pdt.datetime(1971, 1, 2, 0, 0))
 def test_datetime_from_timestamp(dt):
-    if PYPY and dt < pdt.datetime(1900, 1, 1):
-        pytest.xfail("pdt.datetime.timestamp will raise on PyPy with dates before 1900")
-
-    ts = pdt.datetime.timestamp(dt)
-    assert rdt.datetime_from_timestamp(ts) == pdt.datetime.fromtimestamp(ts)
+    try:
+        ts = pdt.datetime.timestamp(dt)
+    except Exception:
+        # out of range for timestamp
+        return
+
+    try:
+        expected = pdt.datetime.fromtimestamp(ts)
+    except Exception as pdt_fail:
+        # datetime from timestamp failed; expect the same from Rust binding
+        with pytest.raises(type(pdt_fail)) as exc_info:
+            rdt.datetime_from_timestamp(ts)
+        assert str(exc_info.value) == str(pdt_fail)
+    else:
+        assert rdt.datetime_from_timestamp(ts) == expected
 
 
 def test_datetime_from_timestamp_tzinfo():
diff --git a/pytests/tests/test_enums.py b/pytests/tests/test_enums.py
index 04b0cdca431..cd4f7e124c9 100644
--- a/pytests/tests/test_enums.py
+++ b/pytests/tests/test_enums.py
@@ -18,6 +18,12 @@ def test_complex_enum_variant_constructors():
     multi_field_struct_variant = enums.ComplexEnum.MultiFieldStruct(42, 3.14, True)
     assert isinstance(multi_field_struct_variant, enums.ComplexEnum.MultiFieldStruct)
 
+    variant_with_default_1 = enums.ComplexEnum.VariantWithDefault()
+    assert isinstance(variant_with_default_1, enums.ComplexEnum.VariantWithDefault)
+
+    variant_with_default_2 = enums.ComplexEnum.VariantWithDefault(25, "Hello")
+    assert isinstance(variant_with_default_2, enums.ComplexEnum.VariantWithDefault)
+
 
 @pytest.mark.parametrize(
     "variant",
@@ -27,6 +33,7 @@ def test_complex_enum_variant_constructors():
         enums.ComplexEnum.Str("hello"),
         enums.ComplexEnum.EmptyStruct(),
         enums.ComplexEnum.MultiFieldStruct(42, 3.14, True),
+        enums.ComplexEnum.VariantWithDefault(),
     ],
 )
 def test_complex_enum_variant_subclasses(variant: enums.ComplexEnum):
@@ -48,6 +55,10 @@ def test_complex_enum_field_getters():
     assert multi_field_struct_variant.b == 3.14
     assert multi_field_struct_variant.c is True
 
+    variant_with_default = enums.ComplexEnum.VariantWithDefault()
+    assert variant_with_default.a == 42
+    assert variant_with_default.b is None
+
 
 @pytest.mark.parametrize(
     "variant",
@@ -57,6 +68,7 @@ def test_complex_enum_field_getters():
         enums.ComplexEnum.Str("hello"),
         enums.ComplexEnum.EmptyStruct(),
         enums.ComplexEnum.MultiFieldStruct(42, 3.14, True),
+        enums.ComplexEnum.VariantWithDefault(),
     ],
 )
 def test_complex_enum_desugared_match(variant: enums.ComplexEnum):
@@ -78,6 +90,11 @@ def test_complex_enum_desugared_match(variant: enums.ComplexEnum):
         assert x == 42
         assert y == 3.14
         assert z is True
+    elif isinstance(variant, enums.ComplexEnum.VariantWithDefault):
+        x = variant.a
+        y = variant.b
+        assert x == 42
+        assert y is None
     else:
         assert False
 
@@ -90,6 +107,7 @@ def test_complex_enum_desugared_match(variant: enums.ComplexEnum):
         enums.ComplexEnum.Str("hello"),
         enums.ComplexEnum.EmptyStruct(),
         enums.ComplexEnum.MultiFieldStruct(42, 3.14, True),
+        enums.ComplexEnum.VariantWithDefault(b="hello"),
     ],
 )
 def test_complex_enum_pyfunction_in_out_desugared_match(variant: enums.ComplexEnum):
@@ -112,5 +130,74 @@ def test_complex_enum_pyfunction_in_out_desugared_match(variant: enums.ComplexEn
         assert x == 42
         assert y == 3.14
         assert z is True
+    elif isinstance(variant, enums.ComplexEnum.VariantWithDefault):
+        x = variant.a
+        y = variant.b
+        assert x == 84
+        assert y == "HELLO"
     else:
         assert False
+
+
+def test_tuple_enum_variant_constructors():
+    tuple_variant = enums.TupleEnum.Full(42, 3.14, False)
+    assert isinstance(tuple_variant, enums.TupleEnum.Full)
+
+    empty_tuple_variant = enums.TupleEnum.EmptyTuple()
+    assert isinstance(empty_tuple_variant, enums.TupleEnum.EmptyTuple)
+
+
+@pytest.mark.parametrize(
+    "variant",
+    [
+        enums.TupleEnum.FullWithDefault(),
+        enums.TupleEnum.Full(42, 3.14, False),
+        enums.TupleEnum.EmptyTuple(),
+    ],
+)
+def test_tuple_enum_variant_subclasses(variant: enums.TupleEnum):
+    assert isinstance(variant, enums.TupleEnum)
+
+
+def test_tuple_enum_defaults():
+    variant = enums.TupleEnum.FullWithDefault()
+    assert variant._0 == 1
+    assert variant._1 == 1.0
+    assert variant._2 is True
+
+
+def test_tuple_enum_field_getters():
+    tuple_variant = enums.TupleEnum.Full(42, 3.14, False)
+    assert tuple_variant._0 == 42
+    assert tuple_variant._1 == 3.14
+    assert tuple_variant._2 is False
+
+
+def test_tuple_enum_index_getter():
+    tuple_variant = enums.TupleEnum.Full(42, 3.14, False)
+    assert len(tuple_variant) == 3
+    assert tuple_variant[0] == 42
+
+
+@pytest.mark.parametrize(
+    "variant",
+    [enums.MixedComplexEnum.Nothing()],
+)
+def test_mixed_complex_enum_pyfunction_instance_nothing(
+    variant: enums.MixedComplexEnum,
+):
+    assert isinstance(variant, enums.MixedComplexEnum.Nothing)
+    assert isinstance(
+        enums.do_mixed_complex_stuff(variant), enums.MixedComplexEnum.Empty
+    )
+
+
+@pytest.mark.parametrize(
+    "variant",
+    [enums.MixedComplexEnum.Empty()],
+)
+def test_mixed_complex_enum_pyfunction_instance_empty(variant: enums.MixedComplexEnum):
+    assert isinstance(variant, enums.MixedComplexEnum.Empty)
+    assert isinstance(
+        enums.do_mixed_complex_stuff(variant), enums.MixedComplexEnum.Nothing
+    )
diff --git a/pytests/tests/test_enums_match.py b/pytests/tests/test_enums_match.py
index 4d55bbbe351..6c4b5f6aa07 100644
--- a/pytests/tests/test_enums_match.py
+++ b/pytests/tests/test_enums_match.py
@@ -57,3 +57,102 @@ def test_complex_enum_pyfunction_in_out(variant: enums.ComplexEnum):
             assert z is True
         case _:
             assert False
+
+
+@pytest.mark.parametrize(
+    "variant",
+    [
+        enums.ComplexEnum.MultiFieldStruct(42, 3.14, True),
+    ],
+)
+def test_complex_enum_partial_match(variant: enums.ComplexEnum):
+    match variant:
+        case enums.ComplexEnum.MultiFieldStruct(a):
+            assert a == 42
+        case _:
+            assert False
+
+
+@pytest.mark.parametrize(
+    "variant",
+    [
+        enums.TupleEnum.Full(42, 3.14, True),
+        enums.TupleEnum.EmptyTuple(),
+    ],
+)
+def test_tuple_enum_match_statement(variant: enums.TupleEnum):
+    match variant:
+        case enums.TupleEnum.Full(_0=x, _1=y, _2=z):
+            assert x == 42
+            assert y == 3.14
+            assert z is True
+        case enums.TupleEnum.EmptyTuple():
+            assert True
+        case _:
+            print(variant)
+            assert False
+
+
+@pytest.mark.parametrize(
+    "variant",
+    [
+        enums.SimpleTupleEnum.Int(42),
+        enums.SimpleTupleEnum.Str("hello"),
+    ],
+)
+def test_simple_tuple_enum_match_statement(variant: enums.SimpleTupleEnum):
+    match variant:
+        case enums.SimpleTupleEnum.Int(x):
+            assert x == 42
+        case enums.SimpleTupleEnum.Str(x):
+            assert x == "hello"
+        case _:
+            assert False
+
+
+@pytest.mark.parametrize(
+    "variant",
+    [
+        enums.TupleEnum.Full(42, 3.14, True),
+    ],
+)
+def test_tuple_enum_match_match_args(variant: enums.TupleEnum):
+    match variant:
+        case enums.TupleEnum.Full(x, y, z):
+            assert x == 42
+            assert y == 3.14
+            assert z is True
+            assert True
+        case _:
+            assert False
+
+
+@pytest.mark.parametrize(
+    "variant",
+    [
+        enums.TupleEnum.Full(42, 3.14, True),
+    ],
+)
+def test_tuple_enum_partial_match(variant: enums.TupleEnum):
+    match variant:
+        case enums.TupleEnum.Full(a):
+            assert a == 42
+        case _:
+            assert False
+
+
+@pytest.mark.parametrize(
+    "variant",
+    [
+        enums.MixedComplexEnum.Nothing(),
+        enums.MixedComplexEnum.Empty(),
+    ],
+)
+def test_mixed_complex_enum_match_statement(variant: enums.MixedComplexEnum):
+    match variant:
+        case enums.MixedComplexEnum.Nothing():
+            assert True
+        case enums.MixedComplexEnum.Empty():
+            assert True
+        case _:
+            assert False
diff --git a/pytests/tests/test_hammer_attaching_in_thread.py b/pytests/tests/test_hammer_attaching_in_thread.py
new file mode 100644
index 00000000000..15ec8953bc6
--- /dev/null
+++ b/pytests/tests/test_hammer_attaching_in_thread.py
@@ -0,0 +1,28 @@
+import sysconfig
+
+import pytest
+
+from pyo3_pytests import misc
+
+
+def make_loop():
+    # create a reference loop that will only be destroyed when the GC is called at the end
+    # of execution
+    start = []
+    cur = [start]
+    for _ in range(1000 * 1000 * 10):
+        cur = [cur]
+    start.append(cur)
+    return start
+
+
+# set a bomb that will explode when modules are cleaned up
+loopy = [make_loop()]
+
+
+@pytest.mark.skipif(
+    sysconfig.get_config_var("Py_DEBUG"),
+    reason="causes a crash on debug builds, see discussion in https://github.com/PyO3/pyo3/pull/4874",
+)
+def test_hammer_attaching_in_thread():
+    loopy.append(misc.hammer_attaching_in_thread())
diff --git a/pytests/tests/test_misc.py b/pytests/tests/test_misc.py
index 6645f942f1a..dd7f8007e81 100644
--- a/pytests/tests/test_misc.py
+++ b/pytests/tests/test_misc.py
@@ -5,6 +5,11 @@
 import pyo3_pytests.misc
 import pytest
 
+if sys.version_info >= (3, 13):
+    subinterpreters = pytest.importorskip("_interpreters")
+else:
+    subinterpreters = pytest.importorskip("_xxsubinterpreters")
+
 
 def test_issue_219():
     # Should not deadlock
@@ -27,33 +32,43 @@ def test_multiple_imports_same_interpreter_ok():
     reason="Cannot identify subinterpreters on Python older than 3.9",
 )
 @pytest.mark.skipif(
-    platform.python_implementation() == "PyPy",
-    reason="PyPy does not support subinterpreters",
+    platform.python_implementation() in ("PyPy", "GraalVM"),
+    reason="PyPy and GraalPy do not support subinterpreters",
 )
 def test_import_in_subinterpreter_forbidden():
-    import _xxsubinterpreters
-
+    sub_interpreter = subinterpreters.create()
     if sys.version_info < (3, 12):
         expected_error = "PyO3 modules do not yet support subinterpreters, see https://github.com/PyO3/pyo3/issues/576"
     else:
         expected_error = "module pyo3_pytests.pyo3_pytests does not support loading in subinterpreters"
 
-    sub_interpreter = _xxsubinterpreters.create()
-    with pytest.raises(
-        _xxsubinterpreters.RunFailedError,
-        match=expected_error,
-    ):
-        _xxsubinterpreters.run_string(
+    if sys.version_info < (3, 13):
+        # Python 3.12 subinterpreters had a special error for this
+        with pytest.raises(
+            subinterpreters.RunFailedError,
+            match=expected_error,
+        ):
+            subinterpreters.run_string(
+                sub_interpreter, "import pyo3_pytests.pyo3_pytests"
+            )
+    else:
+        res = subinterpreters.run_string(
             sub_interpreter, "import pyo3_pytests.pyo3_pytests"
         )
+        assert res.type.__name__ == "ImportError"
+        assert res.msg == expected_error
 
-    _xxsubinterpreters.destroy(sub_interpreter)
+    subinterpreters.destroy(sub_interpreter)
 
 
-def test_type_full_name_includes_module():
+def test_type_fully_qualified_name_includes_module():
     numpy = pytest.importorskip("numpy")
 
-    assert pyo3_pytests.misc.get_type_full_name(numpy.bool_(True)) == "numpy.bool_"
+    # For numpy 1.x and 2.x
+    assert pyo3_pytests.misc.get_type_fully_qualified_name(numpy.bool_(True)) in [
+        "numpy.bool",
+        "numpy.bool_",
+    ]
 
 
 def test_accepts_numpy_bool():
diff --git a/pytests/tests/test_objstore.py b/pytests/tests/test_objstore.py
index bfd8bad84df..3f0d23fa97c 100644
--- a/pytests/tests/test_objstore.py
+++ b/pytests/tests/test_objstore.py
@@ -12,6 +12,11 @@ def test_objstore_doesnot_leak_memory():
     # check refcount on PyPy
     getrefcount = getattr(sys, "getrefcount", lambda obj: 0)
 
+    if sys.implementation.name == "graalpy":
+        # GraalPy has an incomplete sys.getrefcount implementation
+        def getrefcount(obj):
+            return 0
+
     before = getrefcount(message)
     store = ObjStore()
     for _ in range(N):
diff --git a/pytests/tests/test_othermod.py b/pytests/tests/test_othermod.py
index ff67bba435c..f2dd9ad8fd2 100644
--- a/pytests/tests/test_othermod.py
+++ b/pytests/tests/test_othermod.py
@@ -3,11 +3,16 @@
 
 from pyo3_pytests import othermod
 
-INTEGER32_ST = st.integers(min_value=(-(2**31)), max_value=(2**31 - 1))
+INTEGER31_ST = st.integers(min_value=(-(2**30)), max_value=(2**30 - 1))
 USIZE_ST = st.integers(min_value=othermod.USIZE_MIN, max_value=othermod.USIZE_MAX)
 
 
-@given(x=INTEGER32_ST)
+# If the full 32 bits are used here, then you can get failures that look like this:
+# hypothesis.errors.FailedHealthCheck: It looks like your strategy is filtering out a lot of data.
+# Health check found 50 filtered examples but only 7 good ones.
+#
+# Limit the range to 31 bits to avoid this problem.
+@given(x=INTEGER31_ST)
 def test_double(x):
     expected = x * 2
     assume(-(2**31) <= expected <= (2**31 - 1))
diff --git a/pytests/tests/test_path.py b/pytests/tests/test_path.py
index 21240187356..d1d6eb83924 100644
--- a/pytests/tests/test_path.py
+++ b/pytests/tests/test_path.py
@@ -7,21 +7,21 @@
 
 def test_make_path():
     p = rpath.make_path()
-    assert p == "/root"
+    assert p == pathlib.Path("/root")
 
 
 def test_take_pathbuf():
     p = "/root"
-    assert rpath.take_pathbuf(p) == p
+    assert rpath.take_pathbuf(p) == pathlib.Path(p)
 
 
 def test_take_pathlib():
     p = pathlib.Path("/root")
-    assert rpath.take_pathbuf(p) == str(p)
+    assert rpath.take_pathbuf(p) == p
 
 
 def test_take_pathlike():
-    assert rpath.take_pathbuf(PathLike("/root")) == "/root"
+    assert rpath.take_pathbuf(PathLike("/root")) == pathlib.Path("/root")
 
 
 def test_take_invalid_pathlike():
diff --git a/pytests/tests/test_pyclasses.py b/pytests/tests/test_pyclasses.py
index 9a9b44b52e8..04430736733 100644
--- a/pytests/tests/test_pyclasses.py
+++ b/pytests/tests/test_pyclasses.py
@@ -1,3 +1,5 @@
+import platform
+import sys
 from typing import Type
 
 import pytest
@@ -8,14 +10,38 @@ def test_empty_class_init(benchmark):
     benchmark(pyclasses.EmptyClass)
 
 
+def test_method_call(benchmark):
+    obj = pyclasses.EmptyClass()
+    assert benchmark(obj.method) is None
+
+
+def test_proto_call(benchmark):
+    obj = pyclasses.EmptyClass()
+    assert benchmark(len, obj) == 0
+
+
 class EmptyClassPy:
-    pass
+    def method(self):
+        pass
+
+    def __len__(self) -> int:
+        return 0
 
 
 def test_empty_class_init_py(benchmark):
     benchmark(EmptyClassPy)
 
 
+def test_method_call_py(benchmark):
+    obj = EmptyClassPy()
+    assert benchmark(obj.method) == pyclasses.EmptyClass().method()
+
+
+def test_proto_call_py(benchmark):
+    obj = EmptyClassPy()
+    assert benchmark(len, obj) == len(pyclasses.EmptyClass())
+
+
 def test_iter():
     i = pyclasses.PyClassIter()
     assert next(i) == 1
@@ -29,22 +55,31 @@ def test_iter():
     assert excinfo.value.value == "Ended"
 
 
-class AssertingSubClass(pyclasses.AssertingBaseClass):
-    pass
+@pytest.mark.skipif(
+    platform.machine() in ["wasm32", "wasm64"],
+    reason="not supporting threads in CI for WASM yet",
+)
+def test_parallel_iter():
+    import concurrent.futures
 
+    i = pyclasses.PyClassThreadIter()
 
-def test_new_classmethod():
-    # The `AssertingBaseClass` constructor errors if it is not passed the
-    # relevant subclass.
-    _ = AssertingSubClass(expected_type=AssertingSubClass)
-    with pytest.raises(ValueError):
-        _ = AssertingSubClass(expected_type=str)
+    # the second thread attempts to borrow a reference to the instance's
+    # state while the first thread is still sleeping, so we trigger a
+    # runtime borrow-check error
+    with pytest.raises(RuntimeError, match="Already borrowed"):
+        with concurrent.futures.ThreadPoolExecutor(max_workers=2) as tpe:
+            # should never reach 100 iterations, should error out as soon
+            # as the borrow error occurs
+            for _ in tpe.map(lambda _: next(i), range(100)):
+                pass
 
 
-def test_new_classmethod_gil_ref():
-    class AssertingSubClass(pyclasses.AssertingBaseClassGilRef):
-        pass
+class AssertingSubClass(pyclasses.AssertingBaseClass):
+    pass
+
 
+def test_new_classmethod():
     # The `AssertingBaseClass` constructor errors if it is not passed the
     # relevant subclass.
     _ = AssertingSubClass(expected_type=AssertingSubClass)
@@ -52,22 +87,80 @@ class AssertingSubClass(pyclasses.AssertingBaseClassGilRef):
         _ = AssertingSubClass(expected_type=str)
 
 
-class ClassWithoutConstructorPy:
+class ClassWithoutConstructor:
     def __new__(cls):
-        raise TypeError("No constructor defined")
+        raise TypeError(
+            f"cannot create '{cls.__module__}.{cls.__qualname__}' instances"
+        )
 
 
+@pytest.mark.xfail(
+    platform.python_implementation() == "PyPy" and sys.version_info[:2] == (3, 11),
+    reason="broken on PyPy 3.11 due to https://github.com/pypy/pypy/issues/5319, waiting for next release",
+)
 @pytest.mark.parametrize(
-    "cls", [pyclasses.ClassWithoutConstructor, ClassWithoutConstructorPy]
+    "cls, exc_message",
+    [
+        (
+            pyclasses.ClassWithoutConstructor,
+            "cannot create 'builtins.ClassWithoutConstructor' instances",
+        ),
+        (
+            ClassWithoutConstructor,
+            "cannot create 'test_pyclasses.ClassWithoutConstructor' instances",
+        ),
+    ],
 )
-def test_no_constructor_defined_propagates_cause(cls: Type):
+def test_no_constructor_defined_propagates_cause(cls: Type, exc_message: str):
     original_error = ValueError("Original message")
     with pytest.raises(Exception) as exc_info:
         try:
             raise original_error
         except Exception:
-            cls()  # should raise TypeError("No constructor defined")
+            cls()  # should raise TypeError("No constructor defined for ...")
 
     assert exc_info.type is TypeError
-    assert exc_info.value.args == ("No constructor defined",)
+    assert exc_info.value.args == (exc_message,)
     assert exc_info.value.__context__ is original_error
+
+
+def test_dict():
+    try:
+        ClassWithDict = pyclasses.ClassWithDict
+    except AttributeError:
+        pytest.skip("not defined using abi3 < 3.9")
+
+    d = ClassWithDict()
+    assert d.__dict__ == {}
+
+    d.foo = 42
+    assert d.__dict__ == {"foo": 42}
+
+
+def test_getter(benchmark):
+    obj = pyclasses.ClassWithDecorators()
+    benchmark(lambda: obj.attr)
+
+
+def test_setter(benchmark):
+    obj = pyclasses.ClassWithDecorators()
+
+    def set_attr():
+        obj.attr = 42
+
+    benchmark(set_attr)
+
+
+def test_class_attribute(benchmark):
+    cls = pyclasses.ClassWithDecorators
+    benchmark(lambda: cls.cls_attribute)
+
+
+def test_class_method(benchmark):
+    cls = pyclasses.ClassWithDecorators
+    benchmark(lambda: cls.cls_method())
+
+
+def test_static_method(benchmark):
+    cls = pyclasses.ClassWithDecorators
+    benchmark(lambda: cls.static_method())
diff --git a/pytests/tests/test_pyfunctions.py b/pytests/tests/test_pyfunctions.py
index c6fb448248b..e33d4d6f102 100644
--- a/pytests/tests/test_pyfunctions.py
+++ b/pytests/tests/test_pyfunctions.py
@@ -1,3 +1,5 @@
+from typing import Any, Tuple
+
 from pyo3_pytests import pyfunctions
 
 
@@ -58,7 +60,7 @@ def test_simple_kwargs_rs(benchmark):
 
 
 def simple_args_kwargs_py(a, b=None, *args, c=None, **kwargs):
-    return (a, b, args, c, kwargs)
+    return a, b, args, c, kwargs
 
 
 def test_simple_args_kwargs_py(benchmark):
@@ -72,7 +74,7 @@ def test_simple_args_kwargs_rs(benchmark):
 
 
 def args_kwargs_py(*args, **kwargs):
-    return (args, kwargs)
+    return args, kwargs
 
 
 def test_args_kwargs_py(benchmark):
@@ -83,3 +85,88 @@ def test_args_kwargs_rs(benchmark):
     rust = benchmark(pyfunctions.args_kwargs, 1, "foo", {1: 2}, bar=4, foo=10)
     py = args_kwargs_py(1, "foo", {1: 2}, bar=4, foo=10)
     assert rust == py
+
+
+# TODO: the second argument should be positional-only
+# but can't be without breaking tests on Python 3.7.
+# See gh-5095.
+def positional_only_py(a, b):
+    return a, b
+
+
+def test_positional_only_py(benchmark):
+    benchmark(positional_only_py, 1, "foo")
+
+
+def test_positional_only_rs(benchmark):
+    rust = benchmark(pyfunctions.positional_only, 1, "foo")
+    py = positional_only_py(1, "foo")
+    assert rust == py
+
+
+def with_typed_args_py(
+    a: bool, b: int, c: float, d: str
+) -> Tuple[bool, int, float, str]:
+    return a, b, c, d
+
+
+def test_with_typed_args_py(benchmark):
+    benchmark(with_typed_args_py, True, 1, 1.2, "foo")
+
+
+def test_with_typed_args_rs(benchmark):
+    rust = benchmark(pyfunctions.with_typed_args, True, 1, 1.2, "foo")
+    py = with_typed_args_py(True, 1, 1.2, "foo")
+    assert rust == py
+
+
+def many_keyword_arguments_py(
+    *,
+    ant: Any = None,
+    bear: Any = None,
+    cat: Any = None,
+    dog: Any = None,
+    elephant: Any = None,
+    fox: Any = None,
+    goat: Any = None,
+    horse: Any = None,
+    iguana: Any = None,
+    jaguar: Any = None,
+    koala: Any = None,
+    lion: Any = None,
+    monkey: Any = None,
+    newt: Any = None,
+    owl: Any = None,
+    penguin: Any = None,
+): ...
+
+
+def call_with_many_keyword_arguments(f) -> Any:
+    return f(
+        ant=True,
+        bear=1,
+        cat=1.2,
+        dog="foo",
+        elephant=None,
+        fox=8,
+        goat=9,
+        horse=10,
+        iguana=None,
+        jaguar=None,
+        koala=None,
+        lion=11,
+        owl=None,
+        penguin=None,
+    )
+
+
+def test_many_keyword_arguments_py(benchmark):
+    benchmark(call_with_many_keyword_arguments, many_keyword_arguments_py)
+
+
+def test_many_keyword_arguments_rs(benchmark):
+    rust = benchmark(
+        call_with_many_keyword_arguments, pyfunctions.many_keyword_arguments
+    )
+    py = call_with_many_keyword_arguments(many_keyword_arguments_py)
+    assert rust == py
diff --git a/src/buffer.rs b/src/buffer.rs
index 84b08289771..081f520e795 100644
--- a/src/buffer.rs
+++ b/src/buffer.rs
@@ -19,37 +19,51 @@
 
 //! `PyBuffer` implementation
 use crate::{err, exceptions::PyBufferError, ffi, FromPyObject, PyAny, PyResult, Python};
-use crate::{Bound, PyNativeType};
-use std::marker::PhantomData;
-use std::os::raw;
+use crate::{Borrowed, Bound, PyErr};
+use std::ffi::{
+    c_char, c_int, c_long, c_longlong, c_schar, c_short, c_uchar, c_uint, c_ulong, c_ulonglong,
+    c_ushort, c_void,
+};
+use std::marker::{PhantomData, PhantomPinned};
 use std::pin::Pin;
 use std::{cell, mem, ptr, slice};
 use std::{ffi::CStr, fmt::Debug};
 
 /// Allows access to the underlying buffer used by a python object such as `bytes`, `bytearray` or `array.array`.
-// use Pin<Box> because Python expects that the Py_buffer struct has a stable memory address
 #[repr(transparent)]
-pub struct PyBuffer<T>(Pin<Box<ffi::Py_buffer>>, PhantomData<T>);
+pub struct PyBuffer<T>(
+    // It is common for exporters filling `Py_buffer` struct to make it self-referential, e.g. see
+    // implementation of
+    // [`PyBuffer_FillInfo`](https://github.com/python/cpython/blob/2fd43a1ffe4ff1f6c46f6045bc327d6085c40fbf/Objects/abstract.c#L798-L802).
+    //
+    // Therefore we use `Pin<Box<...>>` to ensure that the memory address of the `Py_buffer` is stable
+    Pin<Box<RawBuffer>>,
+    PhantomData<T>,
+);
+
+/// Wrapper around `ffi::Py_buffer` to be `!Unpin`.
+#[repr(transparent)]
+struct RawBuffer(ffi::Py_buffer, PhantomPinned);
 
 // PyBuffer is thread-safe: the shape of the buffer is immutable while a Py_buffer exists.
-// Accessing the buffer contents is protected using the GIL.
 unsafe impl<T> Send for PyBuffer<T> {}
 unsafe impl<T> Sync for PyBuffer<T> {}
 
 impl<T> Debug for PyBuffer<T> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let raw = self.raw();
         f.debug_struct("PyBuffer")
-            .field("buf", &self.0.buf)
-            .field("obj", &self.0.obj)
-            .field("len", &self.0.len)
-            .field("itemsize", &self.0.itemsize)
-            .field("readonly", &self.0.readonly)
-            .field("ndim", &self.0.ndim)
-            .field("format", &self.0.format)
-            .field("shape", &self.0.shape)
-            .field("strides", &self.0.strides)
-            .field("suboffsets", &self.0.suboffsets)
-            .field("internal", &self.0.internal)
+            .field("buf", &raw.buf)
+            .field("obj", &raw.obj)
+            .field("len", &raw.len)
+            .field("itemsize", &raw.itemsize)
+            .field("readonly", &raw.readonly)
+            .field("ndim", &raw.ndim)
+            .field("format", &self.format())
+            .field("shape", &self.shape())
+            .field("strides", &self.strides())
+            .field("suboffsets", &self.suboffsets())
+            .field("internal", &raw.internal)
             .finish()
     }
 }
@@ -96,38 +110,38 @@ fn native_element_type_from_type_char(type_char: u8) -> ElementType {
     use self::ElementType::*;
     match type_char {
         b'c' => UnsignedInteger {
-            bytes: mem::size_of::<raw::c_char>(),
+            bytes: mem::size_of::<c_char>(),
         },
         b'b' => SignedInteger {
-            bytes: mem::size_of::<raw::c_schar>(),
+            bytes: mem::size_of::<c_schar>(),
         },
         b'B' => UnsignedInteger {
-            bytes: mem::size_of::<raw::c_uchar>(),
+            bytes: mem::size_of::<c_uchar>(),
         },
         b'?' => Bool,
         b'h' => SignedInteger {
-            bytes: mem::size_of::<raw::c_short>(),
+            bytes: mem::size_of::<c_short>(),
         },
         b'H' => UnsignedInteger {
-            bytes: mem::size_of::<raw::c_ushort>(),
+            bytes: mem::size_of::<c_ushort>(),
         },
         b'i' => SignedInteger {
-            bytes: mem::size_of::<raw::c_int>(),
+            bytes: mem::size_of::<c_int>(),
         },
         b'I' => UnsignedInteger {
-            bytes: mem::size_of::<raw::c_uint>(),
+            bytes: mem::size_of::<c_uint>(),
         },
         b'l' => SignedInteger {
-            bytes: mem::size_of::<raw::c_long>(),
+            bytes: mem::size_of::<c_long>(),
         },
         b'L' => UnsignedInteger {
-            bytes: mem::size_of::<raw::c_ulong>(),
+            bytes: mem::size_of::<c_ulong>(),
         },
         b'q' => SignedInteger {
-            bytes: mem::size_of::<raw::c_longlong>(),
+            bytes: mem::size_of::<c_longlong>(),
         },
         b'Q' => UnsignedInteger {
-            bytes: mem::size_of::<raw::c_ulonglong>(),
+            bytes: mem::size_of::<c_ulonglong>(),
         },
         b'n' => SignedInteger {
             bytes: mem::size_of::<libc::ssize_t>(),
@@ -182,51 +196,45 @@ pub unsafe trait Element: Copy {
     fn is_compatible_format(format: &CStr) -> bool;
 }
 
-impl<'py, T: Element> FromPyObject<'py> for PyBuffer<T> {
-    fn extract_bound(obj: &Bound<'_, PyAny>) -> PyResult<PyBuffer<T>> {
-        Self::get_bound(obj)
+impl<T: Element> FromPyObject<'_, '_> for PyBuffer<T> {
+    type Error = PyErr;
+
+    fn extract(obj: Borrowed<'_, '_, PyAny>) -> Result<PyBuffer<T>, Self::Error> {
+        Self::get(&obj)
     }
 }
 
 impl<T: Element> PyBuffer<T> {
-    /// Deprecated form of [`PyBuffer::get_bound`]
-    #[cfg_attr(
-        not(feature = "gil-refs"),
-        deprecated(
-            since = "0.21.0",
-            note = "`PyBuffer::get` will be replaced by `PyBuffer::get_bound` in a future PyO3 version"
-        )
-    )]
-    pub fn get(obj: &PyAny) -> PyResult<PyBuffer<T>> {
-        Self::get_bound(&obj.as_borrowed())
-    }
-
     /// Gets the underlying buffer from the specified python object.
-    pub fn get_bound(obj: &Bound<'_, PyAny>) -> PyResult<PyBuffer<T>> {
-        // TODO: use nightly API Box::new_uninit() once stable
-        let mut buf = Box::new(mem::MaybeUninit::uninit());
-        let buf: Box<ffi::Py_buffer> = {
+    pub fn get(obj: &Bound<'_, PyAny>) -> PyResult<PyBuffer<T>> {
+        let mut buf = Box::<RawBuffer>::new_uninit();
+        let buf: Box<RawBuffer> = {
             err::error_on_minusone(obj.py(), unsafe {
-                ffi::PyObject_GetBuffer(obj.as_ptr(), buf.as_mut_ptr(), ffi::PyBUF_FULL_RO)
+                ffi::PyObject_GetBuffer(
+                    obj.as_ptr(),
+                    // SAFETY: RawBuffer is `#[repr(transparent)]` around FFI struct
+                    buf.as_mut_ptr().cast::<ffi::Py_buffer>(),
+                    ffi::PyBUF_FULL_RO,
+                )
             })?;
             // Safety: buf is initialized by PyObject_GetBuffer.
-            // TODO: use nightly API Box::assume_init() once stable
-            unsafe { mem::transmute(buf) }
+            unsafe { buf.assume_init() }
         };
         // Create PyBuffer immediately so that if validation checks fail, the PyBuffer::drop code
         // will call PyBuffer_Release (thus avoiding any leaks).
         let buf = PyBuffer(Pin::from(buf), PhantomData);
+        let raw = buf.raw();
 
-        if buf.0.shape.is_null() {
+        if raw.shape.is_null() {
             Err(PyBufferError::new_err("shape is null"))
-        } else if buf.0.strides.is_null() {
+        } else if raw.strides.is_null() {
             Err(PyBufferError::new_err("strides is null"))
         } else if mem::size_of::<T>() != buf.item_size() || !T::is_compatible_format(buf.format()) {
             Err(PyBufferError::new_err(format!(
                 "buffer contents are not compatible with {}",
                 std::any::type_name::<T>()
             )))
-        } else if buf.0.buf.align_offset(mem::align_of::<T>()) != 0 {
+        } else if raw.buf.align_offset(mem::align_of::<T>()) != 0 {
             Err(PyBufferError::new_err(format!(
                 "buffer contents are insufficiently aligned for {}",
                 std::any::type_name::<T>()
@@ -235,20 +243,27 @@ impl<T: Element> PyBuffer<T> {
             Ok(buf)
         }
     }
+}
 
+impl<T> PyBuffer<T> {
     /// Gets the pointer to the start of the buffer memory.
     ///
-    /// Warning: the buffer memory might be mutated by other Python functions,
-    /// and thus may only be accessed while the GIL is held.
+    /// Warning: the buffer memory can be mutated by other code (including
+    /// other Python functions, if the GIL is released, or other extension
+    /// modules even if the GIL is held). You must either access memory
+    /// atomically, or ensure there are no data races yourself. See
+    /// [this blog post] for more details.
+    ///
+    /// [this blog post]: https://alexgaynor.net/2022/oct/23/buffers-on-the-edge/
     #[inline]
-    pub fn buf_ptr(&self) -> *mut raw::c_void {
-        self.0.buf
+    pub fn buf_ptr(&self) -> *mut c_void {
+        self.raw().buf
     }
 
     /// Gets a pointer to the specified item.
     ///
     /// If `indices.len() < self.dimensions()`, returns the start address of the sub-array at the specified dimension.
-    pub fn get_ptr(&self, indices: &[usize]) -> *mut raw::c_void {
+    pub fn get_ptr(&self, indices: &[usize]) -> *mut c_void {
         let shape = &self.shape()[..indices.len()];
         for i in 0..indices.len() {
             assert!(indices[i] < shape[i]);
@@ -256,14 +271,14 @@ impl<T: Element> PyBuffer<T> {
         unsafe {
             ffi::PyBuffer_GetPointer(
                 #[cfg(Py_3_11)]
-                &*self.0,
+                self.raw(),
                 #[cfg(not(Py_3_11))]
                 {
-                    &*self.0 as *const ffi::Py_buffer as *mut ffi::Py_buffer
+                    self.raw() as *const ffi::Py_buffer as *mut ffi::Py_buffer
                 },
                 #[cfg(Py_3_11)]
                 {
-                    indices.as_ptr() as *const ffi::Py_ssize_t
+                    indices.as_ptr().cast()
                 },
                 #[cfg(not(Py_3_11))]
                 {
@@ -276,20 +291,20 @@ impl<T: Element> PyBuffer<T> {
     /// Gets whether the underlying buffer is read-only.
     #[inline]
     pub fn readonly(&self) -> bool {
-        self.0.readonly != 0
+        self.raw().readonly != 0
     }
 
     /// Gets the size of a single element, in bytes.
     /// Important exception: when requesting an unformatted buffer, item_size still has the value
     #[inline]
     pub fn item_size(&self) -> usize {
-        self.0.itemsize as usize
+        self.raw().itemsize as usize
     }
 
     /// Gets the total number of items.
     #[inline]
     pub fn item_count(&self) -> usize {
-        (self.0.len as usize) / (self.0.itemsize as usize)
+        (self.raw().len as usize) / (self.raw().itemsize as usize)
     }
 
     /// `item_size() * item_count()`.
@@ -297,7 +312,7 @@ impl<T: Element> PyBuffer<T> {
     /// For non-contiguous arrays, it is the length that the logical structure would have if it were copied to a contiguous representation.
     #[inline]
     pub fn len_bytes(&self) -> usize {
-        self.0.len as usize
+        self.raw().len as usize
     }
 
     /// Gets the number of dimensions.
@@ -305,7 +320,7 @@ impl<T: Element> PyBuffer<T> {
     /// May be 0 to indicate a single scalar value.
     #[inline]
     pub fn dimensions(&self) -> usize {
-        self.0.ndim as usize
+        self.raw().ndim as usize
     }
 
     /// Returns an array of length `dimensions`. `shape()[i]` is the length of the array in dimension number `i`.
@@ -317,7 +332,7 @@ impl<T: Element> PyBuffer<T> {
     /// However, dimensions of length 0 are possible and might need special attention.
     #[inline]
     pub fn shape(&self) -> &[usize] {
-        unsafe { slice::from_raw_parts(self.0.shape as *const usize, self.0.ndim as usize) }
+        unsafe { slice::from_raw_parts(self.raw().shape.cast(), self.raw().ndim as usize) }
     }
 
     /// Returns an array that holds, for each dimension, the number of bytes to skip to get to the next element in the dimension.
@@ -326,7 +341,7 @@ impl<T: Element> PyBuffer<T> {
     /// but a consumer MUST be able to handle the case `strides[n] <= 0`.
     #[inline]
     pub fn strides(&self) -> &[isize] {
-        unsafe { slice::from_raw_parts(self.0.strides, self.0.ndim as usize) }
+        unsafe { slice::from_raw_parts(self.raw().strides, self.raw().ndim as usize) }
     }
 
     /// An array of length ndim.
@@ -337,12 +352,12 @@ impl<T: Element> PyBuffer<T> {
     #[inline]
     pub fn suboffsets(&self) -> Option<&[isize]> {
         unsafe {
-            if self.0.suboffsets.is_null() {
+            if self.raw().suboffsets.is_null() {
                 None
             } else {
                 Some(slice::from_raw_parts(
-                    self.0.suboffsets,
-                    self.0.ndim as usize,
+                    self.raw().suboffsets,
+                    self.raw().ndim as usize,
                 ))
             }
         }
@@ -351,35 +366,31 @@ impl<T: Element> PyBuffer<T> {
     /// A NUL terminated string in struct module style syntax describing the contents of a single item.
     #[inline]
     pub fn format(&self) -> &CStr {
-        if self.0.format.is_null() {
-            CStr::from_bytes_with_nul(b"B\0").unwrap()
+        if self.raw().format.is_null() {
+            c"B"
         } else {
-            unsafe { CStr::from_ptr(self.0.format) }
+            unsafe { CStr::from_ptr(self.raw().format) }
         }
     }
 
     /// Gets whether the buffer is contiguous in C-style order (last index varies fastest when visiting items in order of memory address).
     #[inline]
     pub fn is_c_contiguous(&self) -> bool {
-        unsafe {
-            ffi::PyBuffer_IsContiguous(
-                &*self.0 as *const ffi::Py_buffer,
-                b'C' as std::os::raw::c_char,
-            ) != 0
-        }
+        unsafe { ffi::PyBuffer_IsContiguous(self.raw(), b'C' as std::ffi::c_char) != 0 }
     }
 
     /// Gets whether the buffer is contiguous in Fortran-style order (first index varies fastest when visiting items in order of memory address).
     #[inline]
     pub fn is_fortran_contiguous(&self) -> bool {
-        unsafe {
-            ffi::PyBuffer_IsContiguous(
-                &*self.0 as *const ffi::Py_buffer,
-                b'F' as std::os::raw::c_char,
-            ) != 0
-        }
+        unsafe { ffi::PyBuffer_IsContiguous(self.raw(), b'F' as std::ffi::c_char) != 0 }
+    }
+
+    fn raw(&self) -> &ffi::Py_buffer {
+        &self.0 .0
     }
+}
 
+impl<T: Element> PyBuffer<T> {
     /// Gets the buffer memory as a slice.
     ///
     /// This function succeeds if:
@@ -393,7 +404,7 @@ impl<T: Element> PyBuffer<T> {
         if self.is_c_contiguous() {
             unsafe {
                 Some(slice::from_raw_parts(
-                    self.0.buf as *mut ReadOnlyCell<T>,
+                    self.raw().buf as *mut ReadOnlyCell<T>,
                     self.item_count(),
                 ))
             }
@@ -416,7 +427,7 @@ impl<T: Element> PyBuffer<T> {
         if !self.readonly() && self.is_c_contiguous() {
             unsafe {
                 Some(slice::from_raw_parts(
-                    self.0.buf as *mut cell::Cell<T>,
+                    self.raw().buf as *mut cell::Cell<T>,
                     self.item_count(),
                 ))
             }
@@ -438,7 +449,7 @@ impl<T: Element> PyBuffer<T> {
         if mem::size_of::<T>() == self.item_size() && self.is_fortran_contiguous() {
             unsafe {
                 Some(slice::from_raw_parts(
-                    self.0.buf as *mut ReadOnlyCell<T>,
+                    self.raw().buf as *mut ReadOnlyCell<T>,
                     self.item_count(),
                 ))
             }
@@ -461,7 +472,7 @@ impl<T: Element> PyBuffer<T> {
         if !self.readonly() && self.is_fortran_contiguous() {
             unsafe {
                 Some(slice::from_raw_parts(
-                    self.0.buf as *mut cell::Cell<T>,
+                    self.raw().buf as *mut cell::Cell<T>,
                     self.item_count(),
                 ))
             }
@@ -509,13 +520,13 @@ impl<T: Element> PyBuffer<T> {
             ffi::PyBuffer_ToContiguous(
                 target.as_mut_ptr().cast(),
                 #[cfg(Py_3_11)]
-                &*self.0,
+                self.raw(),
                 #[cfg(not(Py_3_11))]
                 {
-                    &*self.0 as *const ffi::Py_buffer as *mut ffi::Py_buffer
+                    self.raw() as *const ffi::Py_buffer as *mut ffi::Py_buffer
                 },
-                self.0.len,
-                fort as std::os::raw::c_char,
+                self.raw().len,
+                fort as std::ffi::c_char,
             )
         })
     }
@@ -544,15 +555,15 @@ impl<T: Element> PyBuffer<T> {
         // Due to T:Copy, we don't need to be concerned with Drop impls.
         err::error_on_minusone(py, unsafe {
             ffi::PyBuffer_ToContiguous(
-                vec.as_ptr() as *mut raw::c_void,
+                vec.as_ptr() as *mut c_void,
                 #[cfg(Py_3_11)]
-                &*self.0,
+                self.raw(),
                 #[cfg(not(Py_3_11))]
                 {
-                    &*self.0 as *const ffi::Py_buffer as *mut ffi::Py_buffer
+                    self.raw() as *const ffi::Py_buffer as *mut ffi::Py_buffer
                 },
-                self.0.len,
-                fort as std::os::raw::c_char,
+                self.raw().len,
+                fort as std::ffi::c_char,
             )
         })?;
         // set vector length to mark the now-initialized space as usable
@@ -602,21 +613,21 @@ impl<T: Element> PyBuffer<T> {
         err::error_on_minusone(py, unsafe {
             ffi::PyBuffer_FromContiguous(
                 #[cfg(Py_3_11)]
-                &*self.0,
+                self.raw(),
                 #[cfg(not(Py_3_11))]
                 {
-                    &*self.0 as *const ffi::Py_buffer as *mut ffi::Py_buffer
+                    self.raw() as *const ffi::Py_buffer as *mut ffi::Py_buffer
                 },
                 #[cfg(Py_3_11)]
                 {
-                    source.as_ptr() as *const raw::c_void
+                    source.as_ptr().cast()
                 },
                 #[cfg(not(Py_3_11))]
                 {
-                    source.as_ptr() as *mut raw::c_void
+                    source.as_ptr() as *mut c_void
                 },
-                self.0.len,
-                fort as std::os::raw::c_char,
+                self.raw().len,
+                fort as std::ffi::c_char,
             )
         })
     }
@@ -627,24 +638,52 @@ impl<T: Element> PyBuffer<T> {
     /// This will automatically be called on drop.
     pub fn release(self, _py: Python<'_>) {
         // First move self into a ManuallyDrop, so that PyBuffer::drop will
-        // never be called. (It would acquire the GIL and call PyBuffer_Release
+        // never be called. (It would attach to the interpreter and call PyBuffer_Release
         // again.)
         let mut mdself = mem::ManuallyDrop::new(self);
         unsafe {
             // Next, make the actual PyBuffer_Release call.
-            ffi::PyBuffer_Release(&mut *mdself.0);
+            // Fine to get a mutable reference to the inner ffi::Py_buffer here, as we're destroying it.
+            mdself.0.release();
 
             // Finally, drop the contained Pin<Box<_>> in place, to free the
             // Box memory.
-            let inner: *mut Pin<Box<ffi::Py_buffer>> = &mut mdself.0;
-            ptr::drop_in_place(inner);
+            ptr::drop_in_place::<Pin<Box<RawBuffer>>>(&mut mdself.0);
+        }
+    }
+}
+
+impl RawBuffer {
+    /// Release the contents of this pinned buffer.
+    ///
+    /// # Safety
+    ///
+    /// - The buffer must not be used after calling this function.
+    /// - This function can only be called once.
+    /// - Must be attached to the interpreter.
+    ///
+    unsafe fn release(self: &mut Pin<Box<Self>>) {
+        unsafe {
+            ffi::PyBuffer_Release(&mut Pin::get_unchecked_mut(self.as_mut()).0);
         }
     }
 }
 
 impl<T> Drop for PyBuffer<T> {
     fn drop(&mut self) {
-        Python::with_gil(|_| unsafe { ffi::PyBuffer_Release(&mut *self.0) });
+        fn inner(buf: &mut Pin<Box<RawBuffer>>) {
+            if Python::try_attach(|_| unsafe { buf.release() }).is_none()
+                && crate::internal::state::is_in_gc_traversal()
+            {
+                eprintln!("Warning: PyBuffer dropped while in GC traversal, this is a bug and will leak memory.");
+            }
+            // If `try_attach` failed and `is_in_gc_traversal()` is false, then probably the interpreter has
+            // already finalized and we can just assume that the underlying memory has already been freed.
+            //
+            // So we don't handle that case here.
+        }
+
+        inner(&mut self.0);
     }
 }
 
@@ -699,30 +738,28 @@ impl_element!(f64, Float);
 
 #[cfg(test)]
 mod tests {
-    use super::PyBuffer;
+    use super::*;
+
     use crate::ffi;
     use crate::types::any::PyAnyMethods;
+    use crate::types::PyBytes;
     use crate::Python;
 
     #[test]
     fn test_debug() {
-        Python::with_gil(|py| {
-            let bytes = py.eval_bound("b'abcde'", None, None).unwrap();
-            let buffer: PyBuffer<u8> = PyBuffer::get_bound(&bytes).unwrap();
+        Python::attach(|py| {
+            let bytes = PyBytes::new(py, b"abcde");
+            let buffer: PyBuffer<u8> = PyBuffer::get(&bytes).unwrap();
             let expected = format!(
                 concat!(
                     "PyBuffer {{ buf: {:?}, obj: {:?}, ",
                     "len: 5, itemsize: 1, readonly: 1, ",
-                    "ndim: 1, format: {:?}, shape: {:?}, ",
-                    "strides: {:?}, suboffsets: {:?}, internal: {:?} }}",
+                    "ndim: 1, format: \"B\", shape: [5], ",
+                    "strides: [1], suboffsets: None, internal: {:?} }}",
                 ),
-                buffer.0.buf,
-                buffer.0.obj,
-                buffer.0.format,
-                buffer.0.shape,
-                buffer.0.strides,
-                buffer.0.suboffsets,
-                buffer.0.internal
+                buffer.raw().buf,
+                buffer.raw().obj,
+                buffer.raw().internal
             );
             let debug_repr = format!("{:?}", buffer);
             assert_eq!(debug_repr, expected);
@@ -731,129 +768,125 @@ mod tests {
 
     #[test]
     fn test_element_type_from_format() {
-        use super::ElementType;
         use super::ElementType::*;
-        use std::ffi::CStr;
         use std::mem::size_of;
-        use std::os::raw;
 
-        for (cstr, expected) in &[
+        for (cstr, expected) in [
             // @ prefix goes to native_element_type_from_type_char
             (
-                "@b\0",
+                c"@b",
                 SignedInteger {
-                    bytes: size_of::<raw::c_schar>(),
+                    bytes: size_of::<c_schar>(),
                 },
             ),
             (
-                "@c\0",
+                c"@c",
                 UnsignedInteger {
-                    bytes: size_of::<raw::c_char>(),
+                    bytes: size_of::<c_char>(),
                 },
             ),
             (
-                "@b\0",
+                c"@b",
                 SignedInteger {
-                    bytes: size_of::<raw::c_schar>(),
+                    bytes: size_of::<c_schar>(),
                 },
             ),
             (
-                "@B\0",
+                c"@B",
                 UnsignedInteger {
-                    bytes: size_of::<raw::c_uchar>(),
+                    bytes: size_of::<c_uchar>(),
                 },
             ),
-            ("@?\0", Bool),
+            (c"@?", Bool),
             (
-                "@h\0",
+                c"@h",
                 SignedInteger {
-                    bytes: size_of::<raw::c_short>(),
+                    bytes: size_of::<c_short>(),
                 },
             ),
             (
-                "@H\0",
+                c"@H",
                 UnsignedInteger {
-                    bytes: size_of::<raw::c_ushort>(),
+                    bytes: size_of::<c_ushort>(),
                 },
             ),
             (
-                "@i\0",
+                c"@i",
                 SignedInteger {
-                    bytes: size_of::<raw::c_int>(),
+                    bytes: size_of::<c_int>(),
                 },
             ),
             (
-                "@I\0",
+                c"@I",
                 UnsignedInteger {
-                    bytes: size_of::<raw::c_uint>(),
+                    bytes: size_of::<c_uint>(),
                 },
             ),
             (
-                "@l\0",
+                c"@l",
                 SignedInteger {
-                    bytes: size_of::<raw::c_long>(),
+                    bytes: size_of::<c_long>(),
                 },
             ),
             (
-                "@L\0",
+                c"@L",
                 UnsignedInteger {
-                    bytes: size_of::<raw::c_ulong>(),
+                    bytes: size_of::<c_ulong>(),
                 },
             ),
             (
-                "@q\0",
+                c"@q",
                 SignedInteger {
-                    bytes: size_of::<raw::c_longlong>(),
+                    bytes: size_of::<c_longlong>(),
                 },
             ),
             (
-                "@Q\0",
+                c"@Q",
                 UnsignedInteger {
-                    bytes: size_of::<raw::c_ulonglong>(),
+                    bytes: size_of::<c_ulonglong>(),
                 },
             ),
             (
-                "@n\0",
+                c"@n",
                 SignedInteger {
                     bytes: size_of::<libc::ssize_t>(),
                 },
             ),
             (
-                "@N\0",
+                c"@N",
                 UnsignedInteger {
                     bytes: size_of::<libc::size_t>(),
                 },
             ),
-            ("@e\0", Float { bytes: 2 }),
-            ("@f\0", Float { bytes: 4 }),
-            ("@d\0", Float { bytes: 8 }),
-            ("@z\0", Unknown),
+            (c"@e", Float { bytes: 2 }),
+            (c"@f", Float { bytes: 4 }),
+            (c"@d", Float { bytes: 8 }),
+            (c"@z", Unknown),
             // = prefix goes to standard_element_type_from_type_char
-            ("=b\0", SignedInteger { bytes: 1 }),
-            ("=c\0", UnsignedInteger { bytes: 1 }),
-            ("=B\0", UnsignedInteger { bytes: 1 }),
-            ("=?\0", Bool),
-            ("=h\0", SignedInteger { bytes: 2 }),
-            ("=H\0", UnsignedInteger { bytes: 2 }),
-            ("=l\0", SignedInteger { bytes: 4 }),
-            ("=l\0", SignedInteger { bytes: 4 }),
-            ("=I\0", UnsignedInteger { bytes: 4 }),
-            ("=L\0", UnsignedInteger { bytes: 4 }),
-            ("=q\0", SignedInteger { bytes: 8 }),
-            ("=Q\0", UnsignedInteger { bytes: 8 }),
-            ("=e\0", Float { bytes: 2 }),
-            ("=f\0", Float { bytes: 4 }),
-            ("=d\0", Float { bytes: 8 }),
-            ("=z\0", Unknown),
-            ("=0\0", Unknown),
+            (c"=b", SignedInteger { bytes: 1 }),
+            (c"=c", UnsignedInteger { bytes: 1 }),
+            (c"=B", UnsignedInteger { bytes: 1 }),
+            (c"=?", Bool),
+            (c"=h", SignedInteger { bytes: 2 }),
+            (c"=H", UnsignedInteger { bytes: 2 }),
+            (c"=l", SignedInteger { bytes: 4 }),
+            (c"=l", SignedInteger { bytes: 4 }),
+            (c"=I", UnsignedInteger { bytes: 4 }),
+            (c"=L", UnsignedInteger { bytes: 4 }),
+            (c"=q", SignedInteger { bytes: 8 }),
+            (c"=Q", UnsignedInteger { bytes: 8 }),
+            (c"=e", Float { bytes: 2 }),
+            (c"=f", Float { bytes: 4 }),
+            (c"=d", Float { bytes: 8 }),
+            (c"=z", Unknown),
+            (c"=0", Unknown),
             // unknown prefix -> Unknown
-            (":b\0", Unknown),
+            (c":b", Unknown),
         ] {
             assert_eq!(
-                ElementType::from_format(CStr::from_bytes_with_nul(cstr.as_bytes()).unwrap()),
-                *expected,
-                "element from format &Cstr: {:?}",
-                cstr,
+                ElementType::from_format(cstr),
+                expected,
+                "element from format &Cstr: {cstr:?}",
             );
         }
     }
@@ -869,9 +902,9 @@ mod tests {
 
     #[test]
     fn test_bytes_buffer() {
-        Python::with_gil(|py| {
-            let bytes = py.eval_bound("b'abcde'", None, None).unwrap();
-            let buffer = PyBuffer::get_bound(&bytes).unwrap();
+        Python::attach(|py| {
+            let bytes = PyBytes::new(py, b"abcde");
+            let buffer = PyBuffer::get(&bytes).unwrap();
             assert_eq!(buffer.dimensions(), 1);
             assert_eq!(buffer.item_count(), 5);
             assert_eq!(buffer.format().to_str().unwrap(), "B");
@@ -901,19 +934,19 @@ mod tests {
 
     #[test]
     fn test_array_buffer() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let array = py
-                .import_bound("array")
+                .import("array")
                 .unwrap()
                 .call_method("array", ("f", (1.0, 1.5, 2.0, 2.5)), None)
                 .unwrap();
-            let buffer = PyBuffer::get_bound(&array).unwrap();
+            let buffer = PyBuffer::get(&array).unwrap();
             assert_eq!(buffer.dimensions(), 1);
             assert_eq!(buffer.item_count(), 4);
             assert_eq!(buffer.format().to_str().unwrap(), "f");
             assert_eq!(buffer.shape(), [4]);
 
-            // array creates a 1D contiguious buffer, so it's both C and F contiguous.  This would
+            // array creates a 1D contiguous buffer, so it's both C and F contiguous.  This would
             // be more interesting if we can come up with a 2D buffer but I think it would need a
             // third-party lib or a custom class.
 
@@ -937,7 +970,7 @@ mod tests {
             assert_eq!(buffer.to_vec(py).unwrap(), [10.0, 11.0, 12.0, 13.0]);
 
             // F-contiguous fns
-            let buffer = PyBuffer::get_bound(&array).unwrap();
+            let buffer = PyBuffer::get(&array).unwrap();
             let slice = buffer.as_fortran_slice(py).unwrap();
             assert_eq!(slice.len(), 4);
             assert_eq!(slice[1].get(), 11.0);
diff --git a/src/call.rs b/src/call.rs
new file mode 100644
index 00000000000..51e67246ef6
--- /dev/null
+++ b/src/call.rs
@@ -0,0 +1,312 @@
+//! Defines how Python calls are dispatched, see [`PyCallArgs`].for more information.
+
+use crate::ffi_ptr_ext::FfiPtrExt as _;
+use crate::types::{PyAnyMethods as _, PyDict, PyString, PyTuple};
+use crate::{ffi, Borrowed, Bound, IntoPyObjectExt as _, Py, PyAny, PyResult};
+
+pub(crate) mod private {
+    use super::*;
+
+    pub trait Sealed {}
+
+    impl Sealed for () {}
+    impl Sealed for Bound<'_, PyTuple> {}
+    impl Sealed for &'_ Bound<'_, PyTuple> {}
+    impl Sealed for Py<PyTuple> {}
+    impl Sealed for &'_ Py<PyTuple> {}
+    impl Sealed for Borrowed<'_, '_, PyTuple> {}
+    pub struct Token;
+}
+
+/// This trait marks types that can be used as arguments to Python function
+/// calls.
+///
+/// This trait is currently implemented for Rust tuple (up to a size of 12),
+/// [`Bound<'py, PyTuple>`] and [`Py<PyTuple>`]. Custom types that are
+/// convertable to `PyTuple` via `IntoPyObject` need to do so before passing it
+/// to `call`.
+///
+/// This trait is not intended to used by downstream crates directly. As such it
+/// has no publicly available methods and cannot be implemented outside of
+/// `pyo3`. The corresponding public API is available through [`call`]
+/// ([`call0`], [`call1`] and friends) on [`PyAnyMethods`].
+///
+/// # What is `PyCallArgs` used for?
+/// `PyCallArgs` is used internally in `pyo3` to dispatch the Python calls in
+/// the most optimal way for the current build configuration. Certain types,
+/// such as Rust tuples, do allow the usage of a faster calling convention of
+/// the Python interpreter (if available). More types that may take advantage
+/// from this may be added in the future.
+///
+/// [`call0`]: crate::types::PyAnyMethods::call0
+/// [`call1`]: crate::types::PyAnyMethods::call1
+/// [`call`]: crate::types::PyAnyMethods::call
+/// [`PyAnyMethods`]: crate::types::PyAnyMethods
+#[diagnostic::on_unimplemented(
+    message = "`{Self}` cannot used as a Python `call` argument",
+    note = "`PyCallArgs` is implemented for Rust tuples, `Bound<'py, PyTuple>` and `Py<PyTuple>`",
+    note = "if your type is convertable to `PyTuple` via `IntoPyObject`, call `<arg>.into_pyobject(py)` manually",
+    note = "if you meant to pass the type as a single argument, wrap it in a 1-tuple, `(<arg>,)`"
+)]
+pub trait PyCallArgs<'py>: Sized + private::Sealed {
+    #[doc(hidden)]
+    fn call(
+        self,
+        function: Borrowed<'_, 'py, PyAny>,
+        kwargs: Borrowed<'_, 'py, PyDict>,
+        token: private::Token,
+    ) -> PyResult<Bound<'py, PyAny>>;
+
+    #[doc(hidden)]
+    fn call_positional(
+        self,
+        function: Borrowed<'_, 'py, PyAny>,
+        token: private::Token,
+    ) -> PyResult<Bound<'py, PyAny>>;
+
+    #[doc(hidden)]
+    fn call_method_positional(
+        self,
+        object: Borrowed<'_, 'py, PyAny>,
+        method_name: Borrowed<'_, 'py, PyString>,
+        _: private::Token,
+    ) -> PyResult<Bound<'py, PyAny>> {
+        object
+            .getattr(method_name)
+            .and_then(|method| method.call1(self))
+    }
+}
+
+impl<'py> PyCallArgs<'py> for () {
+    fn call(
+        self,
+        function: Borrowed<'_, 'py, PyAny>,
+        kwargs: Borrowed<'_, 'py, PyDict>,
+        token: private::Token,
+    ) -> PyResult<Bound<'py, PyAny>> {
+        let args = self.into_pyobject_or_pyerr(function.py())?;
+        args.call(function, kwargs, token)
+    }
+
+    fn call_positional(
+        self,
+        function: Borrowed<'_, 'py, PyAny>,
+        token: private::Token,
+    ) -> PyResult<Bound<'py, PyAny>> {
+        let args = self.into_pyobject_or_pyerr(function.py())?;
+        args.call_positional(function, token)
+    }
+}
+
+impl<'py> PyCallArgs<'py> for Bound<'py, PyTuple> {
+    #[inline]
+    fn call(
+        self,
+        function: Borrowed<'_, 'py, PyAny>,
+        kwargs: Borrowed<'_, 'py, PyDict>,
+        token: private::Token,
+    ) -> PyResult<Bound<'py, PyAny>> {
+        self.as_borrowed().call(function, kwargs, token)
+    }
+
+    #[inline]
+    fn call_positional(
+        self,
+        function: Borrowed<'_, 'py, PyAny>,
+        token: private::Token,
+    ) -> PyResult<Bound<'py, PyAny>> {
+        self.as_borrowed().call_positional(function, token)
+    }
+}
+
+impl<'py> PyCallArgs<'py> for &'_ Bound<'py, PyTuple> {
+    #[inline]
+    fn call(
+        self,
+        function: Borrowed<'_, 'py, PyAny>,
+        kwargs: Borrowed<'_, 'py, PyDict>,
+        token: private::Token,
+    ) -> PyResult<Bound<'py, PyAny>> {
+        self.as_borrowed().call(function, kwargs, token)
+    }
+
+    #[inline]
+    fn call_positional(
+        self,
+        function: Borrowed<'_, 'py, PyAny>,
+        token: private::Token,
+    ) -> PyResult<Bound<'py, PyAny>> {
+        self.as_borrowed().call_positional(function, token)
+    }
+}
+
+impl<'py> PyCallArgs<'py> for Py<PyTuple> {
+    #[inline]
+    fn call(
+        self,
+        function: Borrowed<'_, 'py, PyAny>,
+        kwargs: Borrowed<'_, 'py, PyDict>,
+        token: private::Token,
+    ) -> PyResult<Bound<'py, PyAny>> {
+        self.bind_borrowed(function.py())
+            .call(function, kwargs, token)
+    }
+
+    #[inline]
+    fn call_positional(
+        self,
+        function: Borrowed<'_, 'py, PyAny>,
+        token: private::Token,
+    ) -> PyResult<Bound<'py, PyAny>> {
+        self.bind_borrowed(function.py())
+            .call_positional(function, token)
+    }
+}
+
+impl<'py> PyCallArgs<'py> for &'_ Py<PyTuple> {
+    #[inline]
+    fn call(
+        self,
+        function: Borrowed<'_, 'py, PyAny>,
+        kwargs: Borrowed<'_, 'py, PyDict>,
+        token: private::Token,
+    ) -> PyResult<Bound<'py, PyAny>> {
+        self.bind_borrowed(function.py())
+            .call(function, kwargs, token)
+    }
+
+    #[inline]
+    fn call_positional(
+        self,
+        function: Borrowed<'_, 'py, PyAny>,
+        token: private::Token,
+    ) -> PyResult<Bound<'py, PyAny>> {
+        self.bind_borrowed(function.py())
+            .call_positional(function, token)
+    }
+}
+
+impl<'py> PyCallArgs<'py> for Borrowed<'_, 'py, PyTuple> {
+    #[inline]
+    fn call(
+        self,
+        function: Borrowed<'_, 'py, PyAny>,
+        kwargs: Borrowed<'_, 'py, PyDict>,
+        _: private::Token,
+    ) -> PyResult<Bound<'py, PyAny>> {
+        unsafe {
+            ffi::PyObject_Call(function.as_ptr(), self.as_ptr(), kwargs.as_ptr())
+                .assume_owned_or_err(function.py())
+        }
+    }
+
+    #[inline]
+    fn call_positional(
+        self,
+        function: Borrowed<'_, 'py, PyAny>,
+        _: private::Token,
+    ) -> PyResult<Bound<'py, PyAny>> {
+        unsafe {
+            ffi::PyObject_Call(function.as_ptr(), self.as_ptr(), std::ptr::null_mut())
+                .assume_owned_or_err(function.py())
+        }
+    }
+}
+
+#[cfg(test)]
+#[cfg(feature = "macros")]
+mod tests {
+    use crate::{
+        pyfunction,
+        types::{PyDict, PyTuple},
+        Py,
+    };
+
+    #[pyfunction(signature = (*args, **kwargs), crate = "crate")]
+    fn args_kwargs(
+        args: Py<PyTuple>,
+        kwargs: Option<Py<PyDict>>,
+    ) -> (Py<PyTuple>, Option<Py<PyDict>>) {
+        (args, kwargs)
+    }
+
+    #[test]
+    fn test_call() {
+        use crate::{
+            types::{IntoPyDict, PyAnyMethods, PyDict, PyTuple},
+            wrap_pyfunction, Py, Python,
+        };
+
+        Python::attach(|py| {
+            let f = wrap_pyfunction!(args_kwargs, py).unwrap();
+
+            let args = PyTuple::new(py, [1, 2, 3]).unwrap();
+            let kwargs = &[("foo", 1), ("bar", 2)].into_py_dict(py).unwrap();
+
+            macro_rules! check_call {
+                ($args:expr, $kwargs:expr) => {
+                    let (a, k): (Py<PyTuple>, Py<PyDict>) = f
+                        .call(args.clone(), Some(kwargs))
+                        .unwrap()
+                        .extract()
+                        .unwrap();
+                    assert!(a.is(&args));
+                    assert!(k.is(kwargs));
+                };
+            }
+
+            // Bound<'py, PyTuple>
+            check_call!(args.clone(), kwargs);
+
+            // &Bound<'py, PyTuple>
+            check_call!(&args, kwargs);
+
+            // Py<PyTuple>
+            check_call!(args.clone().unbind(), kwargs);
+
+            // &Py<PyTuple>
+            check_call!(&args.as_unbound(), kwargs);
+
+            // Borrowed<'_, '_, PyTuple>
+            check_call!(args.as_borrowed(), kwargs);
+        })
+    }
+
+    #[test]
+    fn test_call_positional() {
+        use crate::{
+            types::{PyAnyMethods, PyNone, PyTuple},
+            wrap_pyfunction, Py, Python,
+        };
+
+        Python::attach(|py| {
+            let f = wrap_pyfunction!(args_kwargs, py).unwrap();
+
+            let args = PyTuple::new(py, [1, 2, 3]).unwrap();
+
+            macro_rules! check_call {
+                ($args:expr, $kwargs:expr) => {
+                    let (a, k): (Py<PyTuple>, Py<PyNone>) =
+                        f.call1(args.clone()).unwrap().extract().unwrap();
+                    assert!(a.is(&args));
+                    assert!(k.is_none(py));
+                };
+            }
+
+            // Bound<'py, PyTuple>
+            check_call!(args.clone(), kwargs);
+
+            // &Bound<'py, PyTuple>
+            check_call!(&args, kwargs);
+
+            // Py<PyTuple>
+            check_call!(args.clone().unbind(), kwargs);
+
+            // &Py<PyTuple>
+            check_call!(args.as_unbound(), kwargs);
+
+            // Borrowed<'_, '_, PyTuple>
+            check_call!(args.as_borrowed(), kwargs);
+        })
+    }
+}
diff --git a/src/conversion.rs b/src/conversion.rs
index d9536aa9445..d4f5c513173 100644
--- a/src/conversion.rs
+++ b/src/conversion.rs
@@ -1,576 +1,575 @@
 //! Defines conversions between Rust and Python types.
-use crate::err::{self, PyDowncastError, PyResult};
+use crate::err::PyResult;
+use crate::impl_::pyclass::ExtractPyClassWithClone;
 #[cfg(feature = "experimental-inspect")]
 use crate::inspect::types::TypeInfo;
+#[cfg(feature = "experimental-inspect")]
+use crate::inspect::TypeHint;
 use crate::pyclass::boolean_struct::False;
-use crate::type_object::PyTypeInfo;
+use crate::pyclass::{PyClassGuardError, PyClassGuardMutError};
 use crate::types::PyTuple;
 use crate::{
-    ffi, gil, Bound, Py, PyAny, PyCell, PyClass, PyNativeType, PyObject, PyRef, PyRefMut, Python,
+    Borrowed, Bound, BoundObject, Py, PyAny, PyClass, PyClassGuard, PyErr, PyRef, PyRefMut, Python,
 };
-use std::cell::Cell;
-use std::ptr::NonNull;
+use std::convert::Infallible;
+use std::marker::PhantomData;
+
+/// Defines a conversion from a Rust type to a Python object, which may fail.
+///
+/// This trait has `#[derive(IntoPyObject)]` to automatically implement it for simple types and
+/// `#[derive(IntoPyObjectRef)]` to implement the same for references.
+///
+/// It functions similarly to std's [`TryInto`] trait, but requires a [`Python<'py>`] token
+/// as an argument.
+///
+/// The [`into_pyobject`][IntoPyObject::into_pyobject] method is designed for maximum flexibility and efficiency; it
+///  - allows for a concrete Python type to be returned (the [`Target`][IntoPyObject::Target] associated type)
+///  - allows for the smart pointer containing the Python object to be either `Bound<'py, Self::Target>` or `Borrowed<'a, 'py, Self::Target>`
+///    to avoid unnecessary reference counting overhead
+///  - allows for a custom error type to be returned in the event of a conversion error to avoid
+///    unnecessarily creating a Python exception
+///
+/// # See also
+///
+/// - The [`IntoPyObjectExt`] trait, which provides convenience methods for common usages of
+///   `IntoPyObject` which erase type information and convert errors to `PyErr`.
+#[diagnostic::on_unimplemented(
+    message = "`{Self}` cannot be converted to a Python object",
+    note = "`IntoPyObject` is automatically implemented by the `#[pyclass]` macro",
+    note = "if you do not wish to have a corresponding Python type, implement it manually",
+    note = "if you do not own `{Self}` you can perform a manual conversion to one of the types in `pyo3::types::*`"
+)]
+pub trait IntoPyObject<'py>: Sized {
+    /// The Python output type
+    type Target;
+    /// The smart pointer type to use.
+    ///
+    /// This will usually be [`Bound<'py, Target>`], but in special cases [`Borrowed<'a, 'py, Target>`] can be
+    /// used to minimize reference counting overhead.
+    type Output: BoundObject<'py, Self::Target>;
+    /// The type returned in the event of a conversion error.
+    type Error: Into<PyErr>;
 
-/// Returns a borrowed pointer to a Python object.
-///
-/// The returned pointer will be valid for as long as `self` is. It may be null depending on the
-/// implementation.
-///
-/// # Examples
-///
-/// ```rust
-/// use pyo3::prelude::*;
-/// use pyo3::types::PyString;
-/// use pyo3::ffi;
-///
-/// Python::with_gil(|py| {
-///     let s: Py<PyString> = "foo".into_py(py);
-///     let ptr = s.as_ptr();
-///
-///     let is_really_a_pystring = unsafe { ffi::PyUnicode_CheckExact(ptr) };
-///     assert_eq!(is_really_a_pystring, 1);
-/// });
-/// ```
-///
-/// # Safety
-///
-/// For callers, it is your responsibility to make sure that the underlying Python object is not dropped too
-/// early. For example, the following code will cause undefined behavior:
-///
-/// ```rust,no_run
-/// # use pyo3::prelude::*;
-/// # use pyo3::ffi;
-/// #
-/// Python::with_gil(|py| {
-///     let ptr: *mut ffi::PyObject = 0xabad1dea_u32.into_py(py).as_ptr();
-///
-///     let isnt_a_pystring = unsafe {
-///         // `ptr` is dangling, this is UB
-///         ffi::PyUnicode_CheckExact(ptr)
-///     };
-/// #    assert_eq!(isnt_a_pystring, 0);
-/// });
-/// ```
-///
-/// This happens because the pointer returned by `as_ptr` does not carry any lifetime information
-/// and the Python object is dropped immediately after the `0xabad1dea_u32.into_py(py).as_ptr()`
-/// expression is evaluated. To fix the problem, bind Python object to a local variable like earlier
-/// to keep the Python object alive until the end of its scope.
-///
-/// Implementors must ensure this returns a valid pointer to a Python object, which borrows a reference count from `&self`.
-pub unsafe trait AsPyPointer {
-    /// Returns the underlying FFI pointer as a borrowed pointer.
-    fn as_ptr(&self) -> *mut ffi::PyObject;
+    /// Extracts the type hint information for this type when it appears as a return value.
+    ///
+    /// For example, `Vec<u32>` would return `List[int]`.
+    /// The default implementation returns `Any`, which is correct for any type.
+    ///
+    /// For most types, the return value for this method will be identical to that of [`FromPyObject::INPUT_TYPE`].
+    /// It may be different for some types, such as `Dict`, to allow duck-typing: functions return `Dict` but take `Mapping` as argument.
+    #[cfg(feature = "experimental-inspect")]
+    const OUTPUT_TYPE: TypeHint = TypeHint::module_attr("typing", "Any");
+
+    /// Performs the conversion.
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>;
+
+    /// Extracts the type hint information for this type when it appears as a return value.
+    ///
+    /// For example, `Vec<u32>` would return `List[int]`.
+    /// The default implementation returns `Any`, which is correct for any type.
+    ///
+    /// For most types, the return value for this method will be identical to that of [`FromPyObject::type_input`].
+    /// It may be different for some types, such as `Dict`, to allow duck-typing: functions return `Dict` but take `Mapping` as argument.
+    #[cfg(feature = "experimental-inspect")]
+    fn type_output() -> TypeInfo {
+        TypeInfo::Any
+    }
+
+    /// Converts sequence of Self into a Python object. Used to specialize `Vec<u8>`, `[u8; N]`
+    /// and `SmallVec<[u8; N]>` as a sequence of bytes into a `bytes` object.
+    #[doc(hidden)]
+    fn owned_sequence_into_pyobject<I>(
+        iter: I,
+        py: Python<'py>,
+        _: private::Token,
+    ) -> Result<Bound<'py, PyAny>, PyErr>
+    where
+        I: IntoIterator<Item = Self> + AsRef<[Self]>,
+        I::IntoIter: ExactSizeIterator<Item = Self>,
+    {
+        let mut iter = iter.into_iter().map(|e| e.into_bound_py_any(py));
+        let list = crate::types::list::try_new_from_iter(py, &mut iter);
+        list.map(Bound::into_any)
+    }
+
+    /// Converts sequence of Self into a Python object. Used to specialize `&[u8]` and `Cow<[u8]>`
+    /// as a sequence of bytes into a `bytes` object.
+    #[doc(hidden)]
+    fn borrowed_sequence_into_pyobject<I>(
+        iter: I,
+        py: Python<'py>,
+        _: private::Token,
+    ) -> Result<Bound<'py, PyAny>, PyErr>
+    where
+        Self: private::Reference,
+        I: IntoIterator<Item = Self> + AsRef<[<Self as private::Reference>::BaseType]>,
+        I::IntoIter: ExactSizeIterator<Item = Self>,
+    {
+        let mut iter = iter.into_iter().map(|e| e.into_bound_py_any(py));
+        let list = crate::types::list::try_new_from_iter(py, &mut iter);
+        list.map(Bound::into_any)
+    }
+}
+
+pub(crate) mod private {
+    pub struct Token;
+
+    pub trait Reference {
+        type BaseType;
+    }
+
+    impl<T> Reference for &'_ T {
+        type BaseType = T;
+    }
+}
+
+impl<'py, T> IntoPyObject<'py> for Bound<'py, T> {
+    type Target = T;
+    type Output = Bound<'py, Self::Target>;
+    type Error = Infallible;
+
+    fn into_pyobject(self, _py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        Ok(self)
+    }
+}
+
+impl<'a, 'py, T> IntoPyObject<'py> for &'a Bound<'py, T> {
+    type Target = T;
+    type Output = Borrowed<'a, 'py, Self::Target>;
+    type Error = Infallible;
+
+    fn into_pyobject(self, _py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        Ok(self.as_borrowed())
+    }
+}
+
+impl<'a, 'py, T> IntoPyObject<'py> for Borrowed<'a, 'py, T> {
+    type Target = T;
+    type Output = Borrowed<'a, 'py, Self::Target>;
+    type Error = Infallible;
+
+    fn into_pyobject(self, _py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        Ok(self)
+    }
+}
+
+impl<'a, 'py, T> IntoPyObject<'py> for &Borrowed<'a, 'py, T> {
+    type Target = T;
+    type Output = Borrowed<'a, 'py, Self::Target>;
+    type Error = Infallible;
+
+    fn into_pyobject(self, _py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        Ok(*self)
+    }
+}
+
+impl<'py, T> IntoPyObject<'py> for Py<T> {
+    type Target = T;
+    type Output = Bound<'py, Self::Target>;
+    type Error = Infallible;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        Ok(self.into_bound(py))
+    }
 }
 
-/// Convert `None` into a null pointer.
-unsafe impl<T> AsPyPointer for Option<T>
+impl<'a, 'py, T> IntoPyObject<'py> for &'a Py<T> {
+    type Target = T;
+    type Output = Borrowed<'a, 'py, Self::Target>;
+    type Error = Infallible;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        Ok(self.bind_borrowed(py))
+    }
+}
+
+impl<'a, 'py, T> IntoPyObject<'py> for &&'a T
 where
-    T: AsPyPointer,
+    &'a T: IntoPyObject<'py>,
 {
+    type Target = <&'a T as IntoPyObject<'py>>::Target;
+    type Output = <&'a T as IntoPyObject<'py>>::Output;
+    type Error = <&'a T as IntoPyObject<'py>>::Error;
+
+    #[cfg(feature = "experimental-inspect")]
+    const OUTPUT_TYPE: TypeHint = <&'a T as IntoPyObject<'py>>::OUTPUT_TYPE;
+
     #[inline]
-    fn as_ptr(&self) -> *mut ffi::PyObject {
-        self.as_ref()
-            .map_or_else(std::ptr::null_mut, |t| t.as_ptr())
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        (*self).into_pyobject(py)
     }
 }
 
-/// Conversion trait that allows various objects to be converted into `PyObject`.
-pub trait ToPyObject {
-    /// Converts self into a Python object.
-    fn to_object(&self, py: Python<'_>) -> PyObject;
+mod into_pyobject_ext {
+    pub trait Sealed {}
+    impl<'py, T> Sealed for T where T: super::IntoPyObject<'py> {}
+}
+
+/// Convenience methods for common usages of [`IntoPyObject`]. Every type that implements
+/// [`IntoPyObject`] also implements this trait.
+///
+/// These methods:
+///   - Drop type information from the output, returning a `PyAny` object.
+///   - Always convert the `Error` type to `PyErr`, which may incur a performance penalty but it
+///     more convenient in contexts where the `?` operator would produce a `PyErr` anyway.
+pub trait IntoPyObjectExt<'py>: IntoPyObject<'py> + into_pyobject_ext::Sealed {
+    /// Converts `self` into an owned Python object, dropping type information.
+    #[inline]
+    fn into_bound_py_any(self, py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {
+        match self.into_pyobject(py) {
+            Ok(obj) => Ok(obj.into_any().into_bound()),
+            Err(err) => Err(err.into()),
+        }
+    }
+
+    /// Converts `self` into an owned Python object, dropping type information and unbinding it
+    /// from the `'py` lifetime.
+    #[inline]
+    fn into_py_any(self, py: Python<'py>) -> PyResult<Py<PyAny>> {
+        match self.into_pyobject(py) {
+            Ok(obj) => Ok(obj.into_any().unbind()),
+            Err(err) => Err(err.into()),
+        }
+    }
+
+    /// Converts `self` into a Python object.
+    ///
+    /// This is equivalent to calling [`into_pyobject`][IntoPyObject::into_pyobject] followed
+    /// with `.map_err(Into::into)` to convert the error type to [`PyErr`]. This is helpful
+    /// for generic code which wants to make use of the `?` operator.
+    #[inline]
+    fn into_pyobject_or_pyerr(self, py: Python<'py>) -> PyResult<Self::Output> {
+        match self.into_pyobject(py) {
+            Ok(obj) => Ok(obj),
+            Err(err) => Err(err.into()),
+        }
+    }
 }
 
-/// Defines a conversion from a Rust type to a Python object.
+impl<'py, T> IntoPyObjectExt<'py> for T where T: IntoPyObject<'py> {}
+
+/// Extract a type from a Python object.
+///
 ///
-/// It functions similarly to std's [`Into`] trait, but requires a [GIL token](Python)
-/// as an argument. Many functions and traits internal to PyO3 require this trait as a bound,
-/// so a lack of this trait can manifest itself in different error messages.
+/// Normal usage is through the `extract` methods on [`Bound`], [`Borrowed`] and [`Py`], which
+/// forward to this trait.
 ///
 /// # Examples
-/// ## With `#[pyclass]`
-/// The easiest way to implement `IntoPy` is by exposing a struct as a native Python object
-/// by annotating it with [`#[pyclass]`](crate::prelude::pyclass).
 ///
 /// ```rust
 /// use pyo3::prelude::*;
+/// use pyo3::types::PyString;
 ///
-/// #[pyclass]
-/// struct Number {
-///     #[pyo3(get, set)]
-///     value: i32,
-/// }
+/// # fn main() -> PyResult<()> {
+/// Python::attach(|py| {
+///     // Calling `.extract()` on a `Bound` smart pointer
+///     let obj: Bound<'_, PyString> = PyString::new(py, "blah");
+///     let s: String = obj.extract()?;
+/// #   assert_eq!(s, "blah");
+///
+///     // Calling `.extract(py)` on a `Py` smart pointer
+///     let obj: Py<PyString> = obj.unbind();
+///     let s: String = obj.extract(py)?;
+/// #   assert_eq!(s, "blah");
+/// #   Ok(())
+/// })
+/// # }
 /// ```
-/// Python code will see this as an instance of the `Number` class with a `value` attribute.
 ///
-/// ## Conversion to a Python object
+/// Note: Depending on the Python version and implementation, some [`FromPyObject`] implementations
+/// may produce a result that borrows into the Python type. This is described by the input lifetime
+/// `'a` of `obj`.
 ///
-/// However, it may not be desirable to expose the existence of `Number` to Python code.
-/// `IntoPy` allows us to define a conversion to an appropriate Python object.
-/// ```rust
-/// use pyo3::prelude::*;
+/// Types that must not borrow from the input can use [`FromPyObjectOwned`] as a restriction. This
+/// is most often the case for collection types. See its documentation for more details.
 ///
-/// struct Number {
-///     value: i32,
-/// }
+/// # How to implement [`FromPyObject`]?
+/// ## `#[derive(FromPyObject)]`
+/// The simplest way to implement [`FromPyObject`] for a custom type is to make use of our derive
+/// macro.
+/// ```rust,no_run
+/// # #![allow(dead_code)]
+/// use pyo3::prelude::*;
 ///
-/// impl IntoPy<PyObject> for Number {
-///     fn into_py(self, py: Python<'_>) -> PyObject {
-///         // delegates to i32's IntoPy implementation.
-///         self.value.into_py(py)
-///     }
+/// #[derive(FromPyObject)]
+/// struct MyObject {
+///     msg: String,
+///     list: Vec<u32>
 /// }
+/// # fn main() {}
 /// ```
-/// Python code will see this as an `int` object.
-///
-/// ## Dynamic conversion into Python objects.
-/// It is also possible to return a different Python object depending on some condition.
-/// This is useful for types like enums that can carry different types.
-///
-/// ```rust
+/// By default this will try to extract each field from the Python object by attribute access, but
+/// this can be customized. For more information about the derive macro, its configuration as well
+/// as its working principle for other types, take a look at the [guide].
+///
+/// In case the derive macro is not sufficient or can not be used for some other reason,
+/// [`FromPyObject`] can be implemented manually. In the following types without lifetime parameters
+/// are handled first, because they are a little bit simpler. Types with lifetime parameters are
+/// explained below.
+///
+/// ## Manual implementation for types without lifetime
+/// Types that do not contain lifetime parameters are unable to borrow from the Python object, so
+/// the lifetimes of [`FromPyObject`] can be elided:
+/// ```rust,no_run
+/// # #![allow(dead_code)]
 /// use pyo3::prelude::*;
 ///
-/// enum Value {
-///     Integer(i32),
-///     String(String),
-///     None,
+/// struct MyObject {
+///     msg: String,
+///     list: Vec<u32>
 /// }
 ///
-/// impl IntoPy<PyObject> for Value {
-///     fn into_py(self, py: Python<'_>) -> PyObject {
-///         match self {
-///             Self::Integer(val) => val.into_py(py),
-///             Self::String(val) => val.into_py(py),
-///             Self::None => py.None(),
-///         }
+/// impl FromPyObject<'_, '_> for MyObject {
+///     type Error = PyErr;
+///
+///     fn extract(obj: Borrowed<'_, '_, PyAny>) -> Result<Self, Self::Error> {
+///         Ok(MyObject {
+///             msg: obj.getattr("msg")?.extract()?,
+///             list: obj.getattr("list")?.extract()?,
+///         })
 ///     }
 /// }
-/// # fn main() {
-/// #     Python::with_gil(|py| {
-/// #         let v = Value::Integer(73).into_py(py);
-/// #         let v = v.extract::<i32>(py).unwrap();
-/// #
-/// #         let v = Value::String("foo".into()).into_py(py);
-/// #         let v = v.extract::<String>(py).unwrap();
-/// #
-/// #         let v = Value::None.into_py(py);
-/// #         let v = v.extract::<Option<Vec<i32>>>(py).unwrap();
-/// #     });
-/// # }
-/// ```
-/// Python code will see this as any of the `int`, `string` or `None` objects.
-#[doc(alias = "IntoPyCallbackOutput")]
-pub trait IntoPy<T>: Sized {
-    /// Performs the conversion.
-    fn into_py(self, py: Python<'_>) -> T;
-
-    /// Extracts the type hint information for this type when it appears as a return value.
-    ///
-    /// For example, `Vec<u32>` would return `List[int]`.
-    /// The default implementation returns `Any`, which is correct for any type.
-    ///
-    /// For most types, the return value for this method will be identical to that of [`FromPyObject::type_input`].
-    /// It may be different for some types, such as `Dict`, to allow duck-typing: functions return `Dict` but take `Mapping` as argument.
-    #[cfg(feature = "experimental-inspect")]
-    fn type_output() -> TypeInfo {
-        TypeInfo::Any
-    }
-}
-
-/// Extract a type from a Python object.
-///
 ///
-/// Normal usage is through the `extract` methods on [`Py`] and  [`PyAny`], which forward to this trait.
+/// # fn main() {}
+/// ```
+/// This is basically what the derive macro above expands to.
 ///
-/// # Examples
+/// ## Manual implementation for types with lifetime paramaters
+/// For types that contain lifetimes, these lifetimes need to be bound to the corresponding
+/// [`FromPyObject`] lifetime. This is roughly how the extraction of a typed [`Bound`] is
+/// implemented within PyO3.
 ///
-/// ```rust
+/// ```rust,no_run
+/// # #![allow(dead_code)]
 /// use pyo3::prelude::*;
 /// use pyo3::types::PyString;
 ///
-/// # fn main() -> PyResult<()> {
-/// Python::with_gil(|py| {
-///     let obj: Py<PyString> = PyString::new_bound(py, "blah").into();
+/// struct MyObject<'py>(Bound<'py, PyString>);
 ///
-///     // Straight from an owned reference
-///     let s: &str = obj.extract(py)?;
-/// #   assert_eq!(s, "blah");
+/// impl<'py> FromPyObject<'_, 'py> for MyObject<'py> {
+///     type Error = PyErr;
 ///
-///     // Or from a borrowed reference
-///     let obj: &PyString = obj.as_ref(py);
-///     let s: &str = obj.extract()?;
-/// #   assert_eq!(s, "blah");
-/// #   Ok(())
-/// })
-/// # }
+///     fn extract(obj: Borrowed<'_, 'py, PyAny>) -> Result<Self, Self::Error> {
+///         Ok(MyObject(obj.cast()?.to_owned()))
+///     }
+/// }
+///
+/// # fn main() {}
 /// ```
 ///
-/// Note: depending on the implementation, the lifetime of the extracted result may
-/// depend on the lifetime of the `obj` or the `prepared` variable.
-///
-/// For example, when extracting `&str` from a Python byte string, the resulting string slice will
-/// point to the existing string data (lifetime: `'py`).
-/// On the other hand, when extracting `&str` from a Python Unicode string, the preparation step
-/// will convert the string to UTF-8, and the resulting string slice will have lifetime `'prepared`.
-/// Since which case applies depends on the runtime type of the Python object,
-/// both the `obj` and `prepared` variables must outlive the resulting string slice.
-///
-/// During the migration of PyO3 from the "GIL Refs" API to the `Bound<T>` smart pointer, this trait
-/// has two methods `extract` and `extract_bound` which are defaulted to call each other. To avoid
-/// infinite recursion, implementors must implement at least one of these methods. The recommendation
-/// is to implement `extract_bound` and leave `extract` as the default implementation.
-pub trait FromPyObject<'py>: Sized {
-    /// Extracts `Self` from the source GIL Ref `obj`.
+/// # Details
+/// [`Cow<'a, str>`] is an example of an output type that may or may not borrow from the input
+/// lifetime `'a`. Which variant will be produced depends on the runtime type of the Python object.
+/// For a Python byte string, the existing string data can be borrowed for `'a` into a
+/// [`Cow::Borrowed`]. For a Python Unicode string, the data may have to be reencoded to UTF-8, and
+/// copied into a [`Cow::Owned`]. It does _not_ depend on the Python lifetime `'py`.
+///
+/// The output type may also depend on the Python lifetime `'py`. This allows the output type to
+/// keep interacting with the Python interpreter. See also [`Bound<'py, T>`].
+///
+/// [`Cow<'a, str>`]: std::borrow::Cow
+/// [`Cow::Borrowed`]: std::borrow::Cow::Borrowed
+/// [`Cow::Owned`]: std::borrow::Cow::Owned
+/// [guide]: https://pyo3.rs/latest/conversions/traits.html#deriving-frompyobject
+pub trait FromPyObject<'a, 'py>: Sized {
+    /// The type returned in the event of a conversion error.
     ///
-    /// Implementors are encouraged to implement `extract_bound` and leave this method as the
-    /// default implementation, which will forward calls to `extract_bound`.
-    fn extract(ob: &'py PyAny) -> PyResult<Self> {
-        Self::extract_bound(&ob.as_borrowed())
-    }
+    /// For most use cases defaulting to [PyErr] here is perfectly acceptable. Using a custom error
+    /// type can be used to avoid having to create a Python exception object in the case where that
+    /// exception never reaches Python. This may lead to slightly better performance under certain
+    /// conditions.
+    ///
+    /// # Note
+    /// Unfortunately `Try` and thus `?` is based on [`From`], not [`Into`], so implementations may
+    /// need to use `.map_err(Into::into)` sometimes to convert a generic `Error` into a [`PyErr`].
+    type Error: Into<PyErr>;
+
+    /// Provides the type hint information for this type when it appears as an argument.
+    ///
+    /// For example, `Vec<u32>` would be `collections.abc.Sequence[int]`.
+    /// The default value is `typing.Any`, which is correct for any type.
+    #[cfg(feature = "experimental-inspect")]
+    const INPUT_TYPE: TypeHint = TypeHint::module_attr("typing", "Any");
 
     /// Extracts `Self` from the bound smart pointer `obj`.
     ///
-    /// Implementors are encouraged to implement this method and leave `extract` defaulted, as
-    /// this will be most compatible with PyO3's future API.
-    fn extract_bound(ob: &Bound<'py, PyAny>) -> PyResult<Self> {
-        Self::extract(ob.clone().into_gil_ref())
-    }
+    /// Users are advised against calling this method directly: instead, use this via
+    /// [`Bound<'_, PyAny>::extract`](crate::types::any::PyAnyMethods::extract) or [`Py::extract`].
+    fn extract(obj: Borrowed<'a, 'py, PyAny>) -> Result<Self, Self::Error>;
 
     /// Extracts the type hint information for this type when it appears as an argument.
     ///
     /// For example, `Vec<u32>` would return `Sequence[int]`.
     /// The default implementation returns `Any`, which is correct for any type.
     ///
-    /// For most types, the return value for this method will be identical to that of [`IntoPy::type_output`].
-    /// It may be different for some types, such as `Dict`, to allow duck-typing: functions return `Dict` but take `Mapping` as argument.
+    /// For most types, the return value for this method will be identical to that of
+    /// [`IntoPyObject::type_output`]. It may be different for some types, such as `Dict`,
+    /// to allow duck-typing: functions return `Dict` but take `Mapping` as argument.
     #[cfg(feature = "experimental-inspect")]
     fn type_input() -> TypeInfo {
         TypeInfo::Any
     }
-}
 
-/// Identity conversion: allows using existing `PyObject` instances where
-/// `T: ToPyObject` is expected.
-impl<T: ?Sized + ToPyObject> ToPyObject for &'_ T {
-    #[inline]
-    fn to_object(&self, py: Python<'_>) -> PyObject {
-        <T as ToPyObject>::to_object(*self, py)
-    }
-}
+    /// Specialization hook for extracting sequences for types like `Vec<u8>` and `[u8; N]`,
+    /// where the bytes can be directly copied from some python objects without going through
+    /// iteration.
+    #[doc(hidden)]
+    #[inline(always)]
+    fn sequence_extractor(
+        _obj: Borrowed<'_, 'py, PyAny>,
+        _: private::Token,
+    ) -> Option<impl FromPyObjectSequence<Target = Self>> {
+        struct NeverASequence<T>(PhantomData<T>);
 
-/// `Option::Some<T>` is converted like `T`.
-/// `Option::None` is converted to Python `None`.
-impl<T> ToPyObject for Option<T>
-where
-    T: ToPyObject,
-{
-    fn to_object(&self, py: Python<'_>) -> PyObject {
-        self.as_ref()
-            .map_or_else(|| py.None(), |val| val.to_object(py))
-    }
-}
+        impl<T> FromPyObjectSequence for NeverASequence<T> {
+            type Target = T;
 
-impl<T> IntoPy<PyObject> for Option<T>
-where
-    T: IntoPy<PyObject>,
-{
-    fn into_py(self, py: Python<'_>) -> PyObject {
-        self.map_or_else(|| py.None(), |val| val.into_py(py))
-    }
-}
+            fn to_vec(&self) -> Vec<Self::Target> {
+                unreachable!()
+            }
 
-impl IntoPy<PyObject> for &'_ PyAny {
-    #[inline]
-    fn into_py(self, py: Python<'_>) -> PyObject {
-        unsafe { PyObject::from_borrowed_ptr(py, self.as_ptr()) }
+            fn to_array<const N: usize>(&self) -> PyResult<[Self::Target; N]> {
+                unreachable!()
+            }
+        }
+
+        Option::<NeverASequence<Self>>::None
     }
-}
 
-impl<T> IntoPy<PyObject> for &'_ T
-where
-    T: AsRef<PyAny>,
-{
+    /// Helper used to make a specialized path in extracting `DateTime<Tz>` where `Tz` is
+    /// `chrono::Local`, which will accept "naive" datetime objects as being in the local timezone.
+    #[cfg(feature = "chrono-local")]
     #[inline]
-    fn into_py(self, py: Python<'_>) -> PyObject {
-        unsafe { PyObject::from_borrowed_ptr(py, self.as_ref().as_ptr()) }
+    fn as_local_tz(_: private::Token) -> Option<Self> {
+        None
     }
 }
 
-impl<T: Copy + ToPyObject> ToPyObject for Cell<T> {
-    fn to_object(&self, py: Python<'_>) -> PyObject {
-        self.get().to_object(py)
-    }
-}
+mod from_py_object_sequence {
+    use crate::PyResult;
 
-impl<T: Copy + IntoPy<PyObject>> IntoPy<PyObject> for Cell<T> {
-    fn into_py(self, py: Python<'_>) -> PyObject {
-        self.get().into_py(py)
-    }
-}
+    /// Private trait for implementing specialized sequence extraction for `Vec<u8>` and `[u8; N]`
+    #[doc(hidden)]
+    pub trait FromPyObjectSequence {
+        type Target;
 
-impl<'py, T: FromPyObject<'py>> FromPyObject<'py> for Cell<T> {
-    fn extract(ob: &'py PyAny) -> PyResult<Self> {
-        T::extract(ob).map(Cell::new)
-    }
-}
+        fn to_vec(&self) -> Vec<Self::Target>;
 
-impl<'py, T> FromPyObject<'py> for &'py PyCell<T>
-where
-    T: PyClass,
-{
-    fn extract(obj: &'py PyAny) -> PyResult<Self> {
-        obj.downcast().map_err(Into::into)
+        fn to_array<const N: usize>(&self) -> PyResult<[Self::Target; N]>;
     }
 }
 
-impl<T> FromPyObject<'_> for T
+// Only reachable / implementable inside PyO3 itself.
+pub(crate) use from_py_object_sequence::FromPyObjectSequence;
+
+/// A data structure that can be extracted without borrowing any data from the input.
+///
+/// This is primarily useful for trait bounds. For example a [`FromPyObject`] implementation of a
+/// wrapper type may be able to borrow data from the input, but a [`FromPyObject`] implementation of
+/// a collection type may only extract owned data.
+///
+/// For example [`PyList`] will not hand out references tied to its own lifetime, but "owned"
+/// references independent of it. (Similar to [`Vec<Arc<T>>`] where you clone the [`Arc<T>`] out).
+/// This makes it impossible to collect borrowed types in a collection, since they would not borrow
+/// from the original [`PyList`], but the much shorter lived element reference. See the example
+/// below.
+///
+/// ```,no_run
+/// # use pyo3::prelude::*;
+/// # #[allow(dead_code)]
+/// pub struct MyWrapper<T>(T);
+///
+/// impl<'a, 'py, T> FromPyObject<'a, 'py> for MyWrapper<T>
+/// where
+///     T: FromPyObject<'a, 'py>
+/// {
+///     type Error = T::Error;
+///
+///     fn extract(obj: Borrowed<'a, 'py, PyAny>) -> Result<Self, Self::Error> {
+///         obj.extract().map(MyWrapper)
+///     }
+/// }
+///
+/// # #[allow(dead_code)]
+/// pub struct MyVec<T>(Vec<T>);
+///
+/// impl<'py, T> FromPyObject<'_, 'py> for MyVec<T>
+/// where
+///     T: FromPyObjectOwned<'py> // 👈 can only extract owned values, because each `item` below
+///                               //    is a temporary short lived owned reference
+/// {
+///     type Error = PyErr;
+///
+///     fn extract(obj: Borrowed<'_, 'py, PyAny>) -> Result<Self, Self::Error> {
+///         let mut v = MyVec(Vec::new());
+///         for item in obj.try_iter()? {
+///             v.0.push(item?.extract::<T>().map_err(Into::into)?);
+///         }
+///         Ok(v)
+///     }
+/// }
+/// ```
+///
+/// [`PyList`]: crate::types::PyList
+/// [`Arc<T>`]: std::sync::Arc
+pub trait FromPyObjectOwned<'py>: for<'a> FromPyObject<'a, 'py> {}
+impl<'py, T> FromPyObjectOwned<'py> for T where T: for<'a> FromPyObject<'a, 'py> {}
+
+impl<'a, 'py, T> FromPyObject<'a, 'py> for T
 where
-    T: PyClass + Clone,
+    T: PyClass + Clone + ExtractPyClassWithClone,
 {
-    fn extract(obj: &PyAny) -> PyResult<Self> {
-        let cell: &PyCell<Self> = obj.downcast()?;
-        Ok(unsafe { cell.try_borrow_unguarded()?.clone() })
+    type Error = PyClassGuardError<'a, 'py>;
+
+    #[cfg(feature = "experimental-inspect")]
+    const INPUT_TYPE: TypeHint = <T as crate::PyTypeInfo>::TYPE_HINT;
+
+    fn extract(obj: Borrowed<'a, 'py, PyAny>) -> Result<Self, Self::Error> {
+        Ok(obj.extract::<PyClassGuard<'_, T>>()?.clone())
     }
 }
 
-impl<'py, T> FromPyObject<'py> for PyRef<'py, T>
+impl<'a, 'py, T> FromPyObject<'a, 'py> for PyRef<'py, T>
 where
     T: PyClass,
 {
-    fn extract(obj: &'py PyAny) -> PyResult<Self> {
-        let cell: &PyCell<T> = obj.downcast()?;
-        cell.try_borrow().map_err(Into::into)
-    }
-}
+    type Error = PyClassGuardError<'a, 'py>;
 
-impl<'py, T> FromPyObject<'py> for PyRefMut<'py, T>
-where
-    T: PyClass<Frozen = False>,
-{
-    fn extract(obj: &'py PyAny) -> PyResult<Self> {
-        let cell: &PyCell<T> = obj.downcast()?;
-        cell.try_borrow_mut().map_err(Into::into)
+    #[cfg(feature = "experimental-inspect")]
+    const INPUT_TYPE: TypeHint = <T as crate::PyTypeInfo>::TYPE_HINT;
+
+    fn extract(obj: Borrowed<'a, 'py, PyAny>) -> Result<Self, Self::Error> {
+        obj.cast::<T>()
+            .map_err(|e| PyClassGuardError(Some(e)))?
+            .try_borrow()
+            .map_err(|_| PyClassGuardError(None))
     }
 }
 
-impl<'py, T> FromPyObject<'py> for Option<T>
+impl<'a, 'py, T> FromPyObject<'a, 'py> for PyRefMut<'py, T>
 where
-    T: FromPyObject<'py>,
+    T: PyClass<Frozen = False>,
 {
-    fn extract(obj: &'py PyAny) -> PyResult<Self> {
-        if obj.as_ptr() == unsafe { ffi::Py_None() } {
-            Ok(None)
-        } else {
-            T::extract(obj).map(Some)
-        }
-    }
-}
-
-/// Trait implemented by Python object types that allow a checked downcast.
-/// If `T` implements `PyTryFrom`, we can convert `&PyAny` to `&T`.
-///
-/// This trait is similar to `std::convert::TryFrom`
-#[deprecated(since = "0.21.0")]
-pub trait PyTryFrom<'v>: Sized + PyNativeType {
-    /// Cast from a concrete Python object type to PyObject.
-    #[deprecated(
-        since = "0.21.0",
-        note = "use `value.downcast::<T>()` instead of `T::try_from(value)`"
-    )]
-    fn try_from<V: Into<&'v PyAny>>(value: V) -> Result<&'v Self, PyDowncastError<'v>>;
-
-    /// Cast from a concrete Python object type to PyObject. With exact type check.
-    #[deprecated(
-        since = "0.21.0",
-        note = "use `value.downcast_exact::<T>()` instead of `T::try_from_exact(value)`"
-    )]
-    fn try_from_exact<V: Into<&'v PyAny>>(value: V) -> Result<&'v Self, PyDowncastError<'v>>;
-
-    /// Cast a PyAny to a specific type of PyObject. The caller must
-    /// have already verified the reference is for this type.
-    ///
-    /// # Safety
-    ///
-    /// Callers must ensure that the type is valid or risk type confusion.
-    #[deprecated(
-        since = "0.21.0",
-        note = "use `value.downcast_unchecked::<T>()` instead of `T::try_from_unchecked(value)`"
-    )]
-    unsafe fn try_from_unchecked<V: Into<&'v PyAny>>(value: V) -> &'v Self;
-}
-
-/// Trait implemented by Python object types that allow a checked downcast.
-/// This trait is similar to `std::convert::TryInto`
-#[deprecated(since = "0.21.0")]
-pub trait PyTryInto<T>: Sized {
-    /// Cast from PyObject to a concrete Python object type.
-    #[deprecated(
-        since = "0.21.0",
-        note = "use `value.downcast()` instead of `value.try_into()`"
-    )]
-    fn try_into(&self) -> Result<&T, PyDowncastError<'_>>;
-
-    /// Cast from PyObject to a concrete Python object type. With exact type check.
-    #[deprecated(
-        since = "0.21.0",
-        note = "use `value.downcast()` instead of `value.try_into_exact()`"
-    )]
-    fn try_into_exact(&self) -> Result<&T, PyDowncastError<'_>>;
-}
-
-#[allow(deprecated)]
-mod implementations {
-    use super::*;
-
-    // TryFrom implies TryInto
-    impl<U> PyTryInto<U> for PyAny
-    where
-        U: for<'v> PyTryFrom<'v>,
-    {
-        fn try_into(&self) -> Result<&U, PyDowncastError<'_>> {
-            <U as PyTryFrom<'_>>::try_from(self)
-        }
-        fn try_into_exact(&self) -> Result<&U, PyDowncastError<'_>> {
-            U::try_from_exact(self)
-        }
-    }
-
-    impl<'v, T> PyTryFrom<'v> for T
-    where
-        T: PyTypeInfo<AsRefTarget = Self> + PyNativeType,
-    {
-        fn try_from<V: Into<&'v PyAny>>(value: V) -> Result<&'v Self, PyDowncastError<'v>> {
-            value.into().downcast()
-        }
+    type Error = PyClassGuardMutError<'a, 'py>;
 
-        fn try_from_exact<V: Into<&'v PyAny>>(value: V) -> Result<&'v Self, PyDowncastError<'v>> {
-            value.into().downcast_exact()
-        }
-
-        #[inline]
-        unsafe fn try_from_unchecked<V: Into<&'v PyAny>>(value: V) -> &'v Self {
-            value.into().downcast_unchecked()
-        }
-    }
-
-    impl<'v, T> PyTryFrom<'v> for PyCell<T>
-    where
-        T: 'v + PyClass,
-    {
-        fn try_from<V: Into<&'v PyAny>>(value: V) -> Result<&'v Self, PyDowncastError<'v>> {
-            value.into().downcast()
-        }
-        fn try_from_exact<V: Into<&'v PyAny>>(value: V) -> Result<&'v Self, PyDowncastError<'v>> {
-            let value = value.into();
-            unsafe {
-                if T::is_exact_type_of(value) {
-                    Ok(Self::try_from_unchecked(value))
-                } else {
-                    Err(PyDowncastError::new(value, T::NAME))
-                }
-            }
-        }
-        #[inline]
-        unsafe fn try_from_unchecked<V: Into<&'v PyAny>>(value: V) -> &'v Self {
-            value.into().downcast_unchecked()
-        }
-    }
-}
+    #[cfg(feature = "experimental-inspect")]
+    const INPUT_TYPE: TypeHint = <T as crate::PyTypeInfo>::TYPE_HINT;
 
-/// Converts `()` to an empty Python tuple.
-impl IntoPy<Py<PyTuple>> for () {
-    fn into_py(self, py: Python<'_>) -> Py<PyTuple> {
-        PyTuple::empty_bound(py).unbind()
+    fn extract(obj: Borrowed<'a, 'py, PyAny>) -> Result<Self, Self::Error> {
+        obj.cast::<T>()
+            .map_err(|e| PyClassGuardMutError(Some(e)))?
+            .try_borrow_mut()
+            .map_err(|_| PyClassGuardMutError(None))
     }
 }
 
-/// Raw level conversion between `*mut ffi::PyObject` and PyO3 types.
-///
-/// # Safety
-///
-/// See safety notes on individual functions.
-pub unsafe trait FromPyPointer<'p>: Sized {
-    /// Convert from an arbitrary `PyObject`.
-    ///
-    /// # Safety
-    ///
-    /// Implementations must ensure the object does not get freed during `'p`
-    /// and ensure that `ptr` is of the correct type.
-    /// Note that it must be safe to decrement the reference count of `ptr`.
-    unsafe fn from_owned_ptr_or_opt(py: Python<'p>, ptr: *mut ffi::PyObject) -> Option<&'p Self>;
-    /// Convert from an arbitrary `PyObject` or panic.
-    ///
-    /// # Safety
-    ///
-    /// Relies on [`from_owned_ptr_or_opt`](#method.from_owned_ptr_or_opt).
-    unsafe fn from_owned_ptr_or_panic(py: Python<'p>, ptr: *mut ffi::PyObject) -> &'p Self {
-        Self::from_owned_ptr_or_opt(py, ptr).unwrap_or_else(|| err::panic_after_error(py))
-    }
-    /// Convert from an arbitrary `PyObject` or panic.
-    ///
-    /// # Safety
-    ///
-    /// Relies on [`from_owned_ptr_or_opt`](#method.from_owned_ptr_or_opt).
-    unsafe fn from_owned_ptr(py: Python<'p>, ptr: *mut ffi::PyObject) -> &'p Self {
-        Self::from_owned_ptr_or_panic(py, ptr)
-    }
-    /// Convert from an arbitrary `PyObject`.
-    ///
-    /// # Safety
-    ///
-    /// Relies on [`from_owned_ptr_or_opt`](#method.from_owned_ptr_or_opt).
-    unsafe fn from_owned_ptr_or_err(py: Python<'p>, ptr: *mut ffi::PyObject) -> PyResult<&'p Self> {
-        Self::from_owned_ptr_or_opt(py, ptr).ok_or_else(|| err::PyErr::fetch(py))
-    }
-    /// Convert from an arbitrary borrowed `PyObject`.
-    ///
-    /// # Safety
-    ///
-    /// Implementations must ensure the object does not get freed during `'p` and avoid type confusion.
-    unsafe fn from_borrowed_ptr_or_opt(py: Python<'p>, ptr: *mut ffi::PyObject)
-        -> Option<&'p Self>;
-    /// Convert from an arbitrary borrowed `PyObject`.
-    ///
-    /// # Safety
-    ///
-    /// Relies on unsafe fn [`from_borrowed_ptr_or_opt`](#method.from_borrowed_ptr_or_opt).
-    unsafe fn from_borrowed_ptr_or_panic(py: Python<'p>, ptr: *mut ffi::PyObject) -> &'p Self {
-        Self::from_borrowed_ptr_or_opt(py, ptr).unwrap_or_else(|| err::panic_after_error(py))
-    }
-    /// Convert from an arbitrary borrowed `PyObject`.
-    ///
-    /// # Safety
-    ///
-    /// Relies on unsafe fn [`from_borrowed_ptr_or_opt`](#method.from_borrowed_ptr_or_opt).
-    unsafe fn from_borrowed_ptr(py: Python<'p>, ptr: *mut ffi::PyObject) -> &'p Self {
-        Self::from_borrowed_ptr_or_panic(py, ptr)
-    }
-    /// Convert from an arbitrary borrowed `PyObject`.
-    ///
-    /// # Safety
-    ///
-    /// Relies on unsafe fn [`from_borrowed_ptr_or_opt`](#method.from_borrowed_ptr_or_opt).
-    unsafe fn from_borrowed_ptr_or_err(
-        py: Python<'p>,
-        ptr: *mut ffi::PyObject,
-    ) -> PyResult<&'p Self> {
-        Self::from_borrowed_ptr_or_opt(py, ptr).ok_or_else(|| err::PyErr::fetch(py))
-    }
-}
+impl<'py> IntoPyObject<'py> for () {
+    type Target = PyTuple;
+    type Output = Bound<'py, Self::Target>;
+    type Error = Infallible;
 
-unsafe impl<'p, T> FromPyPointer<'p> for T
-where
-    T: 'p + crate::PyNativeType,
-{
-    unsafe fn from_owned_ptr_or_opt(py: Python<'p>, ptr: *mut ffi::PyObject) -> Option<&'p Self> {
-        gil::register_owned(py, NonNull::new(ptr)?);
-        Some(&*(ptr as *mut Self))
-    }
-    unsafe fn from_borrowed_ptr_or_opt(
-        _py: Python<'p>,
-        ptr: *mut ffi::PyObject,
-    ) -> Option<&'p Self> {
-        NonNull::new(ptr as *mut Self).map(|p| &*p.as_ptr())
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        Ok(PyTuple::empty(py))
     }
 }
 
@@ -584,7 +583,7 @@ where
 ///
 /// let t = TestClass { num: 10 };
 ///
-/// Python::with_gil(|py| {
+/// Python::attach(|py| {
 ///     let pyvalue = Py::new(py, t).unwrap().to_object(py);
 ///     let t: TestClass = pyvalue.extract(py).unwrap();
 /// })
@@ -593,67 +592,56 @@ mod test_no_clone {}
 
 #[cfg(test)]
 mod tests {
-    use crate::{PyObject, Python};
-
-    #[allow(deprecated)]
-    mod deprecated {
-        use super::super::PyTryFrom;
-        use crate::types::{IntoPyDict, PyAny, PyDict, PyList};
-        use crate::{Python, ToPyObject};
-
-        #[test]
-        fn test_try_from() {
-            Python::with_gil(|py| {
-                let list: &PyAny = vec![3, 6, 5, 4, 7].to_object(py).into_ref(py);
-                let dict: &PyAny = vec![("reverse", true)].into_py_dict(py).as_ref();
-
-                assert!(<PyList as PyTryFrom<'_>>::try_from(list).is_ok());
-                assert!(<PyDict as PyTryFrom<'_>>::try_from(dict).is_ok());
-
-                assert!(<PyAny as PyTryFrom<'_>>::try_from(list).is_ok());
-                assert!(<PyAny as PyTryFrom<'_>>::try_from(dict).is_ok());
-            });
-        }
+    #[test]
+    #[cfg(feature = "macros")]
+    fn test_pyclass_skip_from_py_object() {
+        use crate::{types::PyAnyMethods, FromPyObject, IntoPyObject, PyErr, Python};
 
-        #[test]
-        fn test_try_from_exact() {
-            Python::with_gil(|py| {
-                let list: &PyAny = vec![3, 6, 5, 4, 7].to_object(py).into_ref(py);
-                let dict: &PyAny = vec![("reverse", true)].into_py_dict(py).as_ref();
+        #[crate::pyclass(crate = "crate", skip_from_py_object)]
+        #[derive(Clone)]
+        struct Foo(i32);
 
-                assert!(PyList::try_from_exact(list).is_ok());
-                assert!(PyDict::try_from_exact(dict).is_ok());
+        impl<'py> FromPyObject<'_, 'py> for Foo {
+            type Error = PyErr;
 
-                assert!(PyAny::try_from_exact(list).is_err());
-                assert!(PyAny::try_from_exact(dict).is_err());
-            });
+            fn extract(obj: crate::Borrowed<'_, 'py, crate::PyAny>) -> Result<Self, Self::Error> {
+                if let Ok(obj) = obj.cast::<Self>() {
+                    Ok(obj.borrow().clone())
+                } else {
+                    obj.extract::<i32>().map(Self)
+                }
+            }
         }
+        Python::attach(|py| {
+            let foo1 = 42i32.into_pyobject(py)?;
+            assert_eq!(foo1.extract::<Foo>()?.0, 42);
 
-        #[test]
-        fn test_try_from_unchecked() {
-            Python::with_gil(|py| {
-                let list = PyList::new(py, [1, 2, 3]);
-                let val = unsafe { <PyList as PyTryFrom>::try_from_unchecked(list.as_ref()) };
-                assert!(list.is(val));
-            });
-        }
+            let foo2 = Foo(0).into_pyobject(py)?;
+            assert_eq!(foo2.extract::<Foo>()?.0, 0);
+
+            Ok::<_, PyErr>(())
+        })
+        .unwrap();
     }
 
     #[test]
-    fn test_option_as_ptr() {
-        Python::with_gil(|py| {
-            use crate::AsPyPointer;
-            let mut option: Option<PyObject> = None;
-            assert_eq!(option.as_ptr(), std::ptr::null_mut());
+    #[cfg(feature = "macros")]
+    fn test_pyclass_from_py_object() {
+        use crate::{types::PyAnyMethods, IntoPyObject, PyErr, Python};
+
+        #[crate::pyclass(crate = "crate", from_py_object)]
+        #[derive(Clone)]
+        struct Foo(i32);
 
-            let none = py.None();
-            option = Some(none.clone());
+        Python::attach(|py| {
+            let foo1 = 42i32.into_pyobject(py)?;
+            assert!(foo1.extract::<Foo>().is_err());
 
-            let ref_cnt = none.get_refcnt(py);
-            assert_eq!(option.as_ptr(), none.as_ptr());
+            let foo2 = Foo(0).into_pyobject(py)?;
+            assert_eq!(foo2.extract::<Foo>()?.0, 0);
 
-            // Ensure ref count not changed by as_ptr call
-            assert_eq!(none.get_refcnt(py), ref_cnt);
-        });
+            Ok::<_, PyErr>(())
+        })
+        .unwrap();
     }
 }
diff --git a/src/conversions/anyhow.rs b/src/conversions/anyhow.rs
index 453799c6e8b..af6bf515fee 100644
--- a/src/conversions/anyhow.rs
+++ b/src/conversions/anyhow.rs
@@ -1,9 +1,6 @@
 #![cfg(feature = "anyhow")]
 
-//! A conversion from
-//! [anyhow](https://docs.rs/anyhow/ "A trait object based error system for easy idiomatic error handling in Rust applications.")’s
-//! [`Error`](https://docs.rs/anyhow/latest/anyhow/struct.Error.html "Anyhows `Error` type, a wrapper around a dynamic error type")
-//! type to [`PyErr`].
+//! A conversion from [anyhow]’s [`Error`][anyhow-error] type to [`PyErr`].
 //!
 //! Use of an error handling library like [anyhow] is common in application code and when you just
 //! want error handling to be easy. If you are writing a library or you need more control over your
@@ -35,7 +32,6 @@
 //!
 //! ```rust
 //! use pyo3::prelude::*;
-//! use pyo3::wrap_pyfunction;
 //! use std::path::PathBuf;
 //!
 //! // A wrapper around a Rust function.
@@ -47,7 +43,7 @@
 //! }
 //!
 //! fn main() {
-//!     let error = Python::with_gil(|py| -> PyResult<Vec<u8>> {
+//!     let error = Python::attach(|py| -> PyResult<Vec<u8>> {
 //!         let fun = wrap_pyfunction!(py_open, py)?;
 //!         let text = fun.call1(("foo.txt",))?.extract::<Vec<u8>>()?;
 //!         Ok(text)
@@ -74,10 +70,10 @@
 //!     // An arbitrary example of a Python api you
 //!     // could call inside an application...
 //!     // This might return a `PyErr`.
-//!     let res = Python::with_gil(|py| {
+//!     let res = Python::attach(|py| {
 //!         let zlib = PyModule::import(py, "zlib")?;
 //!         let decompress = zlib.getattr("decompress")?;
-//!         let bytes = PyBytes::new_bound(py, bytes);
+//!         let bytes = PyBytes::new(py, bytes);
 //!         let value = decompress.call1((bytes,))?;
 //!         value.extract::<Vec<u8>>()
 //!     })?;
@@ -100,6 +96,8 @@
 //! }
 //! ```
 //!
+//! [anyhow]: https://docs.rs/anyhow/ "A trait object based error system for easy idiomatic error handling in Rust applications."
+//! [anyhow-error]: https://docs.rs/anyhow/latest/anyhow/struct.Error.html "Anyhows `Error` type, a wrapper around a dynamic error type"
 //! [`RuntimeError`]: https://docs.python.org/3/library/exceptions.html#RuntimeError "Built-in Exceptions — Python documentation"
 //! [Error handling]: https://doc.rust-lang.org/book/ch09-02-recoverable-errors-with-result.html "Recoverable Errors with Result - The Rust Programming Language"
 
@@ -115,7 +113,7 @@ impl From<anyhow::Error> for PyErr {
                 Err(error) => error,
             };
         }
-        PyRuntimeError::new_err(format!("{:?}", error))
+        PyRuntimeError::new_err(format!("{error:?}"))
     }
 }
 
@@ -143,12 +141,12 @@ mod test_anyhow {
     #[test]
     fn test_pyo3_exception_contents() {
         let err = h().unwrap_err();
-        let expected_contents = format!("{:?}", err);
+        let expected_contents = format!("{err:?}");
         let pyerr = PyErr::from(err);
 
-        Python::with_gil(|py| {
-            let locals = [("err", pyerr)].into_py_dict_bound(py);
-            let pyerr = py.run_bound("raise err", None, Some(&locals)).unwrap_err();
+        Python::attach(|py| {
+            let locals = [("err", pyerr)].into_py_dict(py).unwrap();
+            let pyerr = py.run(c"raise err", None, Some(&locals)).unwrap_err();
             assert_eq!(pyerr.value(py).to_string(), expected_contents);
         })
     }
@@ -160,12 +158,12 @@ mod test_anyhow {
     #[test]
     fn test_pyo3_exception_contents2() {
         let err = k().unwrap_err();
-        let expected_contents = format!("{:?}", err);
+        let expected_contents = format!("{err:?}");
         let pyerr = PyErr::from(err);
 
-        Python::with_gil(|py| {
-            let locals = [("err", pyerr)].into_py_dict_bound(py);
-            let pyerr = py.run_bound("raise err", None, Some(&locals)).unwrap_err();
+        Python::attach(|py| {
+            let locals = [("err", pyerr)].into_py_dict(py).unwrap();
+            let pyerr = py.run(c"raise err", None, Some(&locals)).unwrap_err();
             assert_eq!(pyerr.value(py).to_string(), expected_contents);
         })
     }
@@ -175,7 +173,7 @@ mod test_anyhow {
         let origin_exc = PyValueError::new_err("Value Error");
         let err: anyhow::Error = origin_exc.into();
         let converted: PyErr = err.into();
-        assert!(Python::with_gil(
+        assert!(Python::attach(
             |py| converted.is_instance_of::<PyValueError>(py)
         ))
     }
@@ -185,7 +183,7 @@ mod test_anyhow {
         let mut err: anyhow::Error = origin_exc.into();
         err = err.context("Context");
         let converted: PyErr = err.into();
-        assert!(Python::with_gil(
+        assert!(Python::attach(
             |py| converted.is_instance_of::<PyRuntimeError>(py)
         ))
     }
diff --git a/src/conversions/bigdecimal.rs b/src/conversions/bigdecimal.rs
new file mode 100644
index 00000000000..70783d0b2b1
--- /dev/null
+++ b/src/conversions/bigdecimal.rs
@@ -0,0 +1,254 @@
+#![cfg(feature = "bigdecimal")]
+//! Conversions to and from [bigdecimal](https://docs.rs/bigdecimal)'s [`BigDecimal`] type.
+//!
+//! This is useful for converting Python's decimal.Decimal into and from a native Rust type.
+//!
+//! # Setup
+//!
+//! To use this feature, add to your **`Cargo.toml`**:
+//!
+//! ```toml
+//! [dependencies]
+#![doc = concat!("pyo3 = { version = \"", env!("CARGO_PKG_VERSION"),  "\", features = [\"bigdecimal\"] }")]
+//! bigdecimal = "0.4"
+//! ```
+//!
+//! Note that you must use a compatible version of bigdecimal and PyO3.
+//! The required bigdecimal version may vary based on the version of PyO3.
+//!
+//! # Example
+//!
+//! Rust code to create a function that adds one to a BigDecimal
+//!
+//! ```rust
+//! use bigdecimal::BigDecimal;
+//! use pyo3::prelude::*;
+//!
+//! #[pyfunction]
+//! fn add_one(d: BigDecimal) -> BigDecimal {
+//!     d + 1
+//! }
+//!
+//! #[pymodule]
+//! fn my_module(m: &Bound<'_, PyModule>) -> PyResult<()> {
+//!     m.add_function(wrap_pyfunction!(add_one, m)?)?;
+//!     Ok(())
+//! }
+//! ```
+//!
+//! Python code that validates the functionality
+//!
+//!
+//! ```python
+//! from my_module import add_one
+//! from decimal import Decimal
+//!
+//! d = Decimal("2")
+//! value = add_one(d)
+//!
+//! assert d + 1 == value
+//! ```
+
+use std::str::FromStr;
+
+use crate::types::PyTuple;
+use crate::{
+    exceptions::PyValueError,
+    sync::PyOnceLock,
+    types::{PyAnyMethods, PyStringMethods, PyType},
+    Borrowed, Bound, FromPyObject, IntoPyObject, Py, PyAny, PyErr, PyResult, Python,
+};
+use bigdecimal::BigDecimal;
+use num_bigint::Sign;
+
+fn get_decimal_cls(py: Python<'_>) -> PyResult<&Bound<'_, PyType>> {
+    static DECIMAL_CLS: PyOnceLock<Py<PyType>> = PyOnceLock::new();
+    DECIMAL_CLS.import(py, "decimal", "Decimal")
+}
+
+fn get_invalid_operation_error_cls(py: Python<'_>) -> PyResult<&Bound<'_, PyType>> {
+    static INVALID_OPERATION_CLS: PyOnceLock<Py<PyType>> = PyOnceLock::new();
+    INVALID_OPERATION_CLS.import(py, "decimal", "InvalidOperation")
+}
+
+impl FromPyObject<'_, '_> for BigDecimal {
+    type Error = PyErr;
+
+    fn extract(obj: Borrowed<'_, '_, PyAny>) -> PyResult<Self> {
+        let py_str = &obj.str()?;
+        let rs_str = &py_str.to_cow()?;
+        BigDecimal::from_str(rs_str).map_err(|e| PyValueError::new_err(e.to_string()))
+    }
+}
+
+impl<'py> IntoPyObject<'py> for BigDecimal {
+    type Target = PyAny;
+
+    type Output = Bound<'py, Self::Target>;
+
+    type Error = PyErr;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        let cls = get_decimal_cls(py)?;
+        let (bigint, scale) = self.into_bigint_and_scale();
+        if scale == 0 {
+            return cls.call1((bigint,));
+        }
+        let exponent = scale.checked_neg().ok_or_else(|| {
+            get_invalid_operation_error_cls(py)
+                .map_or_else(|err| err, |cls| PyErr::from_type(cls.clone(), ()))
+        })?;
+        let (sign, digits) = bigint.to_radix_be(10);
+        let signed = matches!(sign, Sign::Minus).into_pyobject(py)?;
+        let digits = PyTuple::new(py, digits)?;
+
+        cls.call1(((signed, digits, exponent),))
+    }
+}
+
+#[cfg(test)]
+mod test_bigdecimal {
+    use super::*;
+    use crate::types::dict::PyDictMethods;
+    use crate::types::PyDict;
+    use std::ffi::CString;
+
+    use bigdecimal::{One, Zero};
+    #[cfg(not(target_arch = "wasm32"))]
+    use proptest::prelude::*;
+
+    macro_rules! convert_constants {
+        ($name:ident, $rs:expr, $py:literal) => {
+            #[test]
+            fn $name() {
+                Python::attach(|py| {
+                    let rs_orig = $rs;
+                    let rs_dec = rs_orig.clone().into_pyobject(py).unwrap();
+                    let locals = PyDict::new(py);
+                    locals.set_item("rs_dec", &rs_dec).unwrap();
+                    // Checks if BigDecimal -> Python Decimal conversion is correct
+                    py.run(
+                        &CString::new(format!(
+                            "import decimal\npy_dec = decimal.Decimal(\"{}\")\nassert py_dec == rs_dec",
+                            $py
+                        ))
+                        .unwrap(),
+                        None,
+                        Some(&locals),
+                    )
+                    .unwrap();
+                    // Checks if Python Decimal -> BigDecimal conversion is correct
+                    let py_dec = locals.get_item("py_dec").unwrap().unwrap();
+                    let py_result: BigDecimal = py_dec.extract().unwrap();
+                    assert_eq!(rs_orig, py_result);
+                })
+            }
+        };
+    }
+
+    convert_constants!(convert_zero, BigDecimal::zero(), "0");
+    convert_constants!(convert_one, BigDecimal::one(), "1");
+    convert_constants!(convert_neg_one, -BigDecimal::one(), "-1");
+    convert_constants!(convert_two, BigDecimal::from(2), "2");
+    convert_constants!(convert_ten, BigDecimal::from_str("10").unwrap(), "10");
+    convert_constants!(
+        convert_one_hundred_point_one,
+        BigDecimal::from_str("100.1").unwrap(),
+        "100.1"
+    );
+    convert_constants!(
+        convert_one_thousand,
+        BigDecimal::from_str("1000").unwrap(),
+        "1000"
+    );
+    convert_constants!(
+        convert_scientific,
+        BigDecimal::from_str("1e10").unwrap(),
+        "1e10"
+    );
+
+    #[cfg(not(target_arch = "wasm32"))]
+    proptest! {
+        #[test]
+        fn test_roundtrip(
+            number in 0..28u32
+        ) {
+            let num = BigDecimal::from(number);
+            Python::attach(|py| {
+                let rs_dec = num.clone().into_pyobject(py).unwrap();
+                let locals = PyDict::new(py);
+                locals.set_item("rs_dec", &rs_dec).unwrap();
+                py.run(
+                    &CString::new(format!(
+                       "import decimal\npy_dec = decimal.Decimal(\"{num}\")\nassert py_dec == rs_dec")).unwrap(),
+                None, Some(&locals)).unwrap();
+                let roundtripped: BigDecimal = rs_dec.extract().unwrap();
+                assert_eq!(num, roundtripped);
+            })
+        }
+
+        #[test]
+        fn test_integers(num in any::<i64>()) {
+            Python::attach(|py| {
+                let py_num = num.into_pyobject(py).unwrap();
+                let roundtripped: BigDecimal = py_num.extract().unwrap();
+                let rs_dec = BigDecimal::from(num);
+                assert_eq!(rs_dec, roundtripped);
+            })
+        }
+    }
+
+    #[test]
+    fn test_nan() {
+        Python::attach(|py| {
+            let locals = PyDict::new(py);
+            py.run(
+                c"import decimal\npy_dec = decimal.Decimal(\"NaN\")",
+                None,
+                Some(&locals),
+            )
+            .unwrap();
+            let py_dec = locals.get_item("py_dec").unwrap().unwrap();
+            let roundtripped: Result<BigDecimal, PyErr> = py_dec.extract();
+            assert!(roundtripped.is_err());
+        })
+    }
+
+    #[test]
+    fn test_infinity() {
+        Python::attach(|py| {
+            let locals = PyDict::new(py);
+            py.run(
+                c"import decimal\npy_dec = decimal.Decimal(\"Infinity\")",
+                None,
+                Some(&locals),
+            )
+            .unwrap();
+            let py_dec = locals.get_item("py_dec").unwrap().unwrap();
+            let roundtripped: Result<BigDecimal, PyErr> = py_dec.extract();
+            assert!(roundtripped.is_err());
+        })
+    }
+
+    #[test]
+    fn test_no_precision_loss() {
+        Python::attach(|py| {
+            let src = "1e4";
+            let expected = get_decimal_cls(py)
+                .unwrap()
+                .call1((src,))
+                .unwrap()
+                .call_method0("as_tuple")
+                .unwrap();
+            let actual = src
+                .parse::<BigDecimal>()
+                .unwrap()
+                .into_pyobject(py)
+                .unwrap()
+                .call_method0("as_tuple")
+                .unwrap();
+
+            assert!(actual.eq(expected).unwrap());
+        });
+    }
+}
diff --git a/src/conversions/bytes.rs b/src/conversions/bytes.rs
new file mode 100644
index 00000000000..fb656579a2d
--- /dev/null
+++ b/src/conversions/bytes.rs
@@ -0,0 +1,132 @@
+#![cfg(feature = "bytes")]
+
+//! Conversions to and from [bytes](https://docs.rs/bytes/latest/bytes/)'s [`Bytes`].
+//!
+//! This is useful for efficiently converting Python's `bytes` types efficiently.
+//! While `bytes` will be directly borrowed, converting from `bytearray` will result in a copy.
+//!
+//! When converting `Bytes` back into Python, this will do a copy, just like `&[u8]` and `Vec<u8>`.
+//!
+//! # When to use `Bytes`
+//!
+//! Unless you specifically need [`Bytes`] for ref-counted ownership and sharing,
+//! you may find that using `&[u8]`, `Vec<u8>`, [`Bound<PyBytes>`], or [`PyBackedBytes`]
+//! is simpler for most use cases.
+//!
+//! # Setup
+//!
+//! To use this feature, add in your **`Cargo.toml`**:
+//!
+//! ```toml
+//! [dependencies]
+//! bytes = "1.10"
+#![doc = concat!("pyo3 = { version = \"", env!("CARGO_PKG_VERSION"),  "\", features = [\"bytes\"] }")]
+//! ```
+//!
+//! Note that you must use compatible versions of bytes and PyO3.
+//!
+//! # Example
+//!
+//! Rust code to create functions which return `Bytes` or take `Bytes` as arguments:
+//!
+//! ```rust,no_run
+//! use pyo3::prelude::*;
+//! use bytes::Bytes;
+//!
+//! #[pyfunction]
+//! fn get_message_bytes() -> Bytes {
+//!     Bytes::from_static(b"Hello Python!")
+//! }
+//!
+//! #[pyfunction]
+//! fn num_bytes(bytes: Bytes) -> usize {
+//!     bytes.len()
+//! }
+//!
+//! #[pymodule]
+//! fn my_module(m: &Bound<'_, PyModule>) -> PyResult<()> {
+//!     m.add_function(wrap_pyfunction!(get_message_bytes, m)?)?;
+//!     m.add_function(wrap_pyfunction!(num_bytes, m)?)?;
+//!     Ok(())
+//! }
+//! ```
+//!
+//! Python code that calls these functions:
+//!
+//! ```python
+//! from my_module import get_message_bytes, num_bytes
+//!
+//! message = get_message_bytes()
+//! assert message == b"Hello Python!"
+//!
+//! size = num_bytes(message)
+//! assert size == 13
+//! ```
+use bytes::Bytes;
+
+use crate::conversion::IntoPyObject;
+use crate::instance::Bound;
+use crate::pybacked::PyBackedBytes;
+use crate::types::PyBytes;
+use crate::{Borrowed, CastError, FromPyObject, PyAny, PyErr, Python};
+
+impl<'a, 'py> FromPyObject<'a, 'py> for Bytes {
+    type Error = CastError<'a, 'py>;
+
+    fn extract(obj: Borrowed<'a, 'py, PyAny>) -> Result<Self, Self::Error> {
+        Ok(Bytes::from_owner(obj.extract::<PyBackedBytes>()?))
+    }
+}
+
+impl<'py> IntoPyObject<'py> for Bytes {
+    type Target = PyBytes;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        Ok(PyBytes::new(py, &self))
+    }
+}
+
+impl<'py> IntoPyObject<'py> for &Bytes {
+    type Target = PyBytes;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        Ok(PyBytes::new(py, self))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::types::{PyAnyMethods, PyByteArray, PyByteArrayMethods, PyBytes};
+    use crate::Python;
+
+    #[test]
+    fn test_bytes() {
+        Python::attach(|py| {
+            let py_bytes = PyBytes::new(py, b"foobar");
+            let bytes: Bytes = py_bytes.extract().unwrap();
+            assert_eq!(&*bytes, b"foobar");
+
+            let bytes = Bytes::from_static(b"foobar").into_pyobject(py).unwrap();
+            assert!(bytes.is_instance_of::<PyBytes>());
+        });
+    }
+
+    #[test]
+    fn test_bytearray() {
+        Python::attach(|py| {
+            let py_bytearray = PyByteArray::new(py, b"foobar");
+            let bytes: Bytes = py_bytearray.extract().unwrap();
+            assert_eq!(&*bytes, b"foobar");
+
+            // Editing the bytearray should not change extracted Bytes
+            unsafe { py_bytearray.as_bytes_mut()[0] = b'x' };
+            assert_eq!(&bytes, "foobar");
+            assert_eq!(&py_bytearray.extract::<Vec<u8>>().unwrap(), b"xoobar");
+        });
+    }
+}
diff --git a/src/conversions/chrono.rs b/src/conversions/chrono.rs
index d67818e645c..7d67f504ad5 100644
--- a/src/conversions/chrono.rs
+++ b/src/conversions/chrono.rs
@@ -20,52 +20,61 @@
 //!
 //! ```rust
 //! use chrono::{DateTime, Duration, TimeZone, Utc};
-//! use pyo3::{Python, ToPyObject};
+//! use pyo3::{Python, PyResult, IntoPyObject, types::PyAnyMethods};
 //!
-//! fn main() {
-//!     pyo3::prepare_freethreaded_python();
-//!     Python::with_gil(|py| {
+//! fn main() -> PyResult<()> {
+//!     Python::initialize();
+//!     Python::attach(|py| {
 //!         // Build some chrono values
 //!         let chrono_datetime = Utc.with_ymd_and_hms(2022, 1, 1, 12, 0, 0).unwrap();
 //!         let chrono_duration = Duration::seconds(1);
 //!         // Convert them to Python
-//!         let py_datetime = chrono_datetime.to_object(py);
-//!         let py_timedelta = chrono_duration.to_object(py);
+//!         let py_datetime = chrono_datetime.into_pyobject(py)?;
+//!         let py_timedelta = chrono_duration.into_pyobject(py)?;
 //!         // Do an operation in Python
-//!         let py_sum = py_datetime.call_method1(py, "__add__", (py_timedelta,)).unwrap();
+//!         let py_sum = py_datetime.call_method1("__add__", (py_timedelta,))?;
 //!         // Convert back to Rust
-//!         let chrono_sum: DateTime<Utc> = py_sum.extract(py).unwrap();
+//!         let chrono_sum: DateTime<Utc> = py_sum.extract()?;
 //!         println!("DateTime<Utc>: {}", chrono_datetime);
-//!     });
+//!         Ok(())
+//!     })
 //! }
 //! ```
+
+use crate::conversion::{FromPyObjectOwned, IntoPyObject};
 use crate::exceptions::{PyTypeError, PyUserWarning, PyValueError};
-#[cfg(Py_LIMITED_API)]
-use crate::sync::GILOnceCell;
+use crate::intern;
 use crate::types::any::PyAnyMethods;
+use crate::types::PyNone;
+use crate::types::{PyDate, PyDateTime, PyDelta, PyTime, PyTzInfo, PyTzInfoAccess};
 #[cfg(not(Py_LIMITED_API))]
-use crate::types::datetime::timezone_from_offset;
-#[cfg(not(Py_LIMITED_API))]
-use crate::types::{
-    timezone_utc_bound, PyDate, PyDateAccess, PyDateTime, PyDelta, PyDeltaAccess, PyTime,
-    PyTimeAccess, PyTzInfo, PyTzInfoAccess,
-};
-#[cfg(Py_LIMITED_API)]
-use crate::{intern, DowncastError};
+use crate::types::{PyDateAccess, PyDeltaAccess, PyTimeAccess};
+#[cfg(feature = "chrono-local")]
 use crate::{
-    Bound, FromPyObject, IntoPy, PyAny, PyErr, PyNativeType, PyObject, PyResult, Python, ToPyObject,
+    exceptions::PyRuntimeError,
+    sync::PyOnceLock,
+    types::{PyString, PyStringMethods},
+    Py,
 };
+use crate::{Borrowed, Bound, FromPyObject, IntoPyObjectExt, PyAny, PyErr, PyResult, Python};
 use chrono::offset::{FixedOffset, Utc};
+#[cfg(feature = "chrono-local")]
+use chrono::Local;
 use chrono::{
-    DateTime, Datelike, Duration, NaiveDate, NaiveDateTime, NaiveTime, Offset, TimeZone, Timelike,
+    DateTime, Datelike, Duration, LocalResult, NaiveDate, NaiveDateTime, NaiveTime, Offset,
+    TimeZone, Timelike,
 };
 
-impl ToPyObject for Duration {
-    fn to_object(&self, py: Python<'_>) -> PyObject {
+impl<'py> IntoPyObject<'py> for Duration {
+    type Target = PyDelta;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
         // Total number of days
         let days = self.num_days();
         // Remainder of seconds
-        let secs_dur = *self - Duration::days(days);
+        let secs_dur = self - Duration::days(days);
         let secs = secs_dur.num_seconds();
         // Fractional part of the microseconds
         let micros = (secs_dur - Duration::seconds(secs_dur.num_seconds()))
@@ -73,49 +82,43 @@ impl ToPyObject for Duration {
             // This should never panic since we are just getting the fractional
             // part of the total microseconds, which should never overflow.
             .unwrap();
-
-        #[cfg(not(Py_LIMITED_API))]
-        {
-            // We do not need to check the days i64 to i32 cast from rust because
-            // python will panic with OverflowError.
-            // We pass true as the `normalize` parameter since we'd need to do several checks here to
-            // avoid that, and it shouldn't have a big performance impact.
-            // The seconds and microseconds cast should never overflow since it's at most the number of seconds per day
-            PyDelta::new_bound(
-                py,
-                days.try_into().unwrap_or(i32::MAX),
-                secs.try_into().unwrap(),
-                micros.try_into().unwrap(),
-                true,
-            )
-            .expect("failed to construct delta")
-            .into()
-        }
-        #[cfg(Py_LIMITED_API)]
-        {
-            DatetimeTypes::get(py)
-                .timedelta
-                .call1(py, (days, secs, micros))
-                .expect("failed to construct datetime.timedelta")
-        }
+        // We do not need to check the days i64 to i32 cast from rust because
+        // python will panic with OverflowError.
+        // We pass true as the `normalize` parameter since we'd need to do several checks here to
+        // avoid that, and it shouldn't have a big performance impact.
+        // The seconds and microseconds cast should never overflow since it's at most the number of seconds per day
+        PyDelta::new(
+            py,
+            days.try_into().unwrap_or(i32::MAX),
+            secs.try_into()?,
+            micros.try_into()?,
+            true,
+        )
     }
 }
 
-impl IntoPy<PyObject> for Duration {
-    fn into_py(self, py: Python<'_>) -> PyObject {
-        self.to_object(py)
+impl<'py> IntoPyObject<'py> for &Duration {
+    type Target = PyDelta;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    #[inline]
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        (*self).into_pyobject(py)
     }
 }
 
-impl FromPyObject<'_> for Duration {
-    fn extract_bound(ob: &Bound<'_, PyAny>) -> PyResult<Duration> {
+impl FromPyObject<'_, '_> for Duration {
+    type Error = PyErr;
+
+    fn extract(ob: Borrowed<'_, '_, PyAny>) -> Result<Self, Self::Error> {
+        let delta = ob.cast::<PyDelta>()?;
         // Python size are much lower than rust size so we do not need bound checks.
         // 0 <= microseconds < 1000000
         // 0 <= seconds < 3600*24
         // -999999999 <= days <= 999999999
         #[cfg(not(Py_LIMITED_API))]
         let (days, seconds, microseconds) = {
-            let delta = ob.downcast::<PyDelta>()?;
             (
                 delta.get_days().into(),
                 delta.get_seconds().into(),
@@ -124,11 +127,11 @@ impl FromPyObject<'_> for Duration {
         };
         #[cfg(Py_LIMITED_API)]
         let (days, seconds, microseconds) = {
-            check_type(ob, &DatetimeTypes::get(ob.py()).timedelta, "PyDelta")?;
+            let py = delta.py();
             (
-                ob.getattr(intern!(ob.py(), "days"))?.extract()?,
-                ob.getattr(intern!(ob.py(), "seconds"))?.extract()?,
-                ob.getattr(intern!(ob.py(), "microseconds"))?.extract()?,
+                delta.getattr(intern!(py, "days"))?.extract()?,
+                delta.getattr(intern!(py, "seconds"))?.extract()?,
+                delta.getattr(intern!(py, "microseconds"))?.extract()?,
             )
         };
         Ok(
@@ -139,118 +142,127 @@ impl FromPyObject<'_> for Duration {
     }
 }
 
-impl ToPyObject for NaiveDate {
-    fn to_object(&self, py: Python<'_>) -> PyObject {
-        let DateArgs { year, month, day } = self.into();
-        #[cfg(not(Py_LIMITED_API))]
-        {
-            PyDate::new_bound(py, year, month, day)
-                .expect("failed to construct date")
-                .into()
-        }
-        #[cfg(Py_LIMITED_API)]
-        {
-            DatetimeTypes::get(py)
-                .date
-                .call1(py, (year, month, day))
-                .expect("failed to construct datetime.date")
-        }
+impl<'py> IntoPyObject<'py> for NaiveDate {
+    type Target = PyDate;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        let DateArgs { year, month, day } = (&self).into();
+        PyDate::new(py, year, month, day)
     }
 }
 
-impl IntoPy<PyObject> for NaiveDate {
-    fn into_py(self, py: Python<'_>) -> PyObject {
-        self.to_object(py)
+impl<'py> IntoPyObject<'py> for &NaiveDate {
+    type Target = PyDate;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    #[inline]
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        (*self).into_pyobject(py)
     }
 }
 
-impl FromPyObject<'_> for NaiveDate {
-    fn extract_bound(ob: &Bound<'_, PyAny>) -> PyResult<NaiveDate> {
-        #[cfg(not(Py_LIMITED_API))]
-        {
-            let date = ob.downcast::<PyDate>()?;
-            py_date_to_naive_date(date)
-        }
-        #[cfg(Py_LIMITED_API)]
-        {
-            check_type(ob, &DatetimeTypes::get(ob.py()).date, "PyDate")?;
-            py_date_to_naive_date(ob)
-        }
+impl FromPyObject<'_, '_> for NaiveDate {
+    type Error = PyErr;
+
+    fn extract(ob: Borrowed<'_, '_, PyAny>) -> Result<Self, Self::Error> {
+        let date = &*ob.cast::<PyDate>()?;
+        py_date_to_naive_date(date)
     }
 }
 
-impl ToPyObject for NaiveTime {
-    fn to_object(&self, py: Python<'_>) -> PyObject {
+impl<'py> IntoPyObject<'py> for NaiveTime {
+    type Target = PyTime;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
         let TimeArgs {
             hour,
             min,
             sec,
             micro,
             truncated_leap_second,
-        } = self.into();
-        #[cfg(not(Py_LIMITED_API))]
-        let time =
-            PyTime::new_bound(py, hour, min, sec, micro, None).expect("Failed to construct time");
-        #[cfg(Py_LIMITED_API)]
-        let time = DatetimeTypes::get(py)
-            .time
-            .bind(py)
-            .call1((hour, min, sec, micro))
-            .expect("failed to construct datetime.time");
+        } = (&self).into();
+
+        let time = PyTime::new(py, hour, min, sec, micro, None)?;
+
         if truncated_leap_second {
             warn_truncated_leap_second(&time);
         }
-        time.into()
+
+        Ok(time)
     }
 }
 
-impl IntoPy<PyObject> for NaiveTime {
-    fn into_py(self, py: Python<'_>) -> PyObject {
-        self.to_object(py)
+impl<'py> IntoPyObject<'py> for &NaiveTime {
+    type Target = PyTime;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    #[inline]
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        (*self).into_pyobject(py)
     }
 }
 
-impl FromPyObject<'_> for NaiveTime {
-    fn extract_bound(ob: &Bound<'_, PyAny>) -> PyResult<NaiveTime> {
-        #[cfg(not(Py_LIMITED_API))]
-        {
-            let time = ob.downcast::<PyTime>()?;
-            py_time_to_naive_time(time)
-        }
-        #[cfg(Py_LIMITED_API)]
-        {
-            check_type(ob, &DatetimeTypes::get(ob.py()).time, "PyTime")?;
-            py_time_to_naive_time(ob)
-        }
+impl FromPyObject<'_, '_> for NaiveTime {
+    type Error = PyErr;
+
+    fn extract(ob: Borrowed<'_, '_, PyAny>) -> Result<Self, Self::Error> {
+        let time = &*ob.cast::<PyTime>()?;
+        py_time_to_naive_time(time)
     }
 }
 
-impl ToPyObject for NaiveDateTime {
-    fn to_object(&self, py: Python<'_>) -> PyObject {
-        naive_datetime_to_py_datetime(py, self, None)
+impl<'py> IntoPyObject<'py> for NaiveDateTime {
+    type Target = PyDateTime;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        let DateArgs { year, month, day } = (&self.date()).into();
+        let TimeArgs {
+            hour,
+            min,
+            sec,
+            micro,
+            truncated_leap_second,
+        } = (&self.time()).into();
+
+        let datetime = PyDateTime::new(py, year, month, day, hour, min, sec, micro, None)?;
+
+        if truncated_leap_second {
+            warn_truncated_leap_second(&datetime);
+        }
+
+        Ok(datetime)
     }
 }
 
-impl IntoPy<PyObject> for NaiveDateTime {
-    fn into_py(self, py: Python<'_>) -> PyObject {
-        self.to_object(py)
+impl<'py> IntoPyObject<'py> for &NaiveDateTime {
+    type Target = PyDateTime;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    #[inline]
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        (*self).into_pyobject(py)
     }
 }
 
-impl FromPyObject<'_> for NaiveDateTime {
-    fn extract_bound(dt: &Bound<'_, PyAny>) -> PyResult<NaiveDateTime> {
-        #[cfg(not(Py_LIMITED_API))]
-        let dt = dt.downcast::<PyDateTime>()?;
-        #[cfg(Py_LIMITED_API)]
-        check_type(dt, &DatetimeTypes::get(dt.py()).datetime, "PyDateTime")?;
+impl FromPyObject<'_, '_> for NaiveDateTime {
+    type Error = PyErr;
+
+    fn extract(dt: Borrowed<'_, '_, PyAny>) -> Result<Self, Self::Error> {
+        let dt = &*dt.cast::<PyDateTime>()?;
 
         // If the user tries to convert a timezone aware datetime into a naive one,
         // we return a hard error. We could silently remove tzinfo, or assume local timezone
         // and do a conversion, but better leave this decision to the user of the library.
-        #[cfg(not(Py_LIMITED_API))]
-        let has_tzinfo = dt.get_tzinfo_bound().is_some();
-        #[cfg(Py_LIMITED_API)]
-        let has_tzinfo = !dt.getattr(intern!(dt.py(), "tzinfo"))?.is_none();
+        let has_tzinfo = dt.get_tzinfo().is_some();
         if has_tzinfo {
             return Err(PyTypeError::new_err("expected a datetime without tzinfo"));
         }
@@ -260,101 +272,137 @@ impl FromPyObject<'_> for NaiveDateTime {
     }
 }
 
-impl<Tz: TimeZone> ToPyObject for DateTime<Tz> {
-    fn to_object(&self, py: Python<'_>) -> PyObject {
-        // FIXME: convert to better timezone representation here than just convert to fixed offset
-        // See https://github.com/PyO3/pyo3/issues/3266
-        let tz = self.offset().fix().to_object(py);
-        let tz = tz.bind(py).downcast().unwrap();
-        naive_datetime_to_py_datetime(py, &self.naive_local(), Some(tz))
+impl<'py, Tz: TimeZone> IntoPyObject<'py> for DateTime<Tz>
+where
+    Tz: IntoPyObject<'py>,
+{
+    type Target = PyDateTime;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    #[inline]
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        (&self).into_pyobject(py)
     }
 }
 
-impl<Tz: TimeZone> IntoPy<PyObject> for DateTime<Tz> {
-    fn into_py(self, py: Python<'_>) -> PyObject {
-        self.to_object(py)
+impl<'py, Tz: TimeZone> IntoPyObject<'py> for &DateTime<Tz>
+where
+    Tz: IntoPyObject<'py>,
+{
+    type Target = PyDateTime;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        let tz = self.timezone().into_bound_py_any(py)?.cast_into()?;
+
+        let DateArgs { year, month, day } = (&self.naive_local().date()).into();
+        let TimeArgs {
+            hour,
+            min,
+            sec,
+            micro,
+            truncated_leap_second,
+        } = (&self.naive_local().time()).into();
+
+        let fold = matches!(
+            self.timezone().offset_from_local_datetime(&self.naive_local()),
+            LocalResult::Ambiguous(_, latest) if self.offset().fix() == latest.fix()
+        );
+
+        let datetime = PyDateTime::new_with_fold(
+            py,
+            year,
+            month,
+            day,
+            hour,
+            min,
+            sec,
+            micro,
+            Some(&tz),
+            fold,
+        )?;
+
+        if truncated_leap_second {
+            warn_truncated_leap_second(&datetime);
+        }
+
+        Ok(datetime)
     }
 }
 
-impl<Tz: TimeZone + for<'py> FromPyObject<'py>> FromPyObject<'_> for DateTime<Tz> {
-    fn extract_bound(dt: &Bound<'_, PyAny>) -> PyResult<DateTime<Tz>> {
-        #[cfg(not(Py_LIMITED_API))]
-        let dt = dt.downcast::<PyDateTime>()?;
-        #[cfg(Py_LIMITED_API)]
-        check_type(dt, &DatetimeTypes::get(dt.py()).datetime, "PyDateTime")?;
+impl<'py, Tz> FromPyObject<'_, 'py> for DateTime<Tz>
+where
+    Tz: TimeZone + FromPyObjectOwned<'py>,
+{
+    type Error = PyErr;
 
-        #[cfg(not(Py_LIMITED_API))]
-        let tzinfo = dt.get_tzinfo_bound();
-        #[cfg(Py_LIMITED_API)]
-        let tzinfo: Option<&PyAny> = dt.getattr(intern!(dt.py(), "tzinfo"))?.extract()?;
+    fn extract(dt: Borrowed<'_, 'py, PyAny>) -> Result<Self, Self::Error> {
+        let dt = &*dt.cast::<PyDateTime>()?;
+        let tzinfo = dt.get_tzinfo();
 
         let tz = if let Some(tzinfo) = tzinfo {
-            tzinfo.extract()?
+            tzinfo.extract().map_err(Into::into)?
         } else {
+            // Special case: allow naive `datetime` objects for `DateTime<Local>`, interpreting them as local time.
+            #[cfg(feature = "chrono-local")]
+            if let Some(tz) = Tz::as_local_tz(crate::conversion::private::Token) {
+                return py_datetime_to_datetime_with_timezone(dt, tz);
+            }
+
             return Err(PyTypeError::new_err(
                 "expected a datetime with non-None tzinfo",
             ));
         };
-        let naive_dt = NaiveDateTime::new(py_date_to_naive_date(dt)?, py_time_to_naive_time(dt)?);
-        naive_dt.and_local_timezone(tz).single().ok_or_else(|| {
-            PyValueError::new_err(format!(
-                "The datetime {:?} contains an incompatible or ambiguous timezone",
-                dt
-            ))
-        })
+
+        py_datetime_to_datetime_with_timezone(dt, tz)
     }
 }
 
-impl ToPyObject for FixedOffset {
-    fn to_object(&self, py: Python<'_>) -> PyObject {
-        let seconds_offset = self.local_minus_utc();
+impl<'py> IntoPyObject<'py> for FixedOffset {
+    type Target = PyTzInfo;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
 
-        #[cfg(not(Py_LIMITED_API))]
-        {
-            let td = PyDelta::new_bound(py, 0, seconds_offset, 0, true)
-                .expect("failed to construct timedelta");
-            timezone_from_offset(&td)
-                .expect("Failed to construct PyTimezone")
-                .into()
-        }
-        #[cfg(Py_LIMITED_API)]
-        {
-            let td = Duration::seconds(seconds_offset.into()).into_py(py);
-            DatetimeTypes::get(py)
-                .timezone
-                .call1(py, (td,))
-                .expect("failed to construct datetime.timezone")
-        }
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        let seconds_offset = self.local_minus_utc();
+        let td = PyDelta::new(py, 0, seconds_offset, 0, true)?;
+        PyTzInfo::fixed_offset(py, td)
     }
 }
 
-impl IntoPy<PyObject> for FixedOffset {
-    fn into_py(self, py: Python<'_>) -> PyObject {
-        self.to_object(py)
+impl<'py> IntoPyObject<'py> for &FixedOffset {
+    type Target = PyTzInfo;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    #[inline]
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        (*self).into_pyobject(py)
     }
 }
 
-impl FromPyObject<'_> for FixedOffset {
+impl FromPyObject<'_, '_> for FixedOffset {
+    type Error = PyErr;
+
     /// Convert python tzinfo to rust [`FixedOffset`].
     ///
     /// Note that the conversion will result in precision lost in microseconds as chrono offset
     /// does not supports microseconds.
-    fn extract_bound(ob: &Bound<'_, PyAny>) -> PyResult<FixedOffset> {
-        #[cfg(not(Py_LIMITED_API))]
-        let ob: &PyTzInfo = ob.extract()?;
-        #[cfg(Py_LIMITED_API)]
-        check_type(ob, &DatetimeTypes::get(ob.py()).tzinfo, "PyTzInfo")?;
+    fn extract(ob: Borrowed<'_, '_, PyAny>) -> Result<Self, Self::Error> {
+        let ob = ob.cast::<PyTzInfo>()?;
 
-        // Passing `()` (so Python's None) to the `utcoffset` function will only
+        // Passing Python's None to the `utcoffset` function will only
         // work for timezones defined as fixed offsets in Python.
         // Any other timezone would require a datetime as the parameter, and return
         // None if the datetime is not provided.
         // Trying to convert None to a PyDelta in the next line will then fail.
-        let py_timedelta = ob.call_method1("utcoffset", ((),))?;
+        let py_timedelta =
+            ob.call_method1(intern!(ob.py(), "utcoffset"), (PyNone::get(ob.py()),))?;
         if py_timedelta.is_none() {
             return Err(PyTypeError::new_err(format!(
-                "{:?} is not a fixed offset timezone",
-                ob
+                "{ob:?} is not a fixed offset timezone"
             )));
         }
         let total_seconds: Duration = py_timedelta.extract()?;
@@ -365,21 +413,32 @@ impl FromPyObject<'_> for FixedOffset {
     }
 }
 
-impl ToPyObject for Utc {
-    fn to_object(&self, py: Python<'_>) -> PyObject {
-        timezone_utc_bound(py).into()
+impl<'py> IntoPyObject<'py> for Utc {
+    type Target = PyTzInfo;
+    type Output = Borrowed<'static, 'py, Self::Target>;
+    type Error = PyErr;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        PyTzInfo::utc(py)
     }
 }
 
-impl IntoPy<PyObject> for Utc {
-    fn into_py(self, py: Python<'_>) -> PyObject {
-        self.to_object(py)
+impl<'py> IntoPyObject<'py> for &Utc {
+    type Target = PyTzInfo;
+    type Output = Borrowed<'static, 'py, Self::Target>;
+    type Error = PyErr;
+
+    #[inline]
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        (*self).into_pyobject(py)
     }
 }
 
-impl FromPyObject<'_> for Utc {
-    fn extract_bound(ob: &Bound<'_, PyAny>) -> PyResult<Utc> {
-        let py_utc = timezone_utc_bound(ob.py());
+impl FromPyObject<'_, '_> for Utc {
+    type Error = PyErr;
+
+    fn extract(ob: Borrowed<'_, '_, PyAny>) -> Result<Self, Self::Error> {
+        let py_utc = PyTzInfo::utc(ob.py())?;
         if ob.eq(py_utc)? {
             Ok(Utc)
         } else {
@@ -388,6 +447,61 @@ impl FromPyObject<'_> for Utc {
     }
 }
 
+#[cfg(feature = "chrono-local")]
+impl<'py> IntoPyObject<'py> for Local {
+    type Target = PyTzInfo;
+    type Output = Borrowed<'static, 'py, Self::Target>;
+    type Error = PyErr;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        static LOCAL_TZ: PyOnceLock<Py<PyTzInfo>> = PyOnceLock::new();
+        let tz = LOCAL_TZ
+            .get_or_try_init(py, || {
+                let iana_name = iana_time_zone::get_timezone().map_err(|e| {
+                    PyRuntimeError::new_err(format!("Could not get local timezone: {e}"))
+                })?;
+                PyTzInfo::timezone(py, iana_name).map(Bound::unbind)
+            })?
+            .bind_borrowed(py);
+        Ok(tz)
+    }
+}
+
+#[cfg(feature = "chrono-local")]
+impl<'py> IntoPyObject<'py> for &Local {
+    type Target = PyTzInfo;
+    type Output = Borrowed<'static, 'py, Self::Target>;
+    type Error = PyErr;
+
+    #[inline]
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        (*self).into_pyobject(py)
+    }
+}
+
+#[cfg(feature = "chrono-local")]
+impl FromPyObject<'_, '_> for Local {
+    type Error = PyErr;
+
+    fn extract(ob: Borrowed<'_, '_, PyAny>) -> PyResult<Local> {
+        let local_tz = Local.into_pyobject(ob.py())?;
+        if ob.eq(local_tz)? {
+            Ok(Local)
+        } else {
+            let name = local_tz.getattr("key")?.cast_into::<PyString>()?;
+            Err(PyValueError::new_err(format!(
+                "expected local timezone {}",
+                name.to_cow()?
+            )))
+        }
+    }
+
+    #[inline]
+    fn as_local_tz(_: crate::conversion::private::Token) -> Option<Self> {
+        Some(Local)
+    }
+}
+
 struct DateArgs {
     year: i32,
     month: u8,
@@ -428,49 +542,22 @@ impl From<&NaiveTime> for TimeArgs {
     }
 }
 
-fn naive_datetime_to_py_datetime(
-    py: Python<'_>,
-    naive_datetime: &NaiveDateTime,
-    #[cfg(not(Py_LIMITED_API))] tzinfo: Option<&Bound<'_, PyTzInfo>>,
-    #[cfg(Py_LIMITED_API)] tzinfo: Option<&Bound<'_, PyAny>>,
-) -> PyObject {
-    let DateArgs { year, month, day } = (&naive_datetime.date()).into();
-    let TimeArgs {
-        hour,
-        min,
-        sec,
-        micro,
-        truncated_leap_second,
-    } = (&naive_datetime.time()).into();
-    #[cfg(not(Py_LIMITED_API))]
-    let datetime = PyDateTime::new_bound(py, year, month, day, hour, min, sec, micro, tzinfo)
-        .expect("failed to construct datetime");
-    #[cfg(Py_LIMITED_API)]
-    let datetime = DatetimeTypes::get(py)
-        .datetime
-        .bind(py)
-        .call1((year, month, day, hour, min, sec, micro, tzinfo))
-        .expect("failed to construct datetime.datetime");
-    if truncated_leap_second {
-        warn_truncated_leap_second(&datetime);
-    }
-    datetime.into()
-}
-
 fn warn_truncated_leap_second(obj: &Bound<'_, PyAny>) {
     let py = obj.py();
-    if let Err(e) = PyErr::warn_bound(
+    if let Err(e) = PyErr::warn(
         py,
-        &py.get_type::<PyUserWarning>().as_borrowed(),
-        "ignored leap-second, `datetime` does not support leap-seconds",
+        &py.get_type::<PyUserWarning>(),
+        c"ignored leap-second, `datetime` does not support leap-seconds",
         0,
     ) {
-        e.write_unraisable_bound(py, Some(&obj.as_borrowed()))
+        e.write_unraisable(py, Some(obj))
     };
 }
 
 #[cfg(not(Py_LIMITED_API))]
-fn py_date_to_naive_date(py_date: &impl PyDateAccess) -> PyResult<NaiveDate> {
+fn py_date_to_naive_date(
+    py_date: impl std::ops::Deref<Target = impl PyDateAccess>,
+) -> PyResult<NaiveDate> {
     NaiveDate::from_ymd_opt(
         py_date.get_year(),
         py_date.get_month().into(),
@@ -490,7 +577,9 @@ fn py_date_to_naive_date(py_date: &Bound<'_, PyAny>) -> PyResult<NaiveDate> {
 }
 
 #[cfg(not(Py_LIMITED_API))]
-fn py_time_to_naive_time(py_time: &impl PyTimeAccess) -> PyResult<NaiveTime> {
+fn py_time_to_naive_time(
+    py_time: impl std::ops::Deref<Target = impl PyTimeAccess>,
+) -> PyResult<NaiveTime> {
     NaiveTime::from_hms_micro_opt(
         py_time.get_hour().into(),
         py_time.get_minute().into(),
@@ -517,56 +606,36 @@ fn py_time_to_naive_time(py_time: &Bound<'_, PyAny>) -> PyResult<NaiveTime> {
     .ok_or_else(|| PyValueError::new_err("invalid or out-of-range time"))
 }
 
-#[cfg(Py_LIMITED_API)]
-fn check_type(value: &Bound<'_, PyAny>, t: &PyObject, type_name: &'static str) -> PyResult<()> {
-    if !value.is_instance(t.bind(value.py()))? {
-        return Err(DowncastError::new(value, type_name).into());
-    }
-    Ok(())
-}
-
-#[cfg(Py_LIMITED_API)]
-struct DatetimeTypes {
-    date: PyObject,
-    datetime: PyObject,
-    time: PyObject,
-    timedelta: PyObject,
-    timezone: PyObject,
-    timezone_utc: PyObject,
-    tzinfo: PyObject,
-}
-
-#[cfg(Py_LIMITED_API)]
-impl DatetimeTypes {
-    fn get(py: Python<'_>) -> &Self {
-        static TYPES: GILOnceCell<DatetimeTypes> = GILOnceCell::new();
-        TYPES
-            .get_or_try_init(py, || {
-                let datetime = py.import_bound("datetime")?;
-                let timezone = datetime.getattr("timezone")?;
-                Ok::<_, PyErr>(Self {
-                    date: datetime.getattr("date")?.into(),
-                    datetime: datetime.getattr("datetime")?.into(),
-                    time: datetime.getattr("time")?.into(),
-                    timedelta: datetime.getattr("timedelta")?.into(),
-                    timezone_utc: timezone.getattr("utc")?.into(),
-                    timezone: timezone.into(),
-                    tzinfo: datetime.getattr("tzinfo")?.into(),
-                })
-            })
-            .expect("failed to load datetime module")
+fn py_datetime_to_datetime_with_timezone<Tz: TimeZone>(
+    dt: &Bound<'_, PyDateTime>,
+    tz: Tz,
+) -> PyResult<DateTime<Tz>> {
+    let naive_dt = NaiveDateTime::new(py_date_to_naive_date(dt)?, py_time_to_naive_time(dt)?);
+    match naive_dt.and_local_timezone(tz) {
+        LocalResult::Single(value) => Ok(value),
+        LocalResult::Ambiguous(earliest, latest) => {
+            #[cfg(not(Py_LIMITED_API))]
+            let fold = dt.get_fold();
+
+            #[cfg(Py_LIMITED_API)]
+            let fold = dt.getattr(intern!(dt.py(), "fold"))?.extract::<usize>()? > 0;
+
+            if fold {
+                Ok(latest)
+            } else {
+                Ok(earliest)
+            }
+        }
+        LocalResult::None => Err(PyValueError::new_err(format!(
+            "The datetime {dt:?} contains an incompatible timezone"
+        ))),
     }
 }
 
-#[cfg(Py_LIMITED_API)]
-fn timezone_utc_bound(py: Python<'_>) -> Bound<'_, PyAny> {
-    DatetimeTypes::get(py).timezone_utc.bind(py).clone()
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{types::PyTuple, Py};
+    use crate::{test_utils::assert_warnings, types::PyTuple, BoundObject};
     use std::{cmp::Ordering, panic};
 
     #[test]
@@ -578,10 +647,10 @@ mod tests {
         use crate::types::any::PyAnyMethods;
         use crate::types::dict::PyDictMethods;
 
-        Python::with_gil(|py| {
-            let locals = crate::types::PyDict::new_bound(py);
-            py.run_bound(
-                "import zoneinfo; zi = zoneinfo.ZoneInfo('Europe/London')",
+        Python::attach(|py| {
+            let locals = crate::types::PyDict::new(py);
+            py.run(
+                c"import zoneinfo; zi = zoneinfo.ZoneInfo('Europe/London')",
                 None,
                 Some(&locals),
             )
@@ -599,7 +668,7 @@ mod tests {
     fn test_timezone_aware_to_naive_fails() {
         // Test that if a user tries to convert a python's timezone aware datetime into a naive
         // one, the conversion fails.
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let py_datetime =
                 new_py_datetime_ob(py, "datetime", (2022, 1, 1, 1, 0, 0, 0, python_utc(py)));
             // Now test that converting a PyDateTime with tzinfo to a NaiveDateTime fails
@@ -615,7 +684,7 @@ mod tests {
     fn test_naive_to_timezone_aware_fails() {
         // Test that if a user tries to convert a python's timezone aware datetime into a naive
         // one, the conversion fails.
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let py_datetime = new_py_datetime_ob(py, "datetime", (2022, 1, 1, 1, 0, 0, 0));
             // Now test that converting a PyDateTime with tzinfo to a NaiveDateTime fails
             let res: PyResult<DateTime<Utc>> = py_datetime.extract();
@@ -637,15 +706,15 @@ mod tests {
     fn test_invalid_types_fail() {
         // Test that if a user tries to convert a python's timezone aware datetime into a naive
         // one, the conversion fails.
-        Python::with_gil(|py| {
-            let none = py.None().into_ref(py);
+        Python::attach(|py| {
+            let none = py.None().into_bound(py);
             assert_eq!(
                 none.extract::<Duration>().unwrap_err().to_string(),
-                "TypeError: 'NoneType' object cannot be converted to 'PyDelta'"
+                "TypeError: 'NoneType' object cannot be cast as 'timedelta'"
             );
             assert_eq!(
                 none.extract::<FixedOffset>().unwrap_err().to_string(),
-                "TypeError: 'NoneType' object cannot be converted to 'PyTzInfo'"
+                "TypeError: 'NoneType' object cannot be cast as 'tzinfo'"
             );
             assert_eq!(
                 none.extract::<Utc>().unwrap_err().to_string(),
@@ -653,43 +722,40 @@ mod tests {
             );
             assert_eq!(
                 none.extract::<NaiveTime>().unwrap_err().to_string(),
-                "TypeError: 'NoneType' object cannot be converted to 'PyTime'"
+                "TypeError: 'NoneType' object cannot be cast as 'time'"
             );
             assert_eq!(
                 none.extract::<NaiveDate>().unwrap_err().to_string(),
-                "TypeError: 'NoneType' object cannot be converted to 'PyDate'"
+                "TypeError: 'NoneType' object cannot be cast as 'date'"
             );
             assert_eq!(
                 none.extract::<NaiveDateTime>().unwrap_err().to_string(),
-                "TypeError: 'NoneType' object cannot be converted to 'PyDateTime'"
+                "TypeError: 'NoneType' object cannot be cast as 'datetime'"
             );
             assert_eq!(
                 none.extract::<DateTime<Utc>>().unwrap_err().to_string(),
-                "TypeError: 'NoneType' object cannot be converted to 'PyDateTime'"
+                "TypeError: 'NoneType' object cannot be cast as 'datetime'"
             );
             assert_eq!(
                 none.extract::<DateTime<FixedOffset>>()
                     .unwrap_err()
                     .to_string(),
-                "TypeError: 'NoneType' object cannot be converted to 'PyDateTime'"
+                "TypeError: 'NoneType' object cannot be cast as 'datetime'"
             );
         });
     }
 
     #[test]
-    fn test_pyo3_timedelta_topyobject() {
+    fn test_pyo3_timedelta_into_pyobject() {
         // Utility function used to check different durations.
         // The `name` parameter is used to identify the check in case of a failure.
         let check = |name: &'static str, delta: Duration, py_days, py_seconds, py_ms| {
-            Python::with_gil(|py| {
-                let delta = delta.to_object(py);
+            Python::attach(|py| {
+                let delta = delta.into_pyobject(py).unwrap();
                 let py_delta = new_py_datetime_ob(py, "timedelta", (py_days, py_seconds, py_ms));
                 assert!(
-                    delta.bind(py).eq(&py_delta).unwrap(),
-                    "{}: {} != {}",
-                    name,
-                    delta,
-                    py_delta
+                    delta.eq(&py_delta).unwrap(),
+                    "{name}: {delta} != {py_delta}"
                 );
             });
         };
@@ -706,10 +772,14 @@ mod tests {
         let delta = Duration::seconds(86399999999999) + Duration::nanoseconds(999999000); // max
         check("delta max value", delta, 999999999, 86399, 999999);
 
-        // Also check that trying to convert an out of bound value panics.
-        Python::with_gil(|py| {
-            assert!(panic::catch_unwind(|| Duration::min_value().to_object(py)).is_err());
-            assert!(panic::catch_unwind(|| Duration::max_value().to_object(py)).is_err());
+        // Also check that trying to convert an out of bound value errors.
+        Python::attach(|py| {
+            // min_value and max_value were deprecated in chrono 0.4.39
+            #[allow(deprecated)]
+            {
+                assert!(Duration::min_value().into_pyobject(py).is_err());
+                assert!(Duration::max_value().into_pyobject(py).is_err());
+            }
         });
     }
 
@@ -718,10 +788,10 @@ mod tests {
         // Utility function used to check different durations.
         // The `name` parameter is used to identify the check in case of a failure.
         let check = |name: &'static str, delta: Duration, py_days, py_seconds, py_ms| {
-            Python::with_gil(|py| {
+            Python::attach(|py| {
                 let py_delta = new_py_datetime_ob(py, "timedelta", (py_days, py_seconds, py_ms));
                 let py_delta: Duration = py_delta.extract().unwrap();
-                assert_eq!(py_delta, delta, "{}: {} != {}", name, py_delta, delta);
+                assert_eq!(py_delta, delta, "{name}: {py_delta} != {delta}");
             })
         };
 
@@ -745,7 +815,7 @@ mod tests {
 
         // This check is to assert that we can't construct every possible Duration from a PyDelta
         // since they have different bounds.
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let low_days: i32 = -1000000000;
             // This is possible
             assert!(panic::catch_unwind(|| Duration::days(low_days as i64)).is_ok());
@@ -773,20 +843,18 @@ mod tests {
     }
 
     #[test]
-    fn test_pyo3_date_topyobject() {
+    fn test_pyo3_date_into_pyobject() {
         let eq_ymd = |name: &'static str, year, month, day| {
-            Python::with_gil(|py| {
+            Python::attach(|py| {
                 let date = NaiveDate::from_ymd_opt(year, month, day)
                     .unwrap()
-                    .to_object(py);
+                    .into_pyobject(py)
+                    .unwrap();
                 let py_date = new_py_datetime_ob(py, "date", (year, month, day));
                 assert_eq!(
-                    date.bind(py).compare(&py_date).unwrap(),
+                    date.compare(&py_date).unwrap(),
                     Ordering::Equal,
-                    "{}: {} != {}",
-                    name,
-                    date,
-                    py_date
+                    "{name}: {date} != {py_date}"
                 );
             })
         };
@@ -800,11 +868,11 @@ mod tests {
     #[test]
     fn test_pyo3_date_frompyobject() {
         let eq_ymd = |name: &'static str, year, month, day| {
-            Python::with_gil(|py| {
+            Python::attach(|py| {
                 let py_date = new_py_datetime_ob(py, "date", (year, month, day));
                 let py_date: NaiveDate = py_date.extract().unwrap();
                 let date = NaiveDate::from_ymd_opt(year, month, day).unwrap();
-                assert_eq!(py_date, date, "{}: {} != {}", name, date, py_date);
+                assert_eq!(py_date, date, "{name}: {date} != {py_date}");
             })
         };
 
@@ -815,8 +883,8 @@ mod tests {
     }
 
     #[test]
-    fn test_pyo3_datetime_topyobject_utc() {
-        Python::with_gil(|py| {
+    fn test_pyo3_datetime_into_pyobject_utc() {
+        Python::attach(|py| {
             let check_utc =
                 |name: &'static str, year, month, day, hour, minute, second, ms, py_ms| {
                     let datetime = NaiveDate::from_ymd_opt(year, month, day)
@@ -824,7 +892,7 @@ mod tests {
                         .and_hms_micro_opt(hour, minute, second, ms)
                         .unwrap()
                         .and_utc();
-                    let datetime = datetime.to_object(py);
+                    let datetime = datetime.into_pyobject(py).unwrap();
                     let py_datetime = new_py_datetime_ob(
                         py,
                         "datetime",
@@ -840,12 +908,9 @@ mod tests {
                         ),
                     );
                     assert_eq!(
-                        datetime.bind(py).compare(&py_datetime).unwrap(),
+                        datetime.compare(&py_datetime).unwrap(),
                         Ordering::Equal,
-                        "{}: {} != {}",
-                        name,
-                        datetime,
-                        py_datetime
+                        "{name}: {datetime} != {py_datetime}"
                     );
                 };
 
@@ -863,8 +928,8 @@ mod tests {
     }
 
     #[test]
-    fn test_pyo3_datetime_topyobject_fixed_offset() {
-        Python::with_gil(|py| {
+    fn test_pyo3_datetime_into_pyobject_fixed_offset() {
+        Python::attach(|py| {
             let check_fixed_offset =
                 |name: &'static str, year, month, day, hour, minute, second, ms, py_ms| {
                     let offset = FixedOffset::east_opt(3600).unwrap();
@@ -874,20 +939,17 @@ mod tests {
                         .unwrap()
                         .and_local_timezone(offset)
                         .unwrap();
-                    let datetime = datetime.to_object(py);
-                    let py_tz = offset.to_object(py);
+                    let datetime = datetime.into_pyobject(py).unwrap();
+                    let py_tz = offset.into_pyobject(py).unwrap();
                     let py_datetime = new_py_datetime_ob(
                         py,
                         "datetime",
                         (year, month, day, hour, minute, second, py_ms, py_tz),
                     );
                     assert_eq!(
-                        datetime.bind(py).compare(&py_datetime).unwrap(),
+                        datetime.compare(&py_datetime).unwrap(),
                         Ordering::Equal,
-                        "{}: {} != {}",
-                        name,
-                        datetime,
-                        py_datetime
+                        "{name}: {datetime} != {py_datetime}"
                     );
                 };
 
@@ -904,9 +966,38 @@ mod tests {
         })
     }
 
+    #[test]
+    #[cfg(all(Py_3_9, feature = "chrono-tz", not(windows)))]
+    fn test_pyo3_datetime_into_pyobject_tz() {
+        Python::attach(|py| {
+            let datetime = NaiveDate::from_ymd_opt(2024, 12, 11)
+                .unwrap()
+                .and_hms_opt(23, 3, 13)
+                .unwrap()
+                .and_local_timezone(chrono_tz::Tz::Europe__London)
+                .unwrap();
+            let datetime = datetime.into_pyobject(py).unwrap();
+            let py_datetime = new_py_datetime_ob(
+                py,
+                "datetime",
+                (
+                    2024,
+                    12,
+                    11,
+                    23,
+                    3,
+                    13,
+                    0,
+                    python_zoneinfo(py, "Europe/London"),
+                ),
+            );
+            assert_eq!(datetime.compare(&py_datetime).unwrap(), Ordering::Equal);
+        })
+    }
+
     #[test]
     fn test_pyo3_datetime_frompyobject_utc() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let year = 2014;
             let month = 5;
             let day = 6;
@@ -914,7 +1005,7 @@ mod tests {
             let minute = 8;
             let second = 9;
             let micro = 999_999;
-            let tz_utc = timezone_utc_bound(py);
+            let tz_utc = PyTzInfo::utc(py).unwrap();
             let py_datetime = new_py_datetime_ob(
                 py,
                 "datetime",
@@ -930,9 +1021,36 @@ mod tests {
         })
     }
 
+    #[test]
+    #[cfg(feature = "chrono-local")]
+    fn test_pyo3_naive_datetime_frompyobject_local() {
+        Python::attach(|py| {
+            let year = 2014;
+            let month = 5;
+            let day = 6;
+            let hour = 7;
+            let minute = 8;
+            let second = 9;
+            let micro = 999_999;
+            let py_datetime = new_py_datetime_ob(
+                py,
+                "datetime",
+                (year, month, day, hour, minute, second, micro),
+            );
+            let py_datetime: DateTime<Local> = py_datetime.extract().unwrap();
+            let expected_datetime = NaiveDate::from_ymd_opt(year, month, day)
+                .unwrap()
+                .and_hms_micro_opt(hour, minute, second, micro)
+                .unwrap()
+                .and_local_timezone(Local)
+                .unwrap();
+            assert_eq!(py_datetime, expected_datetime);
+        })
+    }
+
     #[test]
     fn test_pyo3_datetime_frompyobject_fixed_offset() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let year = 2014;
             let month = 5;
             let day = 6;
@@ -941,7 +1059,7 @@ mod tests {
             let second = 9;
             let micro = 999_999;
             let offset = FixedOffset::east_opt(3600).unwrap();
-            let py_tz = offset.to_object(py);
+            let py_tz = offset.into_pyobject(py).unwrap();
             let py_datetime = new_py_datetime_ob(
                 py,
                 "datetime",
@@ -974,27 +1092,33 @@ mod tests {
     }
 
     #[test]
-    fn test_pyo3_offset_fixed_topyobject() {
-        Python::with_gil(|py| {
+    fn test_pyo3_offset_fixed_into_pyobject() {
+        Python::attach(|py| {
             // Chrono offset
-            let offset = FixedOffset::east_opt(3600).unwrap().to_object(py);
+            let offset = FixedOffset::east_opt(3600)
+                .unwrap()
+                .into_pyobject(py)
+                .unwrap();
             // Python timezone from timedelta
             let td = new_py_datetime_ob(py, "timedelta", (0, 3600, 0));
             let py_timedelta = new_py_datetime_ob(py, "timezone", (td,));
             // Should be equal
-            assert!(offset.as_ref(py).eq(py_timedelta).unwrap());
+            assert!(offset.eq(py_timedelta).unwrap());
 
             // Same but with negative values
-            let offset = FixedOffset::east_opt(-3600).unwrap().to_object(py);
+            let offset = FixedOffset::east_opt(-3600)
+                .unwrap()
+                .into_pyobject(py)
+                .unwrap();
             let td = new_py_datetime_ob(py, "timedelta", (0, -3600, 0));
             let py_timedelta = new_py_datetime_ob(py, "timezone", (td,));
-            assert!(offset.as_ref(py).eq(py_timedelta).unwrap());
+            assert!(offset.eq(py_timedelta).unwrap());
         })
     }
 
     #[test]
     fn test_pyo3_offset_fixed_frompyobject() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let py_timedelta = new_py_datetime_ob(py, "timedelta", (0, 3600, 0));
             let py_tzinfo = new_py_datetime_ob(py, "timezone", (py_timedelta,));
             let offset: FixedOffset = py_tzinfo.extract().unwrap();
@@ -1003,17 +1127,17 @@ mod tests {
     }
 
     #[test]
-    fn test_pyo3_offset_utc_topyobject() {
-        Python::with_gil(|py| {
-            let utc = Utc.to_object(py);
+    fn test_pyo3_offset_utc_into_pyobject() {
+        Python::attach(|py| {
+            let utc = Utc.into_pyobject(py).unwrap();
             let py_utc = python_utc(py);
-            assert!(utc.bind(py).is(&py_utc));
+            assert!(utc.is(&py_utc));
         })
     }
 
     #[test]
     fn test_pyo3_offset_utc_frompyobject() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let py_utc = python_utc(py);
             let py_utc: Utc = py_utc.extract().unwrap();
             assert_eq!(Utc, py_utc);
@@ -1030,20 +1154,15 @@ mod tests {
     }
 
     #[test]
-    fn test_pyo3_time_topyobject() {
-        Python::with_gil(|py| {
+    fn test_pyo3_time_into_pyobject() {
+        Python::attach(|py| {
             let check_time = |name: &'static str, hour, minute, second, ms, py_ms| {
                 let time = NaiveTime::from_hms_micro_opt(hour, minute, second, ms)
                     .unwrap()
-                    .to_object(py);
+                    .into_pyobject(py)
+                    .unwrap();
                 let py_time = new_py_datetime_ob(py, "time", (hour, minute, second, py_ms));
-                assert!(
-                    time.bind(py).eq(&py_time).unwrap(),
-                    "{}: {} != {}",
-                    name,
-                    time,
-                    py_time
-                );
+                assert!(time.eq(&py_time).unwrap(), "{name}: {time} != {py_time}");
             };
 
             check_time("regular", 3, 5, 7, 999_999, 999_999);
@@ -1065,7 +1184,7 @@ mod tests {
         let minute = 5;
         let second = 7;
         let micro = 999_999;
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let py_time = new_py_datetime_ob(py, "time", (hour, minute, second, micro));
             let py_time: NaiveTime = py_time.extract().unwrap();
             let time = NaiveTime::from_hms_micro_opt(hour, minute, second, micro).unwrap();
@@ -1073,21 +1192,25 @@ mod tests {
         })
     }
 
-    fn new_py_datetime_ob<'py>(
-        py: Python<'py>,
-        name: &str,
-        args: impl IntoPy<Py<PyTuple>>,
-    ) -> Bound<'py, PyAny> {
-        py.import_bound("datetime")
+    fn new_py_datetime_ob<'py, A>(py: Python<'py>, name: &str, args: A) -> Bound<'py, PyAny>
+    where
+        A: IntoPyObject<'py, Target = PyTuple>,
+    {
+        py.import("datetime")
             .unwrap()
             .getattr(name)
             .unwrap()
-            .call1(args)
+            .call1(
+                args.into_pyobject(py)
+                    .map_err(Into::into)
+                    .unwrap()
+                    .into_bound(),
+            )
             .unwrap()
     }
 
     fn python_utc(py: Python<'_>) -> Bound<'_, PyAny> {
-        py.import_bound("datetime")
+        py.import("datetime")
             .unwrap()
             .getattr("timezone")
             .unwrap()
@@ -1095,24 +1218,34 @@ mod tests {
             .unwrap()
     }
 
-    #[cfg(not(target_arch = "wasm32"))]
+    #[cfg(all(Py_3_9, feature = "chrono-tz", not(windows)))]
+    fn python_zoneinfo<'py>(py: Python<'py>, timezone: &str) -> Bound<'py, PyAny> {
+        py.import("zoneinfo")
+            .unwrap()
+            .getattr("ZoneInfo")
+            .unwrap()
+            .call1((timezone,))
+            .unwrap()
+    }
+
+    #[cfg(not(any(target_arch = "wasm32")))]
     mod proptests {
         use super::*;
-        use crate::tests::common::CatchWarnings;
-        use crate::types::any::PyAnyMethods;
+        use crate::test_utils::CatchWarnings;
         use crate::types::IntoPyDict;
         use proptest::prelude::*;
+        use std::ffi::CString;
 
         proptest! {
 
             // Range is limited to 1970 to 2038 due to windows limitations
             #[test]
             fn test_pyo3_offset_fixed_frompyobject_created_in_python(timestamp in 0..(i32::MAX as i64), timedelta in -86399i32..=86399i32) {
-                Python::with_gil(|py| {
+                Python::attach(|py| {
 
-                    let globals = [("datetime", py.import_bound("datetime").unwrap())].into_py_dict_bound(py);
-                    let code = format!("datetime.datetime.fromtimestamp({}).replace(tzinfo=datetime.timezone(datetime.timedelta(seconds={})))", timestamp, timedelta);
-                    let t = py.eval_bound(&code, Some(&globals), None).unwrap();
+                    let globals = [("datetime", py.import("datetime").unwrap())].into_py_dict(py).unwrap();
+                    let code = format!("datetime.datetime.fromtimestamp({timestamp}).replace(tzinfo=datetime.timezone(datetime.timedelta(seconds={timedelta})))");
+                    let t = py.eval(&CString::new(code).unwrap(), Some(&globals), None).unwrap();
 
                     // Get ISO 8601 string from python
                     let py_iso_str = t.call_method0("isoformat").unwrap();
@@ -1135,20 +1268,20 @@ mod tests {
             fn test_duration_roundtrip(days in -999999999i64..=999999999i64) {
                 // Test roundtrip conversion rust->python->rust for all allowed
                 // python values of durations (from -999999999 to 999999999 days),
-                Python::with_gil(|py| {
+                Python::attach(|py| {
                     let dur = Duration::days(days);
-                    let py_delta = dur.into_py(py);
-                    let roundtripped: Duration = py_delta.extract(py).expect("Round trip");
+                    let py_delta = dur.into_pyobject(py).unwrap();
+                    let roundtripped: Duration = py_delta.extract().expect("Round trip");
                     assert_eq!(dur, roundtripped);
                 })
             }
 
             #[test]
             fn test_fixed_offset_roundtrip(secs in -86399i32..=86399i32) {
-                Python::with_gil(|py| {
+                Python::attach(|py| {
                     let offset = FixedOffset::east_opt(secs).unwrap();
-                    let py_offset = offset.into_py(py);
-                    let roundtripped: FixedOffset = py_offset.extract(py).expect("Round trip");
+                    let py_offset = offset.into_pyobject(py).unwrap();
+                    let roundtripped: FixedOffset = py_offset.extract().expect("Round trip");
                     assert_eq!(offset, roundtripped);
                 })
             }
@@ -1161,12 +1294,12 @@ mod tests {
             ) {
                 // Test roundtrip conversion rust->python->rust for all allowed
                 // python dates (from year 1 to year 9999)
-                Python::with_gil(|py| {
+                Python::attach(|py| {
                     // We use to `from_ymd_opt` constructor so that we only test valid `NaiveDate`s.
                     // This is to skip the test if we are creating an invalid date, like February 31.
                     if let Some(date) = NaiveDate::from_ymd_opt(year, month, day) {
-                        let py_date = date.to_object(py);
-                        let roundtripped: NaiveDate = py_date.extract(py).expect("Round trip");
+                        let py_date = date.into_pyobject(py).unwrap();
+                        let roundtripped: NaiveDate = py_date.extract().expect("Round trip");
                         assert_eq!(date, roundtripped);
                     }
                 })
@@ -1183,11 +1316,11 @@ mod tests {
                 // Python time has a resolution of microseconds, so we only test
                 // NaiveTimes with microseconds resolution, even if NaiveTime has nanosecond
                 // resolution.
-                Python::with_gil(|py| {
+                Python::attach(|py| {
                     if let Some(time) = NaiveTime::from_hms_micro_opt(hour, min, sec, micro) {
                         // Wrap in CatchWarnings to avoid to_object firing warning for truncated leap second
-                        let py_time = CatchWarnings::enter(py, |_| Ok(time.to_object(py))).unwrap();
-                        let roundtripped: NaiveTime = py_time.extract(py).expect("Round trip");
+                        let py_time = CatchWarnings::enter(py, |_| time.into_pyobject(py)).unwrap();
+                        let roundtripped: NaiveTime = py_time.extract().expect("Round trip");
                         // Leap seconds are not roundtripped
                         let expected_roundtrip_time = micro.checked_sub(1_000_000).map(|micro| NaiveTime::from_hms_micro_opt(hour, min, sec, micro).unwrap()).unwrap_or(time);
                         assert_eq!(expected_roundtrip_time, roundtripped);
@@ -1205,13 +1338,13 @@ mod tests {
                 sec in 0u32..=60u32,
                 micro in 0u32..=999_999u32
             ) {
-                Python::with_gil(|py| {
+                Python::attach(|py| {
                     let date_opt = NaiveDate::from_ymd_opt(year, month, day);
                     let time_opt = NaiveTime::from_hms_micro_opt(hour, min, sec, micro);
                     if let (Some(date), Some(time)) = (date_opt, time_opt) {
                         let dt = NaiveDateTime::new(date, time);
-                        let pydt = dt.to_object(py);
-                        let roundtripped: NaiveDateTime = pydt.extract(py).expect("Round trip");
+                        let pydt = dt.into_pyobject(py).unwrap();
+                        let roundtripped: NaiveDateTime = pydt.extract().expect("Round trip");
                         assert_eq!(dt, roundtripped);
                     }
                 })
@@ -1227,14 +1360,14 @@ mod tests {
                 sec in 0u32..=59u32,
                 micro in 0u32..=1_999_999u32
             ) {
-                Python::with_gil(|py| {
+                Python::attach(|py| {
                     let date_opt = NaiveDate::from_ymd_opt(year, month, day);
                     let time_opt = NaiveTime::from_hms_micro_opt(hour, min, sec, micro);
                     if let (Some(date), Some(time)) = (date_opt, time_opt) {
                         let dt: DateTime<Utc> = NaiveDateTime::new(date, time).and_utc();
                         // Wrap in CatchWarnings to avoid into_py firing warning for truncated leap second
-                        let py_dt = CatchWarnings::enter(py, |_| Ok(dt.into_py(py))).unwrap();
-                        let roundtripped: DateTime<Utc> = py_dt.extract(py).expect("Round trip");
+                        let py_dt = CatchWarnings::enter(py, |_| dt.into_pyobject(py)).unwrap();
+                        let roundtripped: DateTime<Utc> = py_dt.extract().expect("Round trip");
                         // Leap seconds are not roundtripped
                         let expected_roundtrip_time = micro.checked_sub(1_000_000).map(|micro| NaiveTime::from_hms_micro_opt(hour, min, sec, micro).unwrap()).unwrap_or(time);
                         let expected_roundtrip_dt: DateTime<Utc> = NaiveDateTime::new(date, expected_roundtrip_time).and_utc();
@@ -1254,15 +1387,15 @@ mod tests {
                 micro in 0u32..=1_999_999u32,
                 offset_secs in -86399i32..=86399i32
             ) {
-                Python::with_gil(|py| {
+                Python::attach(|py| {
                     let date_opt = NaiveDate::from_ymd_opt(year, month, day);
                     let time_opt = NaiveTime::from_hms_micro_opt(hour, min, sec, micro);
                     let offset = FixedOffset::east_opt(offset_secs).unwrap();
                     if let (Some(date), Some(time)) = (date_opt, time_opt) {
                         let dt: DateTime<FixedOffset> = NaiveDateTime::new(date, time).and_local_timezone(offset).unwrap();
                         // Wrap in CatchWarnings to avoid into_py firing warning for truncated leap second
-                        let py_dt = CatchWarnings::enter(py, |_| Ok(dt.into_py(py))).unwrap();
-                        let roundtripped: DateTime<FixedOffset> = py_dt.extract(py).expect("Round trip");
+                        let py_dt = CatchWarnings::enter(py, |_| dt.into_pyobject(py)).unwrap();
+                        let roundtripped: DateTime<FixedOffset> = py_dt.extract().expect("Round trip");
                         // Leap seconds are not roundtripped
                         let expected_roundtrip_time = micro.checked_sub(1_000_000).map(|micro| NaiveTime::from_hms_micro_opt(hour, min, sec, micro).unwrap()).unwrap_or(time);
                         let expected_roundtrip_dt: DateTime<FixedOffset> = NaiveDateTime::new(date, expected_roundtrip_time).and_local_timezone(offset).unwrap();
@@ -1270,6 +1403,43 @@ mod tests {
                     }
                 })
             }
+
+            #[test]
+            #[cfg(all(feature = "chrono-local", not(target_os = "windows")))]
+            fn test_local_datetime_roundtrip(
+                year in 1i32..=9999i32,
+                month in 1u32..=12u32,
+                day in 1u32..=31u32,
+                hour in 0u32..=23u32,
+                min in 0u32..=59u32,
+                sec in 0u32..=59u32,
+                micro in 0u32..=1_999_999u32,
+            ) {
+                Python::attach(|py| {
+                    let date_opt = NaiveDate::from_ymd_opt(year, month, day);
+                    let time_opt = NaiveTime::from_hms_micro_opt(hour, min, sec, micro);
+                    if let (Some(date), Some(time)) = (date_opt, time_opt) {
+                        let dts = match NaiveDateTime::new(date, time).and_local_timezone(Local) {
+                            LocalResult::None => return,
+                            LocalResult::Single(dt) => [Some((dt, false)), None],
+                            LocalResult::Ambiguous(dt1, dt2) => [Some((dt1, false)), Some((dt2, true))],
+                        };
+                        for (dt, fold) in dts.iter().filter_map(|input| *input) {
+                            // Wrap in CatchWarnings to avoid into_py firing warning for truncated leap second
+                            let py_dt = CatchWarnings::enter(py, |_| dt.into_pyobject(py)).unwrap();
+                            let roundtripped: DateTime<Local> = py_dt.extract().expect("Round trip");
+                            // Leap seconds are not roundtripped
+                            let expected_roundtrip_time = micro.checked_sub(1_000_000).map(|micro| NaiveTime::from_hms_micro_opt(hour, min, sec, micro).unwrap()).unwrap_or(time);
+                            let expected_roundtrip_dt: DateTime<Local> = if fold {
+                                NaiveDateTime::new(date, expected_roundtrip_time).and_local_timezone(Local).latest()
+                            } else {
+                                NaiveDateTime::new(date, expected_roundtrip_time).and_local_timezone(Local).earliest()
+                            }.unwrap();
+                            assert_eq!(expected_roundtrip_dt, roundtripped);
+                        }
+                    }
+                })
+            }
         }
     }
 }
diff --git a/src/conversions/chrono_tz.rs b/src/conversions/chrono_tz.rs
index b4d0e7edf8c..433a56b4ebf 100644
--- a/src/conversions/chrono_tz.rs
+++ b/src/conversions/chrono_tz.rs
@@ -21,59 +21,76 @@
 //!
 //! ```rust,no_run
 //! use chrono_tz::Tz;
-//! use pyo3::{Python, ToPyObject};
+//! use pyo3::{Python, PyResult, IntoPyObject, types::PyAnyMethods};
 //!
-//! fn main() {
-//!     pyo3::prepare_freethreaded_python();
-//!     Python::with_gil(|py| {
+//! fn main() -> PyResult<()> {
+//!     Python::initialize();
+//!     Python::attach(|py| {
 //!         // Convert to Python
-//!         let py_tzinfo = Tz::Europe__Paris.to_object(py);
+//!         let py_tzinfo = Tz::Europe__Paris.into_pyobject(py)?;
 //!         // Convert back to Rust
-//!         assert_eq!(py_tzinfo.extract::<Tz>(py).unwrap(), Tz::Europe__Paris);
-//!     });
+//!         assert_eq!(py_tzinfo.extract::<Tz>()?, Tz::Europe__Paris);
+//!         Ok(())
+//!     })
 //! }
 //! ```
+use crate::conversion::IntoPyObject;
 use crate::exceptions::PyValueError;
-use crate::sync::GILOnceCell;
-use crate::types::{any::PyAnyMethods, PyType};
-use crate::{
-    intern, Bound, FromPyObject, IntoPy, Py, PyAny, PyObject, PyResult, Python, ToPyObject,
-};
+use crate::pybacked::PyBackedStr;
+use crate::types::{any::PyAnyMethods, PyTzInfo};
+use crate::{intern, Borrowed, Bound, FromPyObject, PyAny, PyErr, Python};
 use chrono_tz::Tz;
 use std::str::FromStr;
 
-impl ToPyObject for Tz {
-    fn to_object(&self, py: Python<'_>) -> PyObject {
-        static ZONE_INFO: GILOnceCell<Py<PyType>> = GILOnceCell::new();
-        ZONE_INFO
-            .get_or_try_init_type_ref(py, "zoneinfo", "ZoneInfo")
-            .unwrap()
-            .call1((self.name(),))
-            .unwrap()
-            .unbind()
+impl<'py> IntoPyObject<'py> for Tz {
+    type Target = PyTzInfo;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        PyTzInfo::timezone(py, self.name())
     }
 }
 
-impl IntoPy<PyObject> for Tz {
-    fn into_py(self, py: Python<'_>) -> PyObject {
-        self.to_object(py)
+impl<'py> IntoPyObject<'py> for &Tz {
+    type Target = PyTzInfo;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    #[inline]
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        (*self).into_pyobject(py)
     }
 }
 
-impl FromPyObject<'_> for Tz {
-    fn extract_bound(ob: &Bound<'_, PyAny>) -> PyResult<Tz> {
-        Tz::from_str(ob.getattr(intern!(ob.py(), "key"))?.extract()?)
-            .map_err(|e| PyValueError::new_err(e.to_string()))
+impl FromPyObject<'_, '_> for Tz {
+    type Error = PyErr;
+
+    fn extract(ob: Borrowed<'_, '_, PyAny>) -> Result<Self, Self::Error> {
+        Tz::from_str(
+            &ob.getattr(intern!(ob.py(), "key"))?
+                .extract::<PyBackedStr>()?,
+        )
+        .map_err(|e| PyValueError::new_err(e.to_string()))
     }
 }
 
 #[cfg(all(test, not(windows)))] // Troubles loading timezones on Windows
 mod tests {
     use super::*;
+    use crate::prelude::PyAnyMethods;
+    use crate::types::IntoPyDict;
+    use crate::types::PyTzInfo;
+    use crate::Bound;
+    use crate::Python;
+    use chrono::offset::LocalResult;
+    use chrono::NaiveDate;
+    use chrono::{DateTime, Utc};
+    use chrono_tz::Tz;
 
     #[test]
     fn test_frompyobject() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             assert_eq!(
                 new_zoneinfo(py, "Europe/Paris").extract::<Tz>().unwrap(),
                 Tz::Europe__Paris
@@ -87,32 +104,105 @@ mod tests {
     }
 
     #[test]
-    fn test_topyobject() {
-        Python::with_gil(|py| {
-            let assert_eq = |l: PyObject, r: Bound<'_, PyAny>| {
-                assert!(l.bind(py).eq(r).unwrap());
+    fn test_ambiguous_datetime_to_pyobject() {
+        let dates = [
+            DateTime::<Utc>::from_str("2020-10-24 23:00:00 UTC").unwrap(),
+            DateTime::<Utc>::from_str("2020-10-25 00:00:00 UTC").unwrap(),
+            DateTime::<Utc>::from_str("2020-10-25 01:00:00 UTC").unwrap(),
+        ];
+
+        let dates = dates.map(|dt| dt.with_timezone(&Tz::Europe__London));
+
+        assert_eq!(
+            dates.map(|dt| dt.to_string()),
+            [
+                "2020-10-25 00:00:00 BST",
+                "2020-10-25 01:00:00 BST",
+                "2020-10-25 01:00:00 GMT"
+            ]
+        );
+
+        let dates = Python::attach(|py| {
+            let pydates = dates.map(|dt| dt.into_pyobject(py).unwrap());
+            assert_eq!(
+                pydates
+                    .clone()
+                    .map(|dt| dt.getattr("hour").unwrap().extract::<usize>().unwrap()),
+                [0, 1, 1]
+            );
+
+            assert_eq!(
+                pydates
+                    .clone()
+                    .map(|dt| dt.getattr("fold").unwrap().extract::<usize>().unwrap() > 0),
+                [false, false, true]
+            );
+
+            pydates.map(|dt| dt.extract::<DateTime<Tz>>().unwrap())
+        });
+
+        assert_eq!(
+            dates.map(|dt| dt.to_string()),
+            [
+                "2020-10-25 00:00:00 BST",
+                "2020-10-25 01:00:00 BST",
+                "2020-10-25 01:00:00 GMT"
+            ]
+        );
+    }
+
+    #[test]
+    fn test_nonexistent_datetime_from_pyobject() {
+        // Pacific_Apia skipped the 30th of December 2011 entirely
+
+        let naive_dt = NaiveDate::from_ymd_opt(2011, 12, 30)
+            .unwrap()
+            .and_hms_opt(2, 0, 0)
+            .unwrap();
+        let tz = Tz::Pacific__Apia;
+
+        // sanity check
+        assert_eq!(naive_dt.and_local_timezone(tz), LocalResult::None);
+
+        Python::attach(|py| {
+            // create as a Python object manually
+            let py_tz = tz.into_pyobject(py).unwrap();
+            let py_dt_naive = naive_dt.into_pyobject(py).unwrap();
+            let py_dt = py_dt_naive
+                .call_method(
+                    "replace",
+                    (),
+                    Some(&[("tzinfo", py_tz)].into_py_dict(py).unwrap()),
+                )
+                .unwrap();
+
+            // now try to extract
+            let err = py_dt.extract::<DateTime<Tz>>().unwrap_err();
+            assert_eq!(err.to_string(), "ValueError: The datetime datetime.datetime(2011, 12, 30, 2, 0, tzinfo=zoneinfo.ZoneInfo(key='Pacific/Apia')) contains an incompatible timezone");
+        });
+    }
+
+    #[test]
+    #[cfg(not(Py_GIL_DISABLED))] // https://github.com/python/cpython/issues/116738#issuecomment-2404360445
+    fn test_into_pyobject() {
+        Python::attach(|py| {
+            let assert_eq = |l: Bound<'_, PyTzInfo>, r: Bound<'_, PyTzInfo>| {
+                assert!(l.eq(&r).unwrap(), "{l:?} != {r:?}");
             };
 
             assert_eq(
-                Tz::Europe__Paris.to_object(py),
+                Tz::Europe__Paris.into_pyobject(py).unwrap(),
                 new_zoneinfo(py, "Europe/Paris"),
             );
-            assert_eq(Tz::UTC.to_object(py), new_zoneinfo(py, "UTC"));
+            assert_eq(Tz::UTC.into_pyobject(py).unwrap(), new_zoneinfo(py, "UTC"));
             assert_eq(
-                Tz::Etc__GMTMinus5.to_object(py),
+                Tz::Etc__GMTMinus5.into_pyobject(py).unwrap(),
                 new_zoneinfo(py, "Etc/GMT-5"),
             );
         });
     }
 
-    fn new_zoneinfo<'py>(py: Python<'py>, name: &str) -> Bound<'py, PyAny> {
-        zoneinfo_class(py).call1((name,)).unwrap()
-    }
-
-    fn zoneinfo_class(py: Python<'_>) -> Bound<'_, PyAny> {
-        py.import_bound("zoneinfo")
-            .unwrap()
-            .getattr("ZoneInfo")
-            .unwrap()
+    fn new_zoneinfo<'py>(py: Python<'py>, name: &str) -> Bound<'py, PyTzInfo> {
+        PyTzInfo::timezone(py, name).unwrap()
     }
 }
diff --git a/src/conversions/either.rs b/src/conversions/either.rs
index c763cdf95e5..6a5acebae75 100644
--- a/src/conversions/either.rs
+++ b/src/conversions/either.rs
@@ -26,18 +26,19 @@
 //!
 //! ```rust
 //! use either::Either;
-//! use pyo3::{Python, ToPyObject};
+//! use pyo3::{Python, PyResult, IntoPyObject, types::PyAnyMethods};
 //!
-//! fn main() {
-//!     pyo3::prepare_freethreaded_python();
-//!     Python::with_gil(|py| {
+//! fn main() -> PyResult<()> {
+//!     Python::initialize();
+//!     Python::attach(|py| {
 //!         // Create a string and an int in Python.
-//!         let py_str = "crab".to_object(py);
-//!         let py_int = 42.to_object(py);
+//!         let py_str = "crab".into_pyobject(py)?;
+//!         let py_int = 42i32.into_pyobject(py)?;
 //!         // Now convert it to an Either<i32, String>.
-//!         let either_str: Either<i32, String> = py_str.extract(py).unwrap();
-//!         let either_int: Either<i32, String> = py_int.extract(py).unwrap();
-//!     });
+//!         let either_str: Either<i32, String> = py_str.extract()?;
+//!         let either_int: Either<i32, String> = py_int.extract()?;
+//!         Ok(())
+//!     })
 //! }
 //! ```
 //!
@@ -46,55 +47,69 @@
 #[cfg(feature = "experimental-inspect")]
 use crate::inspect::types::TypeInfo;
 use crate::{
-    exceptions::PyTypeError, types::any::PyAnyMethods, Bound, FromPyObject, IntoPy, PyAny,
-    PyObject, PyResult, Python, ToPyObject,
+    exceptions::PyTypeError, Borrowed, Bound, FromPyObject, IntoPyObject, IntoPyObjectExt, PyAny,
+    PyErr, Python,
 };
 use either::Either;
 
 #[cfg_attr(docsrs, doc(cfg(feature = "either")))]
-impl<L, R> IntoPy<PyObject> for Either<L, R>
+impl<'py, L, R> IntoPyObject<'py> for Either<L, R>
 where
-    L: IntoPy<PyObject>,
-    R: IntoPy<PyObject>,
+    L: IntoPyObject<'py>,
+    R: IntoPyObject<'py>,
 {
-    #[inline]
-    fn into_py(self, py: Python<'_>) -> PyObject {
+    type Target = PyAny;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
         match self {
-            Either::Left(l) => l.into_py(py),
-            Either::Right(r) => r.into_py(py),
+            Either::Left(l) => l.into_bound_py_any(py),
+            Either::Right(r) => r.into_bound_py_any(py),
         }
     }
 }
 
 #[cfg_attr(docsrs, doc(cfg(feature = "either")))]
-impl<L, R> ToPyObject for Either<L, R>
+impl<'a, 'py, L, R> IntoPyObject<'py> for &'a Either<L, R>
 where
-    L: ToPyObject,
-    R: ToPyObject,
+    &'a L: IntoPyObject<'py>,
+    &'a R: IntoPyObject<'py>,
 {
-    #[inline]
-    fn to_object(&self, py: Python<'_>) -> PyObject {
+    type Target = PyAny;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
         match self {
-            Either::Left(l) => l.to_object(py),
-            Either::Right(r) => r.to_object(py),
+            Either::Left(l) => l.into_bound_py_any(py),
+            Either::Right(r) => r.into_bound_py_any(py),
         }
     }
 }
 
 #[cfg_attr(docsrs, doc(cfg(feature = "either")))]
-impl<'py, L, R> FromPyObject<'py> for Either<L, R>
+impl<'a, 'py, L, R> FromPyObject<'a, 'py> for Either<L, R>
 where
-    L: FromPyObject<'py>,
-    R: FromPyObject<'py>,
+    L: FromPyObject<'a, 'py>,
+    R: FromPyObject<'a, 'py>,
 {
+    type Error = PyErr;
+
     #[inline]
-    fn extract_bound(obj: &Bound<'py, PyAny>) -> PyResult<Self> {
+    fn extract(obj: Borrowed<'a, 'py, PyAny>) -> Result<Self, Self::Error> {
         if let Ok(l) = obj.extract::<L>() {
             Ok(Either::Left(l))
         } else if let Ok(r) = obj.extract::<R>() {
             Ok(Either::Right(r))
         } else {
-            let err_msg = format!("failed to convert the value to '{}'", Self::type_input());
+            // TODO: it might be nice to use the `type_input()` name here once `type_input`
+            // is not experimental, rather than the Rust type names.
+            let err_msg = format!(
+                "failed to convert the value to 'Union[{}, {}]'",
+                std::any::type_name::<L>(),
+                std::any::type_name::<R>()
+            );
             Err(PyTypeError::new_err(err_msg))
         }
     }
@@ -107,9 +122,12 @@ where
 
 #[cfg(test)]
 mod tests {
+    use std::borrow::Cow;
+
     use crate::exceptions::PyTypeError;
-    use crate::{Python, ToPyObject};
+    use crate::{IntoPyObject, Python};
 
+    use crate::types::PyAnyMethods;
     use either::Either;
 
     #[test]
@@ -118,32 +136,32 @@ mod tests {
         type E1 = Either<i32, f32>;
         type E2 = Either<f32, i32>;
 
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let l = E::Left(42);
-            let obj_l = l.to_object(py);
-            assert_eq!(obj_l.extract::<i32>(py).unwrap(), 42);
-            assert_eq!(obj_l.extract::<E>(py).unwrap(), l);
+            let obj_l = (&l).into_pyobject(py).unwrap();
+            assert_eq!(obj_l.extract::<i32>().unwrap(), 42);
+            assert_eq!(obj_l.extract::<E>().unwrap(), l);
 
             let r = E::Right("foo".to_owned());
-            let obj_r = r.to_object(py);
-            assert_eq!(obj_r.extract::<&str>(py).unwrap(), "foo");
-            assert_eq!(obj_r.extract::<E>(py).unwrap(), r);
+            let obj_r = (&r).into_pyobject(py).unwrap();
+            assert_eq!(obj_r.extract::<Cow<'_, str>>().unwrap(), "foo");
+            assert_eq!(obj_r.extract::<E>().unwrap(), r);
 
-            let obj_s = "foo".to_object(py);
-            let err = obj_s.extract::<E1>(py).unwrap_err();
+            let obj_s = "foo".into_pyobject(py).unwrap();
+            let err = obj_s.extract::<E1>().unwrap_err();
             assert!(err.is_instance_of::<PyTypeError>(py));
             assert_eq!(
                 err.to_string(),
-                "TypeError: failed to convert the value to 'Union[int, float]'"
+                "TypeError: failed to convert the value to 'Union[i32, f32]'"
             );
 
-            let obj_i = 42.to_object(py);
-            assert_eq!(obj_i.extract::<E1>(py).unwrap(), E1::Left(42));
-            assert_eq!(obj_i.extract::<E2>(py).unwrap(), E2::Left(42.0));
+            let obj_i = 42i32.into_pyobject(py).unwrap();
+            assert_eq!(obj_i.extract::<E1>().unwrap(), E1::Left(42));
+            assert_eq!(obj_i.extract::<E2>().unwrap(), E2::Left(42.0));
 
-            let obj_f = 42.0.to_object(py);
-            assert_eq!(obj_f.extract::<E1>(py).unwrap(), E1::Right(42.0));
-            assert_eq!(obj_f.extract::<E2>(py).unwrap(), E2::Left(42.0));
+            let obj_f = 42.0f64.into_pyobject(py).unwrap();
+            assert_eq!(obj_f.extract::<E1>().unwrap(), E1::Right(42.0));
+            assert_eq!(obj_f.extract::<E2>().unwrap(), E2::Left(42.0));
         });
     }
 }
diff --git a/src/conversions/eyre.rs b/src/conversions/eyre.rs
index d25a10af9ee..5923854a188 100644
--- a/src/conversions/eyre.rs
+++ b/src/conversions/eyre.rs
@@ -34,7 +34,6 @@
 //!
 //! ```rust
 //! use pyo3::prelude::*;
-//! use pyo3::wrap_pyfunction;
 //! use std::path::PathBuf;
 //!
 //! // A wrapper around a Rust function.
@@ -46,7 +45,7 @@
 //! }
 //!
 //! fn main() {
-//!     let error = Python::with_gil(|py| -> PyResult<Vec<u8>> {
+//!     let error = Python::attach(|py| -> PyResult<Vec<u8>> {
 //!         let fun = wrap_pyfunction!(py_open, py)?;
 //!         let text = fun.call1(("foo.txt",))?.extract::<Vec<u8>>()?;
 //!         Ok(text)
@@ -73,10 +72,10 @@
 //!     // An arbitrary example of a Python api you
 //!     // could call inside an application...
 //!     // This might return a `PyErr`.
-//!     let res = Python::with_gil(|py| {
+//!     let res = Python::attach(|py| {
 //!         let zlib = PyModule::import(py, "zlib")?;
 //!         let decompress = zlib.getattr("decompress")?;
-//!         let bytes = PyBytes::new_bound(py, bytes);
+//!         let bytes = PyBytes::new(py, bytes);
 //!         let value = decompress.call1((bytes,))?;
 //!         value.extract::<Vec<u8>>()
 //!     })?;
@@ -120,7 +119,7 @@ impl From<eyre::Report> for PyErr {
                 Err(error) => error,
             };
         }
-        PyRuntimeError::new_err(format!("{:?}", error))
+        PyRuntimeError::new_err(format!("{error:?}"))
     }
 }
 
@@ -148,12 +147,12 @@ mod tests {
     #[test]
     fn test_pyo3_exception_contents() {
         let err = h().unwrap_err();
-        let expected_contents = format!("{:?}", err);
+        let expected_contents = format!("{err:?}");
         let pyerr = PyErr::from(err);
 
-        Python::with_gil(|py| {
-            let locals = [("err", pyerr)].into_py_dict_bound(py);
-            let pyerr = py.run_bound("raise err", None, Some(&locals)).unwrap_err();
+        Python::attach(|py| {
+            let locals = [("err", pyerr)].into_py_dict(py).unwrap();
+            let pyerr = py.run(c"raise err", None, Some(&locals)).unwrap_err();
             assert_eq!(pyerr.value(py).to_string(), expected_contents);
         })
     }
@@ -165,12 +164,12 @@ mod tests {
     #[test]
     fn test_pyo3_exception_contents2() {
         let err = k().unwrap_err();
-        let expected_contents = format!("{:?}", err);
+        let expected_contents = format!("{err:?}");
         let pyerr = PyErr::from(err);
 
-        Python::with_gil(|py| {
-            let locals = [("err", pyerr)].into_py_dict_bound(py);
-            let pyerr = py.run_bound("raise err", None, Some(&locals)).unwrap_err();
+        Python::attach(|py| {
+            let locals = [("err", pyerr)].into_py_dict(py).unwrap();
+            let pyerr = py.run(c"raise err", None, Some(&locals)).unwrap_err();
             assert_eq!(pyerr.value(py).to_string(), expected_contents);
         })
     }
@@ -180,7 +179,7 @@ mod tests {
         let origin_exc = PyValueError::new_err("Value Error");
         let report: Report = origin_exc.into();
         let converted: PyErr = report.into();
-        assert!(Python::with_gil(
+        assert!(Python::attach(
             |py| converted.is_instance_of::<PyValueError>(py)
         ))
     }
@@ -190,7 +189,7 @@ mod tests {
         let mut report: Report = origin_exc.into();
         report = report.wrap_err("Wrapped");
         let converted: PyErr = report.into();
-        assert!(Python::with_gil(
+        assert!(Python::attach(
             |py| converted.is_instance_of::<PyRuntimeError>(py)
         ))
     }
diff --git a/src/conversions/hashbrown.rs b/src/conversions/hashbrown.rs
index 7e57d332d91..48735a9734c 100644
--- a/src/conversions/hashbrown.rs
+++ b/src/conversions/hashbrown.rs
@@ -17,90 +17,124 @@
 //! Note that you must use compatible versions of hashbrown and PyO3.
 //! The required hashbrown version may vary based on the version of PyO3.
 use crate::{
-    types::any::PyAnyMethods,
-    types::dict::PyDictMethods,
-    types::frozenset::PyFrozenSetMethods,
-    types::set::{new_from_iter, PySetMethods},
-    types::{IntoPyDict, PyDict, PyFrozenSet, PySet},
-    Bound, FromPyObject, IntoPy, PyAny, PyErr, PyObject, PyResult, Python, ToPyObject,
+    conversion::{FromPyObjectOwned, IntoPyObject},
+    types::{
+        any::PyAnyMethods,
+        dict::PyDictMethods,
+        frozenset::PyFrozenSetMethods,
+        set::{try_new_from_iter, PySetMethods},
+        PyDict, PyFrozenSet, PySet,
+    },
+    Borrowed, Bound, FromPyObject, PyAny, PyErr, PyResult, Python,
 };
 use std::{cmp, hash};
 
-impl<K, V, H> ToPyObject for hashbrown::HashMap<K, V, H>
+impl<'py, K, V, H> IntoPyObject<'py> for hashbrown::HashMap<K, V, H>
 where
-    K: hash::Hash + cmp::Eq + ToPyObject,
-    V: ToPyObject,
+    K: IntoPyObject<'py> + cmp::Eq + hash::Hash,
+    V: IntoPyObject<'py>,
     H: hash::BuildHasher,
 {
-    fn to_object(&self, py: Python<'_>) -> PyObject {
-        IntoPyDict::into_py_dict_bound(self, py).into()
+    type Target = PyDict;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        let dict = PyDict::new(py);
+        for (k, v) in self {
+            dict.set_item(k, v)?;
+        }
+        Ok(dict)
     }
 }
 
-impl<K, V, H> IntoPy<PyObject> for hashbrown::HashMap<K, V, H>
+impl<'a, 'py, K, V, H> IntoPyObject<'py> for &'a hashbrown::HashMap<K, V, H>
 where
-    K: hash::Hash + cmp::Eq + IntoPy<PyObject>,
-    V: IntoPy<PyObject>,
+    &'a K: IntoPyObject<'py> + cmp::Eq + hash::Hash,
+    &'a V: IntoPyObject<'py>,
     H: hash::BuildHasher,
 {
-    fn into_py(self, py: Python<'_>) -> PyObject {
-        let iter = self
-            .into_iter()
-            .map(|(k, v)| (k.into_py(py), v.into_py(py)));
-        IntoPyDict::into_py_dict_bound(iter, py).into()
+    type Target = PyDict;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        let dict = PyDict::new(py);
+        for (k, v) in self {
+            dict.set_item(k, v)?;
+        }
+        Ok(dict)
     }
 }
 
-impl<'py, K, V, S> FromPyObject<'py> for hashbrown::HashMap<K, V, S>
+impl<'py, K, V, S> FromPyObject<'_, 'py> for hashbrown::HashMap<K, V, S>
 where
-    K: FromPyObject<'py> + cmp::Eq + hash::Hash,
-    V: FromPyObject<'py>,
+    K: FromPyObjectOwned<'py> + cmp::Eq + hash::Hash,
+    V: FromPyObjectOwned<'py>,
     S: hash::BuildHasher + Default,
 {
-    fn extract_bound(ob: &Bound<'py, PyAny>) -> Result<Self, PyErr> {
-        let dict = ob.downcast::<PyDict>()?;
+    type Error = PyErr;
+
+    fn extract(ob: Borrowed<'_, 'py, PyAny>) -> Result<Self, PyErr> {
+        let dict = ob.cast::<PyDict>()?;
         let mut ret = hashbrown::HashMap::with_capacity_and_hasher(dict.len(), S::default());
         for (k, v) in dict.iter() {
-            ret.insert(k.extract()?, v.extract()?);
+            ret.insert(
+                k.extract().map_err(Into::into)?,
+                v.extract().map_err(Into::into)?,
+            );
         }
         Ok(ret)
     }
 }
 
-impl<T> ToPyObject for hashbrown::HashSet<T>
+impl<'py, K, H> IntoPyObject<'py> for hashbrown::HashSet<K, H>
 where
-    T: hash::Hash + Eq + ToPyObject,
+    K: IntoPyObject<'py> + cmp::Eq + hash::Hash,
+    H: hash::BuildHasher,
 {
-    fn to_object(&self, py: Python<'_>) -> PyObject {
-        new_from_iter(py, self)
-            .expect("Failed to create Python set from hashbrown::HashSet")
-            .into()
+    type Target = PySet;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        try_new_from_iter(py, self)
     }
 }
 
-impl<K, S> IntoPy<PyObject> for hashbrown::HashSet<K, S>
+impl<'a, 'py, K, H> IntoPyObject<'py> for &'a hashbrown::HashSet<K, H>
 where
-    K: IntoPy<PyObject> + Eq + hash::Hash,
-    S: hash::BuildHasher + Default,
+    &'a K: IntoPyObject<'py> + cmp::Eq + hash::Hash,
+    H: hash::BuildHasher,
 {
-    fn into_py(self, py: Python<'_>) -> PyObject {
-        new_from_iter(py, self.into_iter().map(|item| item.into_py(py)))
-            .expect("Failed to create Python set from hashbrown::HashSet")
-            .into()
+    type Target = PySet;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        try_new_from_iter(py, self)
     }
 }
 
-impl<'py, K, S> FromPyObject<'py> for hashbrown::HashSet<K, S>
+impl<'py, K, S> FromPyObject<'_, 'py> for hashbrown::HashSet<K, S>
 where
-    K: FromPyObject<'py> + cmp::Eq + hash::Hash,
+    K: FromPyObjectOwned<'py> + cmp::Eq + hash::Hash,
     S: hash::BuildHasher + Default,
 {
-    fn extract_bound(ob: &Bound<'py, PyAny>) -> PyResult<Self> {
-        match ob.downcast::<PySet>() {
-            Ok(set) => set.iter().map(|any| any.extract()).collect(),
+    type Error = PyErr;
+
+    fn extract(ob: Borrowed<'_, 'py, PyAny>) -> PyResult<Self> {
+        match ob.cast::<PySet>() {
+            Ok(set) => set
+                .iter()
+                .map(|any| any.extract().map_err(Into::into))
+                .collect(),
             Err(err) => {
-                if let Ok(frozen_set) = ob.downcast::<PyFrozenSet>() {
-                    frozen_set.iter().map(|any| any.extract()).collect()
+                if let Ok(frozen_set) = ob.cast::<PyFrozenSet>() {
+                    frozen_set
+                        .iter()
+                        .map(|any| any.extract().map_err(Into::into))
+                        .collect()
                 } else {
                     Err(PyErr::from(err))
                 }
@@ -112,18 +146,19 @@ where
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::types::any::PyAnyMethods;
+    use crate::types::IntoPyDict;
+    use std::collections::hash_map::RandomState;
 
     #[test]
-    fn test_hashbrown_hashmap_to_python() {
-        Python::with_gil(|py| {
-            let mut map = hashbrown::HashMap::<i32, i32>::new();
+    fn test_hashbrown_hashmap_into_pyobject() {
+        Python::attach(|py| {
+            let mut map =
+                hashbrown::HashMap::<i32, i32, RandomState>::with_hasher(RandomState::new());
             map.insert(1, 1);
 
-            let m = map.to_object(py);
-            let py_map: &PyDict = m.downcast(py).unwrap();
+            let py_map = (&map).into_pyobject(py).unwrap();
 
-            assert!(py_map.len() == 1);
+            assert_eq!(py_map.len(), 1);
             assert!(
                 py_map
                     .get_item(1)
@@ -136,35 +171,15 @@ mod tests {
             assert_eq!(map, py_map.extract().unwrap());
         });
     }
-    #[test]
-    fn test_hashbrown_hashmap_into_python() {
-        Python::with_gil(|py| {
-            let mut map = hashbrown::HashMap::<i32, i32>::new();
-            map.insert(1, 1);
-
-            let m: PyObject = map.into_py(py);
-            let py_map: &PyDict = m.downcast(py).unwrap();
-
-            assert!(py_map.len() == 1);
-            assert!(
-                py_map
-                    .get_item(1)
-                    .unwrap()
-                    .unwrap()
-                    .extract::<i32>()
-                    .unwrap()
-                    == 1
-            );
-        });
-    }
 
     #[test]
     fn test_hashbrown_hashmap_into_dict() {
-        Python::with_gil(|py| {
-            let mut map = hashbrown::HashMap::<i32, i32>::new();
+        Python::attach(|py| {
+            let mut map =
+                hashbrown::HashMap::<i32, i32, RandomState>::with_hasher(RandomState::new());
             map.insert(1, 1);
 
-            let py_map = map.into_py_dict_bound(py);
+            let py_map = map.into_py_dict(py).unwrap();
 
             assert_eq!(py_map.len(), 1);
             assert_eq!(
@@ -181,25 +196,26 @@ mod tests {
 
     #[test]
     fn test_extract_hashbrown_hashset() {
-        Python::with_gil(|py| {
-            let set = PySet::new_bound(py, &[1, 2, 3, 4, 5]).unwrap();
-            let hash_set: hashbrown::HashSet<usize> = set.extract().unwrap();
+        Python::attach(|py| {
+            let set = PySet::new(py, [1, 2, 3, 4, 5]).unwrap();
+            let hash_set: hashbrown::HashSet<usize, RandomState> = set.extract().unwrap();
             assert_eq!(hash_set, [1, 2, 3, 4, 5].iter().copied().collect());
 
-            let set = PyFrozenSet::new_bound(py, &[1, 2, 3, 4, 5]).unwrap();
-            let hash_set: hashbrown::HashSet<usize> = set.extract().unwrap();
+            let set = PyFrozenSet::new(py, [1, 2, 3, 4, 5]).unwrap();
+            let hash_set: hashbrown::HashSet<usize, RandomState> = set.extract().unwrap();
             assert_eq!(hash_set, [1, 2, 3, 4, 5].iter().copied().collect());
         });
     }
 
     #[test]
-    fn test_hashbrown_hashset_into_py() {
-        Python::with_gil(|py| {
-            let hs: hashbrown::HashSet<u64> = [1, 2, 3, 4, 5].iter().cloned().collect();
+    fn test_hashbrown_hashset_into_pyobject() {
+        Python::attach(|py| {
+            let hs: hashbrown::HashSet<u64, RandomState> =
+                [1, 2, 3, 4, 5].iter().cloned().collect();
 
-            let hso: PyObject = hs.clone().into_py(py);
+            let hso = hs.clone().into_pyobject(py).unwrap();
 
-            assert_eq!(hs, hso.extract(py).unwrap());
+            assert_eq!(hs, hso.extract().unwrap());
         });
     }
 }
diff --git a/src/conversions/indexmap.rs b/src/conversions/indexmap.rs
index ec7ed5de557..cccd3c7a49a 100644
--- a/src/conversions/indexmap.rs
+++ b/src/conversions/indexmap.rs
@@ -71,7 +71,7 @@
 //! }
 //!
 //! #[pymodule]
-//! fn my_module(_py: Python<'_>, m: &PyModule) -> PyResult<()> {
+//! fn my_module(m: &Bound<'_, PyModule>) -> PyResult<()> {
 //!     m.add_function(wrap_pyfunction!(calculate_statistics, m)?)?;
 //!     Ok(())
 //! }
@@ -87,48 +87,65 @@
 //! # if another hash table was used, the order could be random
 //! ```
 
-use crate::types::any::PyAnyMethods;
-use crate::types::dict::PyDictMethods;
+use crate::conversion::{FromPyObjectOwned, IntoPyObject};
 use crate::types::*;
-use crate::{Bound, FromPyObject, IntoPy, PyErr, PyObject, Python, ToPyObject};
+use crate::{Borrowed, Bound, FromPyObject, PyErr, Python};
 use std::{cmp, hash};
 
-impl<K, V, H> ToPyObject for indexmap::IndexMap<K, V, H>
+impl<'py, K, V, H> IntoPyObject<'py> for indexmap::IndexMap<K, V, H>
 where
-    K: hash::Hash + cmp::Eq + ToPyObject,
-    V: ToPyObject,
+    K: IntoPyObject<'py> + cmp::Eq + hash::Hash,
+    V: IntoPyObject<'py>,
     H: hash::BuildHasher,
 {
-    fn to_object(&self, py: Python<'_>) -> PyObject {
-        IntoPyDict::into_py_dict_bound(self, py).into()
+    type Target = PyDict;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        let dict = PyDict::new(py);
+        for (k, v) in self {
+            dict.set_item(k, v)?;
+        }
+        Ok(dict)
     }
 }
 
-impl<K, V, H> IntoPy<PyObject> for indexmap::IndexMap<K, V, H>
+impl<'a, 'py, K, V, H> IntoPyObject<'py> for &'a indexmap::IndexMap<K, V, H>
 where
-    K: hash::Hash + cmp::Eq + IntoPy<PyObject>,
-    V: IntoPy<PyObject>,
+    &'a K: IntoPyObject<'py> + cmp::Eq + hash::Hash,
+    &'a V: IntoPyObject<'py>,
     H: hash::BuildHasher,
 {
-    fn into_py(self, py: Python<'_>) -> PyObject {
-        let iter = self
-            .into_iter()
-            .map(|(k, v)| (k.into_py(py), v.into_py(py)));
-        IntoPyDict::into_py_dict_bound(iter, py).into()
+    type Target = PyDict;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        let dict = PyDict::new(py);
+        for (k, v) in self {
+            dict.set_item(k, v)?;
+        }
+        Ok(dict)
     }
 }
 
-impl<'py, K, V, S> FromPyObject<'py> for indexmap::IndexMap<K, V, S>
+impl<'py, K, V, S> FromPyObject<'_, 'py> for indexmap::IndexMap<K, V, S>
 where
-    K: FromPyObject<'py> + cmp::Eq + hash::Hash,
-    V: FromPyObject<'py>,
+    K: FromPyObjectOwned<'py> + cmp::Eq + hash::Hash,
+    V: FromPyObjectOwned<'py>,
     S: hash::BuildHasher + Default,
 {
-    fn extract_bound(ob: &Bound<'py, PyAny>) -> Result<Self, PyErr> {
-        let dict = ob.downcast::<PyDict>()?;
+    type Error = PyErr;
+
+    fn extract(ob: Borrowed<'_, 'py, PyAny>) -> Result<Self, Self::Error> {
+        let dict = ob.cast::<PyDict>()?;
         let mut ret = indexmap::IndexMap::with_capacity_and_hasher(dict.len(), S::default());
         for (k, v) in dict.iter() {
-            ret.insert(k.extract()?, v.extract()?);
+            ret.insert(
+                k.extract().map_err(Into::into)?,
+                v.extract().map_err(Into::into)?,
+            );
         }
         Ok(ret)
     }
@@ -137,21 +154,18 @@ where
 #[cfg(test)]
 mod test_indexmap {
 
-    use crate::types::any::PyAnyMethods;
-    use crate::types::dict::PyDictMethods;
     use crate::types::*;
-    use crate::{IntoPy, PyObject, Python, ToPyObject};
+    use crate::{IntoPyObject, Python};
 
     #[test]
-    fn test_indexmap_indexmap_to_python() {
-        Python::with_gil(|py| {
+    fn test_indexmap_indexmap_into_pyobject() {
+        Python::attach(|py| {
             let mut map = indexmap::IndexMap::<i32, i32>::new();
             map.insert(1, 1);
 
-            let m = map.to_object(py);
-            let py_map: &PyDict = m.downcast(py).unwrap();
+            let py_map = (&map).into_pyobject(py).unwrap();
 
-            assert!(py_map.len() == 1);
+            assert_eq!(py_map.len(), 1);
             assert!(
                 py_map
                     .get_item(1)
@@ -168,35 +182,13 @@ mod test_indexmap {
         });
     }
 
-    #[test]
-    fn test_indexmap_indexmap_into_python() {
-        Python::with_gil(|py| {
-            let mut map = indexmap::IndexMap::<i32, i32>::new();
-            map.insert(1, 1);
-
-            let m: PyObject = map.into_py(py);
-            let py_map: &PyDict = m.downcast(py).unwrap();
-
-            assert!(py_map.len() == 1);
-            assert!(
-                py_map
-                    .get_item(1)
-                    .unwrap()
-                    .unwrap()
-                    .extract::<i32>()
-                    .unwrap()
-                    == 1
-            );
-        });
-    }
-
     #[test]
     fn test_indexmap_indexmap_into_dict() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let mut map = indexmap::IndexMap::<i32, i32>::new();
             map.insert(1, 1);
 
-            let py_map = map.into_py_dict_bound(py);
+            let py_map = map.into_py_dict(py).unwrap();
 
             assert_eq!(py_map.len(), 1);
             assert_eq!(
@@ -213,7 +205,7 @@ mod test_indexmap {
 
     #[test]
     fn test_indexmap_indexmap_insertion_order_round_trip() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let n = 20;
             let mut map = indexmap::IndexMap::<i32, i32>::new();
 
@@ -225,7 +217,7 @@ mod test_indexmap {
                 }
             }
 
-            let py_map = map.clone().into_py_dict_bound(py);
+            let py_map = (&map).into_py_dict(py).unwrap();
 
             let trip_map = py_map.extract::<indexmap::IndexMap<i32, i32>>().unwrap();
 
diff --git a/src/conversions/jiff.rs b/src/conversions/jiff.rs
new file mode 100644
index 00000000000..db1a591b968
--- /dev/null
+++ b/src/conversions/jiff.rs
@@ -0,0 +1,1229 @@
+#![cfg(feature = "jiff-02")]
+
+//! Conversions to and from [jiff](https://docs.rs/jiff/)’s `Span`, `SignedDuration`, `TimeZone`,
+//! `Offset`, `Date`, `Time`, `DateTime`, `Zoned`, and `Timestamp`.
+//!
+//! # Setup
+//!
+//! To use this feature, add this to your **`Cargo.toml`**:
+//!
+//! ```toml
+//! [dependencies]
+//! jiff = "0.2"
+#![doc = concat!("pyo3 = { version = \"", env!("CARGO_PKG_VERSION"),  "\", features = [\"jiff-02\"] }")]
+//! ```
+//!
+//! Note that you must use compatible versions of jiff and PyO3.
+//! The required jiff version may vary based on the version of PyO3.
+//!
+//! # Example: Convert a `datetime.datetime` to jiff `Zoned`
+//!
+//! ```rust
+//! # #![cfg_attr(windows, allow(unused_imports))]
+//! # use jiff_02 as jiff;
+//! use jiff::{Zoned, SignedDuration, ToSpan};
+//! use pyo3::{Python, PyResult, IntoPyObject, types::PyAnyMethods};
+//!
+//! # #[cfg(windows)]
+//! # fn main() -> () {}
+//! # #[cfg(not(windows))]
+//! fn main() -> PyResult<()> {
+//!     Python::initialize();
+//!     Python::attach(|py| {
+//!         // Build some jiff values
+//!         let jiff_zoned = Zoned::now();
+//!         let jiff_span = 1.second();
+//!         // Convert them to Python
+//!         let py_datetime = jiff_zoned.into_pyobject(py)?;
+//!         let py_timedelta = SignedDuration::try_from(jiff_span)?.into_pyobject(py)?;
+//!         // Do an operation in Python
+//!         let py_sum = py_datetime.call_method1("__add__", (py_timedelta,))?;
+//!         // Convert back to Rust
+//!         let jiff_sum: Zoned = py_sum.extract()?;
+//!         println!("Zoned: {}", jiff_sum);
+//!         Ok(())
+//!     })
+//! }
+//! ```
+use crate::exceptions::{PyTypeError, PyValueError};
+use crate::pybacked::PyBackedStr;
+use crate::types::{PyAnyMethods, PyNone};
+use crate::types::{PyDate, PyDateTime, PyDelta, PyTime, PyTzInfo, PyTzInfoAccess};
+#[cfg(not(Py_LIMITED_API))]
+use crate::types::{PyDateAccess, PyDeltaAccess, PyTimeAccess};
+use crate::{intern, Borrowed, Bound, FromPyObject, IntoPyObject, PyAny, PyErr, PyResult, Python};
+use jiff::civil::{Date, DateTime, ISOWeekDate, Time};
+use jiff::tz::{Offset, TimeZone};
+use jiff::{SignedDuration, Span, Timestamp, Zoned};
+#[cfg(feature = "jiff-02")]
+use jiff_02 as jiff;
+
+fn datetime_to_pydatetime<'py>(
+    py: Python<'py>,
+    datetime: &DateTime,
+    fold: bool,
+    timezone: Option<&TimeZone>,
+) -> PyResult<Bound<'py, PyDateTime>> {
+    PyDateTime::new_with_fold(
+        py,
+        datetime.year().into(),
+        datetime.month().try_into()?,
+        datetime.day().try_into()?,
+        datetime.hour().try_into()?,
+        datetime.minute().try_into()?,
+        datetime.second().try_into()?,
+        (datetime.subsec_nanosecond() / 1000).try_into()?,
+        timezone
+            .map(|tz| tz.into_pyobject(py))
+            .transpose()?
+            .as_ref(),
+        fold,
+    )
+}
+
+#[cfg(not(Py_LIMITED_API))]
+fn pytime_to_time(time: &impl PyTimeAccess) -> PyResult<Time> {
+    Ok(Time::new(
+        time.get_hour().try_into()?,
+        time.get_minute().try_into()?,
+        time.get_second().try_into()?,
+        (time.get_microsecond() * 1000).try_into()?,
+    )?)
+}
+
+#[cfg(Py_LIMITED_API)]
+fn pytime_to_time(time: &Bound<'_, PyAny>) -> PyResult<Time> {
+    let py = time.py();
+    Ok(Time::new(
+        time.getattr(intern!(py, "hour"))?.extract()?,
+        time.getattr(intern!(py, "minute"))?.extract()?,
+        time.getattr(intern!(py, "second"))?.extract()?,
+        time.getattr(intern!(py, "microsecond"))?.extract::<i32>()? * 1000,
+    )?)
+}
+
+impl<'py> IntoPyObject<'py> for Timestamp {
+    type Target = PyDateTime;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        (&self).into_pyobject(py)
+    }
+}
+
+impl<'py> IntoPyObject<'py> for &Timestamp {
+    type Target = PyDateTime;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        self.to_zoned(TimeZone::UTC).into_pyobject(py)
+    }
+}
+
+impl<'a, 'py> FromPyObject<'a, 'py> for Timestamp {
+    type Error = <Zoned as FromPyObject<'a, 'py>>::Error;
+
+    fn extract(ob: Borrowed<'_, 'py, PyAny>) -> Result<Self, Self::Error> {
+        let zoned = ob.extract::<Zoned>()?;
+        Ok(zoned.timestamp())
+    }
+}
+
+impl<'py> IntoPyObject<'py> for Date {
+    type Target = PyDate;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        (&self).into_pyobject(py)
+    }
+}
+
+impl<'py> IntoPyObject<'py> for &Date {
+    type Target = PyDate;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        PyDate::new(
+            py,
+            self.year().into(),
+            self.month().try_into()?,
+            self.day().try_into()?,
+        )
+    }
+}
+
+impl<'py> FromPyObject<'_, 'py> for Date {
+    type Error = PyErr;
+
+    fn extract(ob: Borrowed<'_, 'py, PyAny>) -> PyResult<Self> {
+        let date = ob.cast::<PyDate>()?;
+
+        #[cfg(not(Py_LIMITED_API))]
+        {
+            Ok(Date::new(
+                date.get_year().try_into()?,
+                date.get_month().try_into()?,
+                date.get_day().try_into()?,
+            )?)
+        }
+
+        #[cfg(Py_LIMITED_API)]
+        {
+            let py = date.py();
+            Ok(Date::new(
+                date.getattr(intern!(py, "year"))?.extract()?,
+                date.getattr(intern!(py, "month"))?.extract()?,
+                date.getattr(intern!(py, "day"))?.extract()?,
+            )?)
+        }
+    }
+}
+
+impl<'py> IntoPyObject<'py> for Time {
+    type Target = PyTime;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        (&self).into_pyobject(py)
+    }
+}
+
+impl<'py> IntoPyObject<'py> for &Time {
+    type Target = PyTime;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        PyTime::new(
+            py,
+            self.hour().try_into()?,
+            self.minute().try_into()?,
+            self.second().try_into()?,
+            (self.subsec_nanosecond() / 1000).try_into()?,
+            None,
+        )
+    }
+}
+
+impl<'py> FromPyObject<'_, 'py> for Time {
+    type Error = PyErr;
+
+    fn extract(ob: Borrowed<'_, 'py, PyAny>) -> PyResult<Self> {
+        let ob = ob.cast::<PyTime>()?;
+        #[allow(clippy::explicit_auto_deref)]
+        pytime_to_time(&*ob)
+    }
+}
+
+impl<'py> IntoPyObject<'py> for DateTime {
+    type Target = PyDateTime;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        (&self).into_pyobject(py)
+    }
+}
+
+impl<'py> IntoPyObject<'py> for &DateTime {
+    type Target = PyDateTime;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        datetime_to_pydatetime(py, self, false, None)
+    }
+}
+
+impl<'py> FromPyObject<'_, 'py> for DateTime {
+    type Error = PyErr;
+
+    fn extract(dt: Borrowed<'_, 'py, PyAny>) -> PyResult<Self> {
+        let dt = dt.cast::<PyDateTime>()?;
+        let has_tzinfo = dt.get_tzinfo().is_some();
+
+        if has_tzinfo {
+            return Err(PyTypeError::new_err("expected a datetime without tzinfo"));
+        }
+
+        #[allow(clippy::explicit_auto_deref)]
+        Ok(DateTime::from_parts(dt.extract()?, pytime_to_time(&*dt)?))
+    }
+}
+
+impl<'py> IntoPyObject<'py> for Zoned {
+    type Target = PyDateTime;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        (&self).into_pyobject(py)
+    }
+}
+
+impl<'py> IntoPyObject<'py> for &Zoned {
+    type Target = PyDateTime;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        fn fold(zoned: &Zoned) -> Option<bool> {
+            let prev = zoned.time_zone().preceding(zoned.timestamp()).next()?;
+            let next = zoned.time_zone().following(prev.timestamp()).next()?;
+            let start_of_current_offset = if next.timestamp() == zoned.timestamp() {
+                next.timestamp()
+            } else {
+                prev.timestamp()
+            };
+            Some(zoned.timestamp() + (zoned.offset() - prev.offset()) <= start_of_current_offset)
+        }
+
+        datetime_to_pydatetime(
+            py,
+            &self.datetime(),
+            fold(self).unwrap_or(false),
+            Some(self.time_zone()),
+        )
+    }
+}
+
+impl<'py> FromPyObject<'_, 'py> for Zoned {
+    type Error = PyErr;
+
+    fn extract(dt: Borrowed<'_, 'py, PyAny>) -> PyResult<Self> {
+        let dt = dt.cast::<PyDateTime>()?;
+
+        let tz = dt
+            .get_tzinfo()
+            .map(|tz| tz.extract::<TimeZone>())
+            .unwrap_or_else(|| {
+                Err(PyTypeError::new_err(
+                    "expected a datetime with non-None tzinfo",
+                ))
+            })?;
+        #[allow(clippy::explicit_auto_deref)]
+        let datetime = DateTime::from_parts(dt.extract()?, pytime_to_time(&*dt)?);
+        let zoned = tz.into_ambiguous_zoned(datetime);
+
+        #[cfg(not(Py_LIMITED_API))]
+        let fold = dt.get_fold();
+
+        #[cfg(Py_LIMITED_API)]
+        let fold = dt.getattr(intern!(dt.py(), "fold"))?.extract::<usize>()? > 0;
+
+        if fold {
+            Ok(zoned.later()?)
+        } else {
+            Ok(zoned.earlier()?)
+        }
+    }
+}
+
+impl<'py> IntoPyObject<'py> for TimeZone {
+    type Target = PyTzInfo;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        (&self).into_pyobject(py)
+    }
+}
+
+impl<'py> IntoPyObject<'py> for &TimeZone {
+    type Target = PyTzInfo;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        if self == &TimeZone::UTC {
+            return Ok(PyTzInfo::utc(py)?.to_owned());
+        }
+
+        if let Some(iana_name) = self.iana_name() {
+            return PyTzInfo::timezone(py, iana_name);
+        }
+
+        self.to_fixed_offset()?.into_pyobject(py)
+    }
+}
+
+impl<'py> FromPyObject<'_, 'py> for TimeZone {
+    type Error = PyErr;
+
+    fn extract(ob: Borrowed<'_, 'py, PyAny>) -> PyResult<Self> {
+        let ob = ob.cast::<PyTzInfo>()?;
+
+        let attr = intern!(ob.py(), "key");
+        if ob.hasattr(attr)? {
+            Ok(TimeZone::get(&ob.getattr(attr)?.extract::<PyBackedStr>()?)?)
+        } else {
+            Ok(ob.extract::<Offset>()?.to_time_zone())
+        }
+    }
+}
+
+impl<'py> IntoPyObject<'py> for &Offset {
+    type Target = PyTzInfo;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        if self == &Offset::UTC {
+            return Ok(PyTzInfo::utc(py)?.to_owned());
+        }
+
+        PyTzInfo::fixed_offset(py, self.duration_since(Offset::UTC))
+    }
+}
+
+impl<'py> IntoPyObject<'py> for Offset {
+    type Target = PyTzInfo;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        (&self).into_pyobject(py)
+    }
+}
+
+impl<'py> FromPyObject<'_, 'py> for Offset {
+    type Error = PyErr;
+
+    fn extract(ob: Borrowed<'_, 'py, PyAny>) -> PyResult<Self> {
+        let py = ob.py();
+        let ob = ob.cast::<PyTzInfo>()?;
+
+        let py_timedelta = ob.call_method1(intern!(py, "utcoffset"), (PyNone::get(py),))?;
+        if py_timedelta.is_none() {
+            return Err(PyTypeError::new_err(format!(
+                "{ob:?} is not a fixed offset timezone"
+            )));
+        }
+
+        let total_seconds = py_timedelta.extract::<SignedDuration>()?.as_secs();
+        debug_assert!(
+            (total_seconds / 3600).abs() <= 24,
+            "Offset must be between -24 hours and 24 hours but was {}h",
+            total_seconds / 3600
+        );
+        // This cast is safe since the timedelta is limited to -24 hours and 24 hours.
+        Ok(Offset::from_seconds(total_seconds as i32)?)
+    }
+}
+
+impl<'py> IntoPyObject<'py> for &SignedDuration {
+    type Target = PyDelta;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        let total_seconds = self.as_secs();
+        let days: i32 = (total_seconds / (24 * 60 * 60)).try_into()?;
+        let seconds: i32 = (total_seconds % (24 * 60 * 60)).try_into()?;
+        let microseconds = self.subsec_micros();
+
+        PyDelta::new(py, days, seconds, microseconds, true)
+    }
+}
+
+impl<'py> IntoPyObject<'py> for SignedDuration {
+    type Target = PyDelta;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        (&self).into_pyobject(py)
+    }
+}
+
+impl<'py> FromPyObject<'_, 'py> for SignedDuration {
+    type Error = PyErr;
+
+    fn extract(ob: Borrowed<'_, 'py, PyAny>) -> PyResult<Self> {
+        let delta = ob.cast::<PyDelta>()?;
+
+        #[cfg(not(Py_LIMITED_API))]
+        let (seconds, microseconds) = {
+            let days = delta.get_days() as i64;
+            let seconds = delta.get_seconds() as i64;
+            let microseconds = delta.get_microseconds();
+            (days * 24 * 60 * 60 + seconds, microseconds)
+        };
+
+        #[cfg(Py_LIMITED_API)]
+        let (seconds, microseconds) = {
+            let py = delta.py();
+            let days = delta.getattr(intern!(py, "days"))?.extract::<i64>()?;
+            let seconds = delta.getattr(intern!(py, "seconds"))?.extract::<i64>()?;
+            let microseconds = ob.getattr(intern!(py, "microseconds"))?.extract::<i32>()?;
+            (days * 24 * 60 * 60 + seconds, microseconds)
+        };
+
+        Ok(SignedDuration::new(seconds, microseconds * 1000))
+    }
+}
+
+impl<'py> FromPyObject<'_, 'py> for Span {
+    type Error = PyErr;
+
+    fn extract(ob: Borrowed<'_, 'py, PyAny>) -> PyResult<Self> {
+        let duration = ob.extract::<SignedDuration>()?;
+        Ok(duration.try_into()?)
+    }
+}
+
+impl<'py> IntoPyObject<'py> for ISOWeekDate {
+    type Target = PyDate;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        self.date().into_pyobject(py)
+    }
+}
+
+impl<'py> IntoPyObject<'py> for &ISOWeekDate {
+    type Target = PyDate;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        (*self).into_pyobject(py)
+    }
+}
+
+impl FromPyObject<'_, '_> for ISOWeekDate {
+    type Error = PyErr;
+
+    fn extract(ob: Borrowed<'_, '_, PyAny>) -> PyResult<Self> {
+        Ok(ob.extract::<Date>()?.iso_week_date())
+    }
+}
+
+impl From<jiff::Error> for PyErr {
+    fn from(e: jiff::Error) -> Self {
+        PyValueError::new_err(e.to_string())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{types::PyTuple, BoundObject};
+    use jiff::tz::Offset;
+    use std::cmp::Ordering;
+
+    #[test]
+    // Only Python>=3.9 has the zoneinfo package
+    // We skip the test on windows too since we'd need to install
+    // tzdata there to make this work.
+    #[cfg(all(Py_3_9, not(target_os = "windows")))]
+    fn test_zoneinfo_is_not_fixed_offset() {
+        use crate::types::any::PyAnyMethods;
+        use crate::types::dict::PyDictMethods;
+
+        Python::attach(|py| {
+            let locals = crate::types::PyDict::new(py);
+            py.run(
+                c"import zoneinfo; zi = zoneinfo.ZoneInfo('Europe/London')",
+                None,
+                Some(&locals),
+            )
+            .unwrap();
+            let result: PyResult<Offset> = locals.get_item("zi").unwrap().unwrap().extract();
+            assert!(result.is_err());
+            let res = result.err().unwrap();
+            // Also check the error message is what we expect
+            let msg = res.value(py).repr().unwrap().to_string();
+            assert_eq!(msg, "TypeError(\"zoneinfo.ZoneInfo(key='Europe/London') is not a fixed offset timezone\")");
+        });
+    }
+
+    #[test]
+    fn test_timezone_aware_to_naive_fails() {
+        // Test that if a user tries to convert a python's timezone aware datetime into a naive
+        // one, the conversion fails.
+        Python::attach(|py| {
+            let py_datetime =
+                new_py_datetime_ob(py, "datetime", (2022, 1, 1, 1, 0, 0, 0, python_utc(py)));
+            // Now test that converting a PyDateTime with tzinfo to a NaiveDateTime fails
+            let res: PyResult<DateTime> = py_datetime.extract();
+            assert_eq!(
+                res.unwrap_err().value(py).repr().unwrap().to_string(),
+                "TypeError('expected a datetime without tzinfo')"
+            );
+        });
+    }
+
+    #[test]
+    fn test_naive_to_timezone_aware_fails() {
+        // Test that if a user tries to convert a python's naive datetime into a timezone aware
+        // one, the conversion fails.
+        Python::attach(|py| {
+            let py_datetime = new_py_datetime_ob(py, "datetime", (2022, 1, 1, 1, 0, 0, 0));
+            let res: PyResult<Zoned> = py_datetime.extract();
+            assert_eq!(
+                res.unwrap_err().value(py).repr().unwrap().to_string(),
+                "TypeError('expected a datetime with non-None tzinfo')"
+            );
+        });
+    }
+
+    #[test]
+    fn test_invalid_types_fail() {
+        Python::attach(|py| {
+            let none = py.None().into_bound(py);
+            assert_eq!(
+                none.extract::<Span>().unwrap_err().to_string(),
+                "TypeError: 'NoneType' object cannot be cast as 'timedelta'"
+            );
+            assert_eq!(
+                none.extract::<Offset>().unwrap_err().to_string(),
+                "TypeError: 'NoneType' object cannot be cast as 'tzinfo'"
+            );
+            assert_eq!(
+                none.extract::<TimeZone>().unwrap_err().to_string(),
+                "TypeError: 'NoneType' object cannot be cast as 'tzinfo'"
+            );
+            assert_eq!(
+                none.extract::<Time>().unwrap_err().to_string(),
+                "TypeError: 'NoneType' object cannot be cast as 'time'"
+            );
+            assert_eq!(
+                none.extract::<Date>().unwrap_err().to_string(),
+                "TypeError: 'NoneType' object cannot be cast as 'date'"
+            );
+            assert_eq!(
+                none.extract::<DateTime>().unwrap_err().to_string(),
+                "TypeError: 'NoneType' object cannot be cast as 'datetime'"
+            );
+            assert_eq!(
+                none.extract::<Zoned>().unwrap_err().to_string(),
+                "TypeError: 'NoneType' object cannot be cast as 'datetime'"
+            );
+        });
+    }
+
+    #[test]
+    fn test_pyo3_date_into_pyobject() {
+        let eq_ymd = |name: &'static str, year, month, day| {
+            Python::attach(|py| {
+                let date = Date::new(year, month, day)
+                    .unwrap()
+                    .into_pyobject(py)
+                    .unwrap();
+                let py_date = new_py_datetime_ob(py, "date", (year, month, day));
+                assert_eq!(
+                    date.compare(&py_date).unwrap(),
+                    Ordering::Equal,
+                    "{name}: {date} != {py_date}"
+                );
+            })
+        };
+
+        eq_ymd("past date", 2012, 2, 29);
+        eq_ymd("min date", 1, 1, 1);
+        eq_ymd("future date", 3000, 6, 5);
+        eq_ymd("max date", 9999, 12, 31);
+    }
+
+    #[test]
+    fn test_pyo3_date_frompyobject() {
+        let eq_ymd = |name: &'static str, year, month, day| {
+            Python::attach(|py| {
+                let py_date = new_py_datetime_ob(py, "date", (year, month, day));
+                let py_date: Date = py_date.extract().unwrap();
+                let date = Date::new(year, month, day).unwrap();
+                assert_eq!(py_date, date, "{name}: {date} != {py_date}");
+            })
+        };
+
+        eq_ymd("past date", 2012, 2, 29);
+        eq_ymd("min date", 1, 1, 1);
+        eq_ymd("future date", 3000, 6, 5);
+        eq_ymd("max date", 9999, 12, 31);
+    }
+
+    #[test]
+    fn test_pyo3_datetime_into_pyobject_utc() {
+        Python::attach(|py| {
+            let check_utc =
+                |name: &'static str, year, month, day, hour, minute, second, ms, py_ms| {
+                    let datetime = DateTime::new(year, month, day, hour, minute, second, ms * 1000)
+                        .unwrap()
+                        .to_zoned(TimeZone::UTC)
+                        .unwrap();
+                    let datetime = datetime.into_pyobject(py).unwrap();
+                    let py_datetime = new_py_datetime_ob(
+                        py,
+                        "datetime",
+                        (
+                            year,
+                            month,
+                            day,
+                            hour,
+                            minute,
+                            second,
+                            py_ms,
+                            python_utc(py),
+                        ),
+                    );
+                    assert_eq!(
+                        datetime.compare(&py_datetime).unwrap(),
+                        Ordering::Equal,
+                        "{name}: {datetime} != {py_datetime}"
+                    );
+                };
+
+            check_utc("regular", 2014, 5, 6, 7, 8, 9, 999_999, 999_999);
+        })
+    }
+
+    #[test]
+    fn test_pyo3_datetime_into_pyobject_fixed_offset() {
+        Python::attach(|py| {
+            let check_fixed_offset =
+                |name: &'static str, year, month, day, hour, minute, second, ms, py_ms| {
+                    let offset = Offset::from_seconds(3600).unwrap();
+                    let datetime = DateTime::new(year, month, day, hour, minute, second, ms * 1000)
+                        .map_err(|e| {
+                            eprintln!("{name}: {e}");
+                            e
+                        })
+                        .unwrap()
+                        .to_zoned(offset.to_time_zone())
+                        .unwrap();
+                    let datetime = datetime.into_pyobject(py).unwrap();
+                    let py_tz = offset.into_pyobject(py).unwrap();
+                    let py_datetime = new_py_datetime_ob(
+                        py,
+                        "datetime",
+                        (year, month, day, hour, minute, second, py_ms, py_tz),
+                    );
+                    assert_eq!(
+                        datetime.compare(&py_datetime).unwrap(),
+                        Ordering::Equal,
+                        "{name}: {datetime} != {py_datetime}"
+                    );
+                };
+
+            check_fixed_offset("regular", 2014, 5, 6, 7, 8, 9, 999_999, 999_999);
+        })
+    }
+
+    #[test]
+    #[cfg(all(Py_3_9, not(windows)))]
+    fn test_pyo3_datetime_into_pyobject_tz() {
+        Python::attach(|py| {
+            let datetime = DateTime::new(2024, 12, 11, 23, 3, 13, 0)
+                .unwrap()
+                .to_zoned(TimeZone::get("Europe/London").unwrap())
+                .unwrap();
+            let datetime = datetime.into_pyobject(py).unwrap();
+            let py_datetime = new_py_datetime_ob(
+                py,
+                "datetime",
+                (
+                    2024,
+                    12,
+                    11,
+                    23,
+                    3,
+                    13,
+                    0,
+                    python_zoneinfo(py, "Europe/London"),
+                ),
+            );
+            assert_eq!(datetime.compare(&py_datetime).unwrap(), Ordering::Equal);
+        })
+    }
+
+    #[test]
+    fn test_pyo3_datetime_frompyobject_utc() {
+        Python::attach(|py| {
+            let year = 2014;
+            let month = 5;
+            let day = 6;
+            let hour = 7;
+            let minute = 8;
+            let second = 9;
+            let micro = 999_999;
+            let tz_utc = PyTzInfo::utc(py).unwrap();
+            let py_datetime = new_py_datetime_ob(
+                py,
+                "datetime",
+                (year, month, day, hour, minute, second, micro, tz_utc),
+            );
+            let py_datetime: Zoned = py_datetime.extract().unwrap();
+            let datetime = DateTime::new(year, month, day, hour, minute, second, micro * 1000)
+                .unwrap()
+                .to_zoned(TimeZone::UTC)
+                .unwrap();
+            assert_eq!(py_datetime, datetime,);
+        })
+    }
+
+    #[test]
+    #[cfg(all(Py_3_9, not(windows)))]
+    fn test_ambiguous_datetime_to_pyobject() {
+        use std::str::FromStr;
+        let dates = [
+            Zoned::from_str("2020-10-24 23:00:00[UTC]").unwrap(),
+            Zoned::from_str("2020-10-25 00:00:00[UTC]").unwrap(),
+            Zoned::from_str("2020-10-25 01:00:00[UTC]").unwrap(),
+            Zoned::from_str("2020-10-25 02:00:00[UTC]").unwrap(),
+        ];
+
+        let tz = TimeZone::get("Europe/London").unwrap();
+        let dates = dates.map(|dt| dt.with_time_zone(tz.clone()));
+
+        assert_eq!(
+            dates.clone().map(|ref dt| dt.to_string()),
+            [
+                "2020-10-25T00:00:00+01:00[Europe/London]",
+                "2020-10-25T01:00:00+01:00[Europe/London]",
+                "2020-10-25T01:00:00+00:00[Europe/London]",
+                "2020-10-25T02:00:00+00:00[Europe/London]",
+            ]
+        );
+
+        let dates = Python::attach(|py| {
+            let pydates = dates.map(|dt| dt.into_pyobject(py).unwrap());
+            assert_eq!(
+                pydates
+                    .clone()
+                    .map(|dt| dt.getattr("hour").unwrap().extract::<usize>().unwrap()),
+                [0, 1, 1, 2]
+            );
+
+            assert_eq!(
+                pydates
+                    .clone()
+                    .map(|dt| dt.getattr("fold").unwrap().extract::<usize>().unwrap() > 0),
+                [false, false, true, false]
+            );
+
+            pydates.map(|dt| dt.extract::<Zoned>().unwrap())
+        });
+
+        assert_eq!(
+            dates.map(|dt| dt.to_string()),
+            [
+                "2020-10-25T00:00:00+01:00[Europe/London]",
+                "2020-10-25T01:00:00+01:00[Europe/London]",
+                "2020-10-25T01:00:00+00:00[Europe/London]",
+                "2020-10-25T02:00:00+00:00[Europe/London]",
+            ]
+        );
+    }
+
+    #[test]
+    fn test_pyo3_datetime_frompyobject_fixed_offset() {
+        Python::attach(|py| {
+            let year = 2014;
+            let month = 5;
+            let day = 6;
+            let hour = 7;
+            let minute = 8;
+            let second = 9;
+            let micro = 999_999;
+            let offset = Offset::from_seconds(3600).unwrap();
+            let py_tz = offset.into_pyobject(py).unwrap();
+            let py_datetime = new_py_datetime_ob(
+                py,
+                "datetime",
+                (year, month, day, hour, minute, second, micro, py_tz),
+            );
+            let datetime_from_py: Zoned = py_datetime.extract().unwrap();
+            let datetime =
+                DateTime::new(year, month, day, hour, minute, second, micro * 1000).unwrap();
+            let datetime = datetime.to_zoned(offset.to_time_zone()).unwrap();
+
+            assert_eq!(datetime_from_py, datetime);
+        })
+    }
+
+    #[test]
+    fn test_pyo3_offset_fixed_into_pyobject() {
+        Python::attach(|py| {
+            // jiff offset
+            let offset = Offset::from_seconds(3600)
+                .unwrap()
+                .into_pyobject(py)
+                .unwrap();
+            // Python timezone from timedelta
+            let td = new_py_datetime_ob(py, "timedelta", (0, 3600, 0));
+            let py_timedelta = new_py_datetime_ob(py, "timezone", (td,));
+            // Should be equal
+            assert!(offset.eq(py_timedelta).unwrap());
+
+            // Same but with negative values
+            let offset = Offset::from_seconds(-3600)
+                .unwrap()
+                .into_pyobject(py)
+                .unwrap();
+            let td = new_py_datetime_ob(py, "timedelta", (0, -3600, 0));
+            let py_timedelta = new_py_datetime_ob(py, "timezone", (td,));
+            assert!(offset.eq(py_timedelta).unwrap());
+        })
+    }
+
+    #[test]
+    fn test_pyo3_offset_fixed_frompyobject() {
+        Python::attach(|py| {
+            let py_timedelta = new_py_datetime_ob(py, "timedelta", (0, 3600, 0));
+            let py_tzinfo = new_py_datetime_ob(py, "timezone", (py_timedelta,));
+            let offset: Offset = py_tzinfo.extract().unwrap();
+            assert_eq!(Offset::from_seconds(3600).unwrap(), offset);
+        })
+    }
+
+    #[test]
+    fn test_pyo3_offset_utc_into_pyobject() {
+        Python::attach(|py| {
+            let utc = Offset::UTC.into_pyobject(py).unwrap();
+            let py_utc = python_utc(py);
+            assert!(utc.is(&py_utc));
+        })
+    }
+
+    #[test]
+    fn test_pyo3_offset_utc_frompyobject() {
+        Python::attach(|py| {
+            let py_utc = python_utc(py);
+            let py_utc: Offset = py_utc.extract().unwrap();
+            assert_eq!(Offset::UTC, py_utc);
+
+            let py_timedelta = new_py_datetime_ob(py, "timedelta", (0, 0, 0));
+            let py_timezone_utc = new_py_datetime_ob(py, "timezone", (py_timedelta,));
+            let py_timezone_utc: Offset = py_timezone_utc.extract().unwrap();
+            assert_eq!(Offset::UTC, py_timezone_utc);
+
+            let py_timedelta = new_py_datetime_ob(py, "timedelta", (0, 3600, 0));
+            let py_timezone = new_py_datetime_ob(py, "timezone", (py_timedelta,));
+            assert_ne!(Offset::UTC, py_timezone.extract::<Offset>().unwrap());
+        })
+    }
+
+    #[test]
+    fn test_pyo3_time_into_pyobject() {
+        Python::attach(|py| {
+            let check_time = |name: &'static str, hour, minute, second, ms, py_ms| {
+                let time = Time::new(hour, minute, second, ms * 1000)
+                    .unwrap()
+                    .into_pyobject(py)
+                    .unwrap();
+                let py_time = new_py_datetime_ob(py, "time", (hour, minute, second, py_ms));
+                assert!(time.eq(&py_time).unwrap(), "{name}: {time} != {py_time}");
+            };
+
+            check_time("regular", 3, 5, 7, 999_999, 999_999);
+        })
+    }
+
+    #[test]
+    fn test_pyo3_time_frompyobject() {
+        let hour = 3;
+        let minute = 5;
+        let second = 7;
+        let micro = 999_999;
+        Python::attach(|py| {
+            let py_time = new_py_datetime_ob(py, "time", (hour, minute, second, micro));
+            let py_time: Time = py_time.extract().unwrap();
+            let time = Time::new(hour, minute, second, micro * 1000).unwrap();
+            assert_eq!(py_time, time);
+        })
+    }
+
+    fn new_py_datetime_ob<'py, A>(py: Python<'py>, name: &str, args: A) -> Bound<'py, PyAny>
+    where
+        A: IntoPyObject<'py, Target = PyTuple>,
+    {
+        py.import("datetime")
+            .unwrap()
+            .getattr(name)
+            .unwrap()
+            .call1(
+                args.into_pyobject(py)
+                    .map_err(Into::into)
+                    .unwrap()
+                    .into_bound(),
+            )
+            .unwrap()
+    }
+
+    fn python_utc(py: Python<'_>) -> Bound<'_, PyAny> {
+        py.import("datetime")
+            .unwrap()
+            .getattr("timezone")
+            .unwrap()
+            .getattr("utc")
+            .unwrap()
+    }
+
+    #[cfg(all(Py_3_9, not(windows)))]
+    fn python_zoneinfo<'py>(py: Python<'py>, timezone: &str) -> Bound<'py, PyAny> {
+        py.import("zoneinfo")
+            .unwrap()
+            .getattr("ZoneInfo")
+            .unwrap()
+            .call1((timezone,))
+            .unwrap()
+    }
+
+    #[cfg(not(any(target_arch = "wasm32", Py_GIL_DISABLED)))]
+    mod proptests {
+        use super::*;
+        use crate::types::IntoPyDict;
+        use jiff::tz::TimeZoneTransition;
+        use jiff::SpanRelativeTo;
+        use proptest::prelude::*;
+        use std::ffi::CString;
+
+        // This is to skip the test if we are creating an invalid date, like February 31.
+        #[track_caller]
+        fn try_date(year: i16, month: i8, day: i8) -> Result<Date, TestCaseError> {
+            let location = std::panic::Location::caller();
+            Date::new(year, month, day)
+                .map_err(|err| TestCaseError::reject(format!("{location}: {err:?}")))
+        }
+
+        #[track_caller]
+        fn try_time(hour: i8, min: i8, sec: i8, micro: i32) -> Result<Time, TestCaseError> {
+            let location = std::panic::Location::caller();
+            Time::new(hour, min, sec, micro * 1000)
+                .map_err(|err| TestCaseError::reject(format!("{location}: {err:?}")))
+        }
+
+        #[allow(clippy::too_many_arguments)]
+        fn try_zoned(
+            year: i16,
+            month: i8,
+            day: i8,
+            hour: i8,
+            min: i8,
+            sec: i8,
+            micro: i32,
+            tz: TimeZone,
+        ) -> Result<Zoned, TestCaseError> {
+            let date = try_date(year, month, day)?;
+            let time = try_time(hour, min, sec, micro)?;
+            let location = std::panic::Location::caller();
+            DateTime::from_parts(date, time)
+                .to_zoned(tz)
+                .map_err(|err| TestCaseError::reject(format!("{location}: {err:?}")))
+        }
+
+        prop_compose! {
+            fn timezone_transitions(timezone: &TimeZone)
+                            (year in 1900i16..=2100i16, month in 1i8..=12i8)
+                            -> TimeZoneTransition<'_> {
+                let datetime = DateTime::new(year, month, 1, 0, 0, 0, 0).unwrap();
+                let timestamp= timezone.to_zoned(datetime).unwrap().timestamp();
+                timezone.following(timestamp).next().unwrap()
+            }
+        }
+
+        proptest! {
+
+            // Range is limited to 1970 to 2038 due to windows limitations
+            #[test]
+            fn test_pyo3_offset_fixed_frompyobject_created_in_python(timestamp in 0..(i32::MAX as i64), timedelta in -86399i32..=86399i32) {
+                Python::attach(|py| {
+                    let globals = [("datetime", py.import("datetime").unwrap())].into_py_dict(py).unwrap();
+                    let code = format!("datetime.datetime.fromtimestamp({timestamp}).replace(tzinfo=datetime.timezone(datetime.timedelta(seconds={timedelta})))");
+                    let t = py.eval(&CString::new(code).unwrap(), Some(&globals), None).unwrap();
+
+                    // Get ISO 8601 string from python
+                    let py_iso_str = t.call_method0("isoformat").unwrap();
+
+                    // Get ISO 8601 string from rust
+                    let rust_iso_str = t.extract::<Zoned>().unwrap().strftime("%Y-%m-%dT%H:%M:%S%:z").to_string();
+
+                    // They should be equal
+                    prop_assert_eq!(py_iso_str.to_string(), rust_iso_str);
+                    Ok(())
+                })?;
+            }
+
+            #[test]
+            fn test_duration_roundtrip(days in -999999999i64..=999999999i64) {
+                // Test roundtrip conversion rust->python->rust for all allowed
+                // python values of durations (from -999999999 to 999999999 days),
+                Python::attach(|py| {
+                    let dur = SignedDuration::new(days * 24 * 60 * 60, 0);
+                    let py_delta = dur.into_pyobject(py).unwrap();
+                    let roundtripped: SignedDuration = py_delta.extract().expect("Round trip");
+                    prop_assert_eq!(dur, roundtripped);
+                    Ok(())
+                })?;
+            }
+
+            #[test]
+            fn test_span_roundtrip(days in -999999999i64..=999999999i64) {
+                // Test roundtrip conversion rust->python->rust for all allowed
+                // python values of durations (from -999999999 to 999999999 days),
+                Python::attach(|py| {
+                    if let Ok(span) = Span::new().try_days(days) {
+                        let relative_to = SpanRelativeTo::days_are_24_hours();
+                        let jiff_duration = span.to_duration(relative_to).unwrap();
+                        let py_delta = jiff_duration.into_pyobject(py).unwrap();
+                        let roundtripped: Span = py_delta.extract().expect("Round trip");
+                        prop_assert_eq!(span.compare((roundtripped, relative_to)).unwrap(), Ordering::Equal);
+                    }
+                    Ok(())
+                })?;
+            }
+
+            #[test]
+            fn test_fixed_offset_roundtrip(secs in -86399i32..=86399i32) {
+                Python::attach(|py| {
+                    let offset = Offset::from_seconds(secs).unwrap();
+                    let py_offset = offset.into_pyobject(py).unwrap();
+                    let roundtripped: Offset = py_offset.extract().expect("Round trip");
+                    prop_assert_eq!(offset, roundtripped);
+                    Ok(())
+                })?;
+            }
+
+            #[test]
+            fn test_naive_date_roundtrip(
+                year in 1i16..=9999i16,
+                month in 1i8..=12i8,
+                day in 1i8..=31i8
+            ) {
+                // Test roundtrip conversion rust->python->rust for all allowed
+                // python dates (from year 1 to year 9999)
+                Python::attach(|py| {
+                    let date = try_date(year, month, day)?;
+                    let py_date = date.into_pyobject(py).unwrap();
+                    let roundtripped: Date = py_date.extract().expect("Round trip");
+                    prop_assert_eq!(date, roundtripped);
+                    Ok(())
+                })?;
+            }
+
+            #[test]
+            fn test_weekdate_roundtrip(
+                year in 1i16..=9999i16,
+                month in 1i8..=12i8,
+                day in 1i8..=31i8
+            ) {
+                // Test roundtrip conversion rust->python->rust for all allowed
+                // python dates (from year 1 to year 9999)
+                Python::attach(|py| {
+                    let weekdate = try_date(year, month, day)?.iso_week_date();
+                    let py_date = weekdate.into_pyobject(py).unwrap();
+                    let roundtripped = py_date.extract::<ISOWeekDate>().expect("Round trip");
+                    prop_assert_eq!(weekdate, roundtripped);
+                    Ok(())
+                })?;
+            }
+
+            #[test]
+            fn test_naive_time_roundtrip(
+                hour in 0i8..=23i8,
+                min in 0i8..=59i8,
+                sec in 0i8..=59i8,
+                micro in 0i32..=999_999i32
+            ) {
+                Python::attach(|py| {
+                    let time = try_time(hour, min, sec, micro)?;
+                    let py_time = time.into_pyobject(py).unwrap();
+                    let roundtripped: Time = py_time.extract().expect("Round trip");
+                    prop_assert_eq!(time, roundtripped);
+                    Ok(())
+                })?;
+            }
+
+            #[test]
+            fn test_naive_datetime_roundtrip(
+                year in 1i16..=9999i16,
+                month in 1i8..=12i8,
+                day in 1i8..=31i8,
+                hour in 0i8..=23i8,
+                min in 0i8..=59i8,
+                sec in 0i8..=59i8,
+                micro in 0i32..=999_999i32
+            ) {
+                Python::attach(|py| {
+                    let date = try_date(year, month, day)?;
+                    let time = try_time(hour, min, sec, micro)?;
+                    let dt = DateTime::from_parts(date, time);
+                    let pydt = dt.into_pyobject(py).unwrap();
+                    let roundtripped: DateTime = pydt.extract().expect("Round trip");
+                    prop_assert_eq!(dt, roundtripped);
+                    Ok(())
+                })?;
+            }
+
+            #[test]
+            fn test_utc_datetime_roundtrip(
+                year in 1i16..=9999i16,
+                month in 1i8..=12i8,
+                day in 1i8..=31i8,
+                hour in 0i8..=23i8,
+                min in 0i8..=59i8,
+                sec in 0i8..=59i8,
+                micro in 0i32..=999_999i32
+            ) {
+                Python::attach(|py| {
+                    let dt: Zoned = try_zoned(year, month, day, hour, min, sec, micro, TimeZone::UTC)?;
+                    let py_dt = (&dt).into_pyobject(py).unwrap();
+                    let roundtripped: Zoned = py_dt.extract().expect("Round trip");
+                    prop_assert_eq!(dt, roundtripped);
+                    Ok(())
+                })?;
+            }
+
+            #[test]
+            fn test_fixed_offset_datetime_roundtrip(
+                year in 1i16..=9999i16,
+                month in 1i8..=12i8,
+                day in 1i8..=31i8,
+                hour in 0i8..=23i8,
+                min in 0i8..=59i8,
+                sec in 0i8..=59i8,
+                micro in 0i32..=999_999i32,
+                offset_secs in -86399i32..=86399i32
+            ) {
+                Python::attach(|py| {
+                    let offset = Offset::from_seconds(offset_secs).unwrap();
+                    let dt = try_zoned(year, month, day, hour, min, sec, micro, offset.to_time_zone())?;
+                    let py_dt = (&dt).into_pyobject(py).unwrap();
+                    let roundtripped: Zoned = py_dt.extract().expect("Round trip");
+                    prop_assert_eq!(dt, roundtripped);
+                    Ok(())
+                })?;
+            }
+
+            #[test]
+            #[cfg(all(Py_3_9, not(windows)))]
+            fn test_zoned_datetime_roundtrip_around_timezone_transition(
+                (timezone, transition) in prop_oneof![
+                                Just(&TimeZone::get("Europe/London").unwrap()),
+                                Just(&TimeZone::get("America/New_York").unwrap()),
+                                Just(&TimeZone::get("Australia/Sydney").unwrap()),
+                            ].prop_flat_map(|tz| (Just(tz), timezone_transitions(tz))),
+                hour in -2i32..=2i32,
+                min in 0u32..=59u32,
+            ) {
+                Python::attach(|py| {
+                    let transition_moment = transition.timestamp();
+                    let zoned = (transition_moment - Span::new().hours(hour).minutes(min))
+                        .to_zoned(timezone.clone());
+
+                    let py_dt = (&zoned).into_pyobject(py).unwrap();
+                    let roundtripped: Zoned = py_dt.extract().expect("Round trip");
+                    prop_assert_eq!(zoned, roundtripped);
+                    Ok(())
+                })?;
+            }
+        }
+    }
+}
diff --git a/src/conversions/mod.rs b/src/conversions/mod.rs
index 3d785c02381..921e4ea40c6 100644
--- a/src/conversions/mod.rs
+++ b/src/conversions/mod.rs
@@ -1,15 +1,22 @@
 //! This module contains conversions between various Rust object and their representation in Python.
 
 pub mod anyhow;
+pub mod bigdecimal;
+pub mod bytes;
 pub mod chrono;
 pub mod chrono_tz;
 pub mod either;
 pub mod eyre;
 pub mod hashbrown;
 pub mod indexmap;
+pub mod jiff;
 pub mod num_bigint;
 pub mod num_complex;
+pub mod num_rational;
+pub mod ordered_float;
 pub mod rust_decimal;
 pub mod serde;
 pub mod smallvec;
-mod std;
+pub(crate) mod std;
+pub mod time;
+pub mod uuid;
diff --git a/src/conversions/num_bigint.rs b/src/conversions/num_bigint.rs
index ff5bd0309bd..1be763070dd 100644
--- a/src/conversions/num_bigint.rs
+++ b/src/conversions/num_bigint.rs
@@ -21,7 +21,7 @@
 //! Using [`BigInt`] to correctly increment an arbitrary precision integer.
 //! This is not possible with Rust's native integers if the Python integer is too large,
 //! in which case it will fail its conversion and raise `OverflowError`.
-//! ```rust
+//! ```rust,no_run
 //! use num_bigint::BigInt;
 //! use pyo3::prelude::*;
 //!
@@ -31,7 +31,7 @@
 //! }
 //!
 //! #[pymodule]
-//! fn my_module(_py: Python<'_>, m: &PyModule) -> PyResult<()> {
+//! fn my_module(m: &Bound<'_, PyModule>) -> PyResult<()> {
 //!     m.add_function(wrap_pyfunction!(add_one, m)?)?;
 //!     Ok(())
 //! }
@@ -48,12 +48,10 @@
 //! ```
 
 #[cfg(Py_LIMITED_API)]
-use crate::types::bytes::PyBytesMethods;
+use crate::types::{bytes::PyBytesMethods, PyBytes};
 use crate::{
-    ffi,
-    instance::Bound,
-    types::{any::PyAnyMethods, *},
-    FromPyObject, IntoPy, Py, PyAny, PyObject, PyResult, Python, ToPyObject,
+    conversion::IntoPyObject, ffi, types::PyInt, Borrowed, Bound, FromPyObject, Py, PyAny, PyErr,
+    PyResult, Python,
 };
 
 use num_bigint::{BigInt, BigUint};
@@ -63,77 +61,87 @@ use num_bigint::Sign;
 
 // for identical functionality between BigInt and BigUint
 macro_rules! bigint_conversion {
-    ($rust_ty: ty, $is_signed: expr, $to_bytes: path) => {
+    ($rust_ty: ty, $is_signed: literal) => {
         #[cfg_attr(docsrs, doc(cfg(feature = "num-bigint")))]
-        impl ToPyObject for $rust_ty {
-            #[cfg(not(Py_LIMITED_API))]
-            fn to_object(&self, py: Python<'_>) -> PyObject {
-                let bytes = $to_bytes(self);
-                unsafe {
-                    let obj = ffi::_PyLong_FromByteArray(
-                        bytes.as_ptr().cast(),
-                        bytes.len(),
-                        1,
-                        $is_signed,
-                    );
-                    PyObject::from_owned_ptr(py, obj)
-                }
-            }
+        impl<'py> IntoPyObject<'py> for $rust_ty {
+            type Target = PyInt;
+            type Output = Bound<'py, Self::Target>;
+            type Error = PyErr;
 
-            #[cfg(Py_LIMITED_API)]
-            fn to_object(&self, py: Python<'_>) -> PyObject {
-                let bytes = $to_bytes(self);
-                let bytes_obj = PyBytes::new_bound(py, &bytes);
-                let kwargs = if $is_signed > 0 {
-                    let kwargs = PyDict::new_bound(py);
-                    kwargs.set_item(crate::intern!(py, "signed"), true).unwrap();
-                    Some(kwargs)
-                } else {
-                    None
-                };
-                py.get_type::<PyLong>()
-                    .call_method(
-                        "from_bytes",
-                        (bytes_obj, "little"),
-                        kwargs.as_ref().map(crate::Bound::as_gil_ref),
-                    )
-                    .expect("int.from_bytes() failed during to_object()") // FIXME: #1813 or similar
-                    .into()
+            #[inline]
+            fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+                (&self).into_pyobject(py)
             }
         }
 
         #[cfg_attr(docsrs, doc(cfg(feature = "num-bigint")))]
-        impl IntoPy<PyObject> for $rust_ty {
-            fn into_py(self, py: Python<'_>) -> PyObject {
-                self.to_object(py)
+        impl<'py> IntoPyObject<'py> for &$rust_ty {
+            type Target = PyInt;
+            type Output = Bound<'py, Self::Target>;
+            type Error = PyErr;
+
+            fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+                use num_traits::ToBytes;
+
+                #[cfg(all(not(Py_LIMITED_API), Py_3_13))]
+                {
+                    use crate::conversions::std::num::int_from_ne_bytes;
+                    let bytes = self.to_ne_bytes();
+                    Ok(int_from_ne_bytes::<{ $is_signed }>(py, &bytes))
+                }
+
+                #[cfg(all(not(Py_LIMITED_API), not(Py_3_13)))]
+                {
+                    use crate::conversions::std::num::int_from_le_bytes;
+                    let bytes = self.to_le_bytes();
+                    Ok(int_from_le_bytes::<{ $is_signed }>(py, &bytes))
+                }
+
+                #[cfg(Py_LIMITED_API)]
+                {
+                    use $crate::py_result_ext::PyResultExt;
+                    use $crate::types::any::PyAnyMethods;
+                    let bytes = self.to_le_bytes();
+                    let bytes_obj = PyBytes::new(py, &bytes);
+                    let kwargs = if $is_signed {
+                        let kwargs = crate::types::PyDict::new(py);
+                        kwargs.set_item(crate::intern!(py, "signed"), true)?;
+                        Some(kwargs)
+                    } else {
+                        None
+                    };
+                    unsafe {
+                        py.get_type::<PyInt>()
+                            .call_method("from_bytes", (bytes_obj, "little"), kwargs.as_ref())
+                            .cast_into_unchecked()
+                    }
+                }
             }
         }
     };
 }
 
-bigint_conversion!(BigUint, 0, BigUint::to_bytes_le);
-bigint_conversion!(BigInt, 1, BigInt::to_signed_bytes_le);
+bigint_conversion!(BigUint, false);
+bigint_conversion!(BigInt, true);
 
 #[cfg_attr(docsrs, doc(cfg(feature = "num-bigint")))]
-impl<'py> FromPyObject<'py> for BigInt {
-    fn extract_bound(ob: &Bound<'py, PyAny>) -> PyResult<BigInt> {
+impl<'py> FromPyObject<'_, 'py> for BigInt {
+    type Error = PyErr;
+
+    fn extract(ob: Borrowed<'_, 'py, PyAny>) -> Result<BigInt, Self::Error> {
         let py = ob.py();
         // fast path - checking for subclass of `int` just checks a bit in the type object
-        let num_owned: Py<PyLong>;
-        let num = if let Ok(long) = ob.downcast::<PyLong>() {
+        let num_owned: Py<PyInt>;
+        let num = if let Ok(long) = ob.cast::<PyInt>() {
             long
         } else {
             num_owned = unsafe { Py::from_owned_ptr_or_err(py, ffi::PyNumber_Index(ob.as_ptr()))? };
-            num_owned.bind(py)
+            num_owned.bind_borrowed(py)
         };
-        let n_bits = int_n_bits(num)?;
-        if n_bits == 0 {
-            return Ok(BigInt::from(0isize));
-        }
         #[cfg(not(Py_LIMITED_API))]
         {
-            let mut buffer = int_to_u32_vec(num, (n_bits + 32) / 32, true)?;
-            let sign = if buffer.last().copied().map_or(false, |last| last >> 31 != 0) {
+            let mut buffer = int_to_u32_vec::<true>(&num)?;
+            let sign = if buffer.last().copied().is_some_and(|last| last >> 31 != 0) {
                 // BigInt::new takes an unsigned array, so need to convert from two's complement
                 // flip all bits, 'subtract' 1 (by adding one to the unsigned array)
                 let mut elements = buffer.iter_mut();
@@ -156,49 +164,61 @@ impl<'py> FromPyObject<'py> for BigInt {
         }
         #[cfg(Py_LIMITED_API)]
         {
-            let bytes = int_to_py_bytes(num, (n_bits + 8) / 8, true)?;
+            let n_bits = int_n_bits(&num)?;
+            if n_bits == 0 {
+                return Ok(BigInt::from(0isize));
+            }
+            let bytes = int_to_py_bytes(&num, (n_bits + 8) / 8, true)?;
             Ok(BigInt::from_signed_bytes_le(bytes.as_bytes()))
         }
     }
 }
 
 #[cfg_attr(docsrs, doc(cfg(feature = "num-bigint")))]
-impl<'py> FromPyObject<'py> for BigUint {
-    fn extract_bound(ob: &Bound<'py, PyAny>) -> PyResult<BigUint> {
+impl<'py> FromPyObject<'_, 'py> for BigUint {
+    type Error = PyErr;
+
+    fn extract(ob: Borrowed<'_, 'py, PyAny>) -> Result<BigUint, Self::Error> {
         let py = ob.py();
         // fast path - checking for subclass of `int` just checks a bit in the type object
-        let num_owned: Py<PyLong>;
-        let num = if let Ok(long) = ob.downcast::<PyLong>() {
+        let num_owned: Py<PyInt>;
+        let num = if let Ok(long) = ob.cast::<PyInt>() {
             long
         } else {
             num_owned = unsafe { Py::from_owned_ptr_or_err(py, ffi::PyNumber_Index(ob.as_ptr()))? };
-            num_owned.bind(py)
+            num_owned.bind_borrowed(py)
         };
-        let n_bits = int_n_bits(num)?;
-        if n_bits == 0 {
-            return Ok(BigUint::from(0usize));
-        }
         #[cfg(not(Py_LIMITED_API))]
         {
-            let buffer = int_to_u32_vec(num, (n_bits + 31) / 32, false)?;
+            let buffer = int_to_u32_vec::<false>(&num)?;
             Ok(BigUint::new(buffer))
         }
         #[cfg(Py_LIMITED_API)]
         {
-            let bytes = int_to_py_bytes(num, (n_bits + 7) / 8, false)?;
+            let n_bits = int_n_bits(&num)?;
+            if n_bits == 0 {
+                return Ok(BigUint::from(0usize));
+            }
+            let bytes = int_to_py_bytes(&num, n_bits.div_ceil(8), false)?;
             Ok(BigUint::from_bytes_le(bytes.as_bytes()))
         }
     }
 }
 
-#[cfg(not(Py_LIMITED_API))]
+#[cfg(not(any(Py_LIMITED_API, Py_3_13)))]
 #[inline]
-fn int_to_u32_vec(
-    long: &Bound<'_, PyLong>,
-    n_digits: usize,
-    is_signed: bool,
-) -> PyResult<Vec<u32>> {
-    let mut buffer = Vec::with_capacity(n_digits);
+fn int_to_u32_vec<const SIGNED: bool>(long: &Bound<'_, PyInt>) -> PyResult<Vec<u32>> {
+    let mut buffer = Vec::new();
+    let n_bits = int_n_bits(long)?;
+    if n_bits == 0 {
+        return Ok(buffer);
+    }
+    let n_digits = if SIGNED {
+        (n_bits + 32) / 32
+    } else {
+        n_bits.div_ceil(32)
+    };
+    buffer.reserve_exact(n_digits);
     unsafe {
         crate::err::error_on_minusone(
             long.py(),
@@ -207,7 +227,7 @@ fn int_to_u32_vec(
                 buffer.as_mut_ptr() as *mut u8,
                 n_digits * 4,
                 1,
-                is_signed.into(),
+                SIGNED.into(),
             ),
         )?;
         buffer.set_len(n_digits)
@@ -219,16 +239,51 @@ fn int_to_u32_vec(
     Ok(buffer)
 }
 
+#[cfg(all(not(Py_LIMITED_API), Py_3_13))]
+#[inline]
+fn int_to_u32_vec<const SIGNED: bool>(long: &Bound<'_, PyInt>) -> PyResult<Vec<u32>> {
+    let mut buffer = Vec::new();
+    let mut flags = ffi::Py_ASNATIVEBYTES_LITTLE_ENDIAN;
+    if !SIGNED {
+        flags |= ffi::Py_ASNATIVEBYTES_UNSIGNED_BUFFER | ffi::Py_ASNATIVEBYTES_REJECT_NEGATIVE;
+    }
+    let n_bytes =
+        unsafe { ffi::PyLong_AsNativeBytes(long.as_ptr().cast(), std::ptr::null_mut(), 0, flags) };
+    let n_bytes_unsigned: usize = n_bytes
+        .try_into()
+        .map_err(|_| crate::PyErr::fetch(long.py()))?;
+    if n_bytes == 0 {
+        return Ok(buffer);
+    }
+    let n_digits = n_bytes_unsigned.div_ceil(4);
+    buffer.reserve_exact(n_digits);
+    unsafe {
+        ffi::PyLong_AsNativeBytes(
+            long.as_ptr().cast(),
+            buffer.as_mut_ptr().cast(),
+            (n_digits * 4).try_into().unwrap(),
+            flags,
+        );
+        buffer.set_len(n_digits);
+    };
+    buffer
+        .iter_mut()
+        .for_each(|chunk| *chunk = u32::from_le(*chunk));
+
+    Ok(buffer)
+}
+
 #[cfg(Py_LIMITED_API)]
 fn int_to_py_bytes<'py>(
-    long: &Bound<'py, PyLong>,
+    long: &Bound<'py, PyInt>,
     n_bytes: usize,
     is_signed: bool,
 ) -> PyResult<Bound<'py, PyBytes>> {
     use crate::intern;
+    use crate::types::any::PyAnyMethods;
     let py = long.py();
     let kwargs = if is_signed {
-        let kwargs = PyDict::new_bound(py);
+        let kwargs = crate::types::PyDict::new(py);
         kwargs.set_item(intern!(py, "signed"), true)?;
         Some(kwargs)
     } else {
@@ -239,11 +294,12 @@ fn int_to_py_bytes<'py>(
         (n_bytes, intern!(py, "little")),
         kwargs.as_ref(),
     )?;
-    Ok(bytes.downcast_into()?)
+    Ok(bytes.cast_into()?)
 }
 
 #[inline]
-fn int_n_bits(long: &Bound<'_, PyLong>) -> PyResult<usize> {
+#[cfg(any(not(Py_3_13), Py_LIMITED_API))]
+fn int_n_bits(long: &Bound<'_, PyInt>) -> PyResult<usize> {
     let py = long.py();
     #[cfg(not(Py_LIMITED_API))]
     {
@@ -258,6 +314,7 @@ fn int_n_bits(long: &Bound<'_, PyLong>) -> PyResult<usize> {
     #[cfg(Py_LIMITED_API)]
     {
         // slow path
+        use crate::types::PyAnyMethods;
         long.call_method0(crate::intern!(py, "bit_length"))
             .and_then(|any| any.extract())
     }
@@ -265,11 +322,11 @@ fn int_n_bits(long: &Bound<'_, PyLong>) -> PyResult<usize> {
 
 #[cfg(test)]
 mod tests {
-    use self::{any::PyAnyMethods, dict::PyDictMethods};
-
     use super::*;
-    use crate::types::{PyDict, PyModule};
+    use crate::test_utils::generate_unique_module_name;
+    use crate::types::{PyAnyMethods as _, PyDict, PyModule};
     use indoc::indoc;
+    use pyo3_ffi::c_str;
 
     fn rust_fib<T>() -> impl Iterator<Item = T>
     where
@@ -284,53 +341,53 @@ mod tests {
         })
     }
 
-    fn python_fib(py: Python<'_>) -> impl Iterator<Item = PyObject> + '_ {
-        let mut f0 = 1.to_object(py);
-        let mut f1 = 1.to_object(py);
+    fn python_fib(py: Python<'_>) -> impl Iterator<Item = Bound<'_, PyAny>> + '_ {
+        let mut f0 = 1i32.into_pyobject(py).unwrap().into_any();
+        let mut f1 = 1i32.into_pyobject(py).unwrap().into_any();
         std::iter::from_fn(move || {
-            let f2 = f0.call_method1(py, "__add__", (f1.as_ref(py),)).unwrap();
+            let f2 = f0.call_method1("__add__", (&f1,)).unwrap();
             Some(std::mem::replace(&mut f0, std::mem::replace(&mut f1, f2)))
         })
     }
 
     #[test]
     fn convert_biguint() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             // check the first 2000 numbers in the fibonacci sequence
             for (py_result, rs_result) in python_fib(py).zip(rust_fib::<BigUint>()).take(2000) {
                 // Python -> Rust
-                assert_eq!(py_result.extract::<BigUint>(py).unwrap(), rs_result);
+                assert_eq!(py_result.extract::<BigUint>().unwrap(), rs_result);
                 // Rust -> Python
-                assert!(py_result.as_ref(py).eq(rs_result).unwrap());
+                assert!(py_result.eq(rs_result).unwrap());
             }
         });
     }
 
     #[test]
     fn convert_bigint() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             // check the first 2000 numbers in the fibonacci sequence
             for (py_result, rs_result) in python_fib(py).zip(rust_fib::<BigInt>()).take(2000) {
                 // Python -> Rust
-                assert_eq!(py_result.extract::<BigInt>(py).unwrap(), rs_result);
+                assert_eq!(py_result.extract::<BigInt>().unwrap(), rs_result);
                 // Rust -> Python
-                assert!(py_result.as_ref(py).eq(&rs_result).unwrap());
+                assert!(py_result.eq(&rs_result).unwrap());
 
                 // negate
 
                 let rs_result = rs_result * -1;
-                let py_result = py_result.call_method0(py, "__neg__").unwrap();
+                let py_result = py_result.call_method0("__neg__").unwrap();
 
                 // Python -> Rust
-                assert_eq!(py_result.extract::<BigInt>(py).unwrap(), rs_result);
+                assert_eq!(py_result.extract::<BigInt>().unwrap(), rs_result);
                 // Rust -> Python
-                assert!(py_result.as_ref(py).eq(rs_result).unwrap());
+                assert!(py_result.eq(rs_result).unwrap());
             }
         });
     }
 
-    fn python_index_class(py: Python<'_>) -> &PyModule {
-        let index_code = indoc!(
+    fn python_index_class(py: Python<'_>) -> Bound<'_, PyModule> {
+        let index_code = c_str!(indoc!(
             r#"
                 class C:
                     def __init__(self, x):
@@ -338,25 +395,31 @@ mod tests {
                     def __index__(self):
                         return self.x
                 "#
-        );
-        PyModule::from_code(py, index_code, "index.py", "index").unwrap()
+        ));
+        PyModule::from_code(
+            py,
+            index_code,
+            c"index.py",
+            &generate_unique_module_name("index"),
+        )
+        .unwrap()
     }
 
     #[test]
     fn convert_index_class() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let index = python_index_class(py);
-            let locals = PyDict::new_bound(py);
+            let locals = PyDict::new(py);
             locals.set_item("index", index).unwrap();
-            let ob = py.eval_bound("index.C(10)", None, Some(&locals)).unwrap();
+            let ob = py.eval(c"index.C(10)", None, Some(&locals)).unwrap();
             let _: BigInt = ob.extract().unwrap();
         });
     }
 
     #[test]
     fn handle_zero() {
-        Python::with_gil(|py| {
-            let zero: BigInt = 0.to_object(py).extract(py).unwrap();
+        Python::attach(|py| {
+            let zero: BigInt = 0i32.into_pyobject(py).unwrap().extract().unwrap();
             assert_eq!(zero, BigInt::from(0));
         })
     }
@@ -364,13 +427,13 @@ mod tests {
     /// `OverflowError` on converting Python int to BigInt, see issue #629
     #[test]
     fn check_overflow() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             macro_rules! test {
                 ($T:ty, $value:expr, $py:expr) => {
                     let value = $value;
                     println!("{}: {}", stringify!($T), value);
-                    let python_value = value.clone().into_py(py);
-                    let roundtrip_value = python_value.extract::<$T>(py).unwrap();
+                    let python_value = value.clone().into_pyobject(py).unwrap();
+                    let roundtrip_value = python_value.extract::<$T>().unwrap();
                     assert_eq!(value, roundtrip_value);
                 };
             }
diff --git a/src/conversions/num_complex.rs b/src/conversions/num_complex.rs
index ba741323611..4464e1addc9 100644
--- a/src/conversions/num_complex.rs
+++ b/src/conversions/num_complex.rs
@@ -27,7 +27,7 @@
 //! ```ignore
 //! # // not tested because nalgebra isn't supported on msrv
 //! # // please file an issue if it breaks!
-//! use nalgebra::base::{dimension::Const, storage::Storage, Matrix};
+//! use nalgebra::base::{dimension::Const, Matrix};
 //! use num_complex::Complex;
 //! use pyo3::prelude::*;
 //!
@@ -44,7 +44,7 @@
 //! }
 //!
 //! #[pymodule]
-//! fn my_module(_py: Python<'_>, m: &PyModule) -> PyResult<()> {
+//! fn my_module(m: &Bound<'_, PyModule>) -> PyResult<()> {
 //!     m.add_function(wrap_pyfunction!(get_eigenvalues, m)?)?;
 //!     Ok(())
 //! }
@@ -54,15 +54,15 @@
 //! # use pyo3::types::PyComplex;
 //! #
 //! # fn main() -> PyResult<()> {
-//! #     Python::with_gil(|py| -> PyResult<()> {
+//! #     Python::attach(|py| -> PyResult<()> {
 //! #         let module = PyModule::new(py, "my_module")?;
 //! #
-//! #         module.add_function(wrap_pyfunction!(get_eigenvalues, module)?)?;
+//! #         module.add_function(&wrap_pyfunction!(get_eigenvalues, module)?)?;
 //! #
-//! #         let m11 = PyComplex::from_doubles_bound(py, 0_f64, -1_f64);
-//! #         let m12 = PyComplex::from_doubles_bound(py, 1_f64, 0_f64);
-//! #         let m21 = PyComplex::from_doubles_bound(py, 2_f64, -1_f64);
-//! #         let m22 = PyComplex::from_doubles_bound(py, -1_f64, 0_f64);
+//! #         let m11 = PyComplex::from_doubles(py, 0_f64, -1_f64);
+//! #         let m12 = PyComplex::from_doubles(py, 1_f64, 0_f64);
+//! #         let m21 = PyComplex::from_doubles(py, 2_f64, -1_f64);
+//! #         let m22 = PyComplex::from_doubles(py, -1_f64, 0_f64);
 //! #
 //! #         let result = module
 //! #             .getattr("get_eigenvalues")?
@@ -93,21 +93,23 @@
 //! result = get_eigenvalues(m11,m12,m21,m22)
 //! assert result == [complex(1,-1), complex(-2,0)]
 //! ```
-#[cfg(any(Py_LIMITED_API, PyPy))]
-use crate::types::any::PyAnyMethods;
 use crate::{
-    ffi, types::PyComplex, Bound, FromPyObject, PyAny, PyErr, PyObject, PyResult, Python,
-    ToPyObject,
+    ffi, ffi_ptr_ext::FfiPtrExt, types::PyComplex, Borrowed, Bound, FromPyObject, PyAny, PyErr,
+    Python,
 };
 use num_complex::Complex;
-use std::os::raw::c_double;
+use std::ffi::c_double;
 
 impl PyComplex {
     /// Creates a new Python `PyComplex` object from `num_complex`'s [`Complex`].
-    pub fn from_complex<F: Into<c_double>>(py: Python<'_>, complex: Complex<F>) -> &PyComplex {
+    pub fn from_complex_bound<F: Into<c_double>>(
+        py: Python<'_>,
+        complex: Complex<F>,
+    ) -> Bound<'_, PyComplex> {
         unsafe {
-            let ptr = ffi::PyComplex_FromDoubles(complex.re.into(), complex.im.into());
-            py.from_owned_ptr(ptr)
+            ffi::PyComplex_FromDoubles(complex.re.into(), complex.im.into())
+                .assume_owned(py)
+                .cast_into_unchecked()
         }
     }
 }
@@ -115,27 +117,39 @@ impl PyComplex {
 macro_rules! complex_conversion {
     ($float: ty) => {
         #[cfg_attr(docsrs, doc(cfg(feature = "num-complex")))]
-        impl ToPyObject for Complex<$float> {
-            #[inline]
-            fn to_object(&self, py: Python<'_>) -> PyObject {
-                crate::IntoPy::<PyObject>::into_py(self.to_owned(), py)
+        impl<'py> crate::conversion::IntoPyObject<'py> for Complex<$float> {
+            type Target = PyComplex;
+            type Output = Bound<'py, Self::Target>;
+            type Error = std::convert::Infallible;
+
+            fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+                unsafe {
+                    Ok(
+                        ffi::PyComplex_FromDoubles(self.re as c_double, self.im as c_double)
+                            .assume_owned(py)
+                            .cast_into_unchecked(),
+                    )
+                }
             }
         }
 
         #[cfg_attr(docsrs, doc(cfg(feature = "num-complex")))]
-        impl crate::IntoPy<PyObject> for Complex<$float> {
-            fn into_py(self, py: Python<'_>) -> PyObject {
-                unsafe {
-                    let raw_obj =
-                        ffi::PyComplex_FromDoubles(self.re as c_double, self.im as c_double);
-                    PyObject::from_owned_ptr(py, raw_obj)
-                }
+        impl<'py> crate::conversion::IntoPyObject<'py> for &Complex<$float> {
+            type Target = PyComplex;
+            type Output = Bound<'py, Self::Target>;
+            type Error = std::convert::Infallible;
+
+            #[inline]
+            fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+                (*self).into_pyobject(py)
             }
         }
 
         #[cfg_attr(docsrs, doc(cfg(feature = "num-complex")))]
-        impl FromPyObject<'_> for Complex<$float> {
-            fn extract_bound(obj: &Bound<'_, PyAny>) -> PyResult<Complex<$float>> {
+        impl FromPyObject<'_, '_> for Complex<$float> {
+            type Error = PyErr;
+
+            fn extract(obj: Borrowed<'_, '_, PyAny>) -> Result<Complex<$float>, Self::Error> {
                 #[cfg(not(any(Py_LIMITED_API, PyPy)))]
                 unsafe {
                     let val = ffi::PyComplex_AsCComplex(obj.as_ptr());
@@ -149,6 +163,7 @@ macro_rules! complex_conversion {
 
                 #[cfg(any(Py_LIMITED_API, PyPy))]
                 unsafe {
+                    use $crate::types::any::PyAnyMethods;
                     let complex;
                     let obj = if obj.is_instance_of::<PyComplex>() {
                         obj
@@ -156,7 +171,7 @@ macro_rules! complex_conversion {
                         obj.lookup_special(crate::intern!(obj.py(), "__complex__"))?
                     {
                         complex = method.call0()?;
-                        &complex
+                        complex.as_borrowed()
                     } else {
                         // `obj` might still implement `__float__` or `__index__`, which will be
                         // handled by `PyComplex_{Real,Imag}AsDouble`, including propagating any
@@ -183,38 +198,41 @@ complex_conversion!(f64);
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::types::PyModule;
+    use crate::test_utils::generate_unique_module_name;
+    use crate::types::PyAnyMethods as _;
+    use crate::types::{complex::PyComplexMethods, PyModule};
+    use crate::IntoPyObject;
 
     #[test]
     fn from_complex() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let complex = Complex::new(3.0, 1.2);
-            let py_c = PyComplex::from_complex(py, complex);
+            let py_c = PyComplex::from_complex_bound(py, complex);
             assert_eq!(py_c.real(), 3.0);
             assert_eq!(py_c.imag(), 1.2);
         });
     }
     #[test]
     fn to_from_complex() {
-        Python::with_gil(|py| {
-            let val = Complex::new(3.0, 1.2);
-            let obj = val.to_object(py);
-            assert_eq!(obj.extract::<Complex<f64>>(py).unwrap(), val);
+        Python::attach(|py| {
+            let val = Complex::new(3.0f64, 1.2);
+            let obj = val.into_pyobject(py).unwrap();
+            assert_eq!(obj.extract::<Complex<f64>>().unwrap(), val);
         });
     }
     #[test]
     fn from_complex_err() {
-        Python::with_gil(|py| {
-            let obj = vec![1].to_object(py);
-            assert!(obj.extract::<Complex<f64>>(py).is_err());
+        Python::attach(|py| {
+            let obj = vec![1i32].into_pyobject(py).unwrap();
+            assert!(obj.extract::<Complex<f64>>().is_err());
         });
     }
     #[test]
     fn from_python_magic() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let module = PyModule::from_code(
                 py,
-                r#"
+                cr#"
 class A:
     def __complex__(self): return 3.0+1.2j
 class B:
@@ -222,8 +240,8 @@ class B:
 class C:
     def __index__(self): return 3
                 "#,
-                "test.py",
-                "test",
+                c"test.py",
+                &generate_unique_module_name("test"),
             )
             .unwrap();
             let from_complex = module.getattr("A").unwrap().call0().unwrap();
@@ -249,10 +267,10 @@ class C:
     }
     #[test]
     fn from_python_inherited_magic() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let module = PyModule::from_code(
                 py,
-                r#"
+                cr#"
 class First: pass
 class ComplexMixin:
     def __complex__(self): return 3.0+1.2j
@@ -264,8 +282,8 @@ class A(First, ComplexMixin): pass
 class B(First, FloatMixin): pass
 class C(First, IndexMixin): pass
                 "#,
-                "test.py",
-                "test",
+                c"test.py",
+                &generate_unique_module_name("test"),
             )
             .unwrap();
             let from_complex = module.getattr("A").unwrap().call0().unwrap();
@@ -293,17 +311,17 @@ class C(First, IndexMixin): pass
         // Functions and lambdas implement the descriptor protocol in a way that makes
         // `type(inst).attr(inst)` equivalent to `inst.attr()` for methods, but this isn't the only
         // way the descriptor protocol might be implemented.
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let module = PyModule::from_code(
                 py,
-                r#"
+                cr#"
 class A:
     @property
     def __complex__(self):
         return lambda: 3.0+1.2j
                 "#,
-                "test.py",
-                "test",
+                c"test.py",
+                &generate_unique_module_name("test"),
             )
             .unwrap();
             let obj = module.getattr("A").unwrap().call0().unwrap();
@@ -316,17 +334,17 @@ class A:
     #[test]
     fn from_python_nondescriptor_magic() {
         // Magic methods don't need to implement the descriptor protocol, if they're callable.
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let module = PyModule::from_code(
                 py,
-                r#"
+                cr#"
 class MyComplex:
     def __call__(self): return 3.0+1.2j
 class A:
     __complex__ = MyComplex()
                 "#,
-                "test.py",
-                "test",
+                c"test.py",
+                &generate_unique_module_name("test"),
             )
             .unwrap();
             let obj = module.getattr("A").unwrap().call0().unwrap();
diff --git a/src/conversions/num_rational.rs b/src/conversions/num_rational.rs
new file mode 100644
index 00000000000..c15b81b6174
--- /dev/null
+++ b/src/conversions/num_rational.rs
@@ -0,0 +1,266 @@
+#![cfg(feature = "num-rational")]
+//! Conversions to and from [num-rational](https://docs.rs/num-rational) types.
+//!
+//! This is useful for converting between Python's [fractions.Fraction](https://docs.python.org/3/library/fractions.html) into and from a native Rust
+//! type.
+//!
+//!
+//! To use this feature, add to your **`Cargo.toml`**:
+//!
+//! ```toml
+//! [dependencies]
+#![doc = concat!("pyo3 = { version = \"", env!("CARGO_PKG_VERSION"),  "\", features = [\"num-rational\"] }")]
+//! num-rational = "0.4.1"
+//! ```
+//!
+//! # Example
+//!
+//! Rust code to create a function that adds five to a fraction:
+//!
+//! ```rust,no_run
+//! use num_rational::Ratio;
+//! use pyo3::prelude::*;
+//!
+//! #[pyfunction]
+//! fn add_five_to_fraction(fraction: Ratio<i32>) -> Ratio<i32> {
+//!     fraction + Ratio::new(5, 1)
+//! }
+//!
+//! #[pymodule]
+//! fn my_module(m: &Bound<'_, PyModule>) -> PyResult<()> {
+//!     m.add_function(wrap_pyfunction!(add_five_to_fraction, m)?)?;
+//!     Ok(())
+//! }
+//! ```
+//!
+//! Python code that validates the functionality:
+//! ```python
+//! from my_module import add_five_to_fraction
+//! from fractions import Fraction
+//!
+//! fraction = Fraction(2,1)
+//! fraction_plus_five = add_five_to_fraction(f)
+//! assert fraction + 5 == fraction_plus_five
+//! ```
+
+use crate::conversion::IntoPyObject;
+use crate::ffi;
+use crate::sync::PyOnceLock;
+use crate::types::any::PyAnyMethods;
+use crate::types::PyType;
+use crate::{Borrowed, Bound, FromPyObject, Py, PyAny, PyErr, PyResult, Python};
+
+#[cfg(feature = "num-bigint")]
+use num_bigint::BigInt;
+use num_rational::Ratio;
+
+static FRACTION_CLS: PyOnceLock<Py<PyType>> = PyOnceLock::new();
+
+fn get_fraction_cls(py: Python<'_>) -> PyResult<&Bound<'_, PyType>> {
+    FRACTION_CLS.import(py, "fractions", "Fraction")
+}
+
+macro_rules! rational_conversion {
+    ($int: ty) => {
+        impl<'py> FromPyObject<'_, 'py> for Ratio<$int> {
+            type Error = PyErr;
+
+            fn extract(obj: Borrowed<'_, 'py, PyAny>) -> Result<Self, Self::Error> {
+                let py = obj.py();
+                let py_numerator_obj = obj.getattr(crate::intern!(py, "numerator"))?;
+                let py_denominator_obj = obj.getattr(crate::intern!(py, "denominator"))?;
+                let numerator_owned = unsafe {
+                    Bound::from_owned_ptr_or_err(py, ffi::PyNumber_Long(py_numerator_obj.as_ptr()))?
+                };
+                let denominator_owned = unsafe {
+                    Bound::from_owned_ptr_or_err(
+                        py,
+                        ffi::PyNumber_Long(py_denominator_obj.as_ptr()),
+                    )?
+                };
+                let rs_numerator: $int = numerator_owned.extract()?;
+                let rs_denominator: $int = denominator_owned.extract()?;
+                Ok(Ratio::new(rs_numerator, rs_denominator))
+            }
+        }
+
+        impl<'py> IntoPyObject<'py> for Ratio<$int> {
+            type Target = PyAny;
+            type Output = Bound<'py, Self::Target>;
+            type Error = PyErr;
+
+            #[inline]
+            fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+                (&self).into_pyobject(py)
+            }
+        }
+
+        impl<'py> IntoPyObject<'py> for &Ratio<$int> {
+            type Target = PyAny;
+            type Output = Bound<'py, Self::Target>;
+            type Error = PyErr;
+
+            fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+                get_fraction_cls(py)?.call1((self.numer().clone(), self.denom().clone()))
+            }
+        }
+    };
+}
+rational_conversion!(i8);
+rational_conversion!(i16);
+rational_conversion!(i32);
+rational_conversion!(isize);
+rational_conversion!(i64);
+#[cfg(feature = "num-bigint")]
+rational_conversion!(BigInt);
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::types::dict::PyDictMethods;
+    use crate::types::PyDict;
+
+    #[cfg(not(target_arch = "wasm32"))]
+    use proptest::prelude::*;
+    #[test]
+    fn test_negative_fraction() {
+        Python::attach(|py| {
+            let locals = PyDict::new(py);
+            py.run(
+                c"import fractions\npy_frac = fractions.Fraction(-0.125)",
+                None,
+                Some(&locals),
+            )
+            .unwrap();
+            let py_frac = locals.get_item("py_frac").unwrap().unwrap();
+            let roundtripped: Ratio<i32> = py_frac.extract().unwrap();
+            let rs_frac = Ratio::new(-1, 8);
+            assert_eq!(roundtripped, rs_frac);
+        })
+    }
+    #[test]
+    fn test_obj_with_incorrect_atts() {
+        Python::attach(|py| {
+            let locals = PyDict::new(py);
+            py.run(
+                c"not_fraction = \"contains_incorrect_atts\"",
+                None,
+                Some(&locals),
+            )
+            .unwrap();
+            let py_frac = locals.get_item("not_fraction").unwrap().unwrap();
+            assert!(py_frac.extract::<Ratio<i32>>().is_err());
+        })
+    }
+
+    #[test]
+    fn test_fraction_with_fraction_type() {
+        Python::attach(|py| {
+            let locals = PyDict::new(py);
+            py.run(
+                c"import fractions\npy_frac = fractions.Fraction(fractions.Fraction(10))",
+                None,
+                Some(&locals),
+            )
+            .unwrap();
+            let py_frac = locals.get_item("py_frac").unwrap().unwrap();
+            let roundtripped: Ratio<i32> = py_frac.extract().unwrap();
+            let rs_frac = Ratio::new(10, 1);
+            assert_eq!(roundtripped, rs_frac);
+        })
+    }
+
+    #[test]
+    fn test_fraction_with_decimal() {
+        Python::attach(|py| {
+            let locals = PyDict::new(py);
+            py.run(
+                c"import fractions\n\nfrom decimal import Decimal\npy_frac = fractions.Fraction(Decimal(\"1.1\"))",
+                None,
+                Some(&locals),
+            )
+            .unwrap();
+            let py_frac = locals.get_item("py_frac").unwrap().unwrap();
+            let roundtripped: Ratio<i32> = py_frac.extract().unwrap();
+            let rs_frac = Ratio::new(11, 10);
+            assert_eq!(roundtripped, rs_frac);
+        })
+    }
+
+    #[test]
+    fn test_fraction_with_num_den() {
+        Python::attach(|py| {
+            let locals = PyDict::new(py);
+            py.run(
+                c"import fractions\npy_frac = fractions.Fraction(10,5)",
+                None,
+                Some(&locals),
+            )
+            .unwrap();
+            let py_frac = locals.get_item("py_frac").unwrap().unwrap();
+            let roundtripped: Ratio<i32> = py_frac.extract().unwrap();
+            let rs_frac = Ratio::new(10, 5);
+            assert_eq!(roundtripped, rs_frac);
+        })
+    }
+
+    #[cfg(target_arch = "wasm32")]
+    #[test]
+    fn test_int_roundtrip() {
+        Python::attach(|py| {
+            let rs_frac = Ratio::new(1i32, 2);
+            let py_frac = rs_frac.into_pyobject(py).unwrap();
+            let roundtripped: Ratio<i32> = py_frac.extract().unwrap();
+            assert_eq!(rs_frac, roundtripped);
+            // float conversion
+        })
+    }
+
+    #[cfg(target_arch = "wasm32")]
+    #[test]
+    fn test_big_int_roundtrip() {
+        Python::attach(|py| {
+            let rs_frac = Ratio::from_float(5.5).unwrap();
+            let py_frac = rs_frac.clone().into_pyobject(py).unwrap();
+            let roundtripped: Ratio<BigInt> = py_frac.extract().unwrap();
+            assert_eq!(rs_frac, roundtripped);
+        })
+    }
+
+    #[cfg(not(target_arch = "wasm32"))]
+    proptest! {
+        #[test]
+        fn test_int_roundtrip(num in any::<i32>(), den in any::<i32>()) {
+            Python::attach(|py| {
+                let rs_frac = Ratio::new(num, den);
+                let py_frac = rs_frac.into_pyobject(py).unwrap();
+                let roundtripped: Ratio<i32> = py_frac.extract().unwrap();
+                assert_eq!(rs_frac, roundtripped);
+            })
+        }
+
+        #[test]
+        #[cfg(feature = "num-bigint")]
+        fn test_big_int_roundtrip(num in any::<f32>()) {
+            Python::attach(|py| {
+                let rs_frac = Ratio::from_float(num).unwrap();
+                let py_frac = rs_frac.clone().into_pyobject(py).unwrap();
+                let roundtripped: Ratio<BigInt> = py_frac.extract().unwrap();
+                assert_eq!(roundtripped, rs_frac);
+            })
+        }
+
+    }
+
+    #[test]
+    fn test_infinity() {
+        Python::attach(|py| {
+            let locals = PyDict::new(py);
+            let py_bound = py.run(
+                c"import fractions\npy_frac = fractions.Fraction(\"Infinity\")",
+                None,
+                Some(&locals),
+            );
+            assert!(py_bound.is_err());
+        })
+    }
+}
diff --git a/src/conversions/ordered_float.rs b/src/conversions/ordered_float.rs
new file mode 100644
index 00000000000..1ddc057120a
--- /dev/null
+++ b/src/conversions/ordered_float.rs
@@ -0,0 +1,332 @@
+#![cfg(feature = "ordered-float")]
+//! Conversions to and from [ordered-float](https://docs.rs/ordered-float) types.
+//! [`NotNan`]`<`[`f32`]`>` and [`NotNan`]`<`[`f64`]`>`.
+//! [`OrderedFloat`]`<`[`f32`]`>` and [`OrderedFloat`]`<`[`f64`]`>`.
+//!
+//! This is useful for converting between Python's float into and from a native Rust type.
+//!
+//! Take care when comparing sorted collections of float types between Python and Rust.
+//! They will likely differ due to the ambiguous sort order of NaNs in Python.
+//
+//!
+//! To use this feature, add to your **`Cargo.toml`**:
+//!
+//! ```toml
+//! [dependencies]
+#![doc = concat!("pyo3 = { version = \"", env!("CARGO_PKG_VERSION"),  "\", features = [\"ordered-float\"] }")]
+//! ordered-float = "5.0.0"
+//! ```
+//!
+//! # Example
+//!
+//! Rust code to create functions that add ordered floats:
+//!
+//! ```rust,no_run
+//! use ordered_float::{NotNan, OrderedFloat};
+//! use pyo3::prelude::*;
+//!
+//! #[pyfunction]
+//! fn add_not_nans(a: NotNan<f64>, b: NotNan<f64>) -> NotNan<f64> {
+//!     a + b
+//! }
+//!
+//! #[pyfunction]
+//! fn add_ordered_floats(a: OrderedFloat<f64>, b: OrderedFloat<f64>) -> OrderedFloat<f64> {
+//!     a + b
+//! }
+//!
+//! #[pymodule]
+//! fn my_module(m: &Bound<'_, PyModule>) -> PyResult<()> {
+//!     m.add_function(wrap_pyfunction!(add_not_nans, m)?)?;
+//!     m.add_function(wrap_pyfunction!(add_ordered_floats, m)?)?;
+//!     Ok(())
+//! }
+//! ```
+//!
+//! Python code that validates the functionality:
+//! ```python
+//! from my_module import add_not_nans, add_ordered_floats
+//!
+//! assert add_not_nans(1.0,2.0) == 3.0
+//! assert add_ordered_floats(1.0,2.0) == 3.0
+//! ```
+
+use crate::conversion::IntoPyObject;
+use crate::exceptions::PyValueError;
+use crate::types::PyFloat;
+use crate::{Borrowed, Bound, FromPyObject, PyAny, Python};
+use ordered_float::{NotNan, OrderedFloat};
+use std::convert::Infallible;
+
+macro_rules! float_conversions {
+    ($wrapper:ident, $float_type:ty, $constructor:expr) => {
+        impl<'a, 'py> FromPyObject<'a, 'py> for $wrapper<$float_type> {
+            type Error = <$float_type as FromPyObject<'a, 'py>>::Error;
+
+            fn extract(obj: Borrowed<'a, 'py, PyAny>) -> Result<Self, Self::Error> {
+                let val: $float_type = obj.extract()?;
+                $constructor(val)
+            }
+        }
+
+        impl<'py> IntoPyObject<'py> for $wrapper<$float_type> {
+            type Target = PyFloat;
+            type Output = Bound<'py, Self::Target>;
+            type Error = Infallible;
+
+            fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+                self.into_inner().into_pyobject(py)
+            }
+        }
+
+        impl<'py> IntoPyObject<'py> for &$wrapper<$float_type> {
+            type Target = PyFloat;
+            type Output = Bound<'py, Self::Target>;
+            type Error = Infallible;
+
+            #[inline]
+            fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+                (*self).into_pyobject(py)
+            }
+        }
+    };
+}
+float_conversions!(OrderedFloat, f32, |val| Ok(OrderedFloat(val)));
+float_conversions!(OrderedFloat, f64, |val| Ok(OrderedFloat(val)));
+float_conversions!(NotNan, f32, |val| NotNan::new(val)
+    .map_err(|e| PyValueError::new_err(e.to_string())));
+float_conversions!(NotNan, f64, |val| NotNan::new(val)
+    .map_err(|e| PyValueError::new_err(e.to_string())));
+
+#[cfg(test)]
+mod test_ordered_float {
+    use super::*;
+    use crate::py_run;
+    use crate::types::PyAnyMethods;
+
+    #[cfg(not(target_arch = "wasm32"))]
+    use proptest::prelude::*;
+
+    macro_rules! float_roundtrip_tests {
+        ($wrapper:ident, $float_type:ty, $constructor:expr, $standard_test:ident, $wasm_test:ident, $infinity_test:ident, $zero_test:ident) => {
+            #[cfg(not(target_arch = "wasm32"))]
+            proptest! {
+            #[test]
+            fn $standard_test(inner_f: $float_type) {
+                let f = $constructor(inner_f);
+
+                Python::attach(|py| {
+                    let f_py: Bound<'_, PyFloat>  = f.into_pyobject(py).unwrap();
+
+                    py_run!(
+                        py,
+                        f_py,
+                        &format!(
+                            "import math\nassert math.isclose(f_py, {})",
+                             inner_f as f64 // Always interpret the literal rs float value as f64
+                                            // so that it's comparable with the python float
+                        )
+                    );
+
+                    let roundtripped_f: $wrapper<$float_type> = f_py.extract().unwrap();
+
+                    assert_eq!(f, roundtripped_f);
+                })
+            }
+            }
+
+            #[cfg(target_arch = "wasm32")]
+            #[test]
+            fn $wasm_test() {
+                let inner_f = 10.0;
+                let f = $constructor(inner_f);
+
+                Python::attach(|py| {
+                    let f_py: Bound<'_, PyFloat>  = f.into_pyobject(py).unwrap();
+
+                    py_run!(
+                        py,
+                        f_py,
+                        &format!(
+                            "import math\nassert math.isclose(f_py, {})",
+                            inner_f as f64 // Always interpret the literal rs float value as f64
+                                           // so that it's comparable with the python float
+                        )
+                    );
+
+                    let roundtripped_f: $wrapper<$float_type> = f_py.extract().unwrap();
+
+                    assert_eq!(f, roundtripped_f);
+                })
+            }
+
+            #[test]
+            fn $infinity_test() {
+                let inner_pinf = <$float_type>::INFINITY;
+                let pinf = $constructor(inner_pinf);
+
+                let inner_ninf = <$float_type>::NEG_INFINITY;
+                let ninf = $constructor(inner_ninf);
+
+                Python::attach(|py| {
+                    let pinf_py: Bound<'_, PyFloat>  = pinf.into_pyobject(py).unwrap();
+                    let ninf_py: Bound<'_, PyFloat>  = ninf.into_pyobject(py).unwrap();
+
+                    py_run!(
+                        py,
+                        pinf_py ninf_py,
+                        "\
+                        assert pinf_py == float('inf')\n\
+                        assert ninf_py == float('-inf')"
+                    );
+
+                    let roundtripped_pinf: $wrapper<$float_type> = pinf_py.extract().unwrap();
+                    let roundtripped_ninf: $wrapper<$float_type> = ninf_py.extract().unwrap();
+
+                    assert_eq!(pinf, roundtripped_pinf);
+                    assert_eq!(ninf, roundtripped_ninf);
+                })
+            }
+
+            #[test]
+            fn $zero_test() {
+                let inner_pzero: $float_type = 0.0;
+                let pzero = $constructor(inner_pzero);
+
+                let inner_nzero: $float_type = -0.0;
+                let nzero = $constructor(inner_nzero);
+
+                Python::attach(|py| {
+                    let pzero_py: Bound<'_, PyFloat>  = pzero.into_pyobject(py).unwrap();
+                    let nzero_py: Bound<'_, PyFloat>  = nzero.into_pyobject(py).unwrap();
+
+                    // This python script verifies that the values are 0.0 in magnitude
+                    // and that the signs are correct(+0.0 vs -0.0)
+                    py_run!(
+                        py,
+                        pzero_py nzero_py,
+                        "\
+                        import math\n\
+                        assert pzero_py == 0.0\n\
+                        assert math.copysign(1.0, pzero_py) > 0.0\n\
+                        assert nzero_py == 0.0\n\
+                        assert math.copysign(1.0, nzero_py) < 0.0"
+                    );
+
+                    let roundtripped_pzero: $wrapper<$float_type> = pzero_py.extract().unwrap();
+                    let roundtripped_nzero: $wrapper<$float_type> = nzero_py.extract().unwrap();
+
+                    assert_eq!(pzero, roundtripped_pzero);
+                    assert_eq!(roundtripped_pzero.signum(), 1.0);
+                    assert_eq!(nzero, roundtripped_nzero);
+                    assert_eq!(roundtripped_nzero.signum(), -1.0);
+                })
+            }
+        };
+    }
+    float_roundtrip_tests!(
+        OrderedFloat,
+        f32,
+        OrderedFloat,
+        ordered_float_f32_standard,
+        ordered_float_f32_wasm,
+        ordered_float_f32_infinity,
+        ordered_float_f32_zero
+    );
+    float_roundtrip_tests!(
+        OrderedFloat,
+        f64,
+        OrderedFloat,
+        ordered_float_f64_standard,
+        ordered_float_f64_wasm,
+        ordered_float_f64_infinity,
+        ordered_float_f64_zero
+    );
+    float_roundtrip_tests!(
+        NotNan,
+        f32,
+        |val| NotNan::new(val).unwrap(),
+        not_nan_f32_standard,
+        not_nan_f32_wasm,
+        not_nan_f32_infinity,
+        not_nan_f32_zero
+    );
+    float_roundtrip_tests!(
+        NotNan,
+        f64,
+        |val| NotNan::new(val).unwrap(),
+        not_nan_f64_standard,
+        not_nan_f64_wasm,
+        not_nan_f64_infinity,
+        not_nan_f64_zero
+    );
+
+    macro_rules! ordered_float_pynan_tests {
+        ($test_name:ident, $float_type:ty) => {
+            #[test]
+            fn $test_name() {
+                let inner_nan: $float_type = <$float_type>::NAN;
+                let nan = OrderedFloat(inner_nan);
+
+                Python::attach(|py| {
+                    let nan_py: Bound<'_, PyFloat> = nan.into_pyobject(py).unwrap();
+
+                    py_run!(
+                        py,
+                        nan_py,
+                        "\
+                        import math\n\
+                        assert math.isnan(nan_py)"
+                    );
+
+                    let roundtripped_nan: OrderedFloat<$float_type> = nan_py.extract().unwrap();
+
+                    assert_eq!(nan, roundtripped_nan);
+                })
+            }
+        };
+    }
+    ordered_float_pynan_tests!(test_ordered_float_pynan_f32, f32);
+    ordered_float_pynan_tests!(test_ordered_float_pynan_f64, f64);
+
+    macro_rules! not_nan_pynan_tests {
+        ($test_name:ident, $float_type:ty) => {
+            #[test]
+            fn $test_name() {
+                Python::attach(|py| {
+                    let nan_py = py.eval(c"float('nan')", None, None).unwrap();
+
+                    let nan_rs: Result<NotNan<$float_type>, _> = nan_py.extract();
+
+                    assert!(nan_rs.is_err());
+                })
+            }
+        };
+    }
+    not_nan_pynan_tests!(test_not_nan_pynan_f32, f32);
+    not_nan_pynan_tests!(test_not_nan_pynan_f64, f64);
+
+    macro_rules! py64_rs32 {
+        ($test_name:ident, $wrapper:ident, $float_type:ty) => {
+            #[test]
+            fn $test_name() {
+                Python::attach(|py| {
+                    let py_64 = py
+                        .import("sys")
+                        .unwrap()
+                        .getattr("float_info")
+                        .unwrap()
+                        .getattr("max")
+                        .unwrap();
+                    let rs_32 = py_64.extract::<$wrapper<f32>>().unwrap();
+                    // The python f64 is not representable in a rust f32
+                    assert!(rs_32.is_infinite());
+                })
+            }
+        };
+    }
+    py64_rs32!(ordered_float_f32, OrderedFloat, f32);
+    py64_rs32!(ordered_float_f64, OrderedFloat, f64);
+    py64_rs32!(not_nan_f32, NotNan, f32);
+    py64_rs32!(not_nan_f64, NotNan, f64);
+}
diff --git a/src/conversions/rust_decimal.rs b/src/conversions/rust_decimal.rs
index 1d0f64148fa..0abe6e58987 100644
--- a/src/conversions/rust_decimal.rs
+++ b/src/conversions/rust_decimal.rs
@@ -20,7 +20,7 @@
 //!
 //! Rust code to create a function that adds one to a Decimal
 //!
-//! ```rust
+//! ```rust,no_run
 //! use rust_decimal::Decimal;
 //! use pyo3::prelude::*;
 //!
@@ -30,7 +30,7 @@
 //! }
 //!
 //! #[pymodule]
-//! fn my_module(_py: Python<'_>, m: &PyModule) -> PyResult<()> {
+//! fn my_module(m: &Bound<'_, PyModule>) -> PyResult<()> {
 //!     m.add_function(wrap_pyfunction!(add_one, m)?)?;
 //!     Ok(())
 //! }
@@ -49,69 +49,69 @@
 //! assert d + 1 == value
 //! ```
 
+use crate::conversion::IntoPyObject;
 use crate::exceptions::PyValueError;
-use crate::sync::GILOnceCell;
+use crate::sync::PyOnceLock;
 use crate::types::any::PyAnyMethods;
 use crate::types::string::PyStringMethods;
 use crate::types::PyType;
-use crate::{
-    intern, Bound, FromPyObject, IntoPy, Py, PyAny, PyObject, PyResult, Python, ToPyObject,
-};
+use crate::{Borrowed, Bound, FromPyObject, Py, PyAny, PyErr, PyResult, Python};
 use rust_decimal::Decimal;
 use std::str::FromStr;
 
-impl FromPyObject<'_> for Decimal {
-    fn extract_bound(obj: &Bound<'_, PyAny>) -> PyResult<Self> {
+impl FromPyObject<'_, '_> for Decimal {
+    type Error = PyErr;
+
+    fn extract(obj: Borrowed<'_, '_, PyAny>) -> Result<Self, Self::Error> {
         // use the string representation to not be lossy
         if let Ok(val) = obj.extract() {
             Ok(Decimal::new(val, 0))
         } else {
-            Decimal::from_str(&obj.str()?.to_cow()?)
-                .map_err(|e| PyValueError::new_err(e.to_string()))
+            let py_str = &obj.str()?;
+            let rs_str = &py_str.to_cow()?;
+            Decimal::from_str(rs_str).or_else(|_| {
+                Decimal::from_scientific(rs_str).map_err(|e| PyValueError::new_err(e.to_string()))
+            })
         }
     }
 }
 
-static DECIMAL_CLS: GILOnceCell<Py<PyType>> = GILOnceCell::new();
+static DECIMAL_CLS: PyOnceLock<Py<PyType>> = PyOnceLock::new();
 
-fn get_decimal_cls(py: Python<'_>) -> PyResult<&PyType> {
-    DECIMAL_CLS
-        .get_or_try_init(py, || {
-            py.import_bound(intern!(py, "decimal"))?
-                .getattr(intern!(py, "Decimal"))?
-                .extract()
-        })
-        .map(|ty| ty.as_ref(py))
+fn get_decimal_cls(py: Python<'_>) -> PyResult<&Bound<'_, PyType>> {
+    DECIMAL_CLS.import(py, "decimal", "Decimal")
 }
 
-impl ToPyObject for Decimal {
-    fn to_object(&self, py: Python<'_>) -> PyObject {
-        // TODO: handle error gracefully when ToPyObject can error
-        // look up the decimal.Decimal
-        let dec_cls = get_decimal_cls(py).expect("failed to load decimal.Decimal");
+impl<'py> IntoPyObject<'py> for Decimal {
+    type Target = PyAny;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        let dec_cls = get_decimal_cls(py)?;
         // now call the constructor with the Rust Decimal string-ified
         // to not be lossy
-        let ret = dec_cls
-            .call1((self.to_string(),))
-            .expect("failed to call decimal.Decimal(value)");
-        ret.to_object(py)
+        dec_cls.call1((self.to_string(),))
     }
 }
 
-impl IntoPy<PyObject> for Decimal {
-    fn into_py(self, py: Python<'_>) -> PyObject {
-        self.to_object(py)
+impl<'py> IntoPyObject<'py> for &Decimal {
+    type Target = PyAny;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    #[inline]
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        (*self).into_pyobject(py)
     }
 }
 
 #[cfg(test)]
 mod test_rust_decimal {
     use super::*;
-    use crate::err::PyErr;
-    use crate::types::any::PyAnyMethods;
     use crate::types::dict::PyDictMethods;
     use crate::types::PyDict;
-    use rust_decimal::Decimal;
+    use std::ffi::CString;
 
     #[cfg(not(target_arch = "wasm32"))]
     use proptest::prelude::*;
@@ -120,17 +120,18 @@ mod test_rust_decimal {
         ($name:ident, $rs:expr, $py:literal) => {
             #[test]
             fn $name() {
-                Python::with_gil(|py| {
+                Python::attach(|py| {
                     let rs_orig = $rs;
-                    let rs_dec = rs_orig.into_py(py);
-                    let locals = PyDict::new_bound(py);
+                    let rs_dec = rs_orig.into_pyobject(py).unwrap();
+                    let locals = PyDict::new(py);
                     locals.set_item("rs_dec", &rs_dec).unwrap();
                     // Checks if Rust Decimal -> Python Decimal conversion is correct
-                    py.run_bound(
-                        &format!(
+                    py.run(
+                        &CString::new(format!(
                             "import decimal\npy_dec = decimal.Decimal({})\nassert py_dec == rs_dec",
                             $py
-                        ),
+                        ))
+                        .unwrap(),
                         None,
                         Some(&locals),
                     )
@@ -163,25 +164,24 @@ mod test_rust_decimal {
             scale in 0..28u32
         ) {
             let num = Decimal::from_parts(lo, mid, high, negative, scale);
-            Python::with_gil(|py| {
-                let rs_dec = num.into_py(py);
-                let locals = PyDict::new_bound(py);
+            Python::attach(|py| {
+                let rs_dec = num.into_pyobject(py).unwrap();
+                let locals = PyDict::new(py);
                 locals.set_item("rs_dec", &rs_dec).unwrap();
-                py.run_bound(
-                    &format!(
-                       "import decimal\npy_dec = decimal.Decimal(\"{}\")\nassert py_dec == rs_dec",
-                     num),
+                py.run(
+                    &CString::new(format!(
+                       "import decimal\npy_dec = decimal.Decimal(\"{num}\")\nassert py_dec == rs_dec")).unwrap(),
                 None, Some(&locals)).unwrap();
-                let roundtripped: Decimal = rs_dec.extract(py).unwrap();
+                let roundtripped: Decimal = rs_dec.extract().unwrap();
                 assert_eq!(num, roundtripped);
             })
         }
 
         #[test]
         fn test_integers(num in any::<i64>()) {
-            Python::with_gil(|py| {
-                let py_num = num.into_py(py);
-                let roundtripped: Decimal = py_num.extract(py).unwrap();
+            Python::attach(|py| {
+                let py_num = num.into_pyobject(py).unwrap();
+                let roundtripped: Decimal = py_num.extract().unwrap();
                 let rs_dec = Decimal::new(num, 0);
                 assert_eq!(rs_dec, roundtripped);
             })
@@ -190,10 +190,10 @@ mod test_rust_decimal {
 
     #[test]
     fn test_nan() {
-        Python::with_gil(|py| {
-            let locals = PyDict::new_bound(py);
-            py.run_bound(
-                "import decimal\npy_dec = decimal.Decimal(\"NaN\")",
+        Python::attach(|py| {
+            let locals = PyDict::new(py);
+            py.run(
+                c"import decimal\npy_dec = decimal.Decimal(\"NaN\")",
                 None,
                 Some(&locals),
             )
@@ -204,12 +204,29 @@ mod test_rust_decimal {
         })
     }
 
+    #[test]
+    fn test_scientific_notation() {
+        Python::attach(|py| {
+            let locals = PyDict::new(py);
+            py.run(
+                c"import decimal\npy_dec = decimal.Decimal(\"1e3\")",
+                None,
+                Some(&locals),
+            )
+            .unwrap();
+            let py_dec = locals.get_item("py_dec").unwrap().unwrap();
+            let roundtripped: Decimal = py_dec.extract().unwrap();
+            let rs_dec = Decimal::from_scientific("1e3").unwrap();
+            assert_eq!(rs_dec, roundtripped);
+        })
+    }
+
     #[test]
     fn test_infinity() {
-        Python::with_gil(|py| {
-            let locals = PyDict::new_bound(py);
-            py.run_bound(
-                "import decimal\npy_dec = decimal.Decimal(\"Infinity\")",
+        Python::attach(|py| {
+            let locals = PyDict::new(py);
+            py.run(
+                c"import decimal\npy_dec = decimal.Decimal(\"Infinity\")",
                 None,
                 Some(&locals),
             )
diff --git a/src/conversions/serde.rs b/src/conversions/serde.rs
index a769bd70273..bb3f4f1c58f 100644
--- a/src/conversions/serde.rs
+++ b/src/conversions/serde.rs
@@ -23,7 +23,7 @@ where
     where
         S: Serializer,
     {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             self.try_borrow(py)
                 .map_err(|e| ser::Error::custom(e.to_string()))?
                 .serialize(serializer)
@@ -41,8 +41,6 @@ where
     {
         let deserialized = T::deserialize(deserializer)?;
 
-        Python::with_gil(|py| {
-            Py::new(py, deserialized).map_err(|e| de::Error::custom(e.to_string()))
-        })
+        Python::attach(|py| Py::new(py, deserialized).map_err(|e| de::Error::custom(e.to_string())))
     }
 }
diff --git a/src/conversions/smallvec.rs b/src/conversions/smallvec.rs
index f51da1de32a..8f199bded78 100644
--- a/src/conversions/smallvec.rs
+++ b/src/conversions/smallvec.rs
@@ -15,51 +15,69 @@
 //!
 //! Note that you must use compatible versions of smallvec and PyO3.
 //! The required smallvec version may vary based on the version of PyO3.
+use crate::conversion::{FromPyObjectOwned, IntoPyObject};
 use crate::exceptions::PyTypeError;
 #[cfg(feature = "experimental-inspect")]
 use crate::inspect::types::TypeInfo;
 use crate::types::any::PyAnyMethods;
-use crate::types::list::new_from_iter;
 use crate::types::{PySequence, PyString};
 use crate::{
-    err::DowncastError, ffi, Bound, FromPyObject, IntoPy, PyAny, PyObject, PyResult, Python,
-    ToPyObject,
+    err::CastError, ffi, Borrowed, Bound, FromPyObject, PyAny, PyErr, PyResult, PyTypeInfo, Python,
 };
 use smallvec::{Array, SmallVec};
 
-impl<A> ToPyObject for SmallVec<A>
+impl<'py, A> IntoPyObject<'py> for SmallVec<A>
 where
     A: Array,
-    A::Item: ToPyObject,
+    A::Item: IntoPyObject<'py>,
 {
-    fn to_object(&self, py: Python<'_>) -> PyObject {
-        self.as_slice().to_object(py)
+    type Target = PyAny;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    /// Turns [`SmallVec<u8>`] into [`PyBytes`], all other `T`s will be turned into a [`PyList`]
+    ///
+    /// [`PyBytes`]: crate::types::PyBytes
+    /// [`PyList`]: crate::types::PyList
+    #[inline]
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        <A::Item>::owned_sequence_into_pyobject(self, py, crate::conversion::private::Token)
+    }
+
+    #[cfg(feature = "experimental-inspect")]
+    fn type_output() -> TypeInfo {
+        TypeInfo::list_of(A::Item::type_output())
     }
 }
 
-impl<A> IntoPy<PyObject> for SmallVec<A>
+impl<'a, 'py, A> IntoPyObject<'py> for &'a SmallVec<A>
 where
     A: Array,
-    A::Item: IntoPy<PyObject>,
+    &'a A::Item: IntoPyObject<'py>,
 {
-    fn into_py(self, py: Python<'_>) -> PyObject {
-        let mut iter = self.into_iter().map(|e| e.into_py(py));
-        let list = new_from_iter(py, &mut iter);
-        list.into()
+    type Target = PyAny;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    #[inline]
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        self.as_slice().into_pyobject(py)
     }
 
     #[cfg(feature = "experimental-inspect")]
     fn type_output() -> TypeInfo {
-        TypeInfo::list_of(A::Item::type_output())
+        TypeInfo::list_of(<&A::Item>::type_output())
     }
 }
 
-impl<'py, A> FromPyObject<'py> for SmallVec<A>
+impl<'py, A> FromPyObject<'_, 'py> for SmallVec<A>
 where
     A: Array,
-    A::Item: FromPyObject<'py>,
+    A::Item: FromPyObjectOwned<'py>,
 {
-    fn extract_bound(obj: &Bound<'py, PyAny>) -> PyResult<Self> {
+    type Error = PyErr;
+
+    fn extract(obj: Borrowed<'_, 'py, PyAny>) -> Result<Self, Self::Error> {
         if obj.is_instance_of::<PyString>() {
             return Err(PyTypeError::new_err("Can't extract `str` to `SmallVec`"));
         }
@@ -72,24 +90,24 @@ where
     }
 }
 
-fn extract_sequence<'py, A>(obj: &Bound<'py, PyAny>) -> PyResult<SmallVec<A>>
+fn extract_sequence<'py, A>(obj: Borrowed<'_, 'py, PyAny>) -> PyResult<SmallVec<A>>
 where
     A: Array,
-    A::Item: FromPyObject<'py>,
+    A::Item: FromPyObjectOwned<'py>,
 {
     // Types that pass `PySequence_Check` usually implement enough of the sequence protocol
     // to support this function and if not, we will only fail extraction safely.
     let seq = unsafe {
         if ffi::PySequence_Check(obj.as_ptr()) != 0 {
-            obj.downcast_unchecked::<PySequence>()
+            obj.cast_unchecked::<PySequence>()
         } else {
-            return Err(DowncastError::new(obj, "Sequence").into());
+            return Err(CastError::new(obj, PySequence::type_object(obj.py()).into_any()).into());
         }
     };
 
     let mut sv = SmallVec::with_capacity(seq.len().unwrap_or(0));
-    for item in seq.iter()? {
-        sv.push(item?.extract::<A::Item>()?);
+    for item in seq.try_iter()? {
+        sv.push(item?.extract::<A::Item>().map_err(Into::into)?);
     }
     Ok(sv)
 }
@@ -97,22 +115,12 @@ where
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::types::{any::PyAnyMethods, PyDict, PyList};
-
-    #[test]
-    fn test_smallvec_into_py() {
-        Python::with_gil(|py| {
-            let sv: SmallVec<[u64; 8]> = [1, 2, 3, 4, 5].iter().cloned().collect();
-            let hso: PyObject = sv.clone().into_py(py);
-            let l = PyList::new_bound(py, [1, 2, 3, 4, 5]);
-            assert!(l.eq(hso).unwrap());
-        });
-    }
+    use crate::types::{PyBytes, PyBytesMethods, PyDict, PyList};
 
     #[test]
     fn test_smallvec_from_py_object() {
-        Python::with_gil(|py| {
-            let l = PyList::new_bound(py, [1, 2, 3, 4, 5]);
+        Python::attach(|py| {
+            let l = PyList::new(py, [1, 2, 3, 4, 5]).unwrap();
             let sv: SmallVec<[u64; 8]> = l.extract().unwrap();
             assert_eq!(sv.as_slice(), [1, 2, 3, 4, 5]);
         });
@@ -120,23 +128,38 @@ mod tests {
 
     #[test]
     fn test_smallvec_from_py_object_fails() {
-        Python::with_gil(|py| {
-            let dict = PyDict::new_bound(py);
+        Python::attach(|py| {
+            let dict = PyDict::new(py);
             let sv: PyResult<SmallVec<[u64; 8]>> = dict.extract();
             assert_eq!(
                 sv.unwrap_err().to_string(),
-                "TypeError: 'dict' object cannot be converted to 'Sequence'"
+                "TypeError: 'dict' object cannot be cast as 'Sequence'"
             );
         });
     }
 
     #[test]
-    fn test_smallvec_to_object() {
-        Python::with_gil(|py| {
+    fn test_smallvec_into_pyobject() {
+        Python::attach(|py| {
             let sv: SmallVec<[u64; 8]> = [1, 2, 3, 4, 5].iter().cloned().collect();
-            let hso: PyObject = sv.to_object(py);
-            let l = PyList::new_bound(py, [1, 2, 3, 4, 5]);
+            let hso = sv.into_pyobject(py).unwrap();
+            let l = PyList::new(py, [1, 2, 3, 4, 5]).unwrap();
             assert!(l.eq(hso).unwrap());
         });
     }
+
+    #[test]
+    fn test_smallvec_intopyobject_impl() {
+        Python::attach(|py| {
+            let bytes: SmallVec<[u8; 8]> = [1, 2, 3, 4, 5].iter().cloned().collect();
+            let obj = bytes.clone().into_pyobject(py).unwrap();
+            assert!(obj.is_instance_of::<PyBytes>());
+            let obj = obj.cast_into::<PyBytes>().unwrap();
+            assert_eq!(obj.as_bytes(), &*bytes);
+
+            let nums: SmallVec<[u16; 8]> = [1, 2, 3, 4, 5].iter().cloned().collect();
+            let obj = nums.into_pyobject(py).unwrap();
+            assert!(obj.is_instance_of::<PyList>());
+        });
+    }
 }
diff --git a/src/conversions/std/array.rs b/src/conversions/std/array.rs
index 016ab0a643d..4b312f769b8 100644
--- a/src/conversions/std/array.rs
+++ b/src/conversions/std/array.rs
@@ -1,81 +1,81 @@
-use crate::instance::Bound;
+use crate::conversion::{FromPyObjectOwned, FromPyObjectSequence, IntoPyObject};
 use crate::types::any::PyAnyMethods;
 use crate::types::PySequence;
-use crate::{
-    err::DowncastError, ffi, FromPyObject, IntoPy, Py, PyAny, PyObject, PyResult, Python,
-    ToPyObject,
-};
-use crate::{exceptions, PyErr};
+use crate::{err::CastError, ffi, FromPyObject, PyAny, PyResult, PyTypeInfo, Python};
+use crate::{exceptions, Borrowed, Bound, PyErr};
 
-impl<T, const N: usize> IntoPy<PyObject> for [T; N]
+impl<'py, T, const N: usize> IntoPyObject<'py> for [T; N]
 where
-    T: IntoPy<PyObject>,
+    T: IntoPyObject<'py>,
 {
-    fn into_py(self, py: Python<'_>) -> PyObject {
-        unsafe {
-            let len = N as ffi::Py_ssize_t;
+    type Target = PyAny;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
 
-            let ptr = ffi::PyList_New(len);
-
-            // We create the  `Py` pointer here for two reasons:
-            // - panics if the ptr is null
-            // - its Drop cleans up the list if user code panics.
-            let list: Py<PyAny> = Py::from_owned_ptr(py, ptr);
-
-            for (i, obj) in (0..len).zip(self) {
-                let obj = obj.into_py(py).into_ptr();
-
-                #[cfg(not(Py_LIMITED_API))]
-                ffi::PyList_SET_ITEM(ptr, i, obj);
-                #[cfg(Py_LIMITED_API)]
-                ffi::PyList_SetItem(ptr, i, obj);
-            }
-
-            list
-        }
+    /// Turns [`[u8; N]`](std::array) into [`PyBytes`], all other `T`s will be turned into a [`PyList`]
+    ///
+    /// [`PyBytes`]: crate::types::PyBytes
+    /// [`PyList`]: crate::types::PyList
+    #[inline]
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        T::owned_sequence_into_pyobject(self, py, crate::conversion::private::Token)
     }
 }
 
-impl<T, const N: usize> ToPyObject for [T; N]
+impl<'a, 'py, T, const N: usize> IntoPyObject<'py> for &'a [T; N]
 where
-    T: ToPyObject,
+    &'a T: IntoPyObject<'py>,
 {
-    fn to_object(&self, py: Python<'_>) -> PyObject {
-        self.as_ref().to_object(py)
+    type Target = PyAny;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    #[inline]
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        self.as_slice().into_pyobject(py)
     }
 }
 
-impl<'py, T, const N: usize> FromPyObject<'py> for [T; N]
+impl<'py, T, const N: usize> FromPyObject<'_, 'py> for [T; N]
 where
-    T: FromPyObject<'py>,
+    T: FromPyObjectOwned<'py>,
 {
-    fn extract_bound(obj: &Bound<'py, PyAny>) -> PyResult<Self> {
+    type Error = PyErr;
+
+    fn extract(obj: Borrowed<'_, 'py, PyAny>) -> PyResult<Self> {
+        if let Some(extractor) = T::sequence_extractor(obj, crate::conversion::private::Token) {
+            return extractor.to_array();
+        }
+
         create_array_from_obj(obj)
     }
 }
 
-fn create_array_from_obj<'py, T, const N: usize>(obj: &Bound<'py, PyAny>) -> PyResult<[T; N]>
+fn create_array_from_obj<'py, T, const N: usize>(obj: Borrowed<'_, 'py, PyAny>) -> PyResult<[T; N]>
 where
-    T: FromPyObject<'py>,
+    T: FromPyObjectOwned<'py>,
 {
     // Types that pass `PySequence_Check` usually implement enough of the sequence protocol
     // to support this function and if not, we will only fail extraction safely.
     let seq = unsafe {
         if ffi::PySequence_Check(obj.as_ptr()) != 0 {
-            obj.downcast_unchecked::<PySequence>()
+            obj.cast_unchecked::<PySequence>()
         } else {
-            return Err(DowncastError::new(obj, "Sequence").into());
+            return Err(CastError::new(obj, PySequence::type_object(obj.py()).into_any()).into());
         }
     };
     let seq_len = seq.len()?;
     if seq_len != N {
         return Err(invalid_sequence_length(N, seq_len));
     }
-    array_try_from_fn(|idx| seq.get_item(idx).and_then(|any| any.extract()))
+    array_try_from_fn(|idx| {
+        seq.get_item(idx)
+            .and_then(|any| any.extract().map_err(Into::into))
+    })
 }
 
 // TODO use std::array::try_from_fn, if that stabilises:
-// (https://github.com/rust-lang/rust/pull/75644)
+// (https://github.com/rust-lang/rust/issues/89379)
 fn array_try_from_fn<E, F, T, const N: usize>(mut cb: F) -> Result<[T; N], E>
 where
     F: FnMut(usize) -> Result<T, E>,
@@ -116,10 +116,9 @@ where
     }
 }
 
-fn invalid_sequence_length(expected: usize, actual: usize) -> PyErr {
+pub(crate) fn invalid_sequence_length(expected: usize, actual: usize) -> PyErr {
     exceptions::PyValueError::new_err(format!(
-        "expected a sequence of length {} (got {})",
-        expected, actual
+        "expected a sequence of length {expected} (got {actual})"
     ))
 }
 
@@ -130,8 +129,11 @@ mod tests {
         sync::atomic::{AtomicUsize, Ordering},
     };
 
-    use crate::types::any::PyAnyMethods;
-    use crate::{types::PyList, IntoPy, PyResult, Python, ToPyObject};
+    use crate::{
+        conversion::IntoPyObject,
+        types::{any::PyAnyMethods, PyBytes, PyBytesMethods},
+    };
+    use crate::{types::PyList, PyResult, Python};
 
     #[test]
     fn array_try_from_fn() {
@@ -154,51 +156,74 @@ mod tests {
         assert_eq!(DROP_COUNTER.load(Ordering::SeqCst), 2);
     }
 
+    #[test]
+    fn test_extract_bytes_to_array() {
+        Python::attach(|py| {
+            let v: [u8; 33] = py
+                .eval(c"b'abcabcabcabcabcabcabcabcabcabcabc'", None, None)
+                .unwrap()
+                .extract()
+                .unwrap();
+            assert_eq!(&v, b"abcabcabcabcabcabcabcabcabcabcabc");
+        })
+    }
+
+    #[test]
+    fn test_extract_bytes_wrong_length() {
+        Python::attach(|py| {
+            let v: PyResult<[u8; 3]> = py.eval(c"b'abcdefg'", None, None).unwrap().extract();
+            assert_eq!(
+                v.unwrap_err().to_string(),
+                "ValueError: expected a sequence of length 3 (got 7)"
+            );
+        })
+    }
+
     #[test]
     fn test_extract_bytearray_to_array() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let v: [u8; 33] = py
-                .eval_bound(
-                    "bytearray(b'abcabcabcabcabcabcabcabcabcabcabc')",
+                .eval(
+                    c"bytearray(b'abcabcabcabcabcabcabcabcabcabcabc')",
                     None,
                     None,
                 )
                 .unwrap()
                 .extract()
                 .unwrap();
-            assert!(&v == b"abcabcabcabcabcabcabcabcabcabcabc");
+            assert_eq!(&v, b"abcabcabcabcabcabcabcabcabcabcabc");
         })
     }
 
     #[test]
     fn test_extract_small_bytearray_to_array() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let v: [u8; 3] = py
-                .eval_bound("bytearray(b'abc')", None, None)
+                .eval(c"bytearray(b'abc')", None, None)
                 .unwrap()
                 .extract()
                 .unwrap();
-            assert!(&v == b"abc");
+            assert_eq!(&v, b"abc");
         });
     }
     #[test]
-    fn test_topyobject_array_conversion() {
-        Python::with_gil(|py| {
+    fn test_into_pyobject_array_conversion() {
+        Python::attach(|py| {
             let array: [f32; 4] = [0.0, -16.0, 16.0, 42.0];
-            let pyobject = array.to_object(py);
-            let pylist: &PyList = pyobject.extract(py).unwrap();
-            assert_eq!(pylist[0].extract::<f32>().unwrap(), 0.0);
-            assert_eq!(pylist[1].extract::<f32>().unwrap(), -16.0);
-            assert_eq!(pylist[2].extract::<f32>().unwrap(), 16.0);
-            assert_eq!(pylist[3].extract::<f32>().unwrap(), 42.0);
+            let pyobject = array.into_pyobject(py).unwrap();
+            let pylist = pyobject.cast::<PyList>().unwrap();
+            assert_eq!(pylist.get_item(0).unwrap().extract::<f32>().unwrap(), 0.0);
+            assert_eq!(pylist.get_item(1).unwrap().extract::<f32>().unwrap(), -16.0);
+            assert_eq!(pylist.get_item(2).unwrap().extract::<f32>().unwrap(), 16.0);
+            assert_eq!(pylist.get_item(3).unwrap().extract::<f32>().unwrap(), 42.0);
         });
     }
 
     #[test]
     fn test_extract_invalid_sequence_length() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let v: PyResult<[u8; 3]> = py
-                .eval_bound("bytearray(b'abcdefg')", None, None)
+                .eval(c"bytearray(b'abcdefg')", None, None)
                 .unwrap()
                 .extract();
             assert_eq!(
@@ -209,22 +234,41 @@ mod tests {
     }
 
     #[test]
-    fn test_intopy_array_conversion() {
-        Python::with_gil(|py| {
+    fn test_intopyobject_array_conversion() {
+        Python::attach(|py| {
             let array: [f32; 4] = [0.0, -16.0, 16.0, 42.0];
-            let pyobject = array.into_py(py);
-            let pylist: &PyList = pyobject.extract(py).unwrap();
-            assert_eq!(pylist[0].extract::<f32>().unwrap(), 0.0);
-            assert_eq!(pylist[1].extract::<f32>().unwrap(), -16.0);
-            assert_eq!(pylist[2].extract::<f32>().unwrap(), 16.0);
-            assert_eq!(pylist[3].extract::<f32>().unwrap(), 42.0);
+            let pylist = array
+                .into_pyobject(py)
+                .unwrap()
+                .cast_into::<PyList>()
+                .unwrap();
+
+            assert_eq!(pylist.get_item(0).unwrap().extract::<f32>().unwrap(), 0.0);
+            assert_eq!(pylist.get_item(1).unwrap().extract::<f32>().unwrap(), -16.0);
+            assert_eq!(pylist.get_item(2).unwrap().extract::<f32>().unwrap(), 16.0);
+            assert_eq!(pylist.get_item(3).unwrap().extract::<f32>().unwrap(), 42.0);
+        });
+    }
+
+    #[test]
+    fn test_array_intopyobject_impl() {
+        Python::attach(|py| {
+            let bytes: [u8; 6] = *b"foobar";
+            let obj = bytes.into_pyobject(py).unwrap();
+            assert!(obj.is_instance_of::<PyBytes>());
+            let obj = obj.cast_into::<PyBytes>().unwrap();
+            assert_eq!(obj.as_bytes(), &bytes);
+
+            let nums: [u16; 4] = [0, 1, 2, 3];
+            let obj = nums.into_pyobject(py).unwrap();
+            assert!(obj.is_instance_of::<PyList>());
         });
     }
 
     #[test]
     fn test_extract_non_iterable_to_array() {
-        Python::with_gil(|py| {
-            let v = py.eval_bound("42", None, None).unwrap();
+        Python::attach(|py| {
+            let v = py.eval(c"42", None, None).unwrap();
             v.extract::<i32>().unwrap();
             v.extract::<[i32; 1]>().unwrap_err();
         });
@@ -236,11 +280,14 @@ mod tests {
         #[crate::pyclass(crate = "crate")]
         struct Foo;
 
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let array: [Foo; 8] = [Foo, Foo, Foo, Foo, Foo, Foo, Foo, Foo];
-            let pyobject = array.into_py(py);
-            let list: &PyList = pyobject.downcast(py).unwrap();
-            let _cell: &crate::PyCell<Foo> = list.get_item(4).unwrap().extract().unwrap();
+            let list = array
+                .into_pyobject(py)
+                .unwrap()
+                .cast_into::<PyList>()
+                .unwrap();
+            let _bound = list.get_item(4).unwrap().cast::<Foo>().unwrap();
         });
     }
 
diff --git a/src/conversions/std/cell.rs b/src/conversions/std/cell.rs
new file mode 100644
index 00000000000..9a79479ad6f
--- /dev/null
+++ b/src/conversions/std/cell.rs
@@ -0,0 +1,44 @@
+use std::cell::Cell;
+
+#[cfg(feature = "experimental-inspect")]
+use crate::inspect::TypeHint;
+use crate::{conversion::IntoPyObject, Borrowed, FromPyObject, PyAny, Python};
+
+impl<'py, T: Copy + IntoPyObject<'py>> IntoPyObject<'py> for Cell<T> {
+    type Target = T::Target;
+    type Output = T::Output;
+    type Error = T::Error;
+
+    #[cfg(feature = "experimental-inspect")]
+    const OUTPUT_TYPE: TypeHint = T::OUTPUT_TYPE;
+
+    #[inline]
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        self.get().into_pyobject(py)
+    }
+}
+
+impl<'py, T: Copy + IntoPyObject<'py>> IntoPyObject<'py> for &Cell<T> {
+    type Target = T::Target;
+    type Output = T::Output;
+    type Error = T::Error;
+
+    #[cfg(feature = "experimental-inspect")]
+    const OUTPUT_TYPE: TypeHint = T::OUTPUT_TYPE;
+
+    #[inline]
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        self.get().into_pyobject(py)
+    }
+}
+
+impl<'a, 'py, T: FromPyObject<'a, 'py>> FromPyObject<'a, 'py> for Cell<T> {
+    type Error = T::Error;
+
+    #[cfg(feature = "experimental-inspect")]
+    const INPUT_TYPE: TypeHint = T::INPUT_TYPE;
+
+    fn extract(ob: Borrowed<'a, 'py, PyAny>) -> Result<Self, Self::Error> {
+        ob.extract().map(Cell::new)
+    }
+}
diff --git a/src/conversions/std/cstring.rs b/src/conversions/std/cstring.rs
new file mode 100644
index 00000000000..3e13619f0c5
--- /dev/null
+++ b/src/conversions/std/cstring.rs
@@ -0,0 +1,188 @@
+use crate::types::PyString;
+use crate::{Borrowed, Bound, FromPyObject, IntoPyObject, PyAny, PyErr, Python};
+use std::borrow::Cow;
+use std::ffi::{CStr, CString};
+use std::str::Utf8Error;
+#[cfg(any(Py_3_10, not(Py_LIMITED_API)))]
+use {
+    crate::{exceptions::PyValueError, ffi},
+    std::slice,
+};
+
+impl<'py> IntoPyObject<'py> for &CStr {
+    type Target = PyString;
+    type Output = Bound<'py, Self::Target>;
+    type Error = Utf8Error;
+
+    #[inline]
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        self.to_str()?.into_pyobject(py).map_err(|err| match err {})
+    }
+}
+
+impl<'py> IntoPyObject<'py> for CString {
+    type Target = PyString;
+    type Output = Bound<'py, Self::Target>;
+    type Error = Utf8Error;
+
+    #[inline]
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        (&*self).into_pyobject(py)
+    }
+}
+
+impl<'py> IntoPyObject<'py> for &CString {
+    type Target = PyString;
+    type Output = Bound<'py, Self::Target>;
+    type Error = Utf8Error;
+
+    #[inline]
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        (&**self).into_pyobject(py)
+    }
+}
+
+impl<'py> IntoPyObject<'py> for Cow<'_, CStr> {
+    type Target = PyString;
+    type Output = Bound<'py, Self::Target>;
+    type Error = Utf8Error;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        (*self).into_pyobject(py)
+    }
+}
+
+impl<'py> IntoPyObject<'py> for &Cow<'_, CStr> {
+    type Target = PyString;
+    type Output = Bound<'py, Self::Target>;
+    type Error = Utf8Error;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        (&**self).into_pyobject(py)
+    }
+}
+
+#[cfg(any(Py_3_10, not(Py_LIMITED_API)))]
+impl<'a> FromPyObject<'a, '_> for &'a CStr {
+    type Error = PyErr;
+
+    fn extract(obj: Borrowed<'a, '_, PyAny>) -> Result<Self, Self::Error> {
+        let obj = obj.cast::<PyString>()?;
+        let mut size = 0;
+        // SAFETY: obj is a PyString so we can safely call PyUnicode_AsUTF8AndSize
+        let ptr = unsafe { ffi::PyUnicode_AsUTF8AndSize(obj.as_ptr(), &mut size) };
+
+        if ptr.is_null() {
+            return Err(PyErr::fetch(obj.py()));
+        }
+
+        // SAFETY: PyUnicode_AsUTF8AndSize always returns a NUL-terminated string but size does not
+        // include the NUL terminator. So we add 1 to the size to include it.
+        let slice = unsafe { slice::from_raw_parts(ptr.cast(), size as usize + 1) };
+
+        CStr::from_bytes_with_nul(slice).map_err(|err| PyValueError::new_err(err.to_string()))
+    }
+}
+
+impl<'a> FromPyObject<'a, '_> for Cow<'a, CStr> {
+    type Error = PyErr;
+
+    fn extract(obj: Borrowed<'a, '_, PyAny>) -> Result<Self, Self::Error> {
+        #[cfg(any(Py_3_10, not(Py_LIMITED_API)))]
+        {
+            Ok(Cow::Borrowed(obj.extract::<&CStr>()?))
+        }
+
+        #[cfg(not(any(Py_3_10, not(Py_LIMITED_API))))]
+        {
+            Ok(Cow::Owned(obj.extract::<CString>()?))
+        }
+    }
+}
+impl FromPyObject<'_, '_> for CString {
+    type Error = PyErr;
+
+    fn extract(obj: Borrowed<'_, '_, PyAny>) -> Result<Self, Self::Error> {
+        #[cfg(any(Py_3_10, not(Py_LIMITED_API)))]
+        {
+            Ok(obj.extract::<&CStr>()?.to_owned())
+        }
+
+        #[cfg(not(any(Py_3_10, not(Py_LIMITED_API))))]
+        {
+            CString::new(&*obj.cast::<PyString>()?.to_cow()?).map_err(Into::into)
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::types::string::PyStringMethods;
+    use crate::types::PyAnyMethods;
+    use crate::Python;
+
+    #[test]
+    fn test_into_pyobject() {
+        Python::attach(|py| {
+            let s = "Hello, Python!";
+            let cstr = CString::new(s).unwrap();
+
+            let py_string = cstr.as_c_str().into_pyobject(py).unwrap();
+            assert_eq!(py_string.to_cow().unwrap(), s);
+
+            let py_string = cstr.into_pyobject(py).unwrap();
+            assert_eq!(py_string.to_cow().unwrap(), s);
+        })
+    }
+
+    #[test]
+    fn test_extract_with_nul_error() {
+        Python::attach(|py| {
+            let s = "Hello\0Python";
+            let py_string = s.into_pyobject(py).unwrap();
+
+            #[cfg(any(Py_3_10, not(Py_LIMITED_API)))]
+            {
+                let err = py_string.extract::<&CStr>();
+                assert!(err.is_err());
+            }
+
+            let err = py_string.extract::<CString>();
+            assert!(err.is_err());
+        })
+    }
+
+    #[test]
+    fn test_extract_cstr_and_cstring() {
+        Python::attach(|py| {
+            let s = "Hello, world!";
+            let cstr = CString::new(s).unwrap();
+            let py_string = cstr.as_c_str().into_pyobject(py).unwrap();
+
+            #[cfg(any(Py_3_10, not(Py_LIMITED_API)))]
+            {
+                let extracted_cstr: &CStr = py_string.extract().unwrap();
+                assert_eq!(extracted_cstr.to_str().unwrap(), s);
+            }
+
+            let extracted_cstring: CString = py_string.extract().unwrap();
+            assert_eq!(extracted_cstring.to_str().unwrap(), s);
+        })
+    }
+
+    #[test]
+    fn test_cow_roundtrip() {
+        Python::attach(|py| {
+            let s = "Hello, world!";
+            let cstr = CString::new(s).unwrap();
+            let cow: Cow<'_, CStr> = Cow::Borrowed(cstr.as_c_str());
+
+            let py_string = cow.into_pyobject(py).unwrap();
+            assert_eq!(py_string.to_cow().unwrap(), s);
+
+            let roundtripped: Cow<'_, CStr> = py_string.extract().unwrap();
+            assert_eq!(roundtripped.as_ref(), cstr.as_c_str());
+        })
+    }
+}
diff --git a/src/conversions/std/ipaddr.rs b/src/conversions/std/ipaddr.rs
old mode 100755
new mode 100644
index 84aacab43a2..6fb1859d196
--- a/src/conversions/std/ipaddr.rs
+++ b/src/conversions/std/ipaddr.rs
@@ -1,15 +1,17 @@
 use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
 
+use crate::conversion::IntoPyObject;
 use crate::exceptions::PyValueError;
-use crate::instance::Bound;
-use crate::sync::GILOnceCell;
+use crate::sync::PyOnceLock;
 use crate::types::any::PyAnyMethods;
 use crate::types::string::PyStringMethods;
 use crate::types::PyType;
-use crate::{intern, FromPyObject, IntoPy, Py, PyAny, PyObject, PyResult, Python, ToPyObject};
+use crate::{intern, Borrowed, Bound, FromPyObject, Py, PyAny, PyErr, Python};
 
-impl FromPyObject<'_> for IpAddr {
-    fn extract_bound(obj: &Bound<'_, PyAny>) -> PyResult<Self> {
+impl FromPyObject<'_, '_> for IpAddr {
+    type Error = PyErr;
+
+    fn extract(obj: Borrowed<'_, '_, PyAny>) -> Result<Self, Self::Error> {
         match obj.getattr(intern!(obj.py(), "packed")) {
             Ok(packed) => {
                 if let Ok(packed) = packed.extract::<[u8; 4]>() {
@@ -28,42 +30,75 @@ impl FromPyObject<'_> for IpAddr {
     }
 }
 
-impl ToPyObject for Ipv4Addr {
-    fn to_object(&self, py: Python<'_>) -> PyObject {
-        static IPV4_ADDRESS: GILOnceCell<Py<PyType>> = GILOnceCell::new();
+impl<'py> IntoPyObject<'py> for Ipv4Addr {
+    type Target = PyAny;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        static IPV4_ADDRESS: PyOnceLock<Py<PyType>> = PyOnceLock::new();
         IPV4_ADDRESS
-            .get_or_try_init_type_ref(py, "ipaddress", "IPv4Address")
-            .expect("failed to load ipaddress.IPv4Address")
+            .import(py, "ipaddress", "IPv4Address")?
             .call1((u32::from_be_bytes(self.octets()),))
-            .expect("failed to construct ipaddress.IPv4Address")
-            .unbind()
     }
 }
 
-impl ToPyObject for Ipv6Addr {
-    fn to_object(&self, py: Python<'_>) -> PyObject {
-        static IPV6_ADDRESS: GILOnceCell<Py<PyType>> = GILOnceCell::new();
+impl<'py> IntoPyObject<'py> for &Ipv4Addr {
+    type Target = PyAny;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    #[inline]
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        (*self).into_pyobject(py)
+    }
+}
+
+impl<'py> IntoPyObject<'py> for Ipv6Addr {
+    type Target = PyAny;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        static IPV6_ADDRESS: PyOnceLock<Py<PyType>> = PyOnceLock::new();
         IPV6_ADDRESS
-            .get_or_try_init_type_ref(py, "ipaddress", "IPv6Address")
-            .expect("failed to load ipaddress.IPv6Address")
+            .import(py, "ipaddress", "IPv6Address")?
             .call1((u128::from_be_bytes(self.octets()),))
-            .expect("failed to construct ipaddress.IPv6Address")
-            .unbind()
     }
 }
 
-impl ToPyObject for IpAddr {
-    fn to_object(&self, py: Python<'_>) -> PyObject {
+impl<'py> IntoPyObject<'py> for &Ipv6Addr {
+    type Target = PyAny;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    #[inline]
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        (*self).into_pyobject(py)
+    }
+}
+
+impl<'py> IntoPyObject<'py> for IpAddr {
+    type Target = PyAny;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
         match self {
-            IpAddr::V4(ip) => ip.to_object(py),
-            IpAddr::V6(ip) => ip.to_object(py),
+            IpAddr::V4(ip) => ip.into_pyobject(py),
+            IpAddr::V6(ip) => ip.into_pyobject(py),
         }
     }
 }
 
-impl IntoPy<PyObject> for IpAddr {
-    fn into_py(self, py: Python<'_>) -> PyObject {
-        self.to_object(py)
+impl<'py> IntoPyObject<'py> for &IpAddr {
+    type Target = PyAny;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    #[inline]
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        (*self).into_pyobject(py)
     }
 }
 
@@ -77,7 +112,7 @@ mod test_ipaddr {
 
     #[test]
     fn test_roundtrip() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             fn roundtrip(py: Python<'_>, ip: &str) {
                 let ip = IpAddr::from_str(ip).unwrap();
                 let py_cls = if ip.is_ipv4() {
@@ -86,11 +121,12 @@ mod test_ipaddr {
                     "IPv6Address"
                 };
 
-                let pyobj = ip.into_py(py);
-                let repr = pyobj.as_ref(py).repr().unwrap().to_string_lossy();
-                assert_eq!(repr, format!("{}('{}')", py_cls, ip));
+                let pyobj = ip.into_pyobject(py).unwrap();
+                let repr = pyobj.repr().unwrap();
+                let repr = repr.to_string_lossy();
+                assert_eq!(repr, format!("{py_cls}('{ip}')"));
 
-                let ip2: IpAddr = pyobj.extract(py).unwrap();
+                let ip2: IpAddr = pyobj.extract().unwrap();
                 assert_eq!(ip, ip2);
             }
             roundtrip(py, "127.0.0.1");
@@ -101,13 +137,13 @@ mod test_ipaddr {
 
     #[test]
     fn test_from_pystring() {
-        Python::with_gil(|py| {
-            let py_str = PyString::new_bound(py, "0:0:0:0:0:0:0:1");
-            let ip: IpAddr = py_str.to_object(py).extract(py).unwrap();
+        Python::attach(|py| {
+            let py_str = PyString::new(py, "0:0:0:0:0:0:0:1");
+            let ip: IpAddr = py_str.extract().unwrap();
             assert_eq!(ip, IpAddr::from_str("::1").unwrap());
 
-            let py_str = PyString::new_bound(py, "invalid");
-            assert!(py_str.to_object(py).extract::<IpAddr>(py).is_err());
+            let py_str = PyString::new(py, "invalid");
+            assert!(py_str.extract::<IpAddr>().is_err());
         });
     }
 }
diff --git a/src/conversions/std/map.rs b/src/conversions/std/map.rs
index 700617ec17a..ad9282bc720 100644
--- a/src/conversions/std/map.rs
+++ b/src/conversions/std/map.rs
@@ -3,44 +3,75 @@ use std::{cmp, collections, hash};
 #[cfg(feature = "experimental-inspect")]
 use crate::inspect::types::TypeInfo;
 use crate::{
+    conversion::{FromPyObjectOwned, IntoPyObject},
     instance::Bound,
-    types::dict::PyDictMethods,
-    types::{any::PyAnyMethods, IntoPyDict, PyDict},
-    FromPyObject, IntoPy, PyAny, PyErr, PyObject, Python, ToPyObject,
+    types::{any::PyAnyMethods, dict::PyDictMethods, PyDict},
+    Borrowed, FromPyObject, PyAny, PyErr, Python,
 };
 
-impl<K, V, H> ToPyObject for collections::HashMap<K, V, H>
+impl<'py, K, V, H> IntoPyObject<'py> for collections::HashMap<K, V, H>
 where
-    K: hash::Hash + cmp::Eq + ToPyObject,
-    V: ToPyObject,
+    K: IntoPyObject<'py> + cmp::Eq + hash::Hash,
+    V: IntoPyObject<'py>,
     H: hash::BuildHasher,
 {
-    fn to_object(&self, py: Python<'_>) -> PyObject {
-        IntoPyDict::into_py_dict_bound(self, py).into()
+    type Target = PyDict;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        let dict = PyDict::new(py);
+        for (k, v) in self {
+            dict.set_item(k, v)?;
+        }
+        Ok(dict)
+    }
+
+    #[cfg(feature = "experimental-inspect")]
+    fn type_output() -> TypeInfo {
+        TypeInfo::dict_of(K::type_output(), V::type_output())
     }
 }
 
-impl<K, V> ToPyObject for collections::BTreeMap<K, V>
+impl<'a, 'py, K, V, H> IntoPyObject<'py> for &'a collections::HashMap<K, V, H>
 where
-    K: cmp::Eq + ToPyObject,
-    V: ToPyObject,
+    &'a K: IntoPyObject<'py> + cmp::Eq + hash::Hash,
+    &'a V: IntoPyObject<'py>,
+    H: hash::BuildHasher,
 {
-    fn to_object(&self, py: Python<'_>) -> PyObject {
-        IntoPyDict::into_py_dict_bound(self, py).into()
+    type Target = PyDict;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        let dict = PyDict::new(py);
+        for (k, v) in self {
+            dict.set_item(k, v)?;
+        }
+        Ok(dict)
+    }
+
+    #[cfg(feature = "experimental-inspect")]
+    fn type_output() -> TypeInfo {
+        TypeInfo::dict_of(<&K>::type_output(), <&V>::type_output())
     }
 }
 
-impl<K, V, H> IntoPy<PyObject> for collections::HashMap<K, V, H>
+impl<'py, K, V> IntoPyObject<'py> for collections::BTreeMap<K, V>
 where
-    K: hash::Hash + cmp::Eq + IntoPy<PyObject>,
-    V: IntoPy<PyObject>,
-    H: hash::BuildHasher,
+    K: IntoPyObject<'py> + cmp::Eq,
+    V: IntoPyObject<'py>,
 {
-    fn into_py(self, py: Python<'_>) -> PyObject {
-        let iter = self
-            .into_iter()
-            .map(|(k, v)| (k.into_py(py), v.into_py(py)));
-        IntoPyDict::into_py_dict_bound(iter, py).into()
+    type Target = PyDict;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        let dict = PyDict::new(py);
+        for (k, v) in self {
+            dict.set_item(k, v)?;
+        }
+        Ok(dict)
     }
 
     #[cfg(feature = "experimental-inspect")]
@@ -49,35 +80,47 @@ where
     }
 }
 
-impl<K, V> IntoPy<PyObject> for collections::BTreeMap<K, V>
+impl<'a, 'py, K, V> IntoPyObject<'py> for &'a collections::BTreeMap<K, V>
 where
-    K: cmp::Eq + IntoPy<PyObject>,
-    V: IntoPy<PyObject>,
+    &'a K: IntoPyObject<'py> + cmp::Eq,
+    &'a V: IntoPyObject<'py>,
+    K: 'a,
+    V: 'a,
 {
-    fn into_py(self, py: Python<'_>) -> PyObject {
-        let iter = self
-            .into_iter()
-            .map(|(k, v)| (k.into_py(py), v.into_py(py)));
-        IntoPyDict::into_py_dict_bound(iter, py).into()
+    type Target = PyDict;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        let dict = PyDict::new(py);
+        for (k, v) in self {
+            dict.set_item(k, v)?;
+        }
+        Ok(dict)
     }
 
     #[cfg(feature = "experimental-inspect")]
     fn type_output() -> TypeInfo {
-        TypeInfo::dict_of(K::type_output(), V::type_output())
+        TypeInfo::dict_of(<&K>::type_output(), <&V>::type_output())
     }
 }
 
-impl<'py, K, V, S> FromPyObject<'py> for collections::HashMap<K, V, S>
+impl<'py, K, V, S> FromPyObject<'_, 'py> for collections::HashMap<K, V, S>
 where
-    K: FromPyObject<'py> + cmp::Eq + hash::Hash,
-    V: FromPyObject<'py>,
+    K: FromPyObjectOwned<'py> + cmp::Eq + hash::Hash,
+    V: FromPyObjectOwned<'py>,
     S: hash::BuildHasher + Default,
 {
-    fn extract_bound(ob: &Bound<'py, PyAny>) -> Result<Self, PyErr> {
-        let dict = ob.downcast::<PyDict>()?;
+    type Error = PyErr;
+
+    fn extract(ob: Borrowed<'_, 'py, PyAny>) -> Result<Self, Self::Error> {
+        let dict = ob.cast::<PyDict>()?;
         let mut ret = collections::HashMap::with_capacity_and_hasher(dict.len(), S::default());
         for (k, v) in dict.iter() {
-            ret.insert(k.extract()?, v.extract()?);
+            ret.insert(
+                k.extract().map_err(Into::into)?,
+                v.extract().map_err(Into::into)?,
+            );
         }
         Ok(ret)
     }
@@ -88,16 +131,21 @@ where
     }
 }
 
-impl<'py, K, V> FromPyObject<'py> for collections::BTreeMap<K, V>
+impl<'py, K, V> FromPyObject<'_, 'py> for collections::BTreeMap<K, V>
 where
-    K: FromPyObject<'py> + cmp::Ord,
-    V: FromPyObject<'py>,
+    K: FromPyObjectOwned<'py> + cmp::Ord,
+    V: FromPyObjectOwned<'py>,
 {
-    fn extract_bound(ob: &Bound<'py, PyAny>) -> Result<Self, PyErr> {
-        let dict = ob.downcast::<PyDict>()?;
+    type Error = PyErr;
+
+    fn extract(ob: Borrowed<'_, 'py, PyAny>) -> Result<Self, PyErr> {
+        let dict = ob.cast::<PyDict>()?;
         let mut ret = collections::BTreeMap::new();
         for (k, v) in dict.iter() {
-            ret.insert(k.extract()?, v.extract()?);
+            ret.insert(
+                k.extract().map_err(Into::into)?,
+                v.extract().map_err(Into::into)?,
+            );
         }
         Ok(ret)
     }
@@ -111,19 +159,17 @@ where
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{IntoPy, PyObject, Python, ToPyObject};
     use std::collections::{BTreeMap, HashMap};
 
     #[test]
     fn test_hashmap_to_python() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let mut map = HashMap::<i32, i32>::new();
             map.insert(1, 1);
 
-            let m = map.to_object(py);
-            let py_map: &PyDict = m.downcast(py).unwrap();
+            let py_map = (&map).into_pyobject(py).unwrap();
 
-            assert!(py_map.len() == 1);
+            assert_eq!(py_map.len(), 1);
             assert!(
                 py_map
                     .get_item(1)
@@ -139,14 +185,13 @@ mod tests {
 
     #[test]
     fn test_btreemap_to_python() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let mut map = BTreeMap::<i32, i32>::new();
             map.insert(1, 1);
 
-            let m = map.to_object(py);
-            let py_map: &PyDict = m.downcast(py).unwrap();
+            let py_map = (&map).into_pyobject(py).unwrap();
 
-            assert!(py_map.len() == 1);
+            assert_eq!(py_map.len(), 1);
             assert!(
                 py_map
                     .get_item(1)
@@ -162,14 +207,13 @@ mod tests {
 
     #[test]
     fn test_hashmap_into_python() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let mut map = HashMap::<i32, i32>::new();
             map.insert(1, 1);
 
-            let m: PyObject = map.into_py(py);
-            let py_map: &PyDict = m.downcast(py).unwrap();
+            let py_map = map.into_pyobject(py).unwrap();
 
-            assert!(py_map.len() == 1);
+            assert_eq!(py_map.len(), 1);
             assert!(
                 py_map
                     .get_item(1)
@@ -184,14 +228,13 @@ mod tests {
 
     #[test]
     fn test_btreemap_into_py() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let mut map = BTreeMap::<i32, i32>::new();
             map.insert(1, 1);
 
-            let m: PyObject = map.into_py(py);
-            let py_map: &PyDict = m.downcast(py).unwrap();
+            let py_map = map.into_pyobject(py).unwrap();
 
-            assert!(py_map.len() == 1);
+            assert_eq!(py_map.len(), 1);
             assert!(
                 py_map
                     .get_item(1)
diff --git a/src/conversions/std/mod.rs b/src/conversions/std/mod.rs
index 9b10b59fd3f..c82f2eba98f 100644
--- a/src/conversions/std/mod.rs
+++ b/src/conversions/std/mod.rs
@@ -1,7 +1,10 @@
 mod array;
+mod cell;
+mod cstring;
 mod ipaddr;
 mod map;
-mod num;
+pub(crate) mod num;
+mod option;
 mod osstr;
 mod path;
 mod set;
diff --git a/src/conversions/std/num.rs b/src/conversions/std/num.rs
index 75c2e16b52b..8ecb10527f8 100644
--- a/src/conversions/std/num.rs
+++ b/src/conversions/std/num.rs
@@ -1,28 +1,52 @@
+use crate::conversion::private::Reference;
+use crate::conversion::{FromPyObjectSequence, IntoPyObject};
+use crate::ffi_ptr_ext::FfiPtrExt;
 #[cfg(feature = "experimental-inspect")]
 use crate::inspect::types::TypeInfo;
-use crate::types::any::PyAnyMethods;
-use crate::{
-    exceptions, ffi, Bound, FromPyObject, IntoPy, PyAny, PyErr, PyObject, PyResult, Python,
-    ToPyObject,
-};
-use std::convert::TryFrom;
+#[cfg(feature = "experimental-inspect")]
+use crate::inspect::TypeHint;
+use crate::types::{PyByteArray, PyByteArrayMethods, PyBytes, PyInt};
+use crate::{exceptions, ffi, Borrowed, Bound, FromPyObject, PyAny, PyErr, PyResult, Python};
+use std::convert::Infallible;
+use std::ffi::c_long;
+use std::mem::MaybeUninit;
 use std::num::{
     NonZeroI128, NonZeroI16, NonZeroI32, NonZeroI64, NonZeroI8, NonZeroIsize, NonZeroU128,
     NonZeroU16, NonZeroU32, NonZeroU64, NonZeroU8, NonZeroUsize,
 };
-use std::os::raw::c_long;
+
+use super::array::invalid_sequence_length;
 
 macro_rules! int_fits_larger_int {
     ($rust_type:ty, $larger_type:ty) => {
-        impl ToPyObject for $rust_type {
-            #[inline]
-            fn to_object(&self, py: Python<'_>) -> PyObject {
-                (*self as $larger_type).into_py(py)
+        impl<'py> IntoPyObject<'py> for $rust_type {
+            type Target = PyInt;
+            type Output = Bound<'py, Self::Target>;
+            type Error = Infallible;
+
+            #[cfg(feature = "experimental-inspect")]
+            const OUTPUT_TYPE: TypeHint = <$larger_type>::OUTPUT_TYPE;
+
+            fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+                (self as $larger_type).into_pyobject(py)
+            }
+
+            #[cfg(feature = "experimental-inspect")]
+            fn type_output() -> TypeInfo {
+                <$larger_type>::type_output()
             }
         }
-        impl IntoPy<PyObject> for $rust_type {
-            fn into_py(self, py: Python<'_>) -> PyObject {
-                (self as $larger_type).into_py(py)
+
+        impl<'py> IntoPyObject<'py> for &$rust_type {
+            type Target = PyInt;
+            type Output = Bound<'py, Self::Target>;
+            type Error = Infallible;
+
+            #[cfg(feature = "experimental-inspect")]
+            const OUTPUT_TYPE: TypeHint = <$larger_type>::OUTPUT_TYPE;
+
+            fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+                (*self).into_pyobject(py)
             }
 
             #[cfg(feature = "experimental-inspect")]
@@ -31,8 +55,13 @@ macro_rules! int_fits_larger_int {
             }
         }
 
-        impl FromPyObject<'_> for $rust_type {
-            fn extract_bound(obj: &Bound<'_, PyAny>) -> PyResult<Self> {
+        impl FromPyObject<'_, '_> for $rust_type {
+            type Error = PyErr;
+
+            #[cfg(feature = "experimental-inspect")]
+            const INPUT_TYPE: TypeHint = <$larger_type>::INPUT_TYPE;
+
+            fn extract(obj: Borrowed<'_, '_, PyAny>) -> Result<Self, Self::Error> {
                 let val: $larger_type = obj.extract()?;
                 <$rust_type>::try_from(val)
                     .map_err(|e| exceptions::PyOverflowError::new_err(e.to_string()))
@@ -56,22 +85,16 @@ macro_rules! extract_int {
         // however 3.8 & 3.9 do lossy conversion of floats, hence we only use the
         // simplest logic for 3.10+ where that was fixed - python/cpython#82180.
         // `PyLong_AsUnsignedLongLong` does not call `PyNumber_Index`, hence the `force_index_call` argument
-        // See https://github.com/PyO3/pyo3/pull/3742 for detials
+        // See https://github.com/PyO3/pyo3/pull/3742 for details
         if cfg!(Py_3_10) && !$force_index_call {
             err_if_invalid_value($obj.py(), $error_val, unsafe { $pylong_as($obj.as_ptr()) })
-        } else if let Ok(long) = $obj.downcast::<crate::types::PyLong>() {
+        } else if let Ok(long) = $obj.cast::<crate::types::PyInt>() {
             // fast path - checking for subclass of `int` just checks a bit in the type $object
             err_if_invalid_value($obj.py(), $error_val, unsafe { $pylong_as(long.as_ptr()) })
         } else {
             unsafe {
-                let num = ffi::PyNumber_Index($obj.as_ptr());
-                if num.is_null() {
-                    Err(PyErr::fetch($obj.py()))
-                } else {
-                    let result = err_if_invalid_value($obj.py(), $error_val, $pylong_as(num));
-                    ffi::Py_DECREF(num);
-                    result
-                }
+                let num = ffi::PyNumber_Index($obj.as_ptr()).assume_owned_or_err($obj.py())?;
+                err_if_invalid_value($obj.py(), $error_val, $pylong_as(num.as_ptr()))
             }
         }
     };
@@ -79,16 +102,20 @@ macro_rules! extract_int {
 
 macro_rules! int_convert_u64_or_i64 {
     ($rust_type:ty, $pylong_from_ll_or_ull:expr, $pylong_as_ll_or_ull:expr, $force_index_call:literal) => {
-        impl ToPyObject for $rust_type {
-            #[inline]
-            fn to_object(&self, py: Python<'_>) -> PyObject {
-                unsafe { PyObject::from_owned_ptr(py, $pylong_from_ll_or_ull(*self)) }
-            }
-        }
-        impl IntoPy<PyObject> for $rust_type {
-            #[inline]
-            fn into_py(self, py: Python<'_>) -> PyObject {
-                unsafe { PyObject::from_owned_ptr(py, $pylong_from_ll_or_ull(self)) }
+        impl<'py> IntoPyObject<'py> for $rust_type {
+            type Target = PyInt;
+            type Output = Bound<'py, Self::Target>;
+            type Error = Infallible;
+
+            #[cfg(feature = "experimental-inspect")]
+            const OUTPUT_TYPE: TypeHint = TypeHint::builtin("int");
+
+            fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+                unsafe {
+                    Ok($pylong_from_ll_or_ull(self)
+                        .assume_owned(py)
+                        .cast_into_unchecked())
+                }
             }
 
             #[cfg(feature = "experimental-inspect")]
@@ -96,8 +123,26 @@ macro_rules! int_convert_u64_or_i64 {
                 TypeInfo::builtin("int")
             }
         }
-        impl FromPyObject<'_> for $rust_type {
-            fn extract_bound(obj: &Bound<'_, PyAny>) -> PyResult<$rust_type> {
+        impl<'py> IntoPyObject<'py> for &$rust_type {
+            type Target = PyInt;
+            type Output = Bound<'py, Self::Target>;
+            type Error = Infallible;
+
+            #[cfg(feature = "experimental-inspect")]
+            const OUTPUT_TYPE: TypeHint = <$rust_type>::OUTPUT_TYPE;
+
+            #[inline]
+            fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+                (*self).into_pyobject(py)
+            }
+        }
+        impl FromPyObject<'_, '_> for $rust_type {
+            type Error = PyErr;
+
+            #[cfg(feature = "experimental-inspect")]
+            const INPUT_TYPE: TypeHint = TypeHint::builtin("int");
+
+            fn extract(obj: Borrowed<'_, '_, PyAny>) -> Result<$rust_type, Self::Error> {
                 extract_int!(obj, !0, $pylong_as_ll_or_ull, $force_index_call)
             }
 
@@ -111,14 +156,39 @@ macro_rules! int_convert_u64_or_i64 {
 
 macro_rules! int_fits_c_long {
     ($rust_type:ty) => {
-        impl ToPyObject for $rust_type {
-            fn to_object(&self, py: Python<'_>) -> PyObject {
-                unsafe { PyObject::from_owned_ptr(py, ffi::PyLong_FromLong(*self as c_long)) }
+        impl<'py> IntoPyObject<'py> for $rust_type {
+            type Target = PyInt;
+            type Output = Bound<'py, Self::Target>;
+            type Error = Infallible;
+
+            #[cfg(feature = "experimental-inspect")]
+            const OUTPUT_TYPE: TypeHint = TypeHint::builtin("int");
+
+            fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+                unsafe {
+                    Ok(ffi::PyLong_FromLong(self as c_long)
+                        .assume_owned(py)
+                        .cast_into_unchecked())
+                }
+            }
+
+            #[cfg(feature = "experimental-inspect")]
+            fn type_output() -> TypeInfo {
+                TypeInfo::builtin("int")
             }
         }
-        impl IntoPy<PyObject> for $rust_type {
-            fn into_py(self, py: Python<'_>) -> PyObject {
-                unsafe { PyObject::from_owned_ptr(py, ffi::PyLong_FromLong(self as c_long)) }
+
+        impl<'py> IntoPyObject<'py> for &$rust_type {
+            type Target = PyInt;
+            type Output = Bound<'py, Self::Target>;
+            type Error = Infallible;
+
+            #[cfg(feature = "experimental-inspect")]
+            const OUTPUT_TYPE: TypeHint = <$rust_type>::OUTPUT_TYPE;
+
+            #[inline]
+            fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+                (*self).into_pyobject(py)
             }
 
             #[cfg(feature = "experimental-inspect")]
@@ -127,8 +197,13 @@ macro_rules! int_fits_c_long {
             }
         }
 
-        impl<'py> FromPyObject<'py> for $rust_type {
-            fn extract_bound(obj: &Bound<'_, PyAny>) -> PyResult<Self> {
+        impl<'py> FromPyObject<'_, 'py> for $rust_type {
+            type Error = PyErr;
+
+            #[cfg(feature = "experimental-inspect")]
+            const INPUT_TYPE: TypeHint = TypeHint::builtin("int");
+
+            fn extract(obj: Borrowed<'_, 'py, PyAny>) -> Result<Self, Self::Error> {
                 let val: c_long = extract_int!(obj, -1, ffi::PyLong_AsLong)?;
                 <$rust_type>::try_from(val)
                     .map_err(|e| exceptions::PyOverflowError::new_err(e.to_string()))
@@ -142,8 +217,156 @@ macro_rules! int_fits_c_long {
     };
 }
 
+impl<'py> IntoPyObject<'py> for u8 {
+    type Target = PyInt;
+    type Output = Bound<'py, Self::Target>;
+    type Error = Infallible;
+
+    #[cfg(feature = "experimental-inspect")]
+    const OUTPUT_TYPE: TypeHint = TypeHint::builtin("int");
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        unsafe {
+            Ok(ffi::PyLong_FromLong(self as c_long)
+                .assume_owned(py)
+                .cast_into_unchecked())
+        }
+    }
+
+    #[cfg(feature = "experimental-inspect")]
+    fn type_output() -> TypeInfo {
+        TypeInfo::builtin("int")
+    }
+
+    #[inline]
+    fn owned_sequence_into_pyobject<I>(
+        iter: I,
+        py: Python<'py>,
+        _: crate::conversion::private::Token,
+    ) -> Result<Bound<'py, PyAny>, PyErr>
+    where
+        I: AsRef<[u8]>,
+    {
+        Ok(PyBytes::new(py, iter.as_ref()).into_any())
+    }
+}
+
+impl<'py> IntoPyObject<'py> for &'_ u8 {
+    type Target = PyInt;
+    type Output = Bound<'py, Self::Target>;
+    type Error = Infallible;
+
+    #[cfg(feature = "experimental-inspect")]
+    const OUTPUT_TYPE: TypeHint = u8::OUTPUT_TYPE;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        u8::into_pyobject(*self, py)
+    }
+
+    #[cfg(feature = "experimental-inspect")]
+    fn type_output() -> TypeInfo {
+        TypeInfo::builtin("int")
+    }
+
+    #[inline]
+    fn borrowed_sequence_into_pyobject<I>(
+        iter: I,
+        py: Python<'py>,
+        _: crate::conversion::private::Token,
+    ) -> Result<Bound<'py, PyAny>, PyErr>
+    where
+        // I: AsRef<[u8]>, but the compiler needs it expressed via the trait for some reason
+        I: AsRef<[<Self as Reference>::BaseType]>,
+    {
+        Ok(PyBytes::new(py, iter.as_ref()).into_any())
+    }
+}
+
+impl<'py> FromPyObject<'_, 'py> for u8 {
+    type Error = PyErr;
+
+    #[cfg(feature = "experimental-inspect")]
+    const INPUT_TYPE: TypeHint = TypeHint::builtin("int");
+
+    fn extract(obj: Borrowed<'_, 'py, PyAny>) -> Result<Self, Self::Error> {
+        let val: c_long = extract_int!(obj, -1, ffi::PyLong_AsLong)?;
+        u8::try_from(val).map_err(|e| exceptions::PyOverflowError::new_err(e.to_string()))
+    }
+
+    #[cfg(feature = "experimental-inspect")]
+    fn type_input() -> TypeInfo {
+        Self::type_output()
+    }
+
+    #[inline]
+    fn sequence_extractor(
+        obj: Borrowed<'_, 'py, PyAny>,
+        _: crate::conversion::private::Token,
+    ) -> Option<impl FromPyObjectSequence<Target = u8>> {
+        if let Ok(bytes) = obj.cast::<PyBytes>() {
+            Some(BytesSequenceExtractor::Bytes(bytes))
+        } else if let Ok(byte_array) = obj.cast::<PyByteArray>() {
+            Some(BytesSequenceExtractor::ByteArray(byte_array))
+        } else {
+            None
+        }
+    }
+}
+
+pub(crate) enum BytesSequenceExtractor<'a, 'py> {
+    Bytes(Borrowed<'a, 'py, PyBytes>),
+    ByteArray(Borrowed<'a, 'py, PyByteArray>),
+}
+
+impl BytesSequenceExtractor<'_, '_> {
+    fn fill_slice(&self, out: &mut [MaybeUninit<u8>]) -> PyResult<()> {
+        let mut copy_slice = |slice: &[u8]| {
+            if slice.len() != out.len() {
+                return Err(invalid_sequence_length(out.len(), slice.len()));
+            }
+            // Safety: `slice` and `out` are guaranteed not to overlap due to `&mut` reference on `out`.
+            unsafe {
+                std::ptr::copy_nonoverlapping(slice.as_ptr(), out.as_mut_ptr().cast(), out.len())
+            };
+            Ok(())
+        };
+
+        match self {
+            BytesSequenceExtractor::Bytes(b) => copy_slice(b.as_bytes()),
+            BytesSequenceExtractor::ByteArray(b) => crate::sync::with_critical_section(b, || {
+                // Safety: b is protected by a critical section
+                copy_slice(unsafe { b.as_bytes() })
+            }),
+        }
+    }
+}
+
+impl FromPyObjectSequence for BytesSequenceExtractor<'_, '_> {
+    type Target = u8;
+
+    fn to_vec(&self) -> Vec<Self::Target> {
+        match self {
+            BytesSequenceExtractor::Bytes(b) => b.as_bytes().to_vec(),
+            BytesSequenceExtractor::ByteArray(b) => b.to_vec(),
+        }
+    }
+
+    fn to_array<const N: usize>(&self) -> PyResult<[u8; N]> {
+        let mut out: MaybeUninit<[u8; N]> = MaybeUninit::uninit();
+
+        // Safety: `[u8; N]` has the same layout as `[MaybeUninit<u8>; N]`
+        let slice = unsafe {
+            std::slice::from_raw_parts_mut(out.as_mut_ptr().cast::<MaybeUninit<u8>>(), N)
+        };
+
+        self.fill_slice(slice)?;
+
+        // Safety: `out` is fully initialized
+        Ok(unsafe { out.assume_init() })
+    }
+}
+
 int_fits_c_long!(i8);
-int_fits_c_long!(u8);
 int_fits_c_long!(i16);
 int_fits_c_long!(u16);
 int_fits_c_long!(i32);
@@ -182,28 +405,45 @@ mod fast_128bit_int_conversion {
 
     // for 128bit Integers
     macro_rules! int_convert_128 {
-        ($rust_type: ty, $is_signed: expr) => {
-            impl ToPyObject for $rust_type {
-                #[inline]
-                fn to_object(&self, py: Python<'_>) -> PyObject {
-                    (*self).into_py(py)
+        ($rust_type: ty, $is_signed: literal) => {
+            impl<'py> IntoPyObject<'py> for $rust_type {
+                type Target = PyInt;
+                type Output = Bound<'py, Self::Target>;
+                type Error = Infallible;
+
+                #[cfg(feature = "experimental-inspect")]
+                const OUTPUT_TYPE: TypeHint = TypeHint::builtin("int");
+
+                fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+                    #[cfg(Py_3_13)]
+                    {
+                        let bytes = self.to_ne_bytes();
+                        Ok(int_from_ne_bytes::<{ $is_signed }>(py, &bytes))
+                    }
+                    #[cfg(not(Py_3_13))]
+                    {
+                        let bytes = self.to_le_bytes();
+                        Ok(int_from_le_bytes::<{ $is_signed }>(py, &bytes))
+                    }
+                }
+
+                #[cfg(feature = "experimental-inspect")]
+                fn type_output() -> TypeInfo {
+                    TypeInfo::builtin("int")
                 }
             }
-            impl IntoPy<PyObject> for $rust_type {
-                fn into_py(self, py: Python<'_>) -> PyObject {
-                    // Always use little endian
-                    let bytes = self.to_le_bytes();
-                    unsafe {
-                        PyObject::from_owned_ptr(
-                            py,
-                            ffi::_PyLong_FromByteArray(
-                                bytes.as_ptr() as *const std::os::raw::c_uchar,
-                                bytes.len(),
-                                1,
-                                $is_signed,
-                            ),
-                        )
-                    }
+
+            impl<'py> IntoPyObject<'py> for &$rust_type {
+                type Target = PyInt;
+                type Output = Bound<'py, Self::Target>;
+                type Error = Infallible;
+
+                #[cfg(feature = "experimental-inspect")]
+                const OUTPUT_TYPE: TypeHint = <$rust_type>::OUTPUT_TYPE;
+
+                #[inline]
+                fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+                    (*self).into_pyobject(py)
                 }
 
                 #[cfg(feature = "experimental-inspect")]
@@ -212,22 +452,56 @@ mod fast_128bit_int_conversion {
                 }
             }
 
-            impl FromPyObject<'_> for $rust_type {
-                fn extract_bound(ob: &Bound<'_, PyAny>) -> PyResult<$rust_type> {
-                    let num = unsafe {
-                        PyObject::from_owned_ptr_or_err(ob.py(), ffi::PyNumber_Index(ob.as_ptr()))?
-                    };
-                    let mut buffer = [0; std::mem::size_of::<$rust_type>()];
-                    crate::err::error_on_minusone(ob.py(), unsafe {
-                        ffi::_PyLong_AsByteArray(
-                            num.as_ptr() as *mut ffi::PyLongObject,
-                            buffer.as_mut_ptr(),
-                            buffer.len(),
-                            1,
-                            $is_signed,
-                        )
-                    })?;
-                    Ok(<$rust_type>::from_le_bytes(buffer))
+            impl FromPyObject<'_, '_> for $rust_type {
+                type Error = PyErr;
+
+                #[cfg(feature = "experimental-inspect")]
+                const INPUT_TYPE: TypeHint = TypeHint::builtin("int");
+
+                fn extract(ob: Borrowed<'_, '_, PyAny>) -> Result<$rust_type, Self::Error> {
+                    let num =
+                        unsafe { ffi::PyNumber_Index(ob.as_ptr()).assume_owned_or_err(ob.py())? };
+                    let mut buffer = [0u8; std::mem::size_of::<$rust_type>()];
+                    #[cfg(not(Py_3_13))]
+                    {
+                        crate::err::error_on_minusone(ob.py(), unsafe {
+                            ffi::_PyLong_AsByteArray(
+                                num.as_ptr() as *mut ffi::PyLongObject,
+                                buffer.as_mut_ptr(),
+                                buffer.len(),
+                                1,
+                                $is_signed.into(),
+                            )
+                        })?;
+                        Ok(<$rust_type>::from_le_bytes(buffer))
+                    }
+                    #[cfg(Py_3_13)]
+                    {
+                        let mut flags = ffi::Py_ASNATIVEBYTES_NATIVE_ENDIAN;
+                        if !$is_signed {
+                            flags |= ffi::Py_ASNATIVEBYTES_UNSIGNED_BUFFER
+                                | ffi::Py_ASNATIVEBYTES_REJECT_NEGATIVE;
+                        }
+                        let actual_size: usize = unsafe {
+                            ffi::PyLong_AsNativeBytes(
+                                num.as_ptr(),
+                                buffer.as_mut_ptr().cast(),
+                                buffer
+                                    .len()
+                                    .try_into()
+                                    .expect("length of buffer fits in Py_ssize_t"),
+                                flags,
+                            )
+                        }
+                        .try_into()
+                        .map_err(|_| PyErr::fetch(ob.py()))?;
+                        if actual_size as usize > buffer.len() {
+                            return Err(crate::exceptions::PyOverflowError::new_err(
+                                "Python int larger than 128 bits",
+                            ));
+                        }
+                        Ok(<$rust_type>::from_ne_bytes(buffer))
+                    }
                 }
 
                 #[cfg(feature = "experimental-inspect")]
@@ -238,40 +512,68 @@ mod fast_128bit_int_conversion {
         };
     }
 
-    int_convert_128!(i128, 1);
-    int_convert_128!(u128, 0);
+    int_convert_128!(i128, true);
+    int_convert_128!(u128, false);
+}
+
+#[cfg(all(not(Py_LIMITED_API), not(Py_3_13)))]
+pub(crate) fn int_from_le_bytes<'py, const IS_SIGNED: bool>(
+    py: Python<'py>,
+    bytes: &[u8],
+) -> Bound<'py, PyInt> {
+    unsafe {
+        ffi::_PyLong_FromByteArray(bytes.as_ptr().cast(), bytes.len(), 1, IS_SIGNED.into())
+            .assume_owned(py)
+            .cast_into_unchecked()
+    }
+}
+
+#[cfg(all(Py_3_13, not(Py_LIMITED_API)))]
+pub(crate) fn int_from_ne_bytes<'py, const IS_SIGNED: bool>(
+    py: Python<'py>,
+    bytes: &[u8],
+) -> Bound<'py, PyInt> {
+    let flags = if IS_SIGNED {
+        ffi::Py_ASNATIVEBYTES_NATIVE_ENDIAN
+    } else {
+        ffi::Py_ASNATIVEBYTES_NATIVE_ENDIAN | ffi::Py_ASNATIVEBYTES_UNSIGNED_BUFFER
+    };
+    unsafe {
+        ffi::PyLong_FromNativeBytes(bytes.as_ptr().cast(), bytes.len(), flags)
+            .assume_owned(py)
+            .cast_into_unchecked()
+    }
 }
 
 // For ABI3 we implement the conversion manually.
 #[cfg(Py_LIMITED_API)]
 mod slow_128bit_int_conversion {
     use super::*;
+    use crate::types::any::PyAnyMethods as _;
     const SHIFT: usize = 64;
 
     // for 128bit Integers
     macro_rules! int_convert_128 {
         ($rust_type: ty, $half_type: ty) => {
-            impl ToPyObject for $rust_type {
-                #[inline]
-                fn to_object(&self, py: Python<'_>) -> PyObject {
-                    (*self).into_py(py)
-                }
-            }
+            impl<'py> IntoPyObject<'py> for $rust_type {
+                type Target = PyInt;
+                type Output = Bound<'py, Self::Target>;
+                type Error = Infallible;
+
+                #[cfg(feature = "experimental-inspect")]
+                const OUTPUT_TYPE: TypeHint = TypeHint::builtin("int");
 
-            impl IntoPy<PyObject> for $rust_type {
-                fn into_py(self, py: Python<'_>) -> PyObject {
-                    let lower = (self as u64).into_py(py);
-                    let upper = ((self >> SHIFT) as $half_type).into_py(py);
-                    let shift = SHIFT.into_py(py);
+                fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+                    let lower = (self as u64).into_pyobject(py)?;
+                    let upper = ((self >> SHIFT) as $half_type).into_pyobject(py)?;
+                    let shift = SHIFT.into_pyobject(py)?;
                     unsafe {
-                        let shifted = PyObject::from_owned_ptr(
-                            py,
-                            ffi::PyNumber_Lshift(upper.as_ptr(), shift.as_ptr()),
-                        );
-                        PyObject::from_owned_ptr(
-                            py,
-                            ffi::PyNumber_Or(shifted.as_ptr(), lower.as_ptr()),
-                        )
+                        let shifted =
+                            ffi::PyNumber_Lshift(upper.as_ptr(), shift.as_ptr()).assume_owned(py);
+
+                        Ok(ffi::PyNumber_Or(shifted.as_ptr(), lower.as_ptr())
+                            .assume_owned(py)
+                            .cast_into_unchecked())
                     }
                 }
 
@@ -281,8 +583,32 @@ mod slow_128bit_int_conversion {
                 }
             }
 
-            impl FromPyObject<'_> for $rust_type {
-                fn extract_bound(ob: &Bound<'_, PyAny>) -> PyResult<$rust_type> {
+            impl<'py> IntoPyObject<'py> for &$rust_type {
+                type Target = PyInt;
+                type Output = Bound<'py, Self::Target>;
+                type Error = Infallible;
+
+                #[cfg(feature = "experimental-inspect")]
+                const OUTPUT_TYPE: TypeHint = <$rust_type>::OUTPUT_TYPE;
+
+                #[inline]
+                fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+                    (*self).into_pyobject(py)
+                }
+
+                #[cfg(feature = "experimental-inspect")]
+                fn type_output() -> TypeInfo {
+                    TypeInfo::builtin("int")
+                }
+            }
+
+            impl FromPyObject<'_, '_> for $rust_type {
+                type Error = PyErr;
+
+                #[cfg(feature = "experimental-inspect")]
+                const INPUT_TYPE: TypeHint = TypeHint::builtin("int");
+
+                fn extract(ob: Borrowed<'_, '_, PyAny>) -> Result<$rust_type, Self::Error> {
                     let py = ob.py();
                     unsafe {
                         let lower = err_if_invalid_value(
@@ -290,12 +616,12 @@ mod slow_128bit_int_conversion {
                             -1 as _,
                             ffi::PyLong_AsUnsignedLongLongMask(ob.as_ptr()),
                         )? as $rust_type;
-                        let shift = SHIFT.into_py(py);
-                        let shifted = PyObject::from_owned_ptr_or_err(
+                        let shift = SHIFT.into_pyobject(py)?;
+                        let shifted = Bound::from_owned_ptr_or_err(
                             py,
                             ffi::PyNumber_Rshift(ob.as_ptr(), shift.as_ptr()),
                         )?;
-                        let upper: $half_type = shifted.extract(py)?;
+                        let upper: $half_type = shifted.extract()?;
                         Ok((<$rust_type>::from(upper) << SHIFT) | lower)
                     }
                 }
@@ -328,20 +654,51 @@ fn err_if_invalid_value<T: PartialEq>(
 
 macro_rules! nonzero_int_impl {
     ($nonzero_type:ty, $primitive_type:ty) => {
-        impl ToPyObject for $nonzero_type {
-            fn to_object(&self, py: Python<'_>) -> PyObject {
-                self.get().to_object(py)
+        impl<'py> IntoPyObject<'py> for $nonzero_type {
+            type Target = PyInt;
+            type Output = Bound<'py, Self::Target>;
+            type Error = Infallible;
+
+            #[cfg(feature = "experimental-inspect")]
+            const OUTPUT_TYPE: TypeHint = TypeHint::builtin("int");
+
+            #[inline]
+            fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+                self.get().into_pyobject(py)
+            }
+
+            #[cfg(feature = "experimental-inspect")]
+            fn type_output() -> TypeInfo {
+                TypeInfo::builtin("int")
             }
         }
 
-        impl IntoPy<PyObject> for $nonzero_type {
-            fn into_py(self, py: Python<'_>) -> PyObject {
-                self.get().into_py(py)
+        impl<'py> IntoPyObject<'py> for &$nonzero_type {
+            type Target = PyInt;
+            type Output = Bound<'py, Self::Target>;
+            type Error = Infallible;
+
+            #[cfg(feature = "experimental-inspect")]
+            const OUTPUT_TYPE: TypeHint = <$nonzero_type>::OUTPUT_TYPE;
+
+            #[inline]
+            fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+                (*self).into_pyobject(py)
+            }
+
+            #[cfg(feature = "experimental-inspect")]
+            fn type_output() -> TypeInfo {
+                TypeInfo::builtin("int")
             }
         }
 
-        impl FromPyObject<'_> for $nonzero_type {
-            fn extract_bound(obj: &Bound<'_, PyAny>) -> PyResult<Self> {
+        impl FromPyObject<'_, '_> for $nonzero_type {
+            type Error = PyErr;
+
+            #[cfg(feature = "experimental-inspect")]
+            const INPUT_TYPE: TypeHint = <$primitive_type>::INPUT_TYPE;
+
+            fn extract(obj: Borrowed<'_, '_, PyAny>) -> Result<Self, Self::Error> {
                 let val: $primitive_type = obj.extract()?;
                 <$nonzero_type>::try_from(val)
                     .map_err(|_| exceptions::PyValueError::new_err("invalid zero value"))
@@ -371,7 +728,7 @@ nonzero_int_impl!(NonZeroUsize, usize);
 #[cfg(test)]
 mod test_128bit_integers {
     use super::*;
-    use crate::types::any::PyAnyMethods;
+    use crate::types::PyAnyMethods;
 
     #[cfg(not(target_arch = "wasm32"))]
     use crate::types::PyDict;
@@ -382,16 +739,19 @@ mod test_128bit_integers {
     #[cfg(not(target_arch = "wasm32"))]
     use proptest::prelude::*;
 
+    #[cfg(not(target_arch = "wasm32"))]
+    use std::ffi::CString;
+
     #[cfg(not(target_arch = "wasm32"))]
     proptest! {
         #[test]
         fn test_i128_roundtrip(x: i128) {
-            Python::with_gil(|py| {
-                let x_py = x.into_py(py);
-                let locals = PyDict::new_bound(py);
-                locals.set_item("x_py", x_py.clone_ref(py)).unwrap();
-                py.run_bound(&format!("assert x_py == {}", x), None, Some(&locals)).unwrap();
-                let roundtripped: i128 = x_py.extract(py).unwrap();
+            Python::attach(|py| {
+                let x_py = x.into_pyobject(py).unwrap();
+                let locals = PyDict::new(py);
+                locals.set_item("x_py", &x_py).unwrap();
+                py.run(&CString::new(format!("assert x_py == {x}")).unwrap(), None, Some(&locals)).unwrap();
+                let roundtripped: i128 = x_py.extract().unwrap();
                 assert_eq!(x, roundtripped);
             })
         }
@@ -402,12 +762,12 @@ mod test_128bit_integers {
                 .prop_filter("Values must not be 0", |x| x != &0)
                 .prop_map(|x| NonZeroI128::new(x).unwrap())
         ) {
-            Python::with_gil(|py| {
-                let x_py = x.into_py(py);
-                let locals = PyDict::new_bound(py);
-                locals.set_item("x_py", x_py.clone_ref(py)).unwrap();
-                py.run_bound(&format!("assert x_py == {}", x), None, Some(&locals)).unwrap();
-                let roundtripped: NonZeroI128 = x_py.extract(py).unwrap();
+            Python::attach(|py| {
+                let x_py = x.into_pyobject(py).unwrap();
+                let locals = PyDict::new(py);
+                locals.set_item("x_py", &x_py).unwrap();
+                py.run(&CString::new(format!("assert x_py == {x}")).unwrap(), None, Some(&locals)).unwrap();
+                let roundtripped: NonZeroI128 = x_py.extract().unwrap();
                 assert_eq!(x, roundtripped);
             })
         }
@@ -417,12 +777,12 @@ mod test_128bit_integers {
     proptest! {
         #[test]
         fn test_u128_roundtrip(x: u128) {
-            Python::with_gil(|py| {
-                let x_py = x.into_py(py);
-                let locals = PyDict::new_bound(py);
-                locals.set_item("x_py", x_py.clone_ref(py)).unwrap();
-                py.run_bound(&format!("assert x_py == {}", x), None, Some(&locals)).unwrap();
-                let roundtripped: u128 = x_py.extract(py).unwrap();
+            Python::attach(|py| {
+                let x_py = x.into_pyobject(py).unwrap();
+                let locals = PyDict::new(py);
+                locals.set_item("x_py", &x_py).unwrap();
+                py.run(&CString::new(format!("assert x_py == {x}")).unwrap(), None, Some(&locals)).unwrap();
+                let roundtripped: u128 = x_py.extract().unwrap();
                 assert_eq!(x, roundtripped);
             })
         }
@@ -433,12 +793,12 @@ mod test_128bit_integers {
                 .prop_filter("Values must not be 0", |x| x != &0)
                 .prop_map(|x| NonZeroU128::new(x).unwrap())
         ) {
-            Python::with_gil(|py| {
-                let x_py = x.into_py(py);
-                let locals = PyDict::new_bound(py);
-                locals.set_item("x_py", x_py.clone_ref(py)).unwrap();
-                py.run_bound(&format!("assert x_py == {}", x), None, Some(&locals)).unwrap();
-                let roundtripped: NonZeroU128 = x_py.extract(py).unwrap();
+            Python::attach(|py| {
+                let x_py = x.into_pyobject(py).unwrap();
+                let locals = PyDict::new(py);
+                locals.set_item("x_py", &x_py).unwrap();
+                py.run(&CString::new(format!("assert x_py == {x}")).unwrap(), None, Some(&locals)).unwrap();
+                let roundtripped: NonZeroU128 = x_py.extract().unwrap();
                 assert_eq!(x, roundtripped);
             })
         }
@@ -446,40 +806,40 @@ mod test_128bit_integers {
 
     #[test]
     fn test_i128_max() {
-        Python::with_gil(|py| {
-            let v = std::i128::MAX;
-            let obj = v.to_object(py);
-            assert_eq!(v, obj.extract::<i128>(py).unwrap());
-            assert_eq!(v as u128, obj.extract::<u128>(py).unwrap());
-            assert!(obj.extract::<u64>(py).is_err());
+        Python::attach(|py| {
+            let v = i128::MAX;
+            let obj = v.into_pyobject(py).unwrap();
+            assert_eq!(v, obj.extract::<i128>().unwrap());
+            assert_eq!(v as u128, obj.extract::<u128>().unwrap());
+            assert!(obj.extract::<u64>().is_err());
         })
     }
 
     #[test]
     fn test_i128_min() {
-        Python::with_gil(|py| {
-            let v = std::i128::MIN;
-            let obj = v.to_object(py);
-            assert_eq!(v, obj.extract::<i128>(py).unwrap());
-            assert!(obj.extract::<i64>(py).is_err());
-            assert!(obj.extract::<u128>(py).is_err());
+        Python::attach(|py| {
+            let v = i128::MIN;
+            let obj = v.into_pyobject(py).unwrap();
+            assert_eq!(v, obj.extract::<i128>().unwrap());
+            assert!(obj.extract::<i64>().is_err());
+            assert!(obj.extract::<u128>().is_err());
         })
     }
 
     #[test]
     fn test_u128_max() {
-        Python::with_gil(|py| {
-            let v = std::u128::MAX;
-            let obj = v.to_object(py);
-            assert_eq!(v, obj.extract::<u128>(py).unwrap());
-            assert!(obj.extract::<i128>(py).is_err());
+        Python::attach(|py| {
+            let v = u128::MAX;
+            let obj = v.into_pyobject(py).unwrap();
+            assert_eq!(v, obj.extract::<u128>().unwrap());
+            assert!(obj.extract::<i128>().is_err());
         })
     }
 
     #[test]
     fn test_i128_overflow() {
-        Python::with_gil(|py| {
-            let obj = py.eval_bound("(1 << 130) * -1", None, None).unwrap();
+        Python::attach(|py| {
+            let obj = py.eval(c"(1 << 130) * -1", None, None).unwrap();
             let err = obj.extract::<i128>().unwrap_err();
             assert!(err.is_instance_of::<crate::exceptions::PyOverflowError>(py));
         })
@@ -487,8 +847,8 @@ mod test_128bit_integers {
 
     #[test]
     fn test_u128_overflow() {
-        Python::with_gil(|py| {
-            let obj = py.eval_bound("1 << 130", None, None).unwrap();
+        Python::attach(|py| {
+            let obj = py.eval(c"1 << 130", None, None).unwrap();
             let err = obj.extract::<u128>().unwrap_err();
             assert!(err.is_instance_of::<crate::exceptions::PyOverflowError>(py));
         })
@@ -496,43 +856,43 @@ mod test_128bit_integers {
 
     #[test]
     fn test_nonzero_i128_max() {
-        Python::with_gil(|py| {
-            let v = NonZeroI128::new(std::i128::MAX).unwrap();
-            let obj = v.to_object(py);
-            assert_eq!(v, obj.extract::<NonZeroI128>(py).unwrap());
+        Python::attach(|py| {
+            let v = NonZeroI128::new(i128::MAX).unwrap();
+            let obj = v.into_pyobject(py).unwrap();
+            assert_eq!(v, obj.extract::<NonZeroI128>().unwrap());
             assert_eq!(
                 NonZeroU128::new(v.get() as u128).unwrap(),
-                obj.extract::<NonZeroU128>(py).unwrap()
+                obj.extract::<NonZeroU128>().unwrap()
             );
-            assert!(obj.extract::<NonZeroU64>(py).is_err());
+            assert!(obj.extract::<NonZeroU64>().is_err());
         })
     }
 
     #[test]
     fn test_nonzero_i128_min() {
-        Python::with_gil(|py| {
-            let v = NonZeroI128::new(std::i128::MIN).unwrap();
-            let obj = v.to_object(py);
-            assert_eq!(v, obj.extract::<NonZeroI128>(py).unwrap());
-            assert!(obj.extract::<NonZeroI64>(py).is_err());
-            assert!(obj.extract::<NonZeroU128>(py).is_err());
+        Python::attach(|py| {
+            let v = NonZeroI128::new(i128::MIN).unwrap();
+            let obj = v.into_pyobject(py).unwrap();
+            assert_eq!(v, obj.extract::<NonZeroI128>().unwrap());
+            assert!(obj.extract::<NonZeroI64>().is_err());
+            assert!(obj.extract::<NonZeroU128>().is_err());
         })
     }
 
     #[test]
     fn test_nonzero_u128_max() {
-        Python::with_gil(|py| {
-            let v = NonZeroU128::new(std::u128::MAX).unwrap();
-            let obj = v.to_object(py);
-            assert_eq!(v, obj.extract::<NonZeroU128>(py).unwrap());
-            assert!(obj.extract::<NonZeroI128>(py).is_err());
+        Python::attach(|py| {
+            let v = NonZeroU128::new(u128::MAX).unwrap();
+            let obj = v.into_pyobject(py).unwrap();
+            assert_eq!(v, obj.extract::<NonZeroU128>().unwrap());
+            assert!(obj.extract::<NonZeroI128>().is_err());
         })
     }
 
     #[test]
     fn test_nonzero_i128_overflow() {
-        Python::with_gil(|py| {
-            let obj = py.eval_bound("(1 << 130) * -1", None, None).unwrap();
+        Python::attach(|py| {
+            let obj = py.eval(c"(1 << 130) * -1", None, None).unwrap();
             let err = obj.extract::<NonZeroI128>().unwrap_err();
             assert!(err.is_instance_of::<crate::exceptions::PyOverflowError>(py));
         })
@@ -540,8 +900,8 @@ mod test_128bit_integers {
 
     #[test]
     fn test_nonzero_u128_overflow() {
-        Python::with_gil(|py| {
-            let obj = py.eval_bound("1 << 130", None, None).unwrap();
+        Python::attach(|py| {
+            let obj = py.eval(c"1 << 130", None, None).unwrap();
             let err = obj.extract::<NonZeroU128>().unwrap_err();
             assert!(err.is_instance_of::<crate::exceptions::PyOverflowError>(py));
         })
@@ -549,8 +909,8 @@ mod test_128bit_integers {
 
     #[test]
     fn test_nonzero_i128_zero_value() {
-        Python::with_gil(|py| {
-            let obj = py.eval_bound("0", None, None).unwrap();
+        Python::attach(|py| {
+            let obj = py.eval(c"0", None, None).unwrap();
             let err = obj.extract::<NonZeroI128>().unwrap_err();
             assert!(err.is_instance_of::<crate::exceptions::PyValueError>(py));
         })
@@ -558,8 +918,8 @@ mod test_128bit_integers {
 
     #[test]
     fn test_nonzero_u128_zero_value() {
-        Python::with_gil(|py| {
-            let obj = py.eval_bound("0", None, None).unwrap();
+        Python::attach(|py| {
+            let obj = py.eval(c"0", None, None).unwrap();
             let err = obj.extract::<NonZeroU128>().unwrap_err();
             assert!(err.is_instance_of::<crate::exceptions::PyValueError>(py));
         })
@@ -568,50 +928,50 @@ mod test_128bit_integers {
 
 #[cfg(test)]
 mod tests {
-    use crate::Python;
-    use crate::ToPyObject;
+    use crate::types::PyAnyMethods;
+    use crate::{IntoPyObject, Python};
     use std::num::*;
 
     #[test]
     fn test_u32_max() {
-        Python::with_gil(|py| {
-            let v = std::u32::MAX;
-            let obj = v.to_object(py);
-            assert_eq!(v, obj.extract::<u32>(py).unwrap());
-            assert_eq!(u64::from(v), obj.extract::<u64>(py).unwrap());
-            assert!(obj.extract::<i32>(py).is_err());
+        Python::attach(|py| {
+            let v = u32::MAX;
+            let obj = v.into_pyobject(py).unwrap();
+            assert_eq!(v, obj.extract::<u32>().unwrap());
+            assert_eq!(u64::from(v), obj.extract::<u64>().unwrap());
+            assert!(obj.extract::<i32>().is_err());
         });
     }
 
     #[test]
     fn test_i64_max() {
-        Python::with_gil(|py| {
-            let v = std::i64::MAX;
-            let obj = v.to_object(py);
-            assert_eq!(v, obj.extract::<i64>(py).unwrap());
-            assert_eq!(v as u64, obj.extract::<u64>(py).unwrap());
-            assert!(obj.extract::<u32>(py).is_err());
+        Python::attach(|py| {
+            let v = i64::MAX;
+            let obj = v.into_pyobject(py).unwrap();
+            assert_eq!(v, obj.extract::<i64>().unwrap());
+            assert_eq!(v as u64, obj.extract::<u64>().unwrap());
+            assert!(obj.extract::<u32>().is_err());
         });
     }
 
     #[test]
     fn test_i64_min() {
-        Python::with_gil(|py| {
-            let v = std::i64::MIN;
-            let obj = v.to_object(py);
-            assert_eq!(v, obj.extract::<i64>(py).unwrap());
-            assert!(obj.extract::<i32>(py).is_err());
-            assert!(obj.extract::<u64>(py).is_err());
+        Python::attach(|py| {
+            let v = i64::MIN;
+            let obj = v.into_pyobject(py).unwrap();
+            assert_eq!(v, obj.extract::<i64>().unwrap());
+            assert!(obj.extract::<i32>().is_err());
+            assert!(obj.extract::<u64>().is_err());
         });
     }
 
     #[test]
     fn test_u64_max() {
-        Python::with_gil(|py| {
-            let v = std::u64::MAX;
-            let obj = v.to_object(py);
-            assert_eq!(v, obj.extract::<u64>(py).unwrap());
-            assert!(obj.extract::<i64>(py).is_err());
+        Python::attach(|py| {
+            let v = u64::MAX;
+            let obj = v.into_pyobject(py).unwrap();
+            assert_eq!(v, obj.extract::<u64>().unwrap());
+            assert!(obj.extract::<i64>().is_err());
         });
     }
 
@@ -619,32 +979,33 @@ mod tests {
         ($test_mod_name:ident, $t:ty) => (
             mod $test_mod_name {
                 use crate::exceptions;
-                use crate::ToPyObject;
+                use crate::conversion::IntoPyObject;
+                use crate::types::PyAnyMethods;
                 use crate::Python;
 
                 #[test]
                 fn from_py_string_type_error() {
-                    Python::with_gil(|py| {
-                    let obj = ("123").to_object(py);
-                    let err = obj.extract::<$t>(py).unwrap_err();
+                    Python::attach(|py| {
+                    let obj = ("123").into_pyobject(py).unwrap();
+                    let err = obj.extract::<$t>().unwrap_err();
                     assert!(err.is_instance_of::<exceptions::PyTypeError>(py));
                     });
                 }
 
                 #[test]
                 fn from_py_float_type_error() {
-                    Python::with_gil(|py| {
-                    let obj = (12.3).to_object(py);
-                    let err = obj.extract::<$t>(py).unwrap_err();
+                    Python::attach(|py| {
+                    let obj = (12.3f64).into_pyobject(py).unwrap();
+                    let err = obj.extract::<$t>().unwrap_err();
                     assert!(err.is_instance_of::<exceptions::PyTypeError>(py));});
                 }
 
                 #[test]
                 fn to_py_object_and_back() {
-                    Python::with_gil(|py| {
+                    Python::attach(|py| {
                     let val = 123 as $t;
-                    let obj = val.to_object(py);
-                    assert_eq!(obj.extract::<$t>(py).unwrap(), val as $t);});
+                    let obj = val.into_pyobject(py).unwrap();
+                    assert_eq!(obj.extract::<$t>().unwrap(), val as $t);});
                 }
             }
         )
@@ -665,47 +1026,47 @@ mod tests {
 
     #[test]
     fn test_nonzero_u32_max() {
-        Python::with_gil(|py| {
-            let v = NonZeroU32::new(std::u32::MAX).unwrap();
-            let obj = v.to_object(py);
-            assert_eq!(v, obj.extract::<NonZeroU32>(py).unwrap());
-            assert_eq!(NonZeroU64::from(v), obj.extract::<NonZeroU64>(py).unwrap());
-            assert!(obj.extract::<NonZeroI32>(py).is_err());
+        Python::attach(|py| {
+            let v = NonZeroU32::new(u32::MAX).unwrap();
+            let obj = v.into_pyobject(py).unwrap();
+            assert_eq!(v, obj.extract::<NonZeroU32>().unwrap());
+            assert_eq!(NonZeroU64::from(v), obj.extract::<NonZeroU64>().unwrap());
+            assert!(obj.extract::<NonZeroI32>().is_err());
         });
     }
 
     #[test]
     fn test_nonzero_i64_max() {
-        Python::with_gil(|py| {
-            let v = NonZeroI64::new(std::i64::MAX).unwrap();
-            let obj = v.to_object(py);
-            assert_eq!(v, obj.extract::<NonZeroI64>(py).unwrap());
+        Python::attach(|py| {
+            let v = NonZeroI64::new(i64::MAX).unwrap();
+            let obj = v.into_pyobject(py).unwrap();
+            assert_eq!(v, obj.extract::<NonZeroI64>().unwrap());
             assert_eq!(
                 NonZeroU64::new(v.get() as u64).unwrap(),
-                obj.extract::<NonZeroU64>(py).unwrap()
+                obj.extract::<NonZeroU64>().unwrap()
             );
-            assert!(obj.extract::<NonZeroU32>(py).is_err());
+            assert!(obj.extract::<NonZeroU32>().is_err());
         });
     }
 
     #[test]
     fn test_nonzero_i64_min() {
-        Python::with_gil(|py| {
-            let v = NonZeroI64::new(std::i64::MIN).unwrap();
-            let obj = v.to_object(py);
-            assert_eq!(v, obj.extract::<NonZeroI64>(py).unwrap());
-            assert!(obj.extract::<NonZeroI32>(py).is_err());
-            assert!(obj.extract::<NonZeroU64>(py).is_err());
+        Python::attach(|py| {
+            let v = NonZeroI64::new(i64::MIN).unwrap();
+            let obj = v.into_pyobject(py).unwrap();
+            assert_eq!(v, obj.extract::<NonZeroI64>().unwrap());
+            assert!(obj.extract::<NonZeroI32>().is_err());
+            assert!(obj.extract::<NonZeroU64>().is_err());
         });
     }
 
     #[test]
     fn test_nonzero_u64_max() {
-        Python::with_gil(|py| {
-            let v = NonZeroU64::new(std::u64::MAX).unwrap();
-            let obj = v.to_object(py);
-            assert_eq!(v, obj.extract::<NonZeroU64>(py).unwrap());
-            assert!(obj.extract::<NonZeroI64>(py).is_err());
+        Python::attach(|py| {
+            let v = NonZeroU64::new(u64::MAX).unwrap();
+            let obj = v.into_pyobject(py).unwrap();
+            assert_eq!(v, obj.extract::<NonZeroU64>().unwrap());
+            assert!(obj.extract::<NonZeroI64>().is_err());
         });
     }
 
@@ -713,33 +1074,34 @@ mod tests {
         ($test_mod_name:ident, $t:ty) => (
             mod $test_mod_name {
                 use crate::exceptions;
-                use crate::ToPyObject;
+                use crate::conversion::IntoPyObject;
+                use crate::types::PyAnyMethods;
                 use crate::Python;
                 use std::num::*;
 
                 #[test]
                 fn from_py_string_type_error() {
-                    Python::with_gil(|py| {
-                    let obj = ("123").to_object(py);
-                    let err = obj.extract::<$t>(py).unwrap_err();
+                    Python::attach(|py| {
+                    let obj = ("123").into_pyobject(py).unwrap();
+                    let err = obj.extract::<$t>().unwrap_err();
                     assert!(err.is_instance_of::<exceptions::PyTypeError>(py));
                     });
                 }
 
                 #[test]
                 fn from_py_float_type_error() {
-                    Python::with_gil(|py| {
-                    let obj = (12.3).to_object(py);
-                    let err = obj.extract::<$t>(py).unwrap_err();
+                    Python::attach(|py| {
+                    let obj = (12.3f64).into_pyobject(py).unwrap();
+                    let err = obj.extract::<$t>().unwrap_err();
                     assert!(err.is_instance_of::<exceptions::PyTypeError>(py));});
                 }
 
                 #[test]
                 fn to_py_object_and_back() {
-                    Python::with_gil(|py| {
+                    Python::attach(|py| {
                     let val = <$t>::new(123).unwrap();
-                    let obj = val.to_object(py);
-                    assert_eq!(obj.extract::<$t>(py).unwrap(), val);});
+                    let obj = val.into_pyobject(py).unwrap();
+                    assert_eq!(obj.extract::<$t>().unwrap(), val);});
                 }
             }
         )
@@ -760,23 +1122,23 @@ mod tests {
 
     #[test]
     fn test_i64_bool() {
-        Python::with_gil(|py| {
-            let obj = true.to_object(py);
-            assert_eq!(1, obj.extract::<i64>(py).unwrap());
-            let obj = false.to_object(py);
-            assert_eq!(0, obj.extract::<i64>(py).unwrap());
+        Python::attach(|py| {
+            let obj = true.into_pyobject(py).unwrap();
+            assert_eq!(1, obj.extract::<i64>().unwrap());
+            let obj = false.into_pyobject(py).unwrap();
+            assert_eq!(0, obj.extract::<i64>().unwrap());
         })
     }
 
     #[test]
     fn test_i64_f64() {
-        Python::with_gil(|py| {
-            let obj = 12.34f64.to_object(py);
-            let err = obj.extract::<i64>(py).unwrap_err();
+        Python::attach(|py| {
+            let obj = 12.34f64.into_pyobject(py).unwrap();
+            let err = obj.extract::<i64>().unwrap_err();
             assert!(err.is_instance_of::<crate::exceptions::PyTypeError>(py));
             // with no remainder
-            let obj = 12f64.to_object(py);
-            let err = obj.extract::<i64>(py).unwrap_err();
+            let obj = 12f64.into_pyobject(py).unwrap();
+            let err = obj.extract::<i64>().unwrap_err();
             assert!(err.is_instance_of::<crate::exceptions::PyTypeError>(py));
         })
     }
diff --git a/src/conversions/std/option.rs b/src/conversions/std/option.rs
new file mode 100644
index 00000000000..8cec88b4e6b
--- /dev/null
+++ b/src/conversions/std/option.rs
@@ -0,0 +1,53 @@
+use crate::{
+    conversion::IntoPyObject, types::any::PyAnyMethods, BoundObject, FromPyObject, PyAny, Python,
+};
+use crate::{Borrowed, Bound};
+
+impl<'py, T> IntoPyObject<'py> for Option<T>
+where
+    T: IntoPyObject<'py>,
+{
+    type Target = PyAny;
+    type Output = Bound<'py, Self::Target>;
+    type Error = T::Error;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        self.map_or_else(
+            || Ok(py.None().into_bound(py)),
+            |val| {
+                val.into_pyobject(py)
+                    .map(BoundObject::into_any)
+                    .map(BoundObject::into_bound)
+            },
+        )
+    }
+}
+
+impl<'a, 'py, T> IntoPyObject<'py> for &'a Option<T>
+where
+    &'a T: IntoPyObject<'py>,
+{
+    type Target = PyAny;
+    type Output = Bound<'py, Self::Target>;
+    type Error = <&'a T as IntoPyObject<'py>>::Error;
+
+    #[inline]
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        self.as_ref().into_pyobject(py)
+    }
+}
+
+impl<'a, 'py, T> FromPyObject<'a, 'py> for Option<T>
+where
+    T: FromPyObject<'a, 'py>,
+{
+    type Error = T::Error;
+
+    fn extract(obj: Borrowed<'a, 'py, PyAny>) -> Result<Self, Self::Error> {
+        if obj.is_none() {
+            Ok(None)
+        } else {
+            obj.extract().map(Some)
+        }
+    }
+}
diff --git a/src/conversions/std/osstr.rs b/src/conversions/std/osstr.rs
index be337959b5f..2c05d0fbff6 100644
--- a/src/conversions/std/osstr.rs
+++ b/src/conversions/std/osstr.rs
@@ -1,17 +1,21 @@
+use crate::conversion::IntoPyObject;
+use crate::ffi_ptr_ext::FfiPtrExt;
 use crate::instance::Bound;
-use crate::types::any::PyAnyMethods;
 use crate::types::PyString;
-use crate::{ffi, FromPyObject, IntoPy, PyAny, PyObject, PyResult, Python, ToPyObject};
+use crate::{ffi, Borrowed, FromPyObject, PyAny, PyErr, Python};
 use std::borrow::Cow;
+use std::convert::Infallible;
 use std::ffi::{OsStr, OsString};
-#[cfg(not(windows))]
-use std::os::raw::c_char;
 
-impl ToPyObject for OsStr {
-    fn to_object(&self, py: Python<'_>) -> PyObject {
+impl<'py> IntoPyObject<'py> for &OsStr {
+    type Target = PyString;
+    type Output = Bound<'py, Self::Target>;
+    type Error = Infallible;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
         // If the string is UTF-8, take the quick and easy shortcut
         if let Some(valid_utf8_path) = self.to_str() {
-            return valid_utf8_path.to_object(py);
+            return valid_utf8_path.into_pyobject(py);
         }
 
         // All targets besides windows support the std::os::unix::ffi::OsStrExt API:
@@ -19,17 +23,18 @@ impl ToPyObject for OsStr {
         #[cfg(not(windows))]
         {
             #[cfg(target_os = "wasi")]
-            let bytes = std::os::wasi::ffi::OsStrExt::as_bytes(self);
+            let bytes = self.to_str().expect("wasi strings are UTF8").as_bytes();
             #[cfg(not(target_os = "wasi"))]
             let bytes = std::os::unix::ffi::OsStrExt::as_bytes(self);
 
-            let ptr = bytes.as_ptr() as *const c_char;
+            let ptr = bytes.as_ptr().cast();
             let len = bytes.len() as ffi::Py_ssize_t;
             unsafe {
                 // DecodeFSDefault automatically chooses an appropriate decoding mechanism to
                 // parse os strings losslessly (i.e. surrogateescape most of the time)
-                let pystring = ffi::PyUnicode_DecodeFSDefaultAndSize(ptr, len);
-                PyObject::from_owned_ptr(py, pystring)
+                Ok(ffi::PyUnicode_DecodeFSDefaultAndSize(ptr, len)
+                    .assume_owned(py)
+                    .cast_into_unchecked::<PyString>())
             }
         }
 
@@ -40,21 +45,33 @@ impl ToPyObject for OsStr {
             unsafe {
                 // This will not panic because the data from encode_wide is well-formed Windows
                 // string data
-                PyObject::from_owned_ptr(
-                    py,
-                    ffi::PyUnicode_FromWideChar(wstr.as_ptr(), wstr.len() as ffi::Py_ssize_t),
+
+                Ok(
+                    ffi::PyUnicode_FromWideChar(wstr.as_ptr(), wstr.len() as ffi::Py_ssize_t)
+                        .assume_owned(py)
+                        .cast_into_unchecked::<PyString>(),
                 )
             }
         }
     }
 }
 
-// There's no FromPyObject implementation for &OsStr because albeit possible on Unix, this would
-// be impossible to implement on Windows. Hence it's omitted entirely
+impl<'py> IntoPyObject<'py> for &&OsStr {
+    type Target = PyString;
+    type Output = Bound<'py, Self::Target>;
+    type Error = Infallible;
+
+    #[inline]
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        (*self).into_pyobject(py)
+    }
+}
 
-impl FromPyObject<'_> for OsString {
-    fn extract_bound(ob: &Bound<'_, PyAny>) -> PyResult<Self> {
-        let pystring = ob.downcast::<PyString>()?;
+impl FromPyObject<'_, '_> for OsString {
+    type Error = PyErr;
+
+    fn extract(ob: Borrowed<'_, '_, PyAny>) -> Result<Self, Self::Error> {
+        let pystring = ob.cast::<PyString>()?;
 
         #[cfg(not(windows))]
         {
@@ -67,22 +84,20 @@ impl FromPyObject<'_> for OsString {
             };
 
             // Create an OsStr view into the raw bytes from Python
+            //
+            // For WASI: OS strings are UTF-8 by definition.
             #[cfg(target_os = "wasi")]
-            let os_str: &OsStr = std::os::wasi::ffi::OsStrExt::from_bytes(
-                fs_encoded_bytes.as_ref(ob.py()).as_bytes(),
-            );
+            let os_str: &OsStr =
+                OsStr::new(std::str::from_utf8(fs_encoded_bytes.as_bytes(ob.py()))?);
             #[cfg(not(target_os = "wasi"))]
-            let os_str: &OsStr = std::os::unix::ffi::OsStrExt::from_bytes(
-                fs_encoded_bytes.as_ref(ob.py()).as_bytes(),
-            );
+            let os_str: &OsStr =
+                std::os::unix::ffi::OsStrExt::from_bytes(fs_encoded_bytes.as_bytes(ob.py()));
 
             Ok(os_str.to_os_string())
         }
 
         #[cfg(windows)]
         {
-            use crate::types::string::PyStringMethods;
-
             // Take the quick and easy shortcut if UTF-8
             if let Ok(utf8_string) = pystring.to_cow() {
                 return Ok(utf8_string.into_owned().into());
@@ -94,6 +109,12 @@ impl FromPyObject<'_> for OsString {
                 unsafe { ffi::PyUnicode_AsWideChar(pystring.as_ptr(), std::ptr::null_mut(), 0) };
             crate::err::error_on_minusone(ob.py(), size)?;
 
+            debug_assert!(
+                size > 0,
+                "PyUnicode_AsWideChar should return at least 1 for null terminator"
+            );
+            let size = size - 1; // exclude null terminator
+
             let mut buffer = vec![0; size as usize];
             let bytes_read =
                 unsafe { ffi::PyUnicode_AsWideChar(pystring.as_ptr(), buffer.as_mut_ptr(), size) };
@@ -107,50 +128,72 @@ impl FromPyObject<'_> for OsString {
     }
 }
 
-impl IntoPy<PyObject> for &'_ OsStr {
+impl<'py> IntoPyObject<'py> for Cow<'_, OsStr> {
+    type Target = PyString;
+    type Output = Bound<'py, Self::Target>;
+    type Error = Infallible;
+
     #[inline]
-    fn into_py(self, py: Python<'_>) -> PyObject {
-        self.to_object(py)
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        (*self).into_pyobject(py)
     }
 }
 
-impl ToPyObject for Cow<'_, OsStr> {
+impl<'py> IntoPyObject<'py> for &Cow<'_, OsStr> {
+    type Target = PyString;
+    type Output = Bound<'py, Self::Target>;
+    type Error = Infallible;
+
     #[inline]
-    fn to_object(&self, py: Python<'_>) -> PyObject {
-        (self as &OsStr).to_object(py)
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        (&**self).into_pyobject(py)
     }
 }
 
-impl IntoPy<PyObject> for Cow<'_, OsStr> {
-    #[inline]
-    fn into_py(self, py: Python<'_>) -> PyObject {
-        self.to_object(py)
+impl<'a> FromPyObject<'a, '_> for Cow<'a, OsStr> {
+    type Error = PyErr;
+
+    fn extract(obj: Borrowed<'a, '_, PyAny>) -> Result<Self, Self::Error> {
+        #[cfg(any(Py_3_10, not(Py_LIMITED_API)))]
+        if let Ok(s) = obj.extract::<&str>() {
+            return Ok(Cow::Borrowed(s.as_ref()));
+        }
+
+        obj.extract::<OsString>().map(Cow::Owned)
     }
 }
 
-impl ToPyObject for OsString {
+impl<'py> IntoPyObject<'py> for OsString {
+    type Target = PyString;
+    type Output = Bound<'py, Self::Target>;
+    type Error = Infallible;
+
     #[inline]
-    fn to_object(&self, py: Python<'_>) -> PyObject {
-        (self as &OsStr).to_object(py)
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        self.as_os_str().into_pyobject(py)
     }
 }
 
-impl IntoPy<PyObject> for OsString {
-    fn into_py(self, py: Python<'_>) -> PyObject {
-        self.to_object(py)
-    }
-}
+impl<'py> IntoPyObject<'py> for &OsString {
+    type Target = PyString;
+    type Output = Bound<'py, Self::Target>;
+    type Error = Infallible;
 
-impl<'a> IntoPy<PyObject> for &'a OsString {
-    fn into_py(self, py: Python<'_>) -> PyObject {
-        self.to_object(py)
+    #[inline]
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        self.as_os_str().into_pyobject(py)
     }
 }
 
 #[cfg(test)]
 mod tests {
-    use crate::{types::PyString, IntoPy, PyObject, Python, ToPyObject};
+    use crate::types::{PyAnyMethods, PyString, PyStringMethods};
+    use crate::{Bound, BoundObject, IntoPyObject, Python};
     use std::fmt::Debug;
+    #[cfg(unix)]
+    use std::os::unix::ffi::OsStringExt;
+    #[cfg(windows)]
+    use std::os::windows::ffi::OsStringExt;
     use std::{
         borrow::Cow,
         ffi::{OsStr, OsString},
@@ -159,7 +202,7 @@ mod tests {
     #[test]
     #[cfg(not(windows))]
     fn test_non_utf8_conversion() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             #[cfg(not(target_os = "wasi"))]
             use std::os::unix::ffi::OsStrExt;
             #[cfg(target_os = "wasi")]
@@ -170,18 +213,22 @@ mod tests {
             let os_str = OsStr::from_bytes(payload);
 
             // do a roundtrip into Pythonland and back and compare
-            let py_str: PyObject = os_str.into_py(py);
-            let os_str_2: OsString = py_str.extract(py).unwrap();
+            let py_str = os_str.into_pyobject(py).unwrap();
+            let os_str_2: OsString = py_str.extract().unwrap();
             assert_eq!(os_str, os_str_2);
         });
     }
 
     #[test]
-    fn test_topyobject_roundtrip() {
-        Python::with_gil(|py| {
-            fn test_roundtrip<T: ToPyObject + AsRef<OsStr> + Debug>(py: Python<'_>, obj: T) {
-                let pyobject = obj.to_object(py);
-                let pystring: &PyString = pyobject.extract(py).unwrap();
+    fn test_intopyobject_roundtrip() {
+        Python::attach(|py| {
+            fn test_roundtrip<'py, T>(py: Python<'py>, obj: T)
+            where
+                T: IntoPyObject<'py> + AsRef<OsStr> + Debug + Clone,
+                T::Error: Debug,
+            {
+                let pyobject = obj.clone().into_pyobject(py).unwrap().into_any();
+                let pystring = pyobject.as_borrowed().cast::<PyString>().unwrap();
                 assert_eq!(pystring.to_string_lossy(), obj.as_ref().to_string_lossy());
                 let roundtripped_obj: OsString = pystring.extract().unwrap();
                 assert_eq!(obj.as_ref(), roundtripped_obj.as_os_str());
@@ -195,22 +242,66 @@ mod tests {
     }
 
     #[test]
-    fn test_intopy_roundtrip() {
-        Python::with_gil(|py| {
-            fn test_roundtrip<T: IntoPy<PyObject> + AsRef<OsStr> + Debug + Clone>(
-                py: Python<'_>,
-                obj: T,
-            ) {
-                let pyobject = obj.clone().into_py(py);
-                let pystring: &PyString = pyobject.extract(py).unwrap();
-                assert_eq!(pystring.to_string_lossy(), obj.as_ref().to_string_lossy());
-                let roundtripped_obj: OsString = pystring.extract().unwrap();
-                assert!(obj.as_ref() == roundtripped_obj.as_os_str());
+    #[cfg(windows)]
+    fn test_windows_non_utf8_osstring_roundtrip() {
+        use std::os::windows::ffi::{OsStrExt, OsStringExt};
+
+        Python::attach(|py| {
+            // Example: Unpaired surrogate (0xD800) is not valid UTF-8, but valid in Windows OsString
+            let wide: &[u16] = &['A' as u16, 0xD800, 'B' as u16]; // 'A', unpaired surrogate, 'B'
+            let os_str = OsString::from_wide(wide);
+
+            assert_eq!(os_str.to_string_lossy(), "A�B");
+
+            // This cannot be represented as UTF-8, so .to_str() would return None
+            assert!(os_str.to_str().is_none());
+
+            // Convert to Python and back
+            let py_str = os_str.as_os_str().into_pyobject(py).unwrap();
+            let os_str_2 = py_str.extract::<OsString>().unwrap();
+
+            // The roundtrip should preserve the original wide data
+            assert_eq!(os_str, os_str_2);
+
+            // Show that encode_wide is necessary: direct UTF-8 conversion would lose information
+            let encoded: Vec<u16> = os_str.encode_wide().collect();
+            assert_eq!(encoded, wide);
+        });
+    }
+
+    #[test]
+    fn test_extract_cow() {
+        Python::attach(|py| {
+            fn test_extract<'py, T>(py: Python<'py>, input: &T, is_borrowed: bool)
+            where
+                for<'a> &'a T: IntoPyObject<'py, Output = Bound<'py, PyString>>,
+                for<'a> <&'a T as IntoPyObject<'py>>::Error: Debug,
+                T: AsRef<OsStr> + ?Sized,
+            {
+                let pystring = input.into_pyobject(py).unwrap();
+                let cow: Cow<'_, OsStr> = pystring.extract().unwrap();
+                assert_eq!(cow, input.as_ref());
+                assert_eq!(is_borrowed, matches!(cow, Cow::Borrowed(_)));
             }
-            let os_str = OsStr::new("Hello\0\n🐍");
-            test_roundtrip::<&OsStr>(py, os_str);
-            test_roundtrip::<OsString>(py, os_str.to_os_string());
-            test_roundtrip::<&OsString>(py, &os_str.to_os_string());
-        })
+
+            // On Python 3.10+ or when not using the limited API, we can borrow strings from python
+            let can_borrow_str = cfg!(any(Py_3_10, not(Py_LIMITED_API)));
+            // This can be borrowed because it is valid UTF-8
+            test_extract::<str>(py, "Hello\0\n🐍", can_borrow_str);
+            test_extract::<str>(py, "Hello, world!", can_borrow_str);
+
+            #[cfg(windows)]
+            let os_str = {
+                // 'A', unpaired surrogate, 'B'
+                OsString::from_wide(&['A' as u16, 0xD800, 'B' as u16])
+            };
+
+            #[cfg(unix)]
+            let os_str = { OsString::from_vec(vec![250, 251, 252, 253, 254, 255, 0, 255]) };
+
+            // This cannot be borrowed because it is not valid UTF-8
+            #[cfg(any(windows, unix))]
+            test_extract::<OsStr>(py, &os_str, false);
+        });
     }
 }
diff --git a/src/conversions/std/path.rs b/src/conversions/std/path.rs
index 5d832e89575..7a92ca860c4 100644
--- a/src/conversions/std/path.rs
+++ b/src/conversions/std/path.rs
@@ -1,79 +1,122 @@
+use crate::conversion::IntoPyObject;
 use crate::ffi_ptr_ext::FfiPtrExt;
-use crate::instance::Bound;
+use crate::sync::PyOnceLock;
 use crate::types::any::PyAnyMethods;
-use crate::{ffi, FromPyObject, IntoPy, PyAny, PyObject, PyResult, Python, ToPyObject};
+use crate::{ffi, Borrowed, Bound, FromPyObject, Py, PyAny, PyErr, Python};
 use std::borrow::Cow;
 use std::ffi::OsString;
 use std::path::{Path, PathBuf};
 
-impl ToPyObject for Path {
-    fn to_object(&self, py: Python<'_>) -> PyObject {
-        self.as_os_str().to_object(py)
-    }
-}
+impl FromPyObject<'_, '_> for PathBuf {
+    type Error = PyErr;
 
-// See osstr.rs for why there's no FromPyObject impl for &Path
-
-impl FromPyObject<'_> for PathBuf {
-    fn extract_bound(ob: &Bound<'_, PyAny>) -> PyResult<Self> {
+    fn extract(ob: Borrowed<'_, '_, PyAny>) -> Result<Self, Self::Error> {
         // We use os.fspath to get the underlying path as bytes or str
         let path = unsafe { ffi::PyOS_FSPath(ob.as_ptr()).assume_owned_or_err(ob.py())? };
         Ok(path.extract::<OsString>()?.into())
     }
 }
 
-impl<'a> IntoPy<PyObject> for &'a Path {
+impl<'py> IntoPyObject<'py> for &Path {
+    type Target = PyAny;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
     #[inline]
-    fn into_py(self, py: Python<'_>) -> PyObject {
-        self.as_os_str().to_object(py)
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        static PY_PATH: PyOnceLock<Py<PyAny>> = PyOnceLock::new();
+        PY_PATH
+            .import(py, "pathlib", "Path")?
+            .call((self.as_os_str(),), None)
     }
 }
 
-impl<'a> ToPyObject for Cow<'a, Path> {
+impl<'py> IntoPyObject<'py> for &&Path {
+    type Target = PyAny;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
     #[inline]
-    fn to_object(&self, py: Python<'_>) -> PyObject {
-        self.as_os_str().to_object(py)
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        (*self).into_pyobject(py)
     }
 }
 
-impl<'a> IntoPy<PyObject> for Cow<'a, Path> {
+impl<'py> IntoPyObject<'py> for Cow<'_, Path> {
+    type Target = PyAny;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
     #[inline]
-    fn into_py(self, py: Python<'_>) -> PyObject {
-        self.to_object(py)
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        (*self).into_pyobject(py)
     }
 }
 
-impl ToPyObject for PathBuf {
+impl<'py> IntoPyObject<'py> for &Cow<'_, Path> {
+    type Target = PyAny;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
     #[inline]
-    fn to_object(&self, py: Python<'_>) -> PyObject {
-        self.as_os_str().to_object(py)
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        (&**self).into_pyobject(py)
     }
 }
 
-impl IntoPy<PyObject> for PathBuf {
-    fn into_py(self, py: Python<'_>) -> PyObject {
-        self.into_os_string().to_object(py)
+impl<'a> FromPyObject<'a, '_> for Cow<'a, Path> {
+    type Error = PyErr;
+
+    fn extract(obj: Borrowed<'a, '_, PyAny>) -> Result<Self, Self::Error> {
+        #[cfg(any(Py_3_10, not(Py_LIMITED_API)))]
+        if let Ok(s) = obj.extract::<&str>() {
+            return Ok(Cow::Borrowed(s.as_ref()));
+        }
+
+        obj.extract::<PathBuf>().map(Cow::Owned)
     }
 }
 
-impl<'a> IntoPy<PyObject> for &'a PathBuf {
-    fn into_py(self, py: Python<'_>) -> PyObject {
-        self.as_os_str().to_object(py)
+impl<'py> IntoPyObject<'py> for PathBuf {
+    type Target = PyAny;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    #[inline]
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        (&self).into_pyobject(py)
+    }
+}
+
+impl<'py> IntoPyObject<'py> for &PathBuf {
+    type Target = PyAny;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    #[inline]
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        (&**self).into_pyobject(py)
     }
 }
 
 #[cfg(test)]
 mod tests {
-    use crate::{types::PyString, IntoPy, PyObject, Python, ToPyObject};
-    use std::borrow::Cow;
+    use super::*;
+    use crate::{
+        types::{PyAnyMethods, PyString},
+        IntoPyObjectExt,
+    };
+    use std::ffi::OsStr;
     use std::fmt::Debug;
-    use std::path::{Path, PathBuf};
+    #[cfg(unix)]
+    use std::os::unix::ffi::OsStringExt;
+    #[cfg(windows)]
+    use std::os::windows::ffi::OsStringExt;
 
     #[test]
     #[cfg(not(windows))]
     fn test_non_utf8_conversion() {
-        Python::with_gil(|py| {
-            use std::ffi::OsStr;
+        Python::attach(|py| {
             #[cfg(not(target_os = "wasi"))]
             use std::os::unix::ffi::OsStrExt;
             #[cfg(target_os = "wasi")]
@@ -84,20 +127,22 @@ mod tests {
             let path = Path::new(OsStr::from_bytes(payload));
 
             // do a roundtrip into Pythonland and back and compare
-            let py_str: PyObject = path.into_py(py);
-            let path_2: PathBuf = py_str.extract(py).unwrap();
+            let py_str = path.into_pyobject(py).unwrap();
+            let path_2: PathBuf = py_str.extract().unwrap();
             assert_eq!(path, path_2);
         });
     }
 
     #[test]
-    fn test_topyobject_roundtrip() {
-        Python::with_gil(|py| {
-            fn test_roundtrip<T: ToPyObject + AsRef<Path> + Debug>(py: Python<'_>, obj: T) {
-                let pyobject = obj.to_object(py);
-                let pystring: &PyString = pyobject.extract(py).unwrap();
-                assert_eq!(pystring.to_string_lossy(), obj.as_ref().to_string_lossy());
-                let roundtripped_obj: PathBuf = pystring.extract().unwrap();
+    fn test_intopyobject_roundtrip() {
+        Python::attach(|py| {
+            fn test_roundtrip<'py, T>(py: Python<'py>, obj: T)
+            where
+                T: IntoPyObject<'py> + AsRef<Path> + Debug + Clone,
+                T::Error: Debug,
+            {
+                let pyobject = obj.clone().into_bound_py_any(py).unwrap();
+                let roundtripped_obj: PathBuf = pyobject.extract().unwrap();
                 assert_eq!(obj.as_ref(), roundtripped_obj.as_path());
             }
             let path = Path::new("Hello\0\n🐍");
@@ -109,22 +154,48 @@ mod tests {
     }
 
     #[test]
-    fn test_intopy_roundtrip() {
-        Python::with_gil(|py| {
-            fn test_roundtrip<T: IntoPy<PyObject> + AsRef<Path> + Debug + Clone>(
-                py: Python<'_>,
-                obj: T,
-            ) {
-                let pyobject = obj.clone().into_py(py);
-                let pystring: &PyString = pyobject.extract(py).unwrap();
-                assert_eq!(pystring.to_string_lossy(), obj.as_ref().to_string_lossy());
-                let roundtripped_obj: PathBuf = pystring.extract().unwrap();
-                assert_eq!(obj.as_ref(), roundtripped_obj.as_path());
+    fn test_from_pystring() {
+        Python::attach(|py| {
+            let path = "Hello\0\n🐍";
+            let pystring = PyString::new(py, path);
+            let roundtrip: PathBuf = pystring.extract().unwrap();
+            assert_eq!(roundtrip, Path::new(path));
+        });
+    }
+
+    #[test]
+    fn test_extract_cow() {
+        Python::attach(|py| {
+            fn test_extract<'py, T>(py: Python<'py>, path: &T, is_borrowed: bool)
+            where
+                for<'a> &'a T: IntoPyObject<'py, Output = Bound<'py, PyString>>,
+                for<'a> <&'a T as IntoPyObject<'py>>::Error: Debug,
+                T: AsRef<Path> + ?Sized,
+            {
+                let pystring = path.into_pyobject(py).unwrap();
+                let cow: Cow<'_, Path> = pystring.extract().unwrap();
+                assert_eq!(cow, path.as_ref());
+                assert_eq!(is_borrowed, matches!(cow, Cow::Borrowed(_)));
             }
-            let path = Path::new("Hello\0\n🐍");
-            test_roundtrip::<&Path>(py, path);
-            test_roundtrip::<PathBuf>(py, path.to_path_buf());
-            test_roundtrip::<&PathBuf>(py, &path.to_path_buf());
-        })
+
+            // On Python 3.10+ or when not using the limited API, we can borrow strings from python
+            let can_borrow_str = cfg!(any(Py_3_10, not(Py_LIMITED_API)));
+            // This can be borrowed because it is valid UTF-8
+            test_extract::<str>(py, "Hello\0\n🐍", can_borrow_str);
+            test_extract::<str>(py, "Hello, world!", can_borrow_str);
+
+            #[cfg(windows)]
+            let os_str = {
+                // 'A', unpaired surrogate, 'B'
+                OsString::from_wide(&['A' as u16, 0xD800, 'B' as u16])
+            };
+
+            #[cfg(unix)]
+            let os_str = { OsString::from_vec(vec![250, 251, 252, 253, 254, 255, 0, 255]) };
+
+            // This cannot be borrowed because it is not valid UTF-8
+            #[cfg(any(unix, windows))]
+            test_extract::<OsStr>(py, &os_str, false);
+        });
     }
 }
diff --git a/src/conversions/std/set.rs b/src/conversions/std/set.rs
index c955801a916..f741f02f8d0 100644
--- a/src/conversions/std/set.rs
+++ b/src/conversions/std/set.rs
@@ -3,65 +3,73 @@ use std::{cmp, collections, hash};
 #[cfg(feature = "experimental-inspect")]
 use crate::inspect::types::TypeInfo;
 use crate::{
-    instance::Bound,
-    types::any::PyAnyMethods,
-    types::frozenset::PyFrozenSetMethods,
-    types::set::{new_from_iter, PySetMethods},
-    types::{PyFrozenSet, PySet},
-    FromPyObject, IntoPy, PyAny, PyErr, PyObject, PyResult, Python, ToPyObject,
+    conversion::{FromPyObjectOwned, IntoPyObject},
+    types::{
+        any::PyAnyMethods,
+        frozenset::PyFrozenSetMethods,
+        set::{try_new_from_iter, PySetMethods},
+        PyFrozenSet, PySet,
+    },
+    Borrowed, Bound, FromPyObject, PyAny, PyErr, Python,
 };
 
-impl<T, S> ToPyObject for collections::HashSet<T, S>
+impl<'py, K, S> IntoPyObject<'py> for collections::HashSet<K, S>
 where
-    T: hash::Hash + Eq + ToPyObject,
+    K: IntoPyObject<'py> + Eq + hash::Hash,
     S: hash::BuildHasher + Default,
 {
-    fn to_object(&self, py: Python<'_>) -> PyObject {
-        new_from_iter(py, self)
-            .expect("Failed to create Python set from HashSet")
-            .into()
+    type Target = PySet;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        try_new_from_iter(py, self)
     }
-}
 
-impl<T> ToPyObject for collections::BTreeSet<T>
-where
-    T: hash::Hash + Eq + ToPyObject,
-{
-    fn to_object(&self, py: Python<'_>) -> PyObject {
-        new_from_iter(py, self)
-            .expect("Failed to create Python set from BTreeSet")
-            .into()
+    #[cfg(feature = "experimental-inspect")]
+    fn type_output() -> TypeInfo {
+        TypeInfo::set_of(K::type_output())
     }
 }
 
-impl<K, S> IntoPy<PyObject> for collections::HashSet<K, S>
+impl<'a, 'py, K, H> IntoPyObject<'py> for &'a collections::HashSet<K, H>
 where
-    K: IntoPy<PyObject> + Eq + hash::Hash,
-    S: hash::BuildHasher + Default,
+    &'a K: IntoPyObject<'py> + Eq + hash::Hash,
+    H: hash::BuildHasher,
 {
-    fn into_py(self, py: Python<'_>) -> PyObject {
-        new_from_iter(py, self.into_iter().map(|item| item.into_py(py)))
-            .expect("Failed to create Python set from HashSet")
-            .into()
+    type Target = PySet;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        try_new_from_iter(py, self.iter())
     }
 
     #[cfg(feature = "experimental-inspect")]
     fn type_output() -> TypeInfo {
-        TypeInfo::set_of(K::type_output())
+        TypeInfo::set_of(<&K>::type_output())
     }
 }
 
-impl<'py, K, S> FromPyObject<'py> for collections::HashSet<K, S>
+impl<'py, K, S> FromPyObject<'_, 'py> for collections::HashSet<K, S>
 where
-    K: FromPyObject<'py> + cmp::Eq + hash::Hash,
+    K: FromPyObjectOwned<'py> + cmp::Eq + hash::Hash,
     S: hash::BuildHasher + Default,
 {
-    fn extract_bound(ob: &Bound<'py, PyAny>) -> PyResult<Self> {
-        match ob.downcast::<PySet>() {
-            Ok(set) => set.iter().map(|any| any.extract()).collect(),
+    type Error = PyErr;
+
+    fn extract(ob: Borrowed<'_, 'py, PyAny>) -> Result<Self, Self::Error> {
+        match ob.cast::<PySet>() {
+            Ok(set) => set
+                .iter()
+                .map(|any| any.extract().map_err(Into::into))
+                .collect(),
             Err(err) => {
-                if let Ok(frozen_set) = ob.downcast::<PyFrozenSet>() {
-                    frozen_set.iter().map(|any| any.extract()).collect()
+                if let Ok(frozen_set) = ob.cast::<PyFrozenSet>() {
+                    frozen_set
+                        .iter()
+                        .map(|any| any.extract().map_err(Into::into))
+                        .collect()
                 } else {
                     Err(PyErr::from(err))
                 }
@@ -75,14 +83,16 @@ where
     }
 }
 
-impl<K> IntoPy<PyObject> for collections::BTreeSet<K>
+impl<'py, K> IntoPyObject<'py> for collections::BTreeSet<K>
 where
-    K: IntoPy<PyObject> + cmp::Ord,
+    K: IntoPyObject<'py> + cmp::Ord,
 {
-    fn into_py(self, py: Python<'_>) -> PyObject {
-        new_from_iter(py, self.into_iter().map(|item| item.into_py(py)))
-            .expect("Failed to create Python set from BTreeSet")
-            .into()
+    type Target = PySet;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        try_new_from_iter(py, self)
     }
 
     #[cfg(feature = "experimental-inspect")]
@@ -91,16 +101,43 @@ where
     }
 }
 
-impl<'py, K> FromPyObject<'py> for collections::BTreeSet<K>
+impl<'a, 'py, K> IntoPyObject<'py> for &'a collections::BTreeSet<K>
 where
-    K: FromPyObject<'py> + cmp::Ord,
+    &'a K: IntoPyObject<'py> + cmp::Ord,
+    K: 'a,
 {
-    fn extract_bound(ob: &Bound<'py, PyAny>) -> PyResult<Self> {
-        match ob.downcast::<PySet>() {
-            Ok(set) => set.iter().map(|any| any.extract()).collect(),
+    type Target = PySet;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        try_new_from_iter(py, self.iter())
+    }
+
+    #[cfg(feature = "experimental-inspect")]
+    fn type_output() -> TypeInfo {
+        TypeInfo::set_of(<&K>::type_output())
+    }
+}
+
+impl<'py, K> FromPyObject<'_, 'py> for collections::BTreeSet<K>
+where
+    K: FromPyObjectOwned<'py> + cmp::Ord,
+{
+    type Error = PyErr;
+
+    fn extract(ob: Borrowed<'_, 'py, PyAny>) -> Result<Self, Self::Error> {
+        match ob.cast::<PySet>() {
+            Ok(set) => set
+                .iter()
+                .map(|any| any.extract().map_err(Into::into))
+                .collect(),
             Err(err) => {
-                if let Ok(frozen_set) = ob.downcast::<PyFrozenSet>() {
-                    frozen_set.iter().map(|any| any.extract()).collect()
+                if let Ok(frozen_set) = ob.cast::<PyFrozenSet>() {
+                    frozen_set
+                        .iter()
+                        .map(|any| any.extract().map_err(Into::into))
+                        .collect()
                 } else {
                     Err(PyErr::from(err))
                 }
@@ -117,17 +154,17 @@ where
 #[cfg(test)]
 mod tests {
     use crate::types::{any::PyAnyMethods, PyFrozenSet, PySet};
-    use crate::{IntoPy, PyObject, Python, ToPyObject};
+    use crate::{IntoPyObject, Python};
     use std::collections::{BTreeSet, HashSet};
 
     #[test]
     fn test_extract_hashset() {
-        Python::with_gil(|py| {
-            let set = PySet::new_bound(py, &[1, 2, 3, 4, 5]).unwrap();
+        Python::attach(|py| {
+            let set = PySet::new(py, [1, 2, 3, 4, 5]).unwrap();
             let hash_set: HashSet<usize> = set.extract().unwrap();
             assert_eq!(hash_set, [1, 2, 3, 4, 5].iter().copied().collect());
 
-            let set = PyFrozenSet::new_bound(py, &[1, 2, 3, 4, 5]).unwrap();
+            let set = PyFrozenSet::new(py, [1, 2, 3, 4, 5]).unwrap();
             let hash_set: HashSet<usize> = set.extract().unwrap();
             assert_eq!(hash_set, [1, 2, 3, 4, 5].iter().copied().collect());
         });
@@ -135,42 +172,28 @@ mod tests {
 
     #[test]
     fn test_extract_btreeset() {
-        Python::with_gil(|py| {
-            let set = PySet::new_bound(py, &[1, 2, 3, 4, 5]).unwrap();
+        Python::attach(|py| {
+            let set = PySet::new(py, [1, 2, 3, 4, 5]).unwrap();
             let hash_set: BTreeSet<usize> = set.extract().unwrap();
             assert_eq!(hash_set, [1, 2, 3, 4, 5].iter().copied().collect());
 
-            let set = PyFrozenSet::new_bound(py, &[1, 2, 3, 4, 5]).unwrap();
+            let set = PyFrozenSet::new(py, [1, 2, 3, 4, 5]).unwrap();
             let hash_set: BTreeSet<usize> = set.extract().unwrap();
             assert_eq!(hash_set, [1, 2, 3, 4, 5].iter().copied().collect());
         });
     }
 
     #[test]
-    fn test_set_into_py() {
-        Python::with_gil(|py| {
-            let bt: BTreeSet<u64> = [1, 2, 3, 4, 5].iter().cloned().collect();
-            let hs: HashSet<u64> = [1, 2, 3, 4, 5].iter().cloned().collect();
-
-            let bto: PyObject = bt.clone().into_py(py);
-            let hso: PyObject = hs.clone().into_py(py);
-
-            assert_eq!(bt, bto.extract(py).unwrap());
-            assert_eq!(hs, hso.extract(py).unwrap());
-        });
-    }
-
-    #[test]
-    fn test_set_to_object() {
-        Python::with_gil(|py| {
+    fn test_set_into_pyobject() {
+        Python::attach(|py| {
             let bt: BTreeSet<u64> = [1, 2, 3, 4, 5].iter().cloned().collect();
             let hs: HashSet<u64> = [1, 2, 3, 4, 5].iter().cloned().collect();
 
-            let bto: PyObject = bt.to_object(py);
-            let hso: PyObject = hs.to_object(py);
+            let bto = (&bt).into_pyobject(py).unwrap();
+            let hso = (&hs).into_pyobject(py).unwrap();
 
-            assert_eq!(bt, bto.extract(py).unwrap());
-            assert_eq!(hs, hso.extract(py).unwrap());
+            assert_eq!(bt, bto.extract().unwrap());
+            assert_eq!(hs, hso.extract().unwrap());
         });
     }
 }
diff --git a/src/conversions/std/slice.rs b/src/conversions/std/slice.rs
index 2d46abe2953..c9598d1fd31 100644
--- a/src/conversions/std/slice.rs
+++ b/src/conversions/std/slice.rs
@@ -3,29 +3,47 @@ use std::borrow::Cow;
 #[cfg(feature = "experimental-inspect")]
 use crate::inspect::types::TypeInfo;
 use crate::{
-    types::{PyByteArray, PyBytes},
-    FromPyObject, IntoPy, Py, PyAny, PyObject, PyResult, Python, ToPyObject,
+    conversion::IntoPyObject,
+    types::{PyByteArray, PyByteArrayMethods, PyBytes},
+    Bound, CastError, PyAny, PyErr, Python,
 };
 
-impl<'a> IntoPy<PyObject> for &'a [u8] {
-    fn into_py(self, py: Python<'_>) -> PyObject {
-        PyBytes::new_bound(py, self).unbind().into()
+impl<'a, 'py, T> IntoPyObject<'py> for &'a [T]
+where
+    &'a T: IntoPyObject<'py>,
+{
+    type Target = PyAny;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    /// Turns [`&[u8]`](std::slice) into [`PyBytes`], all other `T`s will be turned into a [`PyList`]
+    ///
+    /// [`PyBytes`]: crate::types::PyBytes
+    /// [`PyList`]: crate::types::PyList
+    #[inline]
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        <&T>::borrowed_sequence_into_pyobject(self, py, crate::conversion::private::Token)
     }
 
     #[cfg(feature = "experimental-inspect")]
     fn type_output() -> TypeInfo {
-        TypeInfo::builtin("bytes")
+        TypeInfo::union_of(&[
+            TypeInfo::builtin("bytes"),
+            TypeInfo::list_of(<&T>::type_output()),
+        ])
     }
 }
 
-impl<'py> FromPyObject<'py> for &'py [u8] {
-    fn extract(obj: &'py PyAny) -> PyResult<Self> {
-        Ok(obj.downcast::<PyBytes>()?.as_bytes())
+impl<'a, 'py> crate::conversion::FromPyObject<'a, 'py> for &'a [u8] {
+    type Error = CastError<'a, 'py>;
+
+    fn extract(obj: crate::Borrowed<'a, 'py, PyAny>) -> Result<Self, Self::Error> {
+        Ok(obj.cast::<PyBytes>()?.as_bytes())
     }
 
     #[cfg(feature = "experimental-inspect")]
     fn type_input() -> TypeInfo {
-        Self::type_output()
+        TypeInfo::builtin("bytes")
     }
 }
 
@@ -34,26 +52,40 @@ impl<'py> FromPyObject<'py> for &'py [u8] {
 /// If the source object is a `bytes` object, the `Cow` will be borrowed and
 /// pointing into the source object, and no copying or heap allocations will happen.
 /// If it is a `bytearray`, its contents will be copied to an owned `Cow`.
-impl<'py> FromPyObject<'py> for Cow<'py, [u8]> {
-    fn extract(ob: &'py PyAny) -> PyResult<Self> {
-        if let Ok(bytes) = ob.downcast::<PyBytes>() {
+impl<'a, 'py> crate::conversion::FromPyObject<'a, 'py> for Cow<'a, [u8]> {
+    type Error = CastError<'a, 'py>;
+
+    fn extract(ob: crate::Borrowed<'a, 'py, PyAny>) -> Result<Self, Self::Error> {
+        if let Ok(bytes) = ob.cast::<PyBytes>() {
             return Ok(Cow::Borrowed(bytes.as_bytes()));
         }
 
-        let byte_array = ob.downcast::<PyByteArray>()?;
+        let byte_array = ob.cast::<PyByteArray>()?;
         Ok(Cow::Owned(byte_array.to_vec()))
     }
-}
 
-impl ToPyObject for Cow<'_, [u8]> {
-    fn to_object(&self, py: Python<'_>) -> Py<PyAny> {
-        PyBytes::new_bound(py, self.as_ref()).into()
+    #[cfg(feature = "experimental-inspect")]
+    fn type_input() -> TypeInfo {
+        Self::type_output()
     }
 }
 
-impl IntoPy<Py<PyAny>> for Cow<'_, [u8]> {
-    fn into_py(self, py: Python<'_>) -> Py<PyAny> {
-        self.to_object(py)
+impl<'py, T> IntoPyObject<'py> for Cow<'_, [T]>
+where
+    T: Clone,
+    for<'a> &'a T: IntoPyObject<'py>,
+{
+    type Target = PyAny;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    /// Turns `Cow<[u8]>` into [`PyBytes`], all other `T`s will be turned into a [`PyList`]
+    ///
+    /// [`PyBytes`]: crate::types::PyBytes
+    /// [`PyList`]: crate::types::PyList
+    #[inline]
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        <&T>::borrowed_sequence_into_pyobject(self.as_ref(), py, crate::conversion::private::Token)
     }
 }
 
@@ -62,14 +94,15 @@ mod tests {
     use std::borrow::Cow;
 
     use crate::{
-        types::{any::PyAnyMethods, PyBytes},
-        Python, ToPyObject,
+        conversion::IntoPyObject,
+        types::{any::PyAnyMethods, PyBytes, PyBytesMethods, PyList},
+        Python,
     };
 
     #[test]
     fn test_extract_bytes() {
-        Python::with_gil(|py| {
-            let py_bytes = py.eval_bound("b'Hello Python'", None, None).unwrap();
+        Python::attach(|py| {
+            let py_bytes = py.eval(c"b'Hello Python'", None, None).unwrap();
             let bytes: &[u8] = py_bytes.extract().unwrap();
             assert_eq!(bytes, b"Hello Python");
         });
@@ -77,27 +110,67 @@ mod tests {
 
     #[test]
     fn test_cow_impl() {
-        Python::with_gil(|py| {
-            let bytes = py.eval_bound(r#"b"foobar""#, None, None).unwrap();
+        Python::attach(|py| {
+            let bytes = py.eval(cr#"b"foobar""#, None, None).unwrap();
             let cow = bytes.extract::<Cow<'_, [u8]>>().unwrap();
             assert_eq!(cow, Cow::<[u8]>::Borrowed(b"foobar"));
 
-            let byte_array = py
-                .eval_bound(r#"bytearray(b"foobar")"#, None, None)
-                .unwrap();
+            let byte_array = py.eval(cr#"bytearray(b"foobar")"#, None, None).unwrap();
             let cow = byte_array.extract::<Cow<'_, [u8]>>().unwrap();
             assert_eq!(cow, Cow::<[u8]>::Owned(b"foobar".to_vec()));
 
-            let something_else_entirely = py.eval_bound("42", None, None).unwrap();
+            let something_else_entirely = py.eval(c"42", None, None).unwrap();
             something_else_entirely
                 .extract::<Cow<'_, [u8]>>()
                 .unwrap_err();
 
-            let cow = Cow::<[u8]>::Borrowed(b"foobar").to_object(py);
-            assert!(cow.as_ref(py).is_instance_of::<PyBytes>());
+            let cow = Cow::<[u8]>::Borrowed(b"foobar").into_pyobject(py).unwrap();
+            assert!(cow.is_instance_of::<PyBytes>());
 
-            let cow = Cow::<[u8]>::Owned(b"foobar".to_vec()).to_object(py);
-            assert!(cow.as_ref(py).is_instance_of::<PyBytes>());
+            let cow = Cow::<[u8]>::Owned(b"foobar".to_vec())
+                .into_pyobject(py)
+                .unwrap();
+            assert!(cow.is_instance_of::<PyBytes>());
+        });
+    }
+
+    #[test]
+    fn test_slice_intopyobject_impl() {
+        Python::attach(|py| {
+            let bytes: &[u8] = b"foobar";
+            let obj = bytes.into_pyobject(py).unwrap();
+            assert!(obj.is_instance_of::<PyBytes>());
+            let obj = obj.cast_into::<PyBytes>().unwrap();
+            assert_eq!(obj.as_bytes(), bytes);
+
+            let nums: &[u16] = &[0, 1, 2, 3];
+            let obj = nums.into_pyobject(py).unwrap();
+            assert!(obj.is_instance_of::<PyList>());
+        });
+    }
+
+    #[test]
+    fn test_cow_intopyobject_impl() {
+        Python::attach(|py| {
+            let borrowed_bytes = Cow::<[u8]>::Borrowed(b"foobar");
+            let obj = borrowed_bytes.clone().into_pyobject(py).unwrap();
+            assert!(obj.is_instance_of::<PyBytes>());
+            let obj = obj.cast_into::<PyBytes>().unwrap();
+            assert_eq!(obj.as_bytes(), &*borrowed_bytes);
+
+            let owned_bytes = Cow::<[u8]>::Owned(b"foobar".to_vec());
+            let obj = owned_bytes.clone().into_pyobject(py).unwrap();
+            assert!(obj.is_instance_of::<PyBytes>());
+            let obj = obj.cast_into::<PyBytes>().unwrap();
+            assert_eq!(obj.as_bytes(), &*owned_bytes);
+
+            let borrowed_nums = Cow::<[u16]>::Borrowed(&[0, 1, 2, 3]);
+            let obj = borrowed_nums.into_pyobject(py).unwrap();
+            assert!(obj.is_instance_of::<PyList>());
+
+            let owned_nums = Cow::<[u16]>::Owned(vec![0, 1, 2, 3]);
+            let obj = owned_nums.into_pyobject(py).unwrap();
+            assert!(obj.is_instance_of::<PyList>());
         });
     }
 }
diff --git a/src/conversions/std/string.rs b/src/conversions/std/string.rs
index ac29d80491c..f46c159967d 100644
--- a/src/conversions/std/string.rs
+++ b/src/conversions/std/string.rs
@@ -1,26 +1,24 @@
-use std::borrow::Cow;
-
 #[cfg(feature = "experimental-inspect")]
 use crate::inspect::types::TypeInfo;
+#[cfg(feature = "experimental-inspect")]
+use crate::inspect::TypeHint;
 use crate::{
-    instance::Bound,
-    types::{any::PyAnyMethods, string::PyStringMethods, PyString},
-    FromPyObject, IntoPy, Py, PyAny, PyObject, PyResult, Python, ToPyObject,
+    conversion::IntoPyObject, instance::Bound, types::PyString, Borrowed, FromPyObject, PyAny,
+    PyErr, Python,
 };
+use std::{borrow::Cow, convert::Infallible};
 
-/// Converts a Rust `str` to a Python object.
-/// See `PyString::new` for details on the conversion.
-impl ToPyObject for str {
-    #[inline]
-    fn to_object(&self, py: Python<'_>) -> PyObject {
-        PyString::new_bound(py, self).into()
-    }
-}
+impl<'py> IntoPyObject<'py> for &str {
+    type Target = PyString;
+    type Output = Bound<'py, Self::Target>;
+    type Error = Infallible;
+
+    #[cfg(feature = "experimental-inspect")]
+    const OUTPUT_TYPE: TypeHint = String::OUTPUT_TYPE;
 
-impl<'a> IntoPy<PyObject> for &'a str {
     #[inline]
-    fn into_py(self, py: Python<'_>) -> PyObject {
-        PyString::new_bound(py, self).into()
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        Ok(PyString::new(py, self))
     }
 
     #[cfg(feature = "experimental-inspect")]
@@ -29,10 +27,17 @@ impl<'a> IntoPy<PyObject> for &'a str {
     }
 }
 
-impl<'a> IntoPy<Py<PyString>> for &'a str {
+impl<'py> IntoPyObject<'py> for &&str {
+    type Target = PyString;
+    type Output = Bound<'py, Self::Target>;
+    type Error = Infallible;
+
+    #[cfg(feature = "experimental-inspect")]
+    const OUTPUT_TYPE: TypeHint = String::OUTPUT_TYPE;
+
     #[inline]
-    fn into_py(self, py: Python<'_>) -> Py<PyString> {
-        PyString::new_bound(py, self).into()
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        (*self).into_pyobject(py)
     }
 
     #[cfg(feature = "experimental-inspect")]
@@ -41,19 +46,36 @@ impl<'a> IntoPy<Py<PyString>> for &'a str {
     }
 }
 
-/// Converts a Rust `Cow<'_, str>` to a Python object.
-/// See `PyString::new` for details on the conversion.
-impl ToPyObject for Cow<'_, str> {
+impl<'py> IntoPyObject<'py> for Cow<'_, str> {
+    type Target = PyString;
+    type Output = Bound<'py, Self::Target>;
+    type Error = Infallible;
+
+    #[cfg(feature = "experimental-inspect")]
+    const OUTPUT_TYPE: TypeHint = String::OUTPUT_TYPE;
+
     #[inline]
-    fn to_object(&self, py: Python<'_>) -> PyObject {
-        PyString::new_bound(py, self).into()
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        (*self).into_pyobject(py)
+    }
+
+    #[cfg(feature = "experimental-inspect")]
+    fn type_output() -> TypeInfo {
+        <String>::type_output()
     }
 }
 
-impl IntoPy<PyObject> for Cow<'_, str> {
+impl<'py> IntoPyObject<'py> for &Cow<'_, str> {
+    type Target = PyString;
+    type Output = Bound<'py, Self::Target>;
+    type Error = Infallible;
+
+    #[cfg(feature = "experimental-inspect")]
+    const OUTPUT_TYPE: TypeHint = String::OUTPUT_TYPE;
+
     #[inline]
-    fn into_py(self, py: Python<'_>) -> PyObject {
-        self.to_object(py)
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        (&**self).into_pyobject(py)
     }
 
     #[cfg(feature = "experimental-inspect")]
@@ -62,25 +84,36 @@ impl IntoPy<PyObject> for Cow<'_, str> {
     }
 }
 
-/// Converts a Rust `String` to a Python object.
-/// See `PyString::new` for details on the conversion.
-impl ToPyObject for String {
-    #[inline]
-    fn to_object(&self, py: Python<'_>) -> PyObject {
-        PyString::new_bound(py, self).into()
+impl<'py> IntoPyObject<'py> for char {
+    type Target = PyString;
+    type Output = Bound<'py, Self::Target>;
+    type Error = Infallible;
+
+    #[cfg(feature = "experimental-inspect")]
+    const OUTPUT_TYPE: TypeHint = String::OUTPUT_TYPE;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        let mut bytes = [0u8; 4];
+        Ok(PyString::new(py, self.encode_utf8(&mut bytes)))
     }
-}
 
-impl ToPyObject for char {
-    fn to_object(&self, py: Python<'_>) -> PyObject {
-        self.into_py(py)
+    #[cfg(feature = "experimental-inspect")]
+    fn type_output() -> TypeInfo {
+        <String>::type_output()
     }
 }
 
-impl IntoPy<PyObject> for char {
-    fn into_py(self, py: Python<'_>) -> PyObject {
-        let mut bytes = [0u8; 4];
-        PyString::new_bound(py, self.encode_utf8(&mut bytes)).into()
+impl<'py> IntoPyObject<'py> for &char {
+    type Target = PyString;
+    type Output = Bound<'py, Self::Target>;
+    type Error = Infallible;
+
+    #[cfg(feature = "experimental-inspect")]
+    const OUTPUT_TYPE: TypeHint = String::OUTPUT_TYPE;
+
+    #[inline]
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        (*self).into_pyobject(py)
     }
 
     #[cfg(feature = "experimental-inspect")]
@@ -89,9 +122,16 @@ impl IntoPy<PyObject> for char {
     }
 }
 
-impl IntoPy<PyObject> for String {
-    fn into_py(self, py: Python<'_>) -> PyObject {
-        PyString::new_bound(py, &self).into()
+impl<'py> IntoPyObject<'py> for String {
+    type Target = PyString;
+    type Output = Bound<'py, Self::Target>;
+    type Error = Infallible;
+
+    #[cfg(feature = "experimental-inspect")]
+    const OUTPUT_TYPE: TypeHint = TypeHint::builtin("str");
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        Ok(PyString::new(py, &self))
     }
 
     #[cfg(feature = "experimental-inspect")]
@@ -100,10 +140,17 @@ impl IntoPy<PyObject> for String {
     }
 }
 
-impl<'a> IntoPy<PyObject> for &'a String {
+impl<'py> IntoPyObject<'py> for &String {
+    type Target = PyString;
+    type Output = Bound<'py, Self::Target>;
+    type Error = Infallible;
+
+    #[cfg(feature = "experimental-inspect")]
+    const OUTPUT_TYPE: TypeHint = String::OUTPUT_TYPE;
+
     #[inline]
-    fn into_py(self, py: Python<'_>) -> PyObject {
-        PyString::new_bound(py, self).into()
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        Ok(PyString::new(py, self))
     }
 
     #[cfg(feature = "experimental-inspect")]
@@ -112,11 +159,31 @@ impl<'a> IntoPy<PyObject> for &'a String {
     }
 }
 
-/// Allows extracting strings from Python objects.
-/// Accepts Python `str` and `unicode` objects.
-impl<'py> FromPyObject<'py> for &'py str {
-    fn extract(ob: &'py PyAny) -> PyResult<Self> {
-        ob.downcast::<PyString>()?.to_str()
+#[cfg(any(Py_3_10, not(Py_LIMITED_API)))]
+impl<'a> crate::conversion::FromPyObject<'a, '_> for &'a str {
+    type Error = PyErr;
+
+    #[cfg(feature = "experimental-inspect")]
+    const INPUT_TYPE: TypeHint = TypeHint::builtin("str");
+
+    fn extract(ob: crate::Borrowed<'a, '_, PyAny>) -> Result<Self, Self::Error> {
+        ob.cast::<PyString>()?.to_str()
+    }
+
+    #[cfg(feature = "experimental-inspect")]
+    fn type_input() -> TypeInfo {
+        <String as crate::FromPyObject>::type_input()
+    }
+}
+
+impl<'a> crate::conversion::FromPyObject<'a, '_> for Cow<'a, str> {
+    type Error = PyErr;
+
+    #[cfg(feature = "experimental-inspect")]
+    const INPUT_TYPE: TypeHint = TypeHint::builtin("str");
+
+    fn extract(ob: crate::Borrowed<'a, '_, PyAny>) -> Result<Self, Self::Error> {
+        ob.cast::<PyString>()?.to_cow()
     }
 
     #[cfg(feature = "experimental-inspect")]
@@ -127,9 +194,14 @@ impl<'py> FromPyObject<'py> for &'py str {
 
 /// Allows extracting strings from Python objects.
 /// Accepts Python `str` and `unicode` objects.
-impl FromPyObject<'_> for String {
-    fn extract_bound(obj: &Bound<'_, PyAny>) -> PyResult<Self> {
-        obj.downcast::<PyString>()?.to_cow().map(Cow::into_owned)
+impl FromPyObject<'_, '_> for String {
+    type Error = PyErr;
+
+    #[cfg(feature = "experimental-inspect")]
+    const INPUT_TYPE: TypeHint = TypeHint::builtin("str");
+
+    fn extract(obj: Borrowed<'_, '_, PyAny>) -> Result<Self, Self::Error> {
+        obj.cast::<PyString>()?.to_cow().map(Cow::into_owned)
     }
 
     #[cfg(feature = "experimental-inspect")]
@@ -138,9 +210,14 @@ impl FromPyObject<'_> for String {
     }
 }
 
-impl FromPyObject<'_> for char {
-    fn extract_bound(obj: &Bound<'_, PyAny>) -> PyResult<Self> {
-        let s = obj.downcast::<PyString>()?.to_cow()?;
+impl FromPyObject<'_, '_> for char {
+    type Error = PyErr;
+
+    #[cfg(feature = "experimental-inspect")]
+    const INPUT_TYPE: TypeHint = TypeHint::builtin("str");
+
+    fn extract(obj: Borrowed<'_, '_, PyAny>) -> Result<Self, Self::Error> {
+        let s = obj.cast::<PyString>()?.to_cow()?;
         let mut iter = s.chars();
         if let (Some(ch), None) = (iter.next(), iter.next()) {
             Ok(ch)
@@ -159,68 +236,57 @@ impl FromPyObject<'_> for char {
 
 #[cfg(test)]
 mod tests {
-    use crate::Python;
-    use crate::{IntoPy, PyObject, ToPyObject};
+    use crate::types::any::PyAnyMethods;
+    use crate::{IntoPyObject, Python};
     use std::borrow::Cow;
 
     #[test]
-    fn test_cow_into_py() {
-        Python::with_gil(|py| {
+    fn test_cow_into_pyobject() {
+        Python::attach(|py| {
             let s = "Hello Python";
-            let py_string: PyObject = Cow::Borrowed(s).into_py(py);
-            assert_eq!(s, py_string.extract::<&str>(py).unwrap());
-            let py_string: PyObject = Cow::<str>::Owned(s.into()).into_py(py);
-            assert_eq!(s, py_string.extract::<&str>(py).unwrap());
-        })
-    }
-
-    #[test]
-    fn test_cow_to_object() {
-        Python::with_gil(|py| {
-            let s = "Hello Python";
-            let py_string = Cow::Borrowed(s).to_object(py);
-            assert_eq!(s, py_string.extract::<&str>(py).unwrap());
-            let py_string = Cow::<str>::Owned(s.into()).to_object(py);
-            assert_eq!(s, py_string.extract::<&str>(py).unwrap());
+            let py_string = Cow::Borrowed(s).into_pyobject(py).unwrap();
+            assert_eq!(s, py_string.extract::<Cow<'_, str>>().unwrap());
+            let py_string = Cow::<str>::Owned(s.into()).into_pyobject(py).unwrap();
+            assert_eq!(s, py_string.extract::<Cow<'_, str>>().unwrap());
         })
     }
 
     #[test]
     fn test_non_bmp() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let s = "\u{1F30F}";
-            let py_string = s.to_object(py);
-            assert_eq!(s, py_string.extract::<String>(py).unwrap());
+            let py_string = s.into_pyobject(py).unwrap();
+            assert_eq!(s, py_string.extract::<String>().unwrap());
         })
     }
 
     #[test]
     fn test_extract_str() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let s = "Hello Python";
-            let py_string = s.to_object(py);
+            let py_string = s.into_pyobject(py).unwrap();
 
-            let s2: &str = py_string.as_ref(py).extract().unwrap();
+            let s2: Cow<'_, str> = py_string.extract().unwrap();
             assert_eq!(s, s2);
         })
     }
 
     #[test]
     fn test_extract_char() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let ch = '😃';
-            let py_string = ch.to_object(py);
-            let ch2: char = py_string.as_ref(py).extract().unwrap();
+            let py_string = ch.into_pyobject(py).unwrap();
+            let ch2: char = py_string.extract().unwrap();
             assert_eq!(ch, ch2);
         })
     }
 
     #[test]
     fn test_extract_char_err() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let s = "Hello Python";
-            let py_string = s.to_object(py);
-            let err: crate::PyResult<char> = py_string.as_ref(py).extract();
+            let py_string = s.into_pyobject(py).unwrap();
+            let err: crate::PyResult<char> = py_string.extract();
             assert!(err
                 .unwrap_err()
                 .to_string()
@@ -229,27 +295,30 @@ mod tests {
     }
 
     #[test]
-    fn test_string_into_py() {
-        Python::with_gil(|py| {
+    fn test_string_into_pyobject() {
+        Python::attach(|py| {
             let s = "Hello Python";
             let s2 = s.to_owned();
             let s3 = &s2;
             assert_eq!(
                 s,
-                IntoPy::<PyObject>::into_py(s3, py)
-                    .extract::<&str>(py)
+                s3.into_pyobject(py)
+                    .unwrap()
+                    .extract::<Cow<'_, str>>()
                     .unwrap()
             );
             assert_eq!(
                 s,
-                IntoPy::<PyObject>::into_py(s2, py)
-                    .extract::<&str>(py)
+                s2.into_pyobject(py)
+                    .unwrap()
+                    .extract::<Cow<'_, str>>()
                     .unwrap()
             );
             assert_eq!(
                 s,
-                IntoPy::<PyObject>::into_py(s, py)
-                    .extract::<&str>(py)
+                s.into_pyobject(py)
+                    .unwrap()
+                    .extract::<Cow<'_, str>>()
                     .unwrap()
             );
         })
diff --git a/src/conversions/std/time.rs b/src/conversions/std/time.rs
old mode 100755
new mode 100644
index 89d61e696a1..18a7e7dec1c
--- a/src/conversions/std/time.rs
+++ b/src/conversions/std/time.rs
@@ -1,24 +1,24 @@
+use crate::conversion::IntoPyObject;
 use crate::exceptions::{PyOverflowError, PyValueError};
-use crate::sync::GILOnceCell;
-use crate::types::any::PyAnyMethods;
 #[cfg(Py_LIMITED_API)]
-use crate::types::PyType;
+use crate::intern;
+use crate::sync::PyOnceLock;
+use crate::types::any::PyAnyMethods;
 #[cfg(not(Py_LIMITED_API))]
-use crate::types::{timezone_utc_bound, PyDateTime, PyDelta, PyDeltaAccess};
-#[cfg(Py_LIMITED_API)]
-use crate::Py;
-use crate::{
-    intern, Bound, FromPyObject, IntoPy, PyAny, PyErr, PyObject, PyResult, Python, ToPyObject,
-};
+use crate::types::PyDeltaAccess;
+use crate::types::{PyDateTime, PyDelta, PyTzInfo};
+use crate::{Borrowed, Bound, FromPyObject, Py, PyAny, PyErr, PyResult, Python};
 use std::time::{Duration, SystemTime, UNIX_EPOCH};
 
 const SECONDS_PER_DAY: u64 = 24 * 60 * 60;
 
-impl FromPyObject<'_> for Duration {
-    fn extract_bound(obj: &Bound<'_, PyAny>) -> PyResult<Self> {
+impl FromPyObject<'_, '_> for Duration {
+    type Error = PyErr;
+
+    fn extract(obj: Borrowed<'_, '_, PyAny>) -> Result<Self, Self::Error> {
+        let delta = obj.cast::<PyDelta>()?;
         #[cfg(not(Py_LIMITED_API))]
         let (days, seconds, microseconds) = {
-            let delta = obj.downcast::<PyDelta>()?;
             (
                 delta.get_days(),
                 delta.get_seconds(),
@@ -27,10 +27,11 @@ impl FromPyObject<'_> for Duration {
         };
         #[cfg(Py_LIMITED_API)]
         let (days, seconds, microseconds): (i32, i32, i32) = {
+            let py = delta.py();
             (
-                obj.getattr(intern!(obj.py(), "days"))?.extract()?,
-                obj.getattr(intern!(obj.py(), "seconds"))?.extract()?,
-                obj.getattr(intern!(obj.py(), "microseconds"))?.extract()?,
+                delta.getattr(intern!(py, "days"))?.extract()?,
+                delta.getattr(intern!(py, "seconds"))?.extract()?,
+                delta.getattr(intern!(py, "microseconds"))?.extract()?,
             )
         };
 
@@ -51,41 +52,34 @@ impl FromPyObject<'_> for Duration {
     }
 }
 
-impl ToPyObject for Duration {
-    fn to_object(&self, py: Python<'_>) -> PyObject {
+impl<'py> IntoPyObject<'py> for Duration {
+    type Target = PyDelta;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
         let days = self.as_secs() / SECONDS_PER_DAY;
         let seconds = self.as_secs() % SECONDS_PER_DAY;
         let microseconds = self.subsec_micros();
 
-        #[cfg(not(Py_LIMITED_API))]
-        {
-            PyDelta::new_bound(
-                py,
-                days.try_into()
-                    .expect("Too large Rust duration for timedelta"),
-                seconds.try_into().unwrap(),
-                microseconds.try_into().unwrap(),
-                false,
-            )
-            .expect("failed to construct timedelta (overflow?)")
-            .into()
-        }
-        #[cfg(Py_LIMITED_API)]
-        {
-            static TIMEDELTA: GILOnceCell<Py<PyType>> = GILOnceCell::new();
-            TIMEDELTA
-                .get_or_try_init_type_ref(py, "datetime", "timedelta")
-                .unwrap()
-                .call1((days, seconds, microseconds))
-                .unwrap()
-                .into()
-        }
+        PyDelta::new(
+            py,
+            days.try_into()?,
+            seconds.try_into()?,
+            microseconds.try_into()?,
+            false,
+        )
     }
 }
 
-impl IntoPy<PyObject> for Duration {
-    fn into_py(self, py: Python<'_>) -> PyObject {
-        self.to_object(py)
+impl<'py> IntoPyObject<'py> for &Duration {
+    type Target = PyDelta;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    #[inline]
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        (*self).into_pyobject(py)
     }
 }
 
@@ -95,11 +89,11 @@ impl IntoPy<PyObject> for Duration {
 //
 // TODO: it might be nice to investigate using timestamps anyway, at least when the datetime is a safe range.
 
-impl FromPyObject<'_> for SystemTime {
-    fn extract_bound(obj: &Bound<'_, PyAny>) -> PyResult<Self> {
-        let duration_since_unix_epoch: Duration = obj
-            .call_method1(intern!(obj.py(), "__sub__"), (unix_epoch_py(obj.py()),))?
-            .extract()?;
+impl FromPyObject<'_, '_> for SystemTime {
+    type Error = PyErr;
+
+    fn extract(obj: Borrowed<'_, '_, PyAny>) -> Result<Self, Self::Error> {
+        let duration_since_unix_epoch: Duration = obj.sub(unix_epoch_py(obj.py())?)?.extract()?;
         UNIX_EPOCH
             .checked_add(duration_since_unix_epoch)
             .ok_or_else(|| {
@@ -108,67 +102,50 @@ impl FromPyObject<'_> for SystemTime {
     }
 }
 
-impl ToPyObject for SystemTime {
-    fn to_object(&self, py: Python<'_>) -> PyObject {
-        let duration_since_unix_epoch = self.duration_since(UNIX_EPOCH).unwrap().into_py(py);
-        unix_epoch_py(py)
-            .call_method1(py, intern!(py, "__add__"), (duration_since_unix_epoch,))
-            .unwrap()
+impl<'py> IntoPyObject<'py> for SystemTime {
+    type Target = PyDateTime;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        let duration_since_unix_epoch =
+            self.duration_since(UNIX_EPOCH).unwrap().into_pyobject(py)?;
+        unix_epoch_py(py)?
+            .add(duration_since_unix_epoch)?
+            .cast_into()
+            .map_err(Into::into)
     }
 }
 
-impl IntoPy<PyObject> for SystemTime {
-    fn into_py(self, py: Python<'_>) -> PyObject {
-        self.to_object(py)
+impl<'py> IntoPyObject<'py> for &SystemTime {
+    type Target = PyDateTime;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    #[inline]
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        (*self).into_pyobject(py)
     }
 }
 
-fn unix_epoch_py(py: Python<'_>) -> &PyObject {
-    static UNIX_EPOCH: GILOnceCell<PyObject> = GILOnceCell::new();
-    UNIX_EPOCH
+fn unix_epoch_py(py: Python<'_>) -> PyResult<Borrowed<'_, '_, PyDateTime>> {
+    static UNIX_EPOCH: PyOnceLock<Py<PyDateTime>> = PyOnceLock::new();
+    Ok(UNIX_EPOCH
         .get_or_try_init(py, || {
-            #[cfg(not(Py_LIMITED_API))]
-            {
-                Ok::<_, PyErr>(
-                    PyDateTime::new_bound(
-                        py,
-                        1970,
-                        1,
-                        1,
-                        0,
-                        0,
-                        0,
-                        0,
-                        Some(&timezone_utc_bound(py)),
-                    )?
-                    .into(),
-                )
-            }
-            #[cfg(Py_LIMITED_API)]
-            {
-                let datetime = py.import_bound("datetime")?;
-                let utc = datetime.getattr("timezone")?.getattr("utc")?;
-                Ok::<_, PyErr>(
-                    datetime
-                        .getattr("datetime")?
-                        .call1((1970, 1, 1, 0, 0, 0, 0, utc))
-                        .unwrap()
-                        .into(),
-                )
-            }
-        })
-        .unwrap()
+            let utc = PyTzInfo::utc(py)?;
+            Ok::<_, PyErr>(PyDateTime::new(py, 1970, 1, 1, 0, 0, 0, 0, Some(&utc))?.into())
+        })?
+        .bind_borrowed(py))
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
     use crate::types::PyDict;
-    use std::panic;
 
     #[test]
     fn test_duration_frompyobject() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             assert_eq!(
                 new_timedelta(py, 0, 0, 0).extract::<Duration>().unwrap(),
                 Duration::new(0, 0)
@@ -202,7 +179,7 @@ mod tests {
 
     #[test]
     fn test_duration_frompyobject_negative() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             assert_eq!(
                 new_timedelta(py, 0, -1, 0)
                     .extract::<Duration>()
@@ -214,53 +191,65 @@ mod tests {
     }
 
     #[test]
-    fn test_duration_topyobject() {
-        Python::with_gil(|py| {
-            let assert_eq = |l: PyObject, r: Bound<'_, PyAny>| {
-                assert!(l.bind(py).eq(r).unwrap());
+    fn test_duration_into_pyobject() {
+        Python::attach(|py| {
+            let assert_eq = |l: Bound<'_, PyAny>, r: Bound<'_, PyAny>| {
+                assert!(l.eq(r).unwrap());
             };
 
             assert_eq(
-                Duration::new(0, 0).to_object(py),
+                Duration::new(0, 0).into_pyobject(py).unwrap().into_any(),
                 new_timedelta(py, 0, 0, 0),
             );
             assert_eq(
-                Duration::new(86400, 0).to_object(py),
+                Duration::new(86400, 0)
+                    .into_pyobject(py)
+                    .unwrap()
+                    .into_any(),
                 new_timedelta(py, 1, 0, 0),
             );
             assert_eq(
-                Duration::new(1, 0).to_object(py),
+                Duration::new(1, 0).into_pyobject(py).unwrap().into_any(),
                 new_timedelta(py, 0, 1, 0),
             );
             assert_eq(
-                Duration::new(0, 1_000).to_object(py),
+                Duration::new(0, 1_000)
+                    .into_pyobject(py)
+                    .unwrap()
+                    .into_any(),
                 new_timedelta(py, 0, 0, 1),
             );
             assert_eq(
-                Duration::new(0, 1).to_object(py),
+                Duration::new(0, 1).into_pyobject(py).unwrap().into_any(),
                 new_timedelta(py, 0, 0, 0),
             );
             assert_eq(
-                Duration::new(86401, 1_000).to_object(py),
+                Duration::new(86401, 1_000)
+                    .into_pyobject(py)
+                    .unwrap()
+                    .into_any(),
                 new_timedelta(py, 1, 1, 1),
             );
             assert_eq(
-                Duration::new(86399999999999, 999999000).to_object(py),
+                Duration::new(86399999999999, 999999000)
+                    .into_pyobject(py)
+                    .unwrap()
+                    .into_any(),
                 timedelta_class(py).getattr("max").unwrap(),
             );
         });
     }
 
     #[test]
-    fn test_duration_topyobject_overflow() {
-        Python::with_gil(|py| {
-            assert!(panic::catch_unwind(|| Duration::MAX.to_object(py)).is_err());
+    fn test_duration_into_pyobject_overflow() {
+        Python::attach(|py| {
+            assert!(Duration::MAX.into_pyobject(py).is_err());
         })
     }
 
     #[test]
     fn test_time_frompyobject() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             assert_eq!(
                 new_datetime(py, 1970, 1, 1, 0, 0, 0, 0)
                     .extract::<SystemTime>()
@@ -286,7 +275,7 @@ mod tests {
 
     #[test]
     fn test_time_frompyobject_before_epoch() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             assert_eq!(
                 new_datetime(py, 1950, 1, 1, 0, 0, 0, 0)
                     .extract::<SystemTime>()
@@ -298,24 +287,26 @@ mod tests {
     }
 
     #[test]
-    fn test_time_topyobject() {
-        Python::with_gil(|py| {
-            let assert_eq = |l: PyObject, r: Bound<'_, PyAny>| {
-                assert!(l.bind(py).eq(r).unwrap());
+    fn test_time_intopyobject() {
+        Python::attach(|py| {
+            let assert_eq = |l: Bound<'_, PyDateTime>, r: Bound<'_, PyDateTime>| {
+                assert!(l.eq(r).unwrap());
             };
 
             assert_eq(
                 UNIX_EPOCH
                     .checked_add(Duration::new(1580702706, 7123))
                     .unwrap()
-                    .into_py(py),
+                    .into_pyobject(py)
+                    .unwrap(),
                 new_datetime(py, 2020, 2, 3, 4, 5, 6, 7),
             );
             assert_eq(
                 UNIX_EPOCH
                     .checked_add(Duration::new(253402300799, 999999000))
                     .unwrap()
-                    .into_py(py),
+                    .into_pyobject(py)
+                    .unwrap(),
                 max_datetime(py),
             );
         });
@@ -331,47 +322,45 @@ mod tests {
         minute: u8,
         second: u8,
         microsecond: u32,
-    ) -> Bound<'_, PyAny> {
-        datetime_class(py)
-            .call1((
-                year,
-                month,
-                day,
-                hour,
-                minute,
-                second,
-                microsecond,
-                tz_utc(py),
-            ))
-            .unwrap()
+    ) -> Bound<'_, PyDateTime> {
+        let utc = PyTzInfo::utc(py).unwrap();
+        PyDateTime::new(
+            py,
+            year,
+            month,
+            day,
+            hour,
+            minute,
+            second,
+            microsecond,
+            Some(&utc),
+        )
+        .unwrap()
     }
 
-    fn max_datetime(py: Python<'_>) -> Bound<'_, PyAny> {
+    fn max_datetime(py: Python<'_>) -> Bound<'_, PyDateTime> {
         let naive_max = datetime_class(py).getattr("max").unwrap();
-        let kargs = PyDict::new_bound(py);
-        kargs.set_item("tzinfo", tz_utc(py)).unwrap();
-        naive_max.call_method("replace", (), Some(&kargs)).unwrap()
+        let kargs = PyDict::new(py);
+        kargs
+            .set_item("tzinfo", PyTzInfo::utc(py).unwrap())
+            .unwrap();
+        naive_max
+            .call_method("replace", (), Some(&kargs))
+            .unwrap()
+            .cast_into()
+            .unwrap()
     }
 
     #[test]
-    fn test_time_topyobject_overflow() {
+    fn test_time_intopyobject_overflow() {
         let big_system_time = UNIX_EPOCH
             .checked_add(Duration::new(300000000000, 0))
             .unwrap();
-        Python::with_gil(|py| {
-            assert!(panic::catch_unwind(|| big_system_time.into_py(py)).is_err());
+        Python::attach(|py| {
+            assert!(big_system_time.into_pyobject(py).is_err());
         })
     }
 
-    fn tz_utc(py: Python<'_>) -> Bound<'_, PyAny> {
-        py.import_bound("datetime")
-            .unwrap()
-            .getattr("timezone")
-            .unwrap()
-            .getattr("utc")
-            .unwrap()
-    }
-
     fn new_timedelta(
         py: Python<'_>,
         days: i32,
@@ -384,16 +373,10 @@ mod tests {
     }
 
     fn datetime_class(py: Python<'_>) -> Bound<'_, PyAny> {
-        py.import_bound("datetime")
-            .unwrap()
-            .getattr("datetime")
-            .unwrap()
+        py.import("datetime").unwrap().getattr("datetime").unwrap()
     }
 
     fn timedelta_class(py: Python<'_>) -> Bound<'_, PyAny> {
-        py.import_bound("datetime")
-            .unwrap()
-            .getattr("timedelta")
-            .unwrap()
+        py.import("datetime").unwrap().getattr("timedelta").unwrap()
     }
 }
diff --git a/src/conversions/std/vec.rs b/src/conversions/std/vec.rs
index df9e4c4f819..c62aa7f1d56 100644
--- a/src/conversions/std/vec.rs
+++ b/src/conversions/std/vec.rs
@@ -1,40 +1,188 @@
 #[cfg(feature = "experimental-inspect")]
 use crate::inspect::types::TypeInfo;
-use crate::types::list::new_from_iter;
-use crate::{IntoPy, PyObject, Python, ToPyObject};
+use crate::{
+    conversion::{FromPyObject, FromPyObjectOwned, FromPyObjectSequence, IntoPyObject},
+    exceptions::PyTypeError,
+    ffi,
+    types::{PyAnyMethods, PySequence, PyString},
+    Borrowed, CastError, PyResult, PyTypeInfo,
+};
+use crate::{Bound, PyAny, PyErr, Python};
 
-impl<T> ToPyObject for [T]
+impl<'py, T> IntoPyObject<'py> for Vec<T>
 where
-    T: ToPyObject,
+    T: IntoPyObject<'py>,
 {
-    fn to_object(&self, py: Python<'_>) -> PyObject {
-        let mut iter = self.iter().map(|e| e.to_object(py));
-        let list = new_from_iter(py, &mut iter);
-        list.into()
+    type Target = PyAny;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    /// Turns [`Vec<u8>`] into [`PyBytes`], all other `T`s will be turned into a [`PyList`]
+    ///
+    /// [`PyBytes`]: crate::types::PyBytes
+    /// [`PyList`]: crate::types::PyList
+    #[inline]
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        T::owned_sequence_into_pyobject(self, py, crate::conversion::private::Token)
+    }
+
+    #[cfg(feature = "experimental-inspect")]
+    fn type_output() -> TypeInfo {
+        TypeInfo::list_of(T::type_output())
     }
 }
 
-impl<T> ToPyObject for Vec<T>
+impl<'a, 'py, T> IntoPyObject<'py> for &'a Vec<T>
 where
-    T: ToPyObject,
+    &'a T: IntoPyObject<'py>,
 {
-    fn to_object(&self, py: Python<'_>) -> PyObject {
-        self.as_slice().to_object(py)
+    type Target = PyAny;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    #[inline]
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        // NB: we could actually not cast to `PyAny`, which would be nice for
+        // `&Vec<u8>`, but that'd be inconsistent with the `IntoPyObject` impl
+        // above which always returns a `PyAny` for `Vec<T>`.
+        self.as_slice().into_pyobject(py).map(Bound::into_any)
+    }
+
+    #[cfg(feature = "experimental-inspect")]
+    fn type_output() -> TypeInfo {
+        TypeInfo::list_of(<&T>::type_output())
     }
 }
 
-impl<T> IntoPy<PyObject> for Vec<T>
+impl<'py, T> FromPyObject<'_, 'py> for Vec<T>
 where
-    T: IntoPy<PyObject>,
+    T: FromPyObjectOwned<'py>,
 {
-    fn into_py(self, py: Python<'_>) -> PyObject {
-        let mut iter = self.into_iter().map(|e| e.into_py(py));
-        let list = new_from_iter(py, &mut iter);
-        list.into()
+    type Error = PyErr;
+
+    fn extract(obj: Borrowed<'_, 'py, PyAny>) -> PyResult<Self> {
+        if let Some(extractor) = T::sequence_extractor(obj, crate::conversion::private::Token) {
+            return Ok(extractor.to_vec());
+        }
+
+        if obj.is_instance_of::<PyString>() {
+            return Err(PyTypeError::new_err("Can't extract `str` to `Vec`"));
+        }
+
+        extract_sequence(obj)
     }
 
     #[cfg(feature = "experimental-inspect")]
-    fn type_output() -> TypeInfo {
-        TypeInfo::list_of(T::type_output())
+    fn type_input() -> TypeInfo {
+        TypeInfo::sequence_of(T::type_input())
+    }
+}
+
+fn extract_sequence<'py, T>(obj: Borrowed<'_, 'py, PyAny>) -> PyResult<Vec<T>>
+where
+    T: FromPyObjectOwned<'py>,
+{
+    // Types that pass `PySequence_Check` usually implement enough of the sequence protocol
+    // to support this function and if not, we will only fail extraction safely.
+    let seq = unsafe {
+        if ffi::PySequence_Check(obj.as_ptr()) != 0 {
+            obj.cast_unchecked::<PySequence>()
+        } else {
+            return Err(CastError::new(obj, PySequence::type_object(obj.py()).into_any()).into());
+        }
+    };
+
+    let mut v = Vec::with_capacity(seq.len().unwrap_or(0));
+    for item in seq.try_iter()? {
+        v.push(item?.extract::<T>().map_err(Into::into)?);
+    }
+    Ok(v)
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::conversion::IntoPyObject;
+    use crate::types::{PyAnyMethods, PyBytes, PyBytesMethods, PyList};
+    use crate::Python;
+
+    #[test]
+    fn test_vec_intopyobject_impl() {
+        Python::attach(|py| {
+            let bytes: Vec<u8> = b"foobar".to_vec();
+            let obj = bytes.clone().into_pyobject(py).unwrap();
+            assert!(obj.is_instance_of::<PyBytes>());
+            let obj = obj.cast_into::<PyBytes>().unwrap();
+            assert_eq!(obj.as_bytes(), &bytes);
+
+            let nums: Vec<u16> = vec![0, 1, 2, 3];
+            let obj = nums.into_pyobject(py).unwrap();
+            assert!(obj.is_instance_of::<PyList>());
+        });
+    }
+
+    #[test]
+    fn test_vec_reference_intopyobject_impl() {
+        Python::attach(|py| {
+            let bytes: Vec<u8> = b"foobar".to_vec();
+            let obj = (&bytes).into_pyobject(py).unwrap();
+            assert!(obj.is_instance_of::<PyBytes>());
+            let obj = obj.cast_into::<PyBytes>().unwrap();
+            assert_eq!(obj.as_bytes(), &bytes);
+
+            let nums: Vec<u16> = vec![0, 1, 2, 3];
+            let obj = (&nums).into_pyobject(py).unwrap();
+            assert!(obj.is_instance_of::<PyList>());
+        });
+    }
+
+    #[test]
+    fn test_strings_cannot_be_extracted_to_vec() {
+        Python::attach(|py| {
+            let v = "London Calling";
+            let ob = v.into_pyobject(py).unwrap();
+
+            assert!(ob.extract::<Vec<String>>().is_err());
+            assert!(ob.extract::<Vec<char>>().is_err());
+        });
+    }
+
+    #[test]
+    fn test_extract_bytes_to_vec() {
+        Python::attach(|py| {
+            let v: Vec<u8> = PyBytes::new(py, b"abc").extract().unwrap();
+            assert_eq!(v, b"abc");
+        });
+    }
+
+    #[test]
+    fn test_extract_tuple_to_vec() {
+        Python::attach(|py| {
+            let v: Vec<i32> = py.eval(c"(1, 2)", None, None).unwrap().extract().unwrap();
+            assert_eq!(v, [1, 2]);
+        });
+    }
+
+    #[test]
+    fn test_extract_range_to_vec() {
+        Python::attach(|py| {
+            let v: Vec<i32> = py
+                .eval(c"range(1, 5)", None, None)
+                .unwrap()
+                .extract()
+                .unwrap();
+            assert_eq!(v, [1, 2, 3, 4]);
+        });
+    }
+
+    #[test]
+    fn test_extract_bytearray_to_vec() {
+        Python::attach(|py| {
+            let v: Vec<u8> = py
+                .eval(c"bytearray(b'abc')", None, None)
+                .unwrap()
+                .extract()
+                .unwrap();
+            assert_eq!(v, b"abc");
+        });
     }
 }
diff --git a/src/conversions/time.rs b/src/conversions/time.rs
new file mode 100644
index 00000000000..562eebd353e
--- /dev/null
+++ b/src/conversions/time.rs
@@ -0,0 +1,1518 @@
+#![cfg(feature = "time")]
+
+//! Conversions to and from [time](https://docs.rs/time/)’s `Date`,
+//! `Duration`, `OffsetDateTime`, `PrimitiveDateTime`, `Time`, `UtcDateTime` and `UtcOffset`.
+//!
+//! # Setup
+//!
+//! To use this feature, add this to your **`Cargo.toml`**:
+//!
+//! ```toml
+//! [dependencies]
+//! time = "0.3"
+#![doc = concat!("pyo3 = { version = \"", env!("CARGO_PKG_VERSION"),  "\", features = [\"time\"] }")]
+//! ```
+//!
+//! Note that you must use compatible versions of time and PyO3.
+//! The required time version may vary based on the version of PyO3.
+//!
+//! ```rust
+//! use time::{Duration, OffsetDateTime, PrimitiveDateTime, Date, Time, Month};
+//! use pyo3::{Python, PyResult, IntoPyObject, types::PyAnyMethods};
+//!
+//! fn main() -> PyResult<()> {
+//!     Python::initialize();
+//!     Python::attach(|py| {
+//!         // Create a fixed date and time (2022-01-01 12:00:00 UTC)
+//!         let date = Date::from_calendar_date(2022, Month::January, 1).unwrap();
+//!         let time = Time::from_hms(12, 0, 0).unwrap();
+//!         let primitive_dt = PrimitiveDateTime::new(date, time);
+//!
+//!         // Convert to OffsetDateTime with UTC offset
+//!         let datetime = primitive_dt.assume_utc();
+//!
+//!         // Create a duration of 1 hour
+//!         let duration = Duration::hours(1);
+//!
+//!         // Convert to Python objects
+//!         let py_datetime = datetime.into_pyobject(py)?;
+//!         let py_timedelta = duration.into_pyobject(py)?;
+//!
+//!         // Add the duration to the datetime in Python
+//!         let py_result = py_datetime.add(py_timedelta)?;
+//!
+//!         // Convert the result back to Rust
+//!         let result: OffsetDateTime = py_result.extract()?;
+//!         assert_eq!(result.hour(), 13);
+//!
+//!         Ok(())
+//!     })
+//! }
+//! ```
+
+use crate::exceptions::{PyTypeError, PyValueError};
+#[cfg(Py_LIMITED_API)]
+use crate::intern;
+#[cfg(not(Py_LIMITED_API))]
+use crate::types::datetime::{PyDateAccess, PyDeltaAccess};
+use crate::types::{PyAnyMethods, PyDate, PyDateTime, PyDelta, PyNone, PyTime, PyTzInfo};
+#[cfg(not(Py_LIMITED_API))]
+use crate::types::{PyTimeAccess, PyTzInfoAccess};
+use crate::{Borrowed, Bound, FromPyObject, IntoPyObject, PyAny, PyErr, PyResult, Python};
+use time::{
+    Date, Duration, Month, OffsetDateTime, PrimitiveDateTime, Time, UtcDateTime, UtcOffset,
+};
+
+const SECONDS_PER_DAY: i64 = 86_400;
+
+// Macro for reference implementation
+macro_rules! impl_into_py_for_ref {
+    ($type:ty, $target:ty) => {
+        impl<'py> IntoPyObject<'py> for &$type {
+            type Target = $target;
+            type Output = Bound<'py, Self::Target>;
+            type Error = PyErr;
+
+            #[inline]
+            fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+                (*self).into_pyobject(py)
+            }
+        }
+    };
+}
+
+// Macro for month conversion
+macro_rules! month_from_number {
+    ($month:expr) => {
+        match $month {
+            1 => Month::January,
+            2 => Month::February,
+            3 => Month::March,
+            4 => Month::April,
+            5 => Month::May,
+            6 => Month::June,
+            7 => Month::July,
+            8 => Month::August,
+            9 => Month::September,
+            10 => Month::October,
+            11 => Month::November,
+            12 => Month::December,
+            _ => return Err(PyValueError::new_err("invalid month value")),
+        }
+    };
+}
+
+fn extract_date_time(dt: &Bound<'_, PyAny>) -> PyResult<(Date, Time)> {
+    #[cfg(not(Py_LIMITED_API))]
+    {
+        let dt = dt.cast::<PyDateTime>()?;
+        let date = Date::from_calendar_date(
+            dt.get_year(),
+            month_from_number!(dt.get_month()),
+            dt.get_day(),
+        )
+        .map_err(|_| PyValueError::new_err("invalid or out-of-range date"))?;
+
+        let time = Time::from_hms_micro(
+            dt.get_hour(),
+            dt.get_minute(),
+            dt.get_second(),
+            dt.get_microsecond(),
+        )
+        .map_err(|_| PyValueError::new_err("invalid or out-of-range time"))?;
+        Ok((date, time))
+    }
+
+    #[cfg(Py_LIMITED_API)]
+    {
+        let date = Date::from_calendar_date(
+            dt.getattr(intern!(dt.py(), "year"))?.extract()?,
+            month_from_number!(dt.getattr(intern!(dt.py(), "month"))?.extract::<u8>()?),
+            dt.getattr(intern!(dt.py(), "day"))?.extract()?,
+        )
+        .map_err(|_| PyValueError::new_err("invalid or out-of-range date"))?;
+
+        let time = Time::from_hms_micro(
+            dt.getattr(intern!(dt.py(), "hour"))?.extract()?,
+            dt.getattr(intern!(dt.py(), "minute"))?.extract()?,
+            dt.getattr(intern!(dt.py(), "second"))?.extract()?,
+            dt.getattr(intern!(dt.py(), "microsecond"))?.extract()?,
+        )
+        .map_err(|_| PyValueError::new_err("invalid or out-of-range time"))?;
+
+        Ok((date, time))
+    }
+}
+
+impl<'py> IntoPyObject<'py> for Duration {
+    type Target = PyDelta;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        let total_seconds = self.whole_seconds();
+        let micro_seconds = self.subsec_microseconds();
+
+        // For negative durations, Python expects days to be negative and
+        // seconds/microseconds to be positive or zero
+        let (days, seconds) = if total_seconds < 0 && total_seconds % SECONDS_PER_DAY != 0 {
+            // For negative values, we need to round down (toward more negative)
+            // e.g., -10 seconds should be -1 days + 86390 seconds
+            let days = total_seconds.div_euclid(SECONDS_PER_DAY);
+            let seconds = total_seconds.rem_euclid(SECONDS_PER_DAY);
+            (days, seconds)
+        } else {
+            // For positive or exact negative days, use normal division
+            (
+                total_seconds / SECONDS_PER_DAY,
+                total_seconds % SECONDS_PER_DAY,
+            )
+        };
+        // Create the timedelta with days, seconds, microseconds
+        // Safe to unwrap as we've verified the values are within bounds
+        PyDelta::new(
+            py,
+            days.try_into().expect("days overflow"),
+            seconds.try_into().expect("seconds overflow"),
+            micro_seconds,
+            true,
+        )
+    }
+}
+
+impl FromPyObject<'_, '_> for Duration {
+    type Error = PyErr;
+
+    fn extract(ob: Borrowed<'_, '_, PyAny>) -> Result<Self, Self::Error> {
+        #[cfg(not(Py_LIMITED_API))]
+        let (days, seconds, microseconds) = {
+            let delta = ob.cast::<PyDelta>()?;
+            (
+                delta.get_days().into(),
+                delta.get_seconds().into(),
+                delta.get_microseconds().into(),
+            )
+        };
+
+        #[cfg(Py_LIMITED_API)]
+        let (days, seconds, microseconds) = {
+            (
+                ob.getattr(intern!(ob.py(), "days"))?.extract()?,
+                ob.getattr(intern!(ob.py(), "seconds"))?.extract()?,
+                ob.getattr(intern!(ob.py(), "microseconds"))?.extract()?,
+            )
+        };
+
+        Ok(
+            Duration::days(days)
+                + Duration::seconds(seconds)
+                + Duration::microseconds(microseconds),
+        )
+    }
+}
+
+impl<'py> IntoPyObject<'py> for Date {
+    type Target = PyDate;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        let year = self.year();
+        let month = self.month() as u8;
+        let day = self.day();
+
+        PyDate::new(py, year, month, day)
+    }
+}
+
+impl FromPyObject<'_, '_> for Date {
+    type Error = PyErr;
+
+    fn extract(ob: Borrowed<'_, '_, PyAny>) -> Result<Self, Self::Error> {
+        let (year, month, day) = {
+            #[cfg(not(Py_LIMITED_API))]
+            {
+                let date = ob.cast::<PyDate>()?;
+                (date.get_year(), date.get_month(), date.get_day())
+            }
+
+            #[cfg(Py_LIMITED_API)]
+            {
+                let year = ob.getattr(intern!(ob.py(), "year"))?.extract()?;
+                let month: u8 = ob.getattr(intern!(ob.py(), "month"))?.extract()?;
+                let day = ob.getattr(intern!(ob.py(), "day"))?.extract()?;
+                (year, month, day)
+            }
+        };
+
+        // Convert the month number to time::Month enum
+        let month = month_from_number!(month);
+
+        Date::from_calendar_date(year, month, day)
+            .map_err(|_| PyValueError::new_err("invalid or out-of-range date"))
+    }
+}
+
+impl<'py> IntoPyObject<'py> for Time {
+    type Target = PyTime;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        let hour = self.hour();
+        let minute = self.minute();
+        let second = self.second();
+        let microsecond = self.microsecond();
+
+        PyTime::new(py, hour, minute, second, microsecond, None)
+    }
+}
+
+impl FromPyObject<'_, '_> for Time {
+    type Error = PyErr;
+
+    fn extract(ob: Borrowed<'_, '_, PyAny>) -> Result<Self, Self::Error> {
+        let (hour, minute, second, microsecond) = {
+            #[cfg(not(Py_LIMITED_API))]
+            {
+                let time = ob.cast::<PyTime>()?;
+                let hour: u8 = time.get_hour();
+                let minute: u8 = time.get_minute();
+                let second: u8 = time.get_second();
+                let microsecond = time.get_microsecond();
+                (hour, minute, second, microsecond)
+            }
+
+            #[cfg(Py_LIMITED_API)]
+            {
+                let hour: u8 = ob.getattr(intern!(ob.py(), "hour"))?.extract()?;
+                let minute: u8 = ob.getattr(intern!(ob.py(), "minute"))?.extract()?;
+                let second: u8 = ob.getattr(intern!(ob.py(), "second"))?.extract()?;
+                let microsecond = ob.getattr(intern!(ob.py(), "microsecond"))?.extract()?;
+                (hour, minute, second, microsecond)
+            }
+        };
+
+        Time::from_hms_micro(hour, minute, second, microsecond)
+            .map_err(|_| PyValueError::new_err("invalid or out-of-range time"))
+    }
+}
+
+impl<'py> IntoPyObject<'py> for PrimitiveDateTime {
+    type Target = PyDateTime;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        let date = self.date();
+        let time = self.time();
+
+        let year = date.year();
+        let month = date.month() as u8;
+        let day = date.day();
+        let hour = time.hour();
+        let minute = time.minute();
+        let second = time.second();
+        let microsecond = time.microsecond();
+
+        PyDateTime::new(
+            py,
+            year,
+            month,
+            day,
+            hour,
+            minute,
+            second,
+            microsecond,
+            None,
+        )
+    }
+}
+
+impl FromPyObject<'_, '_> for PrimitiveDateTime {
+    type Error = PyErr;
+
+    fn extract(dt: Borrowed<'_, '_, PyAny>) -> Result<Self, Self::Error> {
+        let has_tzinfo = {
+            #[cfg(not(Py_LIMITED_API))]
+            {
+                let dt = dt.cast::<PyDateTime>()?;
+                dt.get_tzinfo().is_some()
+            }
+            #[cfg(Py_LIMITED_API)]
+            {
+                !dt.getattr(intern!(dt.py(), "tzinfo"))?.is_none()
+            }
+        };
+
+        if has_tzinfo {
+            return Err(PyTypeError::new_err("expected a datetime without tzinfo"));
+        }
+
+        let (date, time) = extract_date_time(&dt)?;
+
+        Ok(PrimitiveDateTime::new(date, time))
+    }
+}
+
+impl<'py> IntoPyObject<'py> for UtcOffset {
+    type Target = PyTzInfo;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        // Get offset in seconds
+        let seconds_offset = self.whole_seconds();
+        let td = PyDelta::new(py, 0, seconds_offset, 0, true)?;
+        PyTzInfo::fixed_offset(py, td)
+    }
+}
+
+impl FromPyObject<'_, '_> for UtcOffset {
+    type Error = PyErr;
+
+    fn extract(ob: Borrowed<'_, '_, PyAny>) -> Result<Self, Self::Error> {
+        #[cfg(not(Py_LIMITED_API))]
+        let ob = ob.cast::<PyTzInfo>()?;
+
+        // Get the offset in seconds from the Python tzinfo
+        let py_timedelta = ob.call_method1("utcoffset", (PyNone::get(ob.py()),))?;
+        if py_timedelta.is_none() {
+            return Err(PyTypeError::new_err(format!(
+                "{ob:?} is not a fixed offset timezone"
+            )));
+        }
+
+        let total_seconds: Duration = py_timedelta.extract()?;
+        let seconds = total_seconds.whole_seconds();
+
+        // Create the UtcOffset from the seconds
+        UtcOffset::from_whole_seconds(seconds as i32)
+            .map_err(|_| PyValueError::new_err("UTC offset out of bounds"))
+    }
+}
+
+impl<'py> IntoPyObject<'py> for OffsetDateTime {
+    type Target = PyDateTime;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        let date = self.date();
+        let time = self.time();
+        let offset = self.offset();
+
+        // Convert the offset to a Python tzinfo
+        let py_tzinfo = offset.into_pyobject(py)?;
+
+        let year = date.year();
+        let month = date.month() as u8;
+        let day = date.day();
+        let hour = time.hour();
+        let minute = time.minute();
+        let second = time.second();
+        let microsecond = time.microsecond();
+
+        PyDateTime::new(
+            py,
+            year,
+            month,
+            day,
+            hour,
+            minute,
+            second,
+            microsecond,
+            Some(py_tzinfo.cast()?),
+        )
+    }
+}
+
+impl FromPyObject<'_, '_> for OffsetDateTime {
+    type Error = PyErr;
+
+    fn extract(ob: Borrowed<'_, '_, PyAny>) -> Result<Self, Self::Error> {
+        let offset: UtcOffset = {
+            #[cfg(not(Py_LIMITED_API))]
+            {
+                let dt = ob.cast::<PyDateTime>()?;
+                let tzinfo = dt.get_tzinfo().ok_or_else(|| {
+                    PyTypeError::new_err("expected a datetime with non-None tzinfo")
+                })?;
+                tzinfo.extract()?
+            }
+            #[cfg(Py_LIMITED_API)]
+            {
+                let tzinfo = ob.getattr(intern!(ob.py(), "tzinfo"))?;
+                if tzinfo.is_none() {
+                    return Err(PyTypeError::new_err(
+                        "expected a datetime with non-None tzinfo",
+                    ));
+                }
+                tzinfo.extract()?
+            }
+        };
+
+        let (date, time) = extract_date_time(&ob)?;
+
+        let primitive_dt = PrimitiveDateTime::new(date, time);
+        Ok(primitive_dt.assume_offset(offset))
+    }
+}
+
+impl<'py> IntoPyObject<'py> for UtcDateTime {
+    type Target = PyDateTime;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        let date = self.date();
+        let time = self.time();
+
+        let py_tzinfo = PyTzInfo::utc(py)?;
+
+        let year = date.year();
+        let month = date.month() as u8;
+        let day = date.day();
+        let hour = time.hour();
+        let minute = time.minute();
+        let second = time.second();
+        let microsecond = time.microsecond();
+
+        PyDateTime::new(
+            py,
+            year,
+            month,
+            day,
+            hour,
+            minute,
+            second,
+            microsecond,
+            Some(&py_tzinfo),
+        )
+    }
+}
+
+impl FromPyObject<'_, '_> for UtcDateTime {
+    type Error = PyErr;
+
+    fn extract(ob: Borrowed<'_, '_, PyAny>) -> Result<Self, Self::Error> {
+        let tzinfo = {
+            #[cfg(not(Py_LIMITED_API))]
+            {
+                let dt = ob.cast::<PyDateTime>()?;
+                dt.get_tzinfo().ok_or_else(|| {
+                    PyTypeError::new_err("expected a datetime with non-None tzinfo")
+                })?
+            }
+
+            #[cfg(Py_LIMITED_API)]
+            {
+                let tzinfo = ob.getattr(intern!(ob.py(), "tzinfo"))?;
+                if tzinfo.is_none() {
+                    return Err(PyTypeError::new_err(
+                        "expected a datetime with non-None tzinfo",
+                    ));
+                }
+                tzinfo
+            }
+        };
+
+        // Verify that the tzinfo is UTC
+        let is_utc = tzinfo.eq(PyTzInfo::utc(ob.py())?)?;
+
+        if !is_utc {
+            return Err(PyValueError::new_err(
+                "expected a datetime with UTC timezone",
+            ));
+        }
+
+        let (date, time) = extract_date_time(&ob)?;
+        let primitive_dt = PrimitiveDateTime::new(date, time);
+        Ok(primitive_dt.assume_utc().into())
+    }
+}
+
+impl_into_py_for_ref!(Duration, PyDelta);
+impl_into_py_for_ref!(Date, PyDate);
+impl_into_py_for_ref!(Time, PyTime);
+impl_into_py_for_ref!(PrimitiveDateTime, PyDateTime);
+impl_into_py_for_ref!(UtcOffset, PyTzInfo);
+impl_into_py_for_ref!(OffsetDateTime, PyDateTime);
+impl_into_py_for_ref!(UtcDateTime, PyDateTime);
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::intern;
+    use crate::types::any::PyAnyMethods;
+    use crate::types::PyTypeMethods;
+
+    mod utils {
+        use super::*;
+
+        pub(crate) fn extract_py_delta_from_duration(
+            duration: Duration,
+            py: Python<'_>,
+        ) -> (i64, i64, i64) {
+            let py_delta = duration.into_pyobject(py).unwrap();
+            let days = py_delta
+                .getattr(intern!(py, "days"))
+                .unwrap()
+                .extract::<i64>()
+                .unwrap();
+            let seconds = py_delta
+                .getattr(intern!(py, "seconds"))
+                .unwrap()
+                .extract::<i64>()
+                .unwrap();
+            let microseconds = py_delta
+                .getattr(intern!(py, "microseconds"))
+                .unwrap()
+                .extract::<i64>()
+                .unwrap();
+            (days, seconds, microseconds)
+        }
+
+        pub(crate) fn extract_py_date_from_date(date: Date, py: Python<'_>) -> (i32, u8, u8) {
+            let py_date = date.into_pyobject(py).unwrap();
+
+            // Check the Python object is correct
+            let year = py_date
+                .getattr(intern!(py, "year"))
+                .unwrap()
+                .extract::<i32>()
+                .unwrap();
+            let month = py_date
+                .getattr(intern!(py, "month"))
+                .unwrap()
+                .extract::<u8>()
+                .unwrap();
+            let day = py_date
+                .getattr(intern!(py, "day"))
+                .unwrap()
+                .extract::<u8>()
+                .unwrap();
+            (year, month, day)
+        }
+
+        pub(crate) fn create_date_from_py_date(
+            py: Python<'_>,
+            year: i32,
+            month: u8,
+            day: u8,
+        ) -> PyResult<Date> {
+            let datetime = py.import("datetime").unwrap();
+            let date_type = datetime.getattr(intern!(py, "date")).unwrap();
+            let py_date = date_type.call1((year, month, day));
+            match py_date {
+                Ok(py_date) => py_date.extract(),
+                Err(err) => Err(err),
+            }
+        }
+
+        pub(crate) fn create_time_from_py_time(
+            py: Python<'_>,
+            hour: u8,
+            minute: u8,
+            second: u8,
+            microseocnd: u32,
+        ) -> PyResult<Time> {
+            let datetime = py.import("datetime").unwrap();
+            let time_type = datetime.getattr(intern!(py, "time")).unwrap();
+            let py_time = time_type.call1((hour, minute, second, microseocnd));
+            match py_time {
+                Ok(py_time) => py_time.extract(),
+                Err(err) => Err(err),
+            }
+        }
+
+        pub(crate) fn extract_py_time_from_time(time: Time, py: Python<'_>) -> (u8, u8, u8, u32) {
+            let py_time = time.into_pyobject(py).unwrap();
+            let hour = py_time
+                .getattr(intern!(py, "hour"))
+                .unwrap()
+                .extract::<u8>()
+                .unwrap();
+            let minute = py_time
+                .getattr(intern!(py, "minute"))
+                .unwrap()
+                .extract::<u8>()
+                .unwrap();
+            let second = py_time
+                .getattr(intern!(py, "second"))
+                .unwrap()
+                .extract::<u8>()
+                .unwrap();
+            let microsecond = py_time
+                .getattr(intern!(py, "microsecond"))
+                .unwrap()
+                .extract::<u32>()
+                .unwrap();
+            (hour, minute, second, microsecond)
+        }
+
+        pub(crate) fn extract_date_time_from_primitive_date_time(
+            dt: PrimitiveDateTime,
+            py: Python<'_>,
+        ) -> (u32, u8, u8, u8, u8, u8, u32) {
+            let py_dt = dt.into_pyobject(py).unwrap();
+            let year = py_dt
+                .getattr(intern!(py, "year"))
+                .unwrap()
+                .extract::<u32>()
+                .unwrap();
+            let month = py_dt
+                .getattr(intern!(py, "month"))
+                .unwrap()
+                .extract::<u8>()
+                .unwrap();
+            let day = py_dt
+                .getattr(intern!(py, "day"))
+                .unwrap()
+                .extract::<u8>()
+                .unwrap();
+            let hour = py_dt
+                .getattr(intern!(py, "hour"))
+                .unwrap()
+                .extract::<u8>()
+                .unwrap();
+            let minute = py_dt
+                .getattr(intern!(py, "minute"))
+                .unwrap()
+                .extract::<u8>()
+                .unwrap();
+            let second = py_dt
+                .getattr(intern!(py, "second"))
+                .unwrap()
+                .extract::<u8>()
+                .unwrap();
+            let microsecond = py_dt
+                .getattr(intern!(py, "microsecond"))
+                .unwrap()
+                .extract::<u32>()
+                .unwrap();
+            (year, month, day, hour, minute, second, microsecond)
+        }
+
+        #[allow(clippy::too_many_arguments)]
+        pub(crate) fn create_primitive_date_time_from_py(
+            py: Python<'_>,
+            year: u32,
+            month: u8,
+            day: u8,
+            hour: u8,
+            minute: u8,
+            second: u8,
+            microsecond: u32,
+        ) -> PyResult<PrimitiveDateTime> {
+            let datetime = py.import("datetime").unwrap();
+            let datetime_type = datetime.getattr(intern!(py, "datetime")).unwrap();
+            let py_dt = datetime_type.call1((year, month, day, hour, minute, second, microsecond));
+            match py_dt {
+                Ok(py_dt) => py_dt.extract(),
+                Err(err) => Err(err),
+            }
+        }
+
+        pub(crate) fn extract_total_seconds_from_utcoffset(
+            offset: UtcOffset,
+            py: Python<'_>,
+        ) -> f64 {
+            let py_tz = offset.into_pyobject(py).unwrap();
+            let utc_offset = py_tz.call_method1("utcoffset", (py.None(),)).unwrap();
+            let total_seconds = utc_offset
+                .getattr(intern!(py, "total_seconds"))
+                .unwrap()
+                .call0()
+                .unwrap()
+                .extract::<f64>()
+                .unwrap();
+            total_seconds
+        }
+
+        pub(crate) fn extract_from_utc_date_time(
+            dt: UtcDateTime,
+            py: Python<'_>,
+        ) -> (u32, u8, u8, u8, u8, u8, u32) {
+            let py_dt = dt.into_pyobject(py).unwrap();
+            let year = py_dt
+                .getattr(intern!(py, "year"))
+                .unwrap()
+                .extract::<u32>()
+                .unwrap();
+            let month = py_dt
+                .getattr(intern!(py, "month"))
+                .unwrap()
+                .extract::<u8>()
+                .unwrap();
+            let day = py_dt
+                .getattr(intern!(py, "day"))
+                .unwrap()
+                .extract::<u8>()
+                .unwrap();
+            let hour = py_dt
+                .getattr(intern!(py, "hour"))
+                .unwrap()
+                .extract::<u8>()
+                .unwrap();
+            let minute = py_dt
+                .getattr(intern!(py, "minute"))
+                .unwrap()
+                .extract::<u8>()
+                .unwrap();
+            let second = py_dt
+                .getattr(intern!(py, "second"))
+                .unwrap()
+                .extract::<u8>()
+                .unwrap();
+            let microsecond = py_dt
+                .getattr(intern!(py, "microsecond"))
+                .unwrap()
+                .extract::<u32>()
+                .unwrap();
+            (year, month, day, hour, minute, second, microsecond)
+        }
+    }
+    #[test]
+    fn test_time_duration_conversion() {
+        Python::attach(|py| {
+            // Regular duration
+            let duration = Duration::new(1, 500_000_000); // 1.5 seconds
+            let (_, seconds, microseconds) = utils::extract_py_delta_from_duration(duration, py);
+            assert_eq!(seconds, 1);
+            assert_eq!(microseconds, 500_000);
+
+            // Check negative durations
+            let neg_duration = Duration::new(-10, 0); // -10 seconds
+            let (days, seconds, _) = utils::extract_py_delta_from_duration(neg_duration, py);
+            assert_eq!(days, -1);
+            assert_eq!(seconds, 86390); // 86400 - 10 seconds
+
+            // Test case for exact negative days (should use normal division path)
+            let exact_day = Duration::seconds(-86_400); // Exactly -1 day
+            let (days, seconds, microseconds) =
+                utils::extract_py_delta_from_duration(exact_day, py);
+            assert_eq!(days, -1);
+            assert_eq!(seconds, 0);
+            assert_eq!(microseconds, 0);
+        });
+    }
+
+    #[test]
+    fn test_time_duration_conversion_large_values() {
+        Python::attach(|py| {
+            // Large duration (close to max)
+            let large_duration = Duration::seconds(86_399_999_000_000); // Almost max
+            let (days, _, _) = utils::extract_py_delta_from_duration(large_duration, py);
+            assert!(days > 999_000_000);
+
+            // Test over limit (should yield Overflow error in python)
+            let too_large = Duration::seconds(86_400_000_000_000); // Over max
+            let result = too_large.into_pyobject(py);
+            assert!(result.is_err());
+            let err_type = result.unwrap_err().get_type(py).name().unwrap();
+            assert_eq!(err_type, "OverflowError");
+        });
+    }
+
+    #[test]
+    fn test_time_duration_nanosecond_resolution() {
+        Python::attach(|py| {
+            // Test nanosecond conversion to microseconds
+            let duration = Duration::new(0, 1_234_567);
+            let (_, _, microseconds) = utils::extract_py_delta_from_duration(duration, py);
+            // Python timedelta only has microsecond resolution, so we should get 1234 microseconds
+            assert_eq!(microseconds, 1234);
+        });
+    }
+
+    #[test]
+    fn test_time_duration_from_python() {
+        Python::attach(|py| {
+            // Create Python timedeltas with various values
+            let datetime = py.import("datetime").unwrap();
+            let timedelta = datetime.getattr(intern!(py, "timedelta")).unwrap();
+
+            // Test positive values
+            let py_delta1 = timedelta.call1((3, 7200, 500000)).unwrap();
+            let duration1: Duration = py_delta1.extract().unwrap();
+            assert_eq!(duration1.whole_days(), 3);
+            assert_eq!(duration1.whole_seconds() % 86400, 7200);
+            assert_eq!(duration1.subsec_nanoseconds(), 500000000);
+
+            // Test negative days
+            let py_delta2 = timedelta.call1((-2, 43200)).unwrap();
+            let duration2: Duration = py_delta2.extract().unwrap();
+            assert_eq!(duration2.whole_days(), -1);
+            assert_eq!(duration2.whole_seconds(), -129600);
+        });
+    }
+
+    #[test]
+    fn test_time_date_conversion() {
+        Python::attach(|py| {
+            // Regular date
+            let date = Date::from_calendar_date(2023, Month::April, 15).unwrap();
+            let (year, month, day) = utils::extract_py_date_from_date(date, py);
+            assert_eq!(year, 2023);
+            assert_eq!(month, 4);
+            assert_eq!(day, 15);
+
+            // Test edge cases
+            let min_date = Date::from_calendar_date(1, Month::January, 1).unwrap();
+            let (min_year, min_month, min_day) = utils::extract_py_date_from_date(min_date, py);
+            assert_eq!(min_year, 1);
+            assert_eq!(min_month, 1);
+            assert_eq!(min_day, 1);
+
+            let max_date = Date::from_calendar_date(9999, Month::December, 31).unwrap();
+            let (max_year, max_month, max_day) = utils::extract_py_date_from_date(max_date, py);
+            assert_eq!(max_year, 9999);
+            assert_eq!(max_month, 12);
+            assert_eq!(max_day, 31);
+        });
+    }
+
+    #[test]
+    fn test_time_date_from_python() {
+        Python::attach(|py| {
+            let date1 = utils::create_date_from_py_date(py, 2023, 4, 15).unwrap();
+            assert_eq!(date1.year(), 2023);
+            assert_eq!(date1.month(), Month::April);
+            assert_eq!(date1.day(), 15);
+
+            // Test min date
+            let date2 = utils::create_date_from_py_date(py, 1, 1, 1).unwrap();
+            assert_eq!(date2.year(), 1);
+            assert_eq!(date2.month(), Month::January);
+            assert_eq!(date2.day(), 1);
+
+            // Test max date
+            let date3 = utils::create_date_from_py_date(py, 9999, 12, 31).unwrap();
+            assert_eq!(date3.year(), 9999);
+            assert_eq!(date3.month(), Month::December);
+            assert_eq!(date3.day(), 31);
+
+            // Test leap year date
+            let date4 = utils::create_date_from_py_date(py, 2024, 2, 29).unwrap();
+            assert_eq!(date4.year(), 2024);
+            assert_eq!(date4.month(), Month::February);
+            assert_eq!(date4.day(), 29);
+        });
+    }
+
+    #[test]
+    fn test_time_date_invalid_values() {
+        Python::attach(|py| {
+            let invalid_date = utils::create_date_from_py_date(py, 2023, 2, 30);
+            assert!(invalid_date.is_err());
+
+            // Test extraction of invalid month
+            let another_invalid_date = utils::create_date_from_py_date(py, 2023, 13, 1);
+            assert!(another_invalid_date.is_err());
+        });
+    }
+
+    #[test]
+    fn test_time_time_conversion() {
+        Python::attach(|py| {
+            // Regular time
+            let time = Time::from_hms_micro(14, 30, 45, 123456).unwrap();
+            let (hour, minute, second, microsecond) = utils::extract_py_time_from_time(time, py);
+            assert_eq!(hour, 14);
+            assert_eq!(minute, 30);
+            assert_eq!(second, 45);
+            assert_eq!(microsecond, 123456);
+
+            // Test edge cases
+            let min_time = Time::from_hms_micro(0, 0, 0, 0).unwrap();
+            let (min_hour, min_minute, min_second, min_microsecond) =
+                utils::extract_py_time_from_time(min_time, py);
+            assert_eq!(min_hour, 0);
+            assert_eq!(min_minute, 0);
+            assert_eq!(min_second, 0);
+            assert_eq!(min_microsecond, 0);
+
+            let max_time = Time::from_hms_micro(23, 59, 59, 999999).unwrap();
+            let (max_hour, max_minute, max_second, max_microsecond) =
+                utils::extract_py_time_from_time(max_time, py);
+            assert_eq!(max_hour, 23);
+            assert_eq!(max_minute, 59);
+            assert_eq!(max_second, 59);
+            assert_eq!(max_microsecond, 999999);
+        });
+    }
+
+    #[test]
+    fn test_time_time_from_python() {
+        Python::attach(|py| {
+            let time1 = utils::create_time_from_py_time(py, 14, 30, 45, 123456).unwrap();
+            assert_eq!(time1.hour(), 14);
+            assert_eq!(time1.minute(), 30);
+            assert_eq!(time1.second(), 45);
+            assert_eq!(time1.microsecond(), 123456);
+
+            // Test min time
+            let time2 = utils::create_time_from_py_time(py, 0, 0, 0, 0).unwrap();
+            assert_eq!(time2.hour(), 0);
+            assert_eq!(time2.minute(), 0);
+            assert_eq!(time2.second(), 0);
+            assert_eq!(time2.microsecond(), 0);
+
+            // Test max time
+            let time3 = utils::create_time_from_py_time(py, 23, 59, 59, 999999).unwrap();
+            assert_eq!(time3.hour(), 23);
+            assert_eq!(time3.minute(), 59);
+            assert_eq!(time3.second(), 59);
+            assert_eq!(time3.microsecond(), 999999);
+        });
+    }
+
+    #[test]
+    fn test_time_time_invalid_values() {
+        Python::attach(|py| {
+            let result = utils::create_time_from_py_time(py, 24, 0, 0, 0);
+            assert!(result.is_err());
+            let result = utils::create_time_from_py_time(py, 12, 60, 0, 0);
+            assert!(result.is_err());
+            let result = utils::create_time_from_py_time(py, 12, 30, 60, 0);
+            assert!(result.is_err());
+            let result = utils::create_time_from_py_time(py, 12, 30, 30, 1000000);
+            assert!(result.is_err());
+        });
+    }
+
+    #[test]
+    fn test_time_time_with_timezone() {
+        Python::attach(|py| {
+            // Create Python time with timezone (just to ensure we can handle it properly)
+            let datetime = py.import("datetime").unwrap();
+            let time_type = datetime.getattr(intern!(py, "time")).unwrap();
+            let tz_utc = PyTzInfo::utc(py).unwrap();
+
+            // Create time with timezone
+            let py_time_with_tz = time_type.call1((12, 30, 45, 0, tz_utc)).unwrap();
+            let time: Time = py_time_with_tz.extract().unwrap();
+
+            assert_eq!(time.hour(), 12);
+            assert_eq!(time.minute(), 30);
+            assert_eq!(time.second(), 45);
+        });
+    }
+
+    #[test]
+    fn test_time_primitive_datetime_conversion() {
+        Python::attach(|py| {
+            // Regular datetime
+            let date = Date::from_calendar_date(2023, Month::April, 15).unwrap();
+            let time = Time::from_hms_micro(14, 30, 45, 123456).unwrap();
+            let dt = PrimitiveDateTime::new(date, time);
+            let (year, month, day, hour, minute, second, microsecond) =
+                utils::extract_date_time_from_primitive_date_time(dt, py);
+
+            assert_eq!(year, 2023);
+            assert_eq!(month, 4);
+            assert_eq!(day, 15);
+            assert_eq!(hour, 14);
+            assert_eq!(minute, 30);
+            assert_eq!(second, 45);
+            assert_eq!(microsecond, 123456);
+
+            // Test min datetime
+            let min_date = Date::from_calendar_date(1, Month::January, 1).unwrap();
+            let min_time = Time::from_hms_micro(0, 0, 0, 0).unwrap();
+            let min_dt = PrimitiveDateTime::new(min_date, min_time);
+            let (year, month, day, hour, minute, second, microsecond) =
+                utils::extract_date_time_from_primitive_date_time(min_dt, py);
+            assert_eq!(year, 1);
+            assert_eq!(month, 1);
+            assert_eq!(day, 1);
+            assert_eq!(hour, 0);
+            assert_eq!(minute, 0);
+            assert_eq!(second, 0);
+            assert_eq!(microsecond, 0);
+        });
+    }
+
+    #[test]
+    fn test_time_primitive_datetime_from_python() {
+        Python::attach(|py| {
+            let dt1 =
+                utils::create_primitive_date_time_from_py(py, 2023, 4, 15, 14, 30, 45, 123456)
+                    .unwrap();
+            assert_eq!(dt1.year(), 2023);
+            assert_eq!(dt1.month(), Month::April);
+            assert_eq!(dt1.day(), 15);
+            assert_eq!(dt1.hour(), 14);
+            assert_eq!(dt1.minute(), 30);
+            assert_eq!(dt1.second(), 45);
+            assert_eq!(dt1.microsecond(), 123456);
+
+            let dt2 = utils::create_primitive_date_time_from_py(py, 1, 1, 1, 0, 0, 0, 0).unwrap();
+            assert_eq!(dt2.year(), 1);
+            assert_eq!(dt2.month(), Month::January);
+            assert_eq!(dt2.day(), 1);
+            assert_eq!(dt2.hour(), 0);
+            assert_eq!(dt2.minute(), 0);
+        });
+    }
+
+    #[test]
+    fn test_time_utc_offset_conversion() {
+        Python::attach(|py| {
+            // Test positive offset
+            let offset = UtcOffset::from_hms(5, 30, 0).unwrap();
+            let total_seconds = utils::extract_total_seconds_from_utcoffset(offset, py);
+            assert_eq!(total_seconds, 5.0 * 3600.0 + 30.0 * 60.0);
+
+            // Test negative offset
+            let neg_offset = UtcOffset::from_hms(-8, -15, 0).unwrap();
+            let neg_total_seconds = utils::extract_total_seconds_from_utcoffset(neg_offset, py);
+            assert_eq!(neg_total_seconds, -8.0 * 3600.0 - 15.0 * 60.0);
+        });
+    }
+
+    #[test]
+    fn test_time_utc_offset_from_python() {
+        Python::attach(|py| {
+            // Create timezone objects
+            let datetime = py.import("datetime").unwrap();
+            let timezone = datetime.getattr(intern!(py, "timezone")).unwrap();
+            let timedelta = datetime.getattr(intern!(py, "timedelta")).unwrap();
+
+            // Test UTC
+            let tz_utc = PyTzInfo::utc(py).unwrap();
+            let utc_offset: UtcOffset = tz_utc.extract().unwrap();
+            assert_eq!(utc_offset.whole_hours(), 0);
+            assert_eq!(utc_offset.minutes_past_hour(), 0);
+            assert_eq!(utc_offset.seconds_past_minute(), 0);
+
+            // Test positive offset
+            let td_pos = timedelta.call1((0, 19800, 0)).unwrap(); // 5 hours 30 minutes
+            let tz_pos = timezone.call1((td_pos,)).unwrap();
+            let offset_pos: UtcOffset = tz_pos.extract().unwrap();
+            assert_eq!(offset_pos.whole_hours(), 5);
+            assert_eq!(offset_pos.minutes_past_hour(), 30);
+
+            // Test negative offset
+            let td_neg = timedelta.call1((0, -30900, 0)).unwrap(); // -8 hours -35 minutes
+            let tz_neg = timezone.call1((td_neg,)).unwrap();
+            let offset_neg: UtcOffset = tz_neg.extract().unwrap();
+            assert_eq!(offset_neg.whole_hours(), -8);
+            assert_eq!(offset_neg.minutes_past_hour(), -35);
+        });
+    }
+
+    #[test]
+    fn test_time_offset_datetime_conversion() {
+        Python::attach(|py| {
+            // Create an OffsetDateTime with +5:30 offset
+            let date = Date::from_calendar_date(2023, Month::April, 15).unwrap();
+            let time = Time::from_hms_micro(14, 30, 45, 123456).unwrap();
+            let offset = UtcOffset::from_hms(5, 30, 0).unwrap();
+            let dt = PrimitiveDateTime::new(date, time).assume_offset(offset);
+
+            // Convert to Python
+            let py_dt = dt.into_pyobject(py).unwrap();
+
+            // Check components
+            let year = py_dt
+                .getattr(intern!(py, "year"))
+                .unwrap()
+                .extract::<i32>()
+                .unwrap();
+            let month = py_dt
+                .getattr(intern!(py, "month"))
+                .unwrap()
+                .extract::<u8>()
+                .unwrap();
+            let day = py_dt
+                .getattr(intern!(py, "day"))
+                .unwrap()
+                .extract::<u8>()
+                .unwrap();
+            let hour = py_dt
+                .getattr(intern!(py, "hour"))
+                .unwrap()
+                .extract::<u8>()
+                .unwrap();
+            let minute = py_dt
+                .getattr(intern!(py, "minute"))
+                .unwrap()
+                .extract::<u8>()
+                .unwrap();
+            let second = py_dt
+                .getattr(intern!(py, "second"))
+                .unwrap()
+                .extract::<u8>()
+                .unwrap();
+            let microsecond = py_dt
+                .getattr(intern!(py, "microsecond"))
+                .unwrap()
+                .extract::<u32>()
+                .unwrap();
+
+            assert_eq!(year, 2023);
+            assert_eq!(month, 4);
+            assert_eq!(day, 15);
+            assert_eq!(hour, 14);
+            assert_eq!(minute, 30);
+            assert_eq!(second, 45);
+            assert_eq!(microsecond, 123456);
+
+            // Check timezone offset
+            let tzinfo = py_dt.getattr(intern!(py, "tzinfo")).unwrap();
+            let utcoffset = tzinfo.call_method1("utcoffset", (py_dt,)).unwrap();
+            let seconds = utcoffset
+                .call_method0("total_seconds")
+                .unwrap()
+                .extract::<f64>()
+                .unwrap();
+            assert_eq!(seconds, 5.0 * 3600.0 + 30.0 * 60.0);
+        });
+    }
+
+    #[test]
+    fn test_time_offset_datetime_from_python() {
+        Python::attach(|py| {
+            // Create Python datetime with timezone
+            let datetime = py.import("datetime").unwrap();
+            let datetime_type = datetime.getattr(intern!(py, "datetime")).unwrap();
+            let timezone = datetime.getattr(intern!(py, "timezone")).unwrap();
+            let timedelta = datetime.getattr(intern!(py, "timedelta")).unwrap();
+
+            // Create a timezone (+5:30)
+            let td = timedelta.call1((0, 19800, 0)).unwrap(); // 5:30:00
+            let tz = timezone.call1((td,)).unwrap();
+
+            // Create datetime with this timezone
+            let py_dt = datetime_type
+                .call1((2023, 4, 15, 14, 30, 45, 123456, tz))
+                .unwrap();
+
+            // Extract to Rust
+            let dt: OffsetDateTime = py_dt.extract().unwrap();
+
+            // Verify components
+            assert_eq!(dt.year(), 2023);
+            assert_eq!(dt.month(), Month::April);
+            assert_eq!(dt.day(), 15);
+            assert_eq!(dt.hour(), 14);
+            assert_eq!(dt.minute(), 30);
+            assert_eq!(dt.second(), 45);
+            assert_eq!(dt.microsecond(), 123456);
+            assert_eq!(dt.offset().whole_hours(), 5);
+            assert_eq!(dt.offset().minutes_past_hour(), 30);
+        });
+    }
+
+    #[test]
+    fn test_time_utc_datetime_conversion() {
+        Python::attach(|py| {
+            let date = Date::from_calendar_date(2023, Month::April, 15).unwrap();
+            let time = Time::from_hms_micro(14, 30, 45, 123456).unwrap();
+            let primitive_dt = PrimitiveDateTime::new(date, time);
+            let dt: UtcDateTime = primitive_dt.assume_utc().into();
+            let (year, month, day, hour, minute, second, microsecond) =
+                utils::extract_from_utc_date_time(dt, py);
+
+            assert_eq!(year, 2023);
+            assert_eq!(month, 4);
+            assert_eq!(day, 15);
+            assert_eq!(hour, 14);
+            assert_eq!(minute, 30);
+            assert_eq!(second, 45);
+            assert_eq!(microsecond, 123456);
+        });
+    }
+
+    #[test]
+    fn test_time_utc_datetime_from_python() {
+        Python::attach(|py| {
+            // Create Python UTC datetime
+            let datetime = py.import("datetime").unwrap();
+            let datetime_type = datetime.getattr(intern!(py, "datetime")).unwrap();
+            let tz_utc = PyTzInfo::utc(py).unwrap();
+
+            // Create datetime with UTC timezone
+            let py_dt = datetime_type
+                .call1((2023, 4, 15, 14, 30, 45, 123456, tz_utc))
+                .unwrap();
+
+            // Convert to Rust
+            let dt: UtcDateTime = py_dt.extract().unwrap();
+
+            // Verify components
+            assert_eq!(dt.year(), 2023);
+            assert_eq!(dt.month(), Month::April);
+            assert_eq!(dt.day(), 15);
+            assert_eq!(dt.hour(), 14);
+            assert_eq!(dt.minute(), 30);
+            assert_eq!(dt.second(), 45);
+            assert_eq!(dt.microsecond(), 123456);
+        });
+    }
+
+    #[test]
+    fn test_time_utc_datetime_non_utc_timezone() {
+        Python::attach(|py| {
+            // Create Python datetime with non-UTC timezone
+            let datetime = py.import("datetime").unwrap();
+            let datetime_type = datetime.getattr(intern!(py, "datetime")).unwrap();
+            let timezone = datetime.getattr(intern!(py, "timezone")).unwrap();
+            let timedelta = datetime.getattr(intern!(py, "timedelta")).unwrap();
+
+            // Create a non-UTC timezone (EST = UTC-5)
+            let td = timedelta.call1((0, -18000, 0)).unwrap(); // -5 hours
+            let tz_est = timezone.call1((td,)).unwrap();
+
+            // Create datetime with EST timezone
+            let py_dt = datetime_type
+                .call1((2023, 4, 15, 14, 30, 45, 123456, tz_est))
+                .unwrap();
+
+            // Try to convert to UtcDateTime - should fail
+            let result: Result<UtcDateTime, _> = py_dt.extract();
+            assert!(result.is_err());
+        });
+    }
+
+    #[cfg(not(any(target_arch = "wasm32", Py_GIL_DISABLED)))]
+    mod proptests {
+        use super::*;
+        use proptest::proptest;
+
+        proptest! {
+            #[test]
+            fn test_time_duration_roundtrip(days in -9999i64..=9999i64, seconds in -86399i64..=86399i64, microseconds in -999999i64..=999999i64) {
+                // Generate a valid duration that should roundtrip successfully
+                Python::attach(|py| {
+                    let duration = Duration::days(days) + Duration::seconds(seconds) + Duration::microseconds(microseconds);
+
+                    // Skip if outside Python's timedelta bounds
+                    let max_seconds = 86_399_999_913_600;
+                    if duration.whole_seconds() <= max_seconds && duration.whole_seconds() >= -max_seconds {
+                        let py_delta = duration.into_pyobject(py).unwrap();
+
+                        // You could add FromPyObject for Duration to fully test the roundtrip
+                        // For now we'll just check that the Python object has the expected properties
+                        let total_seconds = py_delta.call_method0(intern!(py, "total_seconds")).unwrap().extract::<f64>().unwrap();
+                        let expected_seconds = duration.whole_seconds() as f64 + (duration.subsec_nanoseconds() as f64 / 1_000_000_000.0);
+
+                        // Allow small floating point differences
+                        assert_eq!(total_seconds, expected_seconds);
+                    }
+                })
+            }
+
+            #[test]
+            fn test_all_valid_dates(
+                year in 1i32..=9999,
+                month_num in 1u8..=12,
+            ) {
+                Python::attach(|py| {
+                    let month = match month_num {
+                        1 => (Month::January, 31),
+                        2 => {
+                            // Handle leap years
+                            if (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0) {
+                                (Month::February, 29)
+                            } else {
+                                (Month::February, 28)
+                            }
+                        },
+                        3 => (Month::March, 31),
+                        4 => (Month::April, 30),
+                        5 => (Month::May, 31),
+                        6 => (Month::June, 30),
+                        7 => (Month::July, 31),
+                        8 => (Month::August, 31),
+                        9 => (Month::September, 30),
+                        10 => (Month::October, 31),
+                        11 => (Month::November, 30),
+                        12 => (Month::December, 31),
+                        _ => unreachable!(),
+                    };
+
+                    // Test the entire month
+                    for day in 1..=month.1 {
+                        let date = Date::from_calendar_date(year, month.0, day).unwrap();
+                        let py_date = date.into_pyobject(py).unwrap();
+                        let roundtripped: Date = py_date.extract().unwrap();
+                        assert_eq!(date, roundtripped);
+                    }
+                });
+            }
+
+            #[test]
+            fn test_time_time_roundtrip_random(
+                hour in 0u8..=23u8,
+                minute in 0u8..=59u8,
+                second in 0u8..=59u8,
+                microsecond in 0u32..=999999u32
+            ) {
+                Python::attach(|py| {
+                    let time = Time::from_hms_micro(hour, minute, second, microsecond).unwrap();
+                    let py_time = time.into_pyobject(py).unwrap();
+                    let roundtripped: Time = py_time.extract().unwrap();
+                    assert_eq!(time, roundtripped);
+                });
+            }
+
+            #[test]
+            fn test_time_primitive_datetime_roundtrip_random(
+                year in 1i32..=9999i32,
+                month in 1u8..=12u8,
+                day in 1u8..=28u8, // Use only valid days for all months
+                hour in 0u8..=23u8,
+                minute in 0u8..=59u8,
+                second in 0u8..=59u8,
+                microsecond in 0u32..=999999u32
+            ) {
+                Python::attach(|py| {
+                    let month = match month {
+                        1 => Month::January,
+                        2 => Month::February,
+                        3 => Month::March,
+                        4 => Month::April,
+                        5 => Month::May,
+                        6 => Month::June,
+                        7 => Month::July,
+                        8 => Month::August,
+                        9 => Month::September,
+                        10 => Month::October,
+                        11 => Month::November,
+                        12 => Month::December,
+                        _ => unreachable!(),
+                    };
+
+                    let date = Date::from_calendar_date(year, month, day).unwrap();
+                    let time = Time::from_hms_micro(hour, minute, second, microsecond).unwrap();
+                    let dt = PrimitiveDateTime::new(date, time);
+
+                    let py_dt = dt.into_pyobject(py).unwrap();
+                    let roundtripped: PrimitiveDateTime = py_dt.extract().unwrap();
+                    assert_eq!(dt, roundtripped);
+                });
+            }
+
+            #[test]
+            fn test_time_utc_offset_roundtrip_random(
+                hours in -23i8..=23i8,
+                minutes in -59i8..=59i8
+            ) {
+                // Skip invalid combinations where hour and minute signs don't match
+                if (hours < 0 && minutes > 0) || (hours > 0 && minutes < 0) {
+                    return Ok(());
+                }
+
+                Python::attach(|py| {
+                    if let Ok(offset) = UtcOffset::from_hms(hours, minutes, 0) {
+                        let py_tz = offset.into_pyobject(py).unwrap();
+                        let roundtripped: UtcOffset = py_tz.extract().unwrap();
+                        assert_eq!(roundtripped.whole_hours(), hours);
+                        assert_eq!(roundtripped.minutes_past_hour(), minutes);
+                    }
+                });
+            }
+
+            #[test]
+            fn test_time_offset_datetime_roundtrip_random(
+                year in 1i32..=9999i32,
+                month in 1u8..=12u8,
+                day in 1u8..=28u8, // Use only valid days for all months
+                hour in 0u8..=23u8,
+                minute in 0u8..=59u8,
+                second in 0u8..=59u8,
+                microsecond in 0u32..=999999u32,
+                tz_hour in -23i8..=23i8,
+                tz_minute in 0i8..=59i8
+            ) {
+                Python::attach(|py| {
+                    let month = match month {
+                        1 => Month::January,
+                        2 => Month::February,
+                        3 => Month::March,
+                        4 => Month::April,
+                        5 => Month::May,
+                        6 => Month::June,
+                        7 => Month::July,
+                        8 => Month::August,
+                        9 => Month::September,
+                        10 => Month::October,
+                        11 => Month::November,
+                        12 => Month::December,
+                        _ => unreachable!(),
+                    };
+
+                    let date = Date::from_calendar_date(year, month, day).unwrap();
+                    let time = Time::from_hms_micro(hour, minute, second, microsecond).unwrap();
+
+                    // Handle timezone sign correctly
+                    let tz_minute = if tz_hour < 0 { -tz_minute } else { tz_minute };
+
+                    if let Ok(offset) = UtcOffset::from_hms(tz_hour, tz_minute, 0) {
+                        let dt = PrimitiveDateTime::new(date, time).assume_offset(offset);
+                        let py_dt = dt.into_pyobject(py).unwrap();
+                        let roundtripped: OffsetDateTime = py_dt.extract().unwrap();
+
+                        assert_eq!(dt.year(), roundtripped.year());
+                        assert_eq!(dt.month(), roundtripped.month());
+                        assert_eq!(dt.day(), roundtripped.day());
+                        assert_eq!(dt.hour(), roundtripped.hour());
+                        assert_eq!(dt.minute(), roundtripped.minute());
+                        assert_eq!(dt.second(), roundtripped.second());
+                        assert_eq!(dt.microsecond(), roundtripped.microsecond());
+                        assert_eq!(dt.offset().whole_hours(), roundtripped.offset().whole_hours());
+                        assert_eq!(dt.offset().minutes_past_hour(), roundtripped.offset().minutes_past_hour());
+                    }
+                });
+            }
+
+            #[test]
+            fn test_time_utc_datetime_roundtrip_random(
+                year in 1i32..=9999i32,
+                month in 1u8..=12u8,
+                day in 1u8..=28u8, // Use only valid days for all months
+                hour in 0u8..=23u8,
+                minute in 0u8..=59u8,
+                second in 0u8..=59u8,
+                microsecond in 0u32..=999999u32
+            ) {
+                Python::attach(|py| {
+                    let month = match month {
+                        1 => Month::January,
+                        2 => Month::February,
+                        3 => Month::March,
+                        4 => Month::April,
+                        5 => Month::May,
+                        6 => Month::June,
+                        7 => Month::July,
+                        8 => Month::August,
+                        9 => Month::September,
+                        10 => Month::October,
+                        11 => Month::November,
+                        12 => Month::December,
+                        _ => unreachable!(),
+                    };
+
+                    let date = Date::from_calendar_date(year, month, day).unwrap();
+                    let time = Time::from_hms_micro(hour, minute, second, microsecond).unwrap();
+                    let primitive_dt = PrimitiveDateTime::new(date, time);
+                    let dt: UtcDateTime = primitive_dt.assume_utc().into();
+
+                    let py_dt = dt.into_pyobject(py).unwrap();
+                    let roundtripped: UtcDateTime = py_dt.extract().unwrap();
+
+                    assert_eq!(dt.year(), roundtripped.year());
+                    assert_eq!(dt.month(), roundtripped.month());
+                    assert_eq!(dt.day(), roundtripped.day());
+                    assert_eq!(dt.hour(), roundtripped.hour());
+                    assert_eq!(dt.minute(), roundtripped.minute());
+                    assert_eq!(dt.second(), roundtripped.second());
+                    assert_eq!(dt.microsecond(), roundtripped.microsecond());
+                })
+            }
+        }
+    }
+}
diff --git a/src/conversions/uuid.rs b/src/conversions/uuid.rs
new file mode 100644
index 00000000000..b937e3e9f0c
--- /dev/null
+++ b/src/conversions/uuid.rs
@@ -0,0 +1,186 @@
+#![cfg(feature = "uuid")]
+
+//! Conversions to and from [uuid](https://docs.rs/uuid/latest/uuid/)'s [`Uuid`] type.
+//!
+//! This is useful for converting Python's uuid.UUID into and from a native Rust type.
+//!
+//! # Setup
+//!
+//! To use this feature, add to your **`Cargo.toml`**:
+//!
+//! ```toml
+//! [dependencies]
+#![doc = concat!("pyo3 = { version = \"", env!("CARGO_PKG_VERSION"),  "\", features = [\"uuid\"] }")]
+//! uuid = "1.11.0"
+//! ```
+//!
+//! Note that you must use a compatible version of uuid and PyO3.
+//! The required uuid version may vary based on the version of PyO3.
+//!
+//! # Example
+//!
+//! Rust code to create a function that parses a UUID string and returns it as a `Uuid`:
+//!
+//! ```rust,no_run
+//! use pyo3::prelude::*;
+//! use pyo3::exceptions::PyValueError;
+//! use uuid::Uuid;
+//!
+//! /// Parse a UUID from a string.
+//! #[pyfunction]
+//! fn get_uuid_from_str(s: &str) -> PyResult<Uuid> {
+//!     Uuid::parse_str(s).map_err(|e| PyValueError::new_err(e.to_string()))
+//! }
+//!
+//! /// Passing a Python uuid.UUID directly to Rust.
+//! #[pyfunction]
+//! fn get_uuid(u: Uuid) -> Uuid {
+//!     u
+//! }
+//!
+//! #[pymodule]
+//! fn my_module(m: &Bound<'_, PyModule>) -> PyResult<()> {
+//!     m.add_function(wrap_pyfunction!(get_uuid_from_str, m)?)?;
+//!     m.add_function(wrap_pyfunction!(get_uuid, m)?)?;
+//!     Ok(())
+//! }
+//! ```
+//!
+//! Python code that validates the functionality
+//!
+//!
+//! ```python
+//! from my_module import get_uuid_from_str, get_uuid
+//! import uuid
+//!
+//! py_uuid = uuid.uuid4()
+//!
+//! # Convert string to Rust Uuid
+//! rust_uuid = get_uuid_from_str(str(py_uuid))
+//! assert py_uuid == rust_uuid
+//!
+//! # Pass Python UUID directly to Rust
+//! returned_uuid = get_uuid(py_uuid)
+//! assert py_uuid == returned_uuid
+//! ```
+use uuid::Uuid;
+
+use crate::conversion::IntoPyObject;
+use crate::exceptions::PyTypeError;
+use crate::instance::Bound;
+use crate::sync::PyOnceLock;
+use crate::types::any::PyAnyMethods;
+use crate::types::PyType;
+use crate::{intern, Borrowed, FromPyObject, Py, PyAny, PyErr, PyResult, Python};
+
+fn get_uuid_cls(py: Python<'_>) -> PyResult<&Bound<'_, PyType>> {
+    static UUID_CLS: PyOnceLock<Py<PyType>> = PyOnceLock::new();
+    UUID_CLS.import(py, "uuid", "UUID")
+}
+
+impl FromPyObject<'_, '_> for Uuid {
+    type Error = PyErr;
+
+    fn extract(obj: Borrowed<'_, '_, PyAny>) -> PyResult<Self> {
+        let py = obj.py();
+        let uuid_cls = get_uuid_cls(py)?;
+
+        if obj.is_instance(uuid_cls)? {
+            let uuid_int: u128 = obj.getattr(intern!(py, "int"))?.extract()?;
+            Ok(Uuid::from_u128(uuid_int))
+        } else {
+            Err(PyTypeError::new_err("Expected a `uuid.UUID` instance."))
+        }
+    }
+}
+
+impl<'py> IntoPyObject<'py> for Uuid {
+    type Target = PyAny;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        let uuid_cls = get_uuid_cls(py)?;
+
+        uuid_cls.call1((py.None(), py.None(), py.None(), py.None(), self.as_u128()))
+    }
+}
+
+impl<'py> IntoPyObject<'py> for &Uuid {
+    type Target = PyAny;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        (*self).into_pyobject(py)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::types::dict::PyDictMethods;
+    use crate::types::PyDict;
+    use std::ffi::CString;
+    use uuid::Uuid;
+
+    macro_rules! convert_constants {
+        ($name:ident, $rs:expr, $py:literal) => {
+            #[test]
+            fn $name() -> PyResult<()> {
+                Python::attach(|py| {
+                    let rs_orig = $rs;
+                    let rs_uuid = rs_orig.into_pyobject(py).unwrap();
+                    let locals = PyDict::new(py);
+                    locals.set_item("rs_uuid", &rs_uuid).unwrap();
+
+                    py.run(
+                        &CString::new(format!(
+                            "import uuid\npy_uuid = uuid.UUID('{}')\nassert py_uuid == rs_uuid",
+                            $py
+                        ))
+                        .unwrap(),
+                        None,
+                        Some(&locals),
+                    )
+                    .unwrap();
+
+                    let py_uuid = locals.get_item("py_uuid").unwrap().unwrap();
+                    let py_result: Uuid = py_uuid.extract().unwrap();
+                    assert_eq!(rs_orig, py_result);
+
+                    Ok(())
+                })
+            }
+        };
+    }
+
+    convert_constants!(
+        convert_nil,
+        Uuid::nil(),
+        "00000000-0000-0000-0000-000000000000"
+    );
+    convert_constants!(
+        convert_max,
+        Uuid::max(),
+        "ffffffff-ffff-ffff-ffff-ffffffffffff"
+    );
+
+    convert_constants!(
+        convert_uuid_v4,
+        Uuid::parse_str("a4f6d1b9-1898-418f-b11d-ecc6fe1e1f00").unwrap(),
+        "a4f6d1b9-1898-418f-b11d-ecc6fe1e1f00"
+    );
+
+    convert_constants!(
+        convert_uuid_v3,
+        Uuid::parse_str("6fa459ea-ee8a-3ca4-894e-db77e160355e").unwrap(),
+        "6fa459ea-ee8a-3ca4-894e-db77e160355e"
+    );
+
+    convert_constants!(
+        convert_uuid_v1,
+        Uuid::parse_str("a6cc5730-2261-11ee-9c43-2eb5a363657c").unwrap(),
+        "a6cc5730-2261-11ee-9c43-2eb5a363657c"
+    );
+}
diff --git a/src/coroutine.rs b/src/coroutine.rs
index c4b5ddf3185..fe352c5ef01 100644
--- a/src/coroutine.rs
+++ b/src/coroutine.rs
@@ -14,8 +14,8 @@ use crate::{
     coroutine::{cancel::ThrowCallback, waker::AsyncioWaker},
     exceptions::{PyAttributeError, PyRuntimeError, PyStopIteration},
     panic::PanicException,
-    types::{PyIterator, PyString},
-    IntoPy, Py, PyAny, PyErr, PyNativeType, PyObject, PyResult, Python,
+    types::{string::PyStringMethods, PyIterator, PyString},
+    Bound, IntoPyObject, IntoPyObjectExt, Py, PyAny, PyErr, PyResult, Python,
 };
 
 pub(crate) mod cancel;
@@ -31,10 +31,15 @@ pub struct Coroutine {
     name: Option<Py<PyString>>,
     qualname_prefix: Option<&'static str>,
     throw_callback: Option<ThrowCallback>,
-    future: Option<Pin<Box<dyn Future<Output = PyResult<PyObject>> + Send>>>,
+    #[allow(clippy::type_complexity)]
+    future: Option<Pin<Box<dyn Future<Output = PyResult<Py<PyAny>>> + Send>>>,
     waker: Option<Arc<AsyncioWaker>>,
 }
 
+// Safety: `Coroutine` is allowed to be `Sync` even though the future is not,
+// because the future is polled with `&mut self` receiver
+unsafe impl Sync for Coroutine {}
+
 impl Coroutine {
     ///  Wrap a future into a Python coroutine.
     ///
@@ -42,24 +47,24 @@ impl Coroutine {
     /// (should always be `None` anyway).
     ///
     /// `Coroutine `throw` drop the wrapped future and reraise the exception passed
-    pub(crate) fn new<F, T, E>(
-        name: Option<Py<PyString>>,
+    pub(crate) fn new<'py, F, T, E>(
+        name: Option<Bound<'py, PyString>>,
         qualname_prefix: Option<&'static str>,
         throw_callback: Option<ThrowCallback>,
         future: F,
     ) -> Self
     where
         F: Future<Output = Result<T, E>> + Send + 'static,
-        T: IntoPy<PyObject>,
+        T: IntoPyObject<'py>,
         E: Into<PyErr>,
     {
         let wrap = async move {
             let obj = future.await.map_err(Into::into)?;
-            // SAFETY: GIL is acquired when future is polled (see `Coroutine::poll`)
-            Ok(obj.into_py(unsafe { Python::assume_gil_acquired() }))
+            // SAFETY: attached when future is polled (see `Coroutine::poll`)
+            obj.into_py_any(unsafe { Python::assume_attached() })
         };
         Self {
-            name,
+            name: name.map(Bound::unbind),
             qualname_prefix,
             throw_callback,
             future: Some(Box::pin(wrap)),
@@ -67,7 +72,7 @@ impl Coroutine {
         }
     }
 
-    fn poll(&mut self, py: Python<'_>, throw: Option<PyObject>) -> PyResult<PyObject> {
+    fn poll(&mut self, py: Python<'_>, throw: Option<Py<PyAny>>) -> PyResult<Py<PyAny>> {
         // raise if the coroutine has already been run to completion
         let future_rs = match self.future {
             Some(ref mut fut) => fut,
@@ -75,10 +80,10 @@ impl Coroutine {
         };
         // reraise thrown exception it
         match (throw, &self.throw_callback) {
-            (Some(exc), Some(cb)) => cb.throw(exc.as_ref(py)),
+            (Some(exc), Some(cb)) => cb.throw(exc),
             (Some(exc), None) => {
                 self.close();
-                return Err(PyErr::from_value(exc.as_ref(py)));
+                return Err(PyErr::from_value(exc.into_bound(py)));
             }
             (None, _) => {}
         }
@@ -95,7 +100,7 @@ impl Coroutine {
         match panic::catch_unwind(panic::AssertUnwindSafe(poll)) {
             Ok(Poll::Ready(res)) => {
                 self.close();
-                return Err(PyStopIteration::new_err(res?));
+                return Err(PyStopIteration::new_err((res?,)));
             }
             Err(err) => {
                 self.close();
@@ -107,10 +112,7 @@ impl Coroutine {
         if let Some(future) = self.waker.as_ref().unwrap().initialize_future(py)? {
             // `asyncio.Future` must be awaited; fortunately, it implements `__iter__ = __await__`
             // and will yield itself if its result has not been set in polling above
-            if let Some(future) = PyIterator::from_bound_object(&future.as_borrowed())
-                .unwrap()
-                .next()
-            {
+            if let Some(future) = PyIterator::from_object(future).unwrap().next() {
                 // future has not been leaked into Python for now, and Rust code can only call
                 // `set_result(None)` in `Wake` implementation, so it's safe to unwrap
                 return Ok(future.unwrap().into());
@@ -118,7 +120,7 @@ impl Coroutine {
         }
         // if waker has been waken during future polling, this is roughly equivalent to
         // `await asyncio.sleep(0)`, so just yield `None`.
-        Ok(py.None().into_py(py))
+        Ok(py.None())
     }
 }
 
@@ -133,21 +135,22 @@ impl Coroutine {
     }
 
     #[getter]
-    fn __qualname__(&self, py: Python<'_>) -> PyResult<Py<PyString>> {
+    fn __qualname__<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyString>> {
         match (&self.name, &self.qualname_prefix) {
-            (Some(name), Some(prefix)) => Ok(format!("{}.{}", prefix, name.as_ref(py).to_str()?)
-                .as_str()
-                .into_py(py)),
-            (Some(name), None) => Ok(name.clone_ref(py)),
+            (Some(name), Some(prefix)) => Ok(PyString::new(
+                py,
+                &format!("{}.{}", prefix, name.bind(py).to_cow()?),
+            )),
+            (Some(name), None) => Ok(name.bind(py).clone()),
             (None, _) => Err(PyAttributeError::new_err("__qualname__")),
         }
     }
 
-    fn send(&mut self, py: Python<'_>, _value: &PyAny) -> PyResult<PyObject> {
+    fn send(&mut self, py: Python<'_>, _value: &Bound<'_, PyAny>) -> PyResult<Py<PyAny>> {
         self.poll(py, None)
     }
 
-    fn throw(&mut self, py: Python<'_>, exc: PyObject) -> PyResult<PyObject> {
+    fn throw(&mut self, py: Python<'_>, exc: Py<PyAny>) -> PyResult<Py<PyAny>> {
         self.poll(py, Some(exc))
     }
 
@@ -161,7 +164,7 @@ impl Coroutine {
         self_
     }
 
-    fn __next__(&mut self, py: Python<'_>) -> PyResult<PyObject> {
+    fn __next__(&mut self, py: Python<'_>) -> PyResult<Py<PyAny>> {
         self.poll(py, None)
     }
 }
diff --git a/src/coroutine/cancel.rs b/src/coroutine/cancel.rs
index 7828986c11e..49185fa56d7 100644
--- a/src/coroutine/cancel.rs
+++ b/src/coroutine/cancel.rs
@@ -1,13 +1,12 @@
-use crate::{PyAny, PyObject};
-use parking_lot::Mutex;
+use crate::{Py, PyAny};
 use std::future::Future;
 use std::pin::Pin;
-use std::sync::Arc;
+use std::sync::{Arc, Mutex};
 use std::task::{Context, Poll, Waker};
 
 #[derive(Debug, Default)]
 struct Inner {
-    exception: Option<PyObject>,
+    exception: Option<Py<PyAny>>,
     waker: Option<Waker>,
 }
 
@@ -25,12 +24,12 @@ impl CancelHandle {
 
     /// Returns whether the associated coroutine has been cancelled.
     pub fn is_cancelled(&self) -> bool {
-        self.0.lock().exception.is_some()
+        self.0.lock().unwrap().exception.is_some()
     }
 
     /// Poll to retrieve the exception thrown in the associated coroutine.
-    pub fn poll_cancelled(&mut self, cx: &mut Context<'_>) -> Poll<PyObject> {
-        let mut inner = self.0.lock();
+    pub fn poll_cancelled(&mut self, cx: &mut Context<'_>) -> Poll<Py<PyAny>> {
+        let mut inner = self.0.lock().unwrap();
         if let Some(exc) = inner.exception.take() {
             return Poll::Ready(exc);
         }
@@ -44,7 +43,7 @@ impl CancelHandle {
     }
 
     /// Retrieve the exception thrown in the associated coroutine.
-    pub async fn cancelled(&mut self) -> PyObject {
+    pub async fn cancelled(&mut self) -> Py<PyAny> {
         Cancelled(self).await
     }
 
@@ -58,7 +57,7 @@ impl CancelHandle {
 struct Cancelled<'a>(&'a mut CancelHandle);
 
 impl Future for Cancelled<'_> {
-    type Output = PyObject;
+    type Output = Py<PyAny>;
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         self.0.poll_cancelled(cx)
     }
@@ -68,9 +67,9 @@ impl Future for Cancelled<'_> {
 pub struct ThrowCallback(Arc<Mutex<Inner>>);
 
 impl ThrowCallback {
-    pub(super) fn throw(&self, exc: &PyAny) {
-        let mut inner = self.0.lock();
-        inner.exception = Some(exc.into());
+    pub(super) fn throw(&self, exc: Py<PyAny>) {
+        let mut inner = self.0.lock().unwrap();
+        inner.exception = Some(exc);
         if let Some(waker) = inner.waker.take() {
             waker.wake();
         }
diff --git a/src/coroutine/waker.rs b/src/coroutine/waker.rs
index c46654896fc..f425545346d 100644
--- a/src/coroutine/waker.rs
+++ b/src/coroutine/waker.rs
@@ -1,7 +1,7 @@
-use crate::sync::GILOnceCell;
+use crate::sync::PyOnceLock;
 use crate::types::any::PyAnyMethods;
 use crate::types::PyCFunction;
-use crate::{intern, wrap_pyfunction, Py, PyAny, PyObject, PyResult, Python};
+use crate::{intern, wrap_pyfunction, Bound, Py, PyAny, PyResult, Python};
 use pyo3_macros::pyfunction;
 use std::sync::Arc;
 use std::task::Wake;
@@ -14,21 +14,24 @@ use std::task::Wake;
 ///
 /// [1]: AsyncioWaker::initialize_future
 /// [2]: AsyncioWaker::wake
-pub struct AsyncioWaker(GILOnceCell<Option<LoopAndFuture>>);
+pub struct AsyncioWaker(PyOnceLock<Option<LoopAndFuture>>);
 
 impl AsyncioWaker {
     pub(super) fn new() -> Self {
-        Self(GILOnceCell::new())
+        Self(PyOnceLock::new())
     }
 
     pub(super) fn reset(&mut self) {
         self.0.take();
     }
 
-    pub(super) fn initialize_future<'a>(&'a self, py: Python<'a>) -> PyResult<Option<&'a PyAny>> {
+    pub(super) fn initialize_future<'py>(
+        &self,
+        py: Python<'py>,
+    ) -> PyResult<Option<&Bound<'py, PyAny>>> {
         let init = || LoopAndFuture::new(py).map(Some);
         let loop_and_future = self.0.get_or_try_init(py, init)?.as_ref();
-        Ok(loop_and_future.map(|LoopAndFuture { future, .. }| future.as_ref(py)))
+        Ok(loop_and_future.map(|LoopAndFuture { future, .. }| future.bind(py)))
     }
 }
 
@@ -38,10 +41,10 @@ impl Wake for AsyncioWaker {
     }
 
     fn wake_by_ref(self: &Arc<Self>) {
-        Python::with_gil(|gil| {
-            if let Some(loop_and_future) = self.0.get_or_init(gil, || None) {
+        Python::attach(|py| {
+            if let Some(loop_and_future) = self.0.get_or_init(py, || None) {
                 loop_and_future
-                    .set_result(gil)
+                    .set_result(py)
                     .expect("unexpected error in coroutine waker");
             }
         });
@@ -49,15 +52,15 @@ impl Wake for AsyncioWaker {
 }
 
 struct LoopAndFuture {
-    event_loop: PyObject,
-    future: PyObject,
+    event_loop: Py<PyAny>,
+    future: Py<PyAny>,
 }
 
 impl LoopAndFuture {
     fn new(py: Python<'_>) -> PyResult<Self> {
-        static GET_RUNNING_LOOP: GILOnceCell<PyObject> = GILOnceCell::new();
+        static GET_RUNNING_LOOP: PyOnceLock<Py<PyAny>> = PyOnceLock::new();
         let import = || -> PyResult<_> {
-            let module = py.import_bound("asyncio")?;
+            let module = py.import("asyncio")?;
             Ok(module.getattr("get_running_loop")?.into())
         };
         let event_loop = GET_RUNNING_LOOP.get_or_try_init(py, import)?.call0(py)?;
@@ -66,15 +69,16 @@ impl LoopAndFuture {
     }
 
     fn set_result(&self, py: Python<'_>) -> PyResult<()> {
-        static RELEASE_WAITER: GILOnceCell<Py<PyCFunction>> = GILOnceCell::new();
-        let release_waiter = RELEASE_WAITER
-            .get_or_try_init(py, || wrap_pyfunction!(release_waiter, py).map(Into::into))?;
+        static RELEASE_WAITER: PyOnceLock<Py<PyCFunction>> = PyOnceLock::new();
+        let release_waiter = RELEASE_WAITER.get_or_try_init(py, || {
+            wrap_pyfunction!(release_waiter, py).map(Bound::unbind)
+        })?;
         // `Future.set_result` must be called in event loop thread,
         // so it requires `call_soon_threadsafe`
         let call_soon_threadsafe = self.event_loop.call_method1(
             py,
             intern!(py, "call_soon_threadsafe"),
-            (release_waiter, self.future.as_ref(py)),
+            (release_waiter, self.future.bind(py)),
         );
         if let Err(err) = call_soon_threadsafe {
             // `call_soon_threadsafe` will raise if the event loop is closed;
@@ -93,7 +97,7 @@ impl LoopAndFuture {
 /// Future can be cancelled by the event loop before being waken.
 /// See <https://github.com/python/cpython/blob/main/Lib/asyncio/tasks.py#L452C5-L452C5>
 #[pyfunction(crate = "crate")]
-fn release_waiter(future: &PyAny) -> PyResult<()> {
+fn release_waiter(future: &Bound<'_, PyAny>) -> PyResult<()> {
     let done = future.call_method0(intern!(future.py(), "done"))?;
     if !done.extract::<bool>()? {
         future.call_method1(intern!(future.py(), "set_result"), (future.py().None(),))?;
diff --git a/src/derive_utils.rs b/src/derive_utils.rs
deleted file mode 100644
index 4ccb38f901b..00000000000
--- a/src/derive_utils.rs
+++ /dev/null
@@ -1,33 +0,0 @@
-//! Functionality for the code generated by the derive backend
-
-use crate::{types::PyModule, Python};
-
-/// Enum to abstract over the arguments of Python function wrappers.
-pub enum PyFunctionArguments<'a> {
-    Python(Python<'a>),
-    PyModule(&'a PyModule),
-}
-
-impl<'a> PyFunctionArguments<'a> {
-    pub fn into_py_and_maybe_module(self) -> (Python<'a>, Option<&'a PyModule>) {
-        match self {
-            PyFunctionArguments::Python(py) => (py, None),
-            PyFunctionArguments::PyModule(module) => {
-                let py = module.py();
-                (py, Some(module))
-            }
-        }
-    }
-}
-
-impl<'a> From<Python<'a>> for PyFunctionArguments<'a> {
-    fn from(py: Python<'a>) -> PyFunctionArguments<'a> {
-        PyFunctionArguments::Python(py)
-    }
-}
-
-impl<'a> From<&'a PyModule> for PyFunctionArguments<'a> {
-    fn from(module: &'a PyModule) -> PyFunctionArguments<'a> {
-        PyFunctionArguments::PyModule(module)
-    }
-}
diff --git a/src/err/cast_error.rs b/src/err/cast_error.rs
new file mode 100644
index 00000000000..6407b251ce5
--- /dev/null
+++ b/src/err/cast_error.rs
@@ -0,0 +1,239 @@
+use std::borrow::Cow;
+
+use crate::{
+    exceptions,
+    types::{PyAnyMethods, PyStringMethods, PyTuple, PyTupleMethods, PyType, PyTypeMethods},
+    Borrowed, Bound, IntoPyObjectExt, Py, PyAny, PyErr, PyErrArguments, Python,
+};
+
+/// Error that indicates a failure to convert a PyAny to a more specific Python type.
+#[derive(Debug)]
+pub struct CastError<'a, 'py> {
+    /// The original object that failed to convert.
+    from: Borrowed<'a, 'py, PyAny>,
+    /// The type we tried (and failed) to convert to.
+    /// (see `PyTypeCheck::classinfo_object`)
+    to: Bound<'py, PyAny>,
+}
+
+impl<'a, 'py> CastError<'a, 'py> {
+    /// Create a new `CastError` representing a failure to convert the object
+    /// `from` into the type `to`.
+    ///
+    /// As with [`PyTypeCheck::classinfo_object`][crate::PyTypeCheck::classinfo_object],
+    /// valid `to` values are those which can be used with `isinstance`, such as `type`
+    /// objects, tuples of `type` objects, or `typing.Union` instances.
+    #[inline]
+    pub fn new(from: Borrowed<'a, 'py, PyAny>, to: Bound<'py, PyAny>) -> Self {
+        Self { from, to }
+    }
+}
+
+/// Error that indicates a failure to convert a PyAny to a more specific Python type.
+#[derive(Debug)]
+pub struct CastIntoError<'py> {
+    from: Bound<'py, PyAny>,
+    to: Bound<'py, PyAny>,
+}
+
+impl<'py> CastIntoError<'py> {
+    /// Create a new `CastIntoError` representing a failure to convert the object
+    /// `from` into the type `to`.
+    ///
+    /// Equivalent to [`CastError::new`] for owned objects.
+    #[inline]
+    pub fn new(from: Bound<'py, PyAny>, to: Bound<'py, PyAny>) -> Self {
+        Self { from, to }
+    }
+
+    /// Consumes this `CastIntoError` and returns the original object, allowing continued
+    /// use of it after a failed conversion.
+    ///
+    /// See [`cast_into`][Bound::cast_into] for an example.
+    pub fn into_inner(self) -> Bound<'py, PyAny> {
+        self.from
+    }
+}
+
+struct CastErrorArguments {
+    from: Py<PyType>,
+    to: Py<PyAny>,
+}
+
+impl PyErrArguments for CastErrorArguments {
+    fn arguments(self, py: Python<'_>) -> Py<PyAny> {
+        format!(
+            "{}",
+            DisplayDowncastError {
+                from: &self.from.into_bound(py),
+                to: &self.to.into_bound(py),
+            }
+        )
+        .into_py_any(py)
+        .expect("failed to create Python string")
+    }
+}
+
+/// Convert `CastError` to Python `TypeError`.
+impl std::convert::From<CastError<'_, '_>> for PyErr {
+    fn from(err: CastError<'_, '_>) -> PyErr {
+        let args = CastErrorArguments {
+            from: err.from.get_type().unbind(),
+            to: err.to.unbind(),
+        };
+
+        exceptions::PyTypeError::new_err(args)
+    }
+}
+
+impl std::error::Error for CastError<'_, '_> {}
+
+impl std::fmt::Display for CastError<'_, '_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
+        DisplayDowncastError {
+            from: &self.from.get_type(),
+            to: &self.to,
+        }
+        .fmt(f)
+    }
+}
+
+/// Convert `CastIntoError` to Python `TypeError`.
+impl std::convert::From<CastIntoError<'_>> for PyErr {
+    fn from(err: CastIntoError<'_>) -> PyErr {
+        let args = CastErrorArguments {
+            from: err.from.get_type().unbind(),
+            to: err.to.unbind(),
+        };
+
+        exceptions::PyTypeError::new_err(args)
+    }
+}
+
+impl std::error::Error for CastIntoError<'_> {}
+
+impl std::fmt::Display for CastIntoError<'_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
+        DisplayDowncastError {
+            from: &self.from.get_type(),
+            to: &self.to,
+        }
+        .fmt(f)
+    }
+}
+
+struct DisplayDowncastError<'a, 'py> {
+    from: &'a Bound<'py, PyType>,
+    to: &'a Bound<'py, PyAny>,
+}
+
+impl std::fmt::Display for DisplayDowncastError<'_, '_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let from = self.from.qualname();
+        let from = from
+            .as_ref()
+            .map(|name| name.to_string_lossy())
+            .unwrap_or(Cow::Borrowed("<failed to extract type name>"));
+        let to = DisplayClassInfo(self.to);
+        write!(f, "'{from}' object cannot be cast as '{to}'")
+    }
+}
+
+struct DisplayClassInfo<'a, 'py>(&'a Bound<'py, PyAny>);
+
+impl std::fmt::Display for DisplayClassInfo<'_, '_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        if let Ok(t) = self.0.cast::<PyType>() {
+            t.qualname()
+                .map_err(|_| std::fmt::Error)?
+                .to_string_lossy()
+                .fmt(f)
+        } else if let Ok(t) = self.0.cast::<PyTuple>() {
+            for (i, t) in t.iter().enumerate() {
+                if i > 0 {
+                    f.write_str(" | ")?;
+                }
+                write!(f, "{}", DisplayClassInfo(&t))?;
+            }
+            Ok(())
+        } else {
+            self.0.fmt(f)
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::PyTypeInfo;
+
+    use super::*;
+
+    #[test]
+    fn test_display_cast_error() {
+        Python::attach(|py| {
+            let obj = py.None().into_bound(py);
+            let to_type = py.get_type::<crate::types::PyInt>().into_any();
+            let err = CastError::new(obj.as_borrowed(), to_type);
+            assert_eq!(err.to_string(), "'NoneType' object cannot be cast as 'int'");
+        })
+    }
+
+    #[test]
+    fn test_display_cast_error_with_tuple() {
+        Python::attach(|py| {
+            let obj = py.None().into_bound(py);
+            let to_type = PyTuple::new(
+                py,
+                &[
+                    py.get_type::<crate::types::PyInt>().into_any(),
+                    crate::types::PyNone::type_object(py).into_any(),
+                ],
+            )
+            .unwrap()
+            .into_any();
+            let err = CastError::new(obj.as_borrowed(), to_type);
+            assert_eq!(
+                err.to_string(),
+                "'NoneType' object cannot be cast as 'int | NoneType'"
+            );
+        })
+    }
+
+    #[test]
+    fn test_display_cast_into_error() {
+        Python::attach(|py| {
+            let obj = py.None().into_bound(py);
+            let to_type = py.get_type::<crate::types::PyInt>().into_any();
+            let err = CastIntoError::new(obj, to_type);
+            assert_eq!(err.to_string(), "'NoneType' object cannot be cast as 'int'");
+        })
+    }
+
+    #[test]
+    fn test_pyerr_from_cast_error() {
+        Python::attach(|py| {
+            let obj = py.None().into_bound(py);
+            let to_type = py.get_type::<crate::types::PyInt>().into_any();
+            let err = CastError::new(obj.as_borrowed(), to_type);
+            let py_err: PyErr = err.into();
+            assert_eq!(
+                py_err.to_string(),
+                "TypeError: 'NoneType' object cannot be cast as 'int'"
+            );
+        })
+    }
+
+    #[test]
+    fn test_pyerr_from_cast_into_error() {
+        Python::attach(|py| {
+            let obj = py.None().into_bound(py);
+            let to_type = py.get_type::<crate::types::PyInt>().into_any();
+            let err = CastIntoError::new(obj, to_type);
+            let py_err: PyErr = err.into();
+            assert_eq!(
+                py_err.to_string(),
+                "TypeError: 'NoneType' object cannot be cast as 'int'"
+            );
+        })
+    }
+}
diff --git a/src/err/downcast_error.rs b/src/err/downcast_error.rs
new file mode 100644
index 00000000000..d5c054a0111
--- /dev/null
+++ b/src/err/downcast_error.rs
@@ -0,0 +1,183 @@
+#![allow(deprecated)]
+
+use std::borrow::Cow;
+
+use crate::{
+    exceptions,
+    types::{PyAnyMethods, PyStringMethods, PyType, PyTypeMethods},
+    Borrowed, Bound, IntoPyObject, Py, PyAny, PyErr, PyErrArguments, Python,
+};
+
+/// Error that indicates a failure to convert a PyAny to a more specific Python type.
+#[derive(Debug)]
+#[deprecated(since = "0.27.0", note = "replaced with `CastError`")]
+pub struct DowncastError<'a, 'py> {
+    from: Borrowed<'a, 'py, PyAny>,
+    to: Cow<'static, str>,
+}
+
+impl<'a, 'py> DowncastError<'a, 'py> {
+    /// Create a new `DowncastError` representing a failure to convert the object
+    /// `from` into the type named in `to`.
+    pub fn new(from: &'a Bound<'py, PyAny>, to: impl Into<Cow<'static, str>>) -> Self {
+        Self {
+            from: from.as_borrowed(),
+            to: to.into(),
+        }
+    }
+}
+
+/// Error that indicates a failure to convert a PyAny to a more specific Python type.
+#[derive(Debug)]
+#[deprecated(since = "0.27.0", note = "replaced with `CastIntoError`")]
+pub struct DowncastIntoError<'py> {
+    from: Bound<'py, PyAny>,
+    to: Cow<'static, str>,
+}
+
+impl<'py> DowncastIntoError<'py> {
+    /// Create a new `DowncastIntoError` representing a failure to convert the object
+    /// `from` into the type named in `to`.
+    pub fn new(from: Bound<'py, PyAny>, to: impl Into<Cow<'static, str>>) -> Self {
+        Self {
+            from,
+            to: to.into(),
+        }
+    }
+
+    /// Consumes this `DowncastIntoError` and returns the original object, allowing continued
+    /// use of it after a failed conversion.
+    ///
+    /// See [`cast_into`][Bound::cast_into] for an example.
+    pub fn into_inner(self) -> Bound<'py, PyAny> {
+        self.from
+    }
+}
+
+struct DowncastErrorArguments {
+    from: Py<PyType>,
+    to: Cow<'static, str>,
+}
+
+impl PyErrArguments for DowncastErrorArguments {
+    fn arguments(self, py: Python<'_>) -> Py<PyAny> {
+        let from = self.from.bind(py).qualname();
+        let from = from
+            .as_ref()
+            .map(|name| name.to_string_lossy())
+            .unwrap_or(Cow::Borrowed("<failed to extract type name>"));
+        format!("'{}' object cannot be converted to '{}'", from, self.to)
+            .into_pyobject(py)
+            .unwrap()
+            .into_any()
+            .unbind()
+    }
+}
+
+/// Convert `CastError` to Python `TypeError`.
+impl std::convert::From<DowncastError<'_, '_>> for PyErr {
+    fn from(err: DowncastError<'_, '_>) -> PyErr {
+        let args = DowncastErrorArguments {
+            from: err.from.get_type().into(),
+            to: err.to,
+        };
+
+        exceptions::PyTypeError::new_err(args)
+    }
+}
+
+impl std::error::Error for DowncastError<'_, '_> {}
+
+impl std::fmt::Display for DowncastError<'_, '_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
+        display_downcast_error(f, &self.from, &self.to)
+    }
+}
+
+/// Convert `DowncastIntoError` to Python `TypeError`.
+impl std::convert::From<DowncastIntoError<'_>> for PyErr {
+    fn from(err: DowncastIntoError<'_>) -> PyErr {
+        let args = DowncastErrorArguments {
+            from: err.from.get_type().into(),
+            to: err.to,
+        };
+
+        exceptions::PyTypeError::new_err(args)
+    }
+}
+
+impl std::error::Error for DowncastIntoError<'_> {}
+
+impl std::fmt::Display for DowncastIntoError<'_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
+        display_downcast_error(f, &self.from, &self.to)
+    }
+}
+
+fn display_downcast_error(
+    f: &mut std::fmt::Formatter<'_>,
+    from: &Bound<'_, PyAny>,
+    to: &str,
+) -> std::fmt::Result {
+    write!(
+        f,
+        "'{}' object cannot be converted to '{}'",
+        from.get_type().qualname().map_err(|_| std::fmt::Error)?,
+        to
+    )
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_display_downcast_error() {
+        Python::attach(|py| {
+            let obj = py.None().into_bound(py);
+            let err = DowncastError::new(&obj, "int");
+            assert_eq!(
+                err.to_string(),
+                "'NoneType' object cannot be converted to 'int'"
+            );
+        })
+    }
+
+    #[test]
+    fn test_display_downcast_into_error() {
+        Python::attach(|py| {
+            let obj = py.None().into_bound(py);
+            let err = DowncastIntoError::new(obj, "int");
+            assert_eq!(
+                err.to_string(),
+                "'NoneType' object cannot be converted to 'int'"
+            );
+        })
+    }
+
+    #[test]
+    fn test_pyerr_from_downcast_error() {
+        Python::attach(|py| {
+            let obj = py.None().into_bound(py);
+            let err = DowncastError::new(&obj, "int");
+            let py_err: PyErr = err.into();
+            assert_eq!(
+                py_err.to_string(),
+                "TypeError: 'NoneType' object cannot be converted to 'int'"
+            );
+        })
+    }
+
+    #[test]
+    fn test_pyerr_from_downcast_into_error() {
+        Python::attach(|py| {
+            let obj = py.None().into_bound(py);
+            let err = DowncastIntoError::new(obj, "int");
+            let py_err: PyErr = err.into();
+            assert_eq!(
+                py_err.to_string(),
+                "TypeError: 'NoneType' object cannot be converted to 'int'"
+            );
+        })
+    }
+}
diff --git a/src/err/err_state.rs b/src/err/err_state.rs
index 863b276307e..44e83edc4e3 100644
--- a/src/err/err_state.rs
+++ b/src/err/err_state.rs
@@ -1,11 +1,137 @@
+use std::{
+    cell::UnsafeCell,
+    sync::{Mutex, Once},
+    thread::ThreadId,
+};
+
 use crate::{
     exceptions::{PyBaseException, PyTypeError},
     ffi,
-    types::{PyTraceback, PyType},
-    Bound, IntoPy, Py, PyAny, PyObject, PyTypeInfo, Python,
+    ffi_ptr_ext::FfiPtrExt,
+    types::{PyAnyMethods, PyTraceback, PyType},
+    Bound, Py, PyAny, PyErrArguments, PyTypeInfo, Python,
 };
 
-#[derive(Clone)]
+pub(crate) struct PyErrState {
+    // Safety: can only hand out references when in the "normalized" state. Will never change
+    // after normalization.
+    normalized: Once,
+    // Guard against re-entrancy when normalizing the exception state.
+    normalizing_thread: Mutex<Option<ThreadId>>,
+    inner: UnsafeCell<Option<PyErrStateInner>>,
+}
+
+// Safety: The inner value is protected by locking to ensure that only the normalized state is
+// handed out as a reference.
+unsafe impl Send for PyErrState {}
+unsafe impl Sync for PyErrState {}
+#[cfg(feature = "nightly")]
+unsafe impl crate::marker::Ungil for PyErrState {}
+
+impl PyErrState {
+    pub(crate) fn lazy(f: Box<PyErrStateLazyFn>) -> Self {
+        Self::from_inner(PyErrStateInner::Lazy(f))
+    }
+
+    pub(crate) fn lazy_arguments(ptype: Py<PyAny>, args: impl PyErrArguments + 'static) -> Self {
+        Self::from_inner(PyErrStateInner::Lazy(Box::new(move |py| {
+            PyErrStateLazyFnOutput {
+                ptype,
+                pvalue: args.arguments(py),
+            }
+        })))
+    }
+
+    pub(crate) fn normalized(normalized: PyErrStateNormalized) -> Self {
+        let state = Self::from_inner(PyErrStateInner::Normalized(normalized));
+        // This state is already normalized, by completing the Once immediately we avoid
+        // reaching the `py.detach` in `make_normalized` which is less efficient
+        // and introduces a GIL switch which could deadlock.
+        // See https://github.com/PyO3/pyo3/issues/4764
+        state.normalized.call_once(|| {});
+        state
+    }
+
+    pub(crate) fn restore(self, py: Python<'_>) {
+        self.inner
+            .into_inner()
+            .expect("PyErr state should never be invalid outside of normalization")
+            .restore(py)
+    }
+
+    fn from_inner(inner: PyErrStateInner) -> Self {
+        Self {
+            normalized: Once::new(),
+            normalizing_thread: Mutex::new(None),
+            inner: UnsafeCell::new(Some(inner)),
+        }
+    }
+
+    #[inline]
+    pub(crate) fn as_normalized(&self, py: Python<'_>) -> &PyErrStateNormalized {
+        if self.normalized.is_completed() {
+            match unsafe {
+                // Safety: self.inner will never be written again once normalized.
+                &*self.inner.get()
+            } {
+                Some(PyErrStateInner::Normalized(n)) => return n,
+                _ => unreachable!(),
+            }
+        }
+
+        self.make_normalized(py)
+    }
+
+    #[cold]
+    fn make_normalized(&self, py: Python<'_>) -> &PyErrStateNormalized {
+        // This process is safe because:
+        // - Write happens only once, and then never will change again.
+        // - The `Once` ensure that only one thread will do the write.
+
+        // Guard against re-entrant normalization, because `Once` does not provide
+        // re-entrancy guarantees.
+        if let Some(thread) = self.normalizing_thread.lock().unwrap().as_ref() {
+            assert!(
+                !(*thread == std::thread::current().id()),
+                "Re-entrant normalization of PyErrState detected"
+            );
+        }
+
+        // avoid deadlock of `.call_once` with the GIL
+        py.detach(|| {
+            self.normalized.call_once(|| {
+                self.normalizing_thread
+                    .lock()
+                    .unwrap()
+                    .replace(std::thread::current().id());
+
+                // Safety: no other thread can access the inner value while we are normalizing it.
+                let state = unsafe {
+                    (*self.inner.get())
+                        .take()
+                        .expect("Cannot normalize a PyErr while already normalizing it.")
+                };
+
+                let normalized_state =
+                    Python::attach(|py| PyErrStateInner::Normalized(state.normalize(py)));
+
+                // Safety: no other thread can access the inner value while we are normalizing it.
+                unsafe {
+                    *self.inner.get() = Some(normalized_state);
+                }
+            })
+        });
+
+        match unsafe {
+            // Safety: self.inner will never be written again once normalized.
+            &*self.inner.get()
+        } {
+            Some(PyErrStateInner::Normalized(n)) => n,
+            _ => unreachable!(),
+        }
+    }
+}
+
 pub(crate) struct PyErrStateNormalized {
     #[cfg(not(Py_3_12))]
     ptype: Py<PyType>,
@@ -15,6 +141,21 @@ pub(crate) struct PyErrStateNormalized {
 }
 
 impl PyErrStateNormalized {
+    pub(crate) fn new(pvalue: Bound<'_, PyBaseException>) -> Self {
+        Self {
+            #[cfg(not(Py_3_12))]
+            ptype: pvalue.get_type().into(),
+            #[cfg(not(Py_3_12))]
+            ptraceback: unsafe {
+                Py::from_owned_ptr_or_opt(
+                    pvalue.py(),
+                    ffi::PyException_GetTraceback(pvalue.as_ptr()),
+                )
+            },
+            pvalue: pvalue.into(),
+        }
+    }
+
     #[cfg(not(Py_3_12))]
     pub(crate) fn ptype<'py>(&self, py: Python<'py>) -> Bound<'py, PyType> {
         self.ptype.bind(py).clone()
@@ -22,9 +163,7 @@ impl PyErrStateNormalized {
 
     #[cfg(Py_3_12)]
     pub(crate) fn ptype<'py>(&self, py: Python<'py>) -> Bound<'py, PyType> {
-        use crate::instance::PyNativeType;
-        use crate::types::any::PyAnyMethods;
-        self.pvalue.bind(py).get_type().as_borrowed().to_owned()
+        self.pvalue.bind(py).get_type()
     }
 
     #[cfg(not(Py_3_12))]
@@ -36,19 +175,61 @@ impl PyErrStateNormalized {
 
     #[cfg(Py_3_12)]
     pub(crate) fn ptraceback<'py>(&self, py: Python<'py>) -> Option<Bound<'py, PyTraceback>> {
-        use crate::ffi_ptr_ext::FfiPtrExt;
-        use crate::types::any::PyAnyMethods;
         unsafe {
             ffi::PyException_GetTraceback(self.pvalue.as_ptr())
                 .assume_owned_or_opt(py)
-                .map(|b| b.downcast_into_unchecked())
+                .map(|b| b.cast_into_unchecked())
         }
     }
 
-    #[cfg(Py_3_12)]
     pub(crate) fn take(py: Python<'_>) -> Option<PyErrStateNormalized> {
-        unsafe { Py::from_owned_ptr_or_opt(py, ffi::PyErr_GetRaisedException()) }
-            .map(|pvalue| PyErrStateNormalized { pvalue })
+        #[cfg(Py_3_12)]
+        {
+            // Safety: PyErr_GetRaisedException can be called when attached to Python and
+            // returns either NULL or an owned reference.
+            unsafe { ffi::PyErr_GetRaisedException().assume_owned_or_opt(py) }.map(|pvalue| {
+                PyErrStateNormalized {
+                    // Safety: PyErr_GetRaisedException returns a valid exception type.
+                    pvalue: unsafe { pvalue.cast_into_unchecked() }.unbind(),
+                }
+            })
+        }
+
+        #[cfg(not(Py_3_12))]
+        {
+            let (ptype, pvalue, ptraceback) = unsafe {
+                let mut ptype: *mut ffi::PyObject = std::ptr::null_mut();
+                let mut pvalue: *mut ffi::PyObject = std::ptr::null_mut();
+                let mut ptraceback: *mut ffi::PyObject = std::ptr::null_mut();
+
+                ffi::PyErr_Fetch(&mut ptype, &mut pvalue, &mut ptraceback);
+
+                // Ensure that the exception coming from the interpreter is normalized.
+                if !ptype.is_null() {
+                    ffi::PyErr_NormalizeException(&mut ptype, &mut pvalue, &mut ptraceback);
+                }
+
+                // Safety: PyErr_NormalizeException will have produced up to three owned
+                // references of the correct types.
+                (
+                    ptype
+                        .assume_owned_or_opt(py)
+                        .map(|b| b.cast_into_unchecked()),
+                    pvalue
+                        .assume_owned_or_opt(py)
+                        .map(|b| b.cast_into_unchecked()),
+                    ptraceback
+                        .assume_owned_or_opt(py)
+                        .map(|b| b.cast_into_unchecked()),
+                )
+            };
+
+            ptype.map(|ptype| PyErrStateNormalized {
+                ptype: ptype.unbind(),
+                pvalue: pvalue.expect("normalized exception value missing").unbind(),
+                ptraceback: ptraceback.map(Bound::unbind),
+            })
+        }
     }
 
     #[cfg(not(Py_3_12))]
@@ -59,120 +240,68 @@ impl PyErrStateNormalized {
         ptraceback: *mut ffi::PyObject,
     ) -> Self {
         PyErrStateNormalized {
-            ptype: Py::from_owned_ptr_or_opt(py, ptype).expect("Exception type missing"),
-            pvalue: Py::from_owned_ptr_or_opt(py, pvalue).expect("Exception value missing"),
-            ptraceback: Py::from_owned_ptr_or_opt(py, ptraceback),
+            ptype: unsafe { Py::from_owned_ptr_or_opt(py, ptype).expect("Exception type missing") },
+            pvalue: unsafe {
+                Py::from_owned_ptr_or_opt(py, pvalue).expect("Exception value missing")
+            },
+            ptraceback: unsafe { Py::from_owned_ptr_or_opt(py, ptraceback) },
+        }
+    }
+
+    pub fn clone_ref(&self, py: Python<'_>) -> Self {
+        Self {
+            #[cfg(not(Py_3_12))]
+            ptype: self.ptype.clone_ref(py),
+            pvalue: self.pvalue.clone_ref(py),
+            #[cfg(not(Py_3_12))]
+            ptraceback: self
+                .ptraceback
+                .as_ref()
+                .map(|ptraceback| ptraceback.clone_ref(py)),
         }
     }
 }
 
 pub(crate) struct PyErrStateLazyFnOutput {
-    pub(crate) ptype: PyObject,
-    pub(crate) pvalue: PyObject,
+    pub(crate) ptype: Py<PyAny>,
+    pub(crate) pvalue: Py<PyAny>,
 }
 
 pub(crate) type PyErrStateLazyFn =
     dyn for<'py> FnOnce(Python<'py>) -> PyErrStateLazyFnOutput + Send + Sync;
 
-pub(crate) enum PyErrState {
+enum PyErrStateInner {
     Lazy(Box<PyErrStateLazyFn>),
-    #[cfg(not(Py_3_12))]
-    FfiTuple {
-        ptype: PyObject,
-        pvalue: Option<PyObject>,
-        ptraceback: Option<PyObject>,
-    },
     Normalized(PyErrStateNormalized),
 }
 
-/// Helper conversion trait that allows to use custom arguments for lazy exception construction.
-pub trait PyErrArguments: Send + Sync {
-    /// Arguments for exception
-    fn arguments(self, py: Python<'_>) -> PyObject;
-}
-
-impl<T> PyErrArguments for T
-where
-    T: IntoPy<PyObject> + Send + Sync,
-{
-    fn arguments(self, py: Python<'_>) -> PyObject {
-        self.into_py(py)
-    }
-}
-
-impl PyErrState {
-    pub(crate) fn lazy(ptype: &PyAny, args: impl PyErrArguments + 'static) -> Self {
-        let ptype = ptype.into();
-        PyErrState::Lazy(Box::new(move |py| PyErrStateLazyFnOutput {
-            ptype,
-            pvalue: args.arguments(py),
-        }))
-    }
-
-    pub(crate) fn normalized(pvalue: &PyBaseException) -> Self {
-        Self::Normalized(PyErrStateNormalized {
-            #[cfg(not(Py_3_12))]
-            ptype: pvalue.get_type().into(),
-            pvalue: pvalue.into(),
-            #[cfg(not(Py_3_12))]
-            ptraceback: unsafe {
-                Py::from_owned_ptr_or_opt(
-                    pvalue.py(),
-                    ffi::PyException_GetTraceback(pvalue.as_ptr()),
-                )
-            },
-        })
-    }
-
-    pub(crate) fn normalize(self, py: Python<'_>) -> PyErrStateNormalized {
+impl PyErrStateInner {
+    fn normalize(self, py: Python<'_>) -> PyErrStateNormalized {
         match self {
             #[cfg(not(Py_3_12))]
-            PyErrState::Lazy(lazy) => {
+            PyErrStateInner::Lazy(lazy) => {
                 let (ptype, pvalue, ptraceback) = lazy_into_normalized_ffi_tuple(py, lazy);
                 unsafe {
                     PyErrStateNormalized::from_normalized_ffi_tuple(py, ptype, pvalue, ptraceback)
                 }
             }
             #[cfg(Py_3_12)]
-            PyErrState::Lazy(lazy) => {
+            PyErrStateInner::Lazy(lazy) => {
                 // To keep the implementation simple, just write the exception into the interpreter,
                 // which will cause it to be normalized
                 raise_lazy(py, lazy);
                 PyErrStateNormalized::take(py)
                     .expect("exception missing after writing to the interpreter")
             }
-            #[cfg(not(Py_3_12))]
-            PyErrState::FfiTuple {
-                ptype,
-                pvalue,
-                ptraceback,
-            } => {
-                let mut ptype = ptype.into_ptr();
-                let mut pvalue = pvalue.map_or(std::ptr::null_mut(), Py::into_ptr);
-                let mut ptraceback = ptraceback.map_or(std::ptr::null_mut(), Py::into_ptr);
-                unsafe {
-                    ffi::PyErr_NormalizeException(&mut ptype, &mut pvalue, &mut ptraceback);
-                    PyErrStateNormalized::from_normalized_ffi_tuple(py, ptype, pvalue, ptraceback)
-                }
-            }
-            PyErrState::Normalized(normalized) => normalized,
+            PyErrStateInner::Normalized(normalized) => normalized,
         }
     }
 
     #[cfg(not(Py_3_12))]
-    pub(crate) fn restore(self, py: Python<'_>) {
+    fn restore(self, py: Python<'_>) {
         let (ptype, pvalue, ptraceback) = match self {
-            PyErrState::Lazy(lazy) => lazy_into_normalized_ffi_tuple(py, lazy),
-            PyErrState::FfiTuple {
-                ptype,
-                pvalue,
-                ptraceback,
-            } => (
-                ptype.into_ptr(),
-                pvalue.map_or(std::ptr::null_mut(), Py::into_ptr),
-                ptraceback.map_or(std::ptr::null_mut(), Py::into_ptr),
-            ),
-            PyErrState::Normalized(PyErrStateNormalized {
+            PyErrStateInner::Lazy(lazy) => lazy_into_normalized_ffi_tuple(py, lazy),
+            PyErrStateInner::Normalized(PyErrStateNormalized {
                 ptype,
                 pvalue,
                 ptraceback,
@@ -186,10 +315,10 @@ impl PyErrState {
     }
 
     #[cfg(Py_3_12)]
-    pub(crate) fn restore(self, py: Python<'_>) {
+    fn restore(self, py: Python<'_>) {
         match self {
-            PyErrState::Lazy(lazy) => raise_lazy(py, lazy),
-            PyErrState::Normalized(PyErrStateNormalized { pvalue }) => unsafe {
+            PyErrStateInner::Lazy(lazy) => raise_lazy(py, lazy),
+            PyErrStateInner::Normalized(PyErrStateNormalized { pvalue }) => unsafe {
                 ffi::PyErr_SetRaisedException(pvalue.into_ptr())
             },
         }
@@ -227,12 +356,87 @@ fn raise_lazy(py: Python<'_>, lazy: Box<PyErrStateLazyFn>) {
         if ffi::PyExceptionClass_Check(ptype.as_ptr()) == 0 {
             ffi::PyErr_SetString(
                 PyTypeError::type_object_raw(py).cast(),
-                "exceptions must derive from BaseException\0"
-                    .as_ptr()
-                    .cast(),
+                c"exceptions must derive from BaseException".as_ptr(),
             )
         } else {
             ffi::PyErr_SetObject(ptype.as_ptr(), pvalue.as_ptr())
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+
+    use crate::{
+        exceptions::PyValueError, sync::PyOnceLock, Py, PyAny, PyErr, PyErrArguments, Python,
+    };
+
+    #[test]
+    #[should_panic(expected = "Re-entrant normalization of PyErrState detected")]
+    fn test_reentrant_normalization() {
+        static ERR: PyOnceLock<PyErr> = PyOnceLock::new();
+
+        struct RecursiveArgs;
+
+        impl PyErrArguments for RecursiveArgs {
+            fn arguments(self, py: Python<'_>) -> Py<PyAny> {
+                // .value(py) triggers normalization
+                ERR.get(py)
+                    .expect("is set just below")
+                    .value(py)
+                    .clone()
+                    .into()
+            }
+        }
+
+        Python::attach(|py| {
+            ERR.set(py, PyValueError::new_err(RecursiveArgs)).unwrap();
+            ERR.get(py).expect("is set just above").value(py);
+        })
+    }
+
+    #[test]
+    #[cfg(not(target_arch = "wasm32"))] // We are building wasm Python with pthreads disabled
+    fn test_no_deadlock_thread_switch() {
+        static ERR: PyOnceLock<PyErr> = PyOnceLock::new();
+
+        struct GILSwitchArgs;
+
+        impl PyErrArguments for GILSwitchArgs {
+            fn arguments(self, py: Python<'_>) -> Py<PyAny> {
+                // releasing the GIL potentially allows for other threads to deadlock
+                // with the normalization going on here
+                py.detach(|| {
+                    std::thread::sleep(std::time::Duration::from_millis(10));
+                });
+                py.None()
+            }
+        }
+
+        Python::attach(|py| ERR.set(py, PyValueError::new_err(GILSwitchArgs)).unwrap());
+
+        // Let many threads attempt to read the normalized value at the same time
+        let handles = (0..10)
+            .map(|_| {
+                std::thread::spawn(|| {
+                    Python::attach(|py| {
+                        ERR.get(py).expect("is set just above").value(py);
+                    });
+                })
+            })
+            .collect::<Vec<_>>();
+
+        for handle in handles {
+            handle.join().unwrap();
+        }
+
+        // We should never have deadlocked, and should be able to run
+        // this assertion
+        Python::attach(|py| {
+            assert!(ERR
+                .get(py)
+                .expect("is set above")
+                .is_instance_of::<PyValueError>(py))
+        });
+    }
+}
diff --git a/src/err/impls.rs b/src/err/impls.rs
index f49ac3eb1a8..c49c7a56f82 100644
--- a/src/err/impls.rs
+++ b/src/err/impls.rs
@@ -1,10 +1,11 @@
-use crate::{err::PyErrArguments, exceptions, IntoPy, PyErr, PyObject, Python};
+use crate::{err::PyErrArguments, exceptions, PyErr, Python};
+use crate::{IntoPyObject, Py, PyAny};
 use std::io;
 
 /// Convert `PyErr` to `io::Error`
 impl From<PyErr> for io::Error {
     fn from(err: PyErr) -> Self {
-        let kind = Python::with_gil(|py| {
+        let kind = Python::attach(|py| {
             if err.is_instance_of::<exceptions::PyBrokenPipeError>(py) {
                 io::ErrorKind::BrokenPipe
             } else if err.is_instance_of::<exceptions::PyConnectionRefusedError>(py) {
@@ -25,6 +26,12 @@ impl From<PyErr> for io::Error {
                 io::ErrorKind::WouldBlock
             } else if err.is_instance_of::<exceptions::PyTimeoutError>(py) {
                 io::ErrorKind::TimedOut
+            } else if err.is_instance_of::<exceptions::PyMemoryError>(py) {
+                io::ErrorKind::OutOfMemory
+            } else if err.is_instance_of::<exceptions::PyIsADirectoryError>(py) {
+                io::ErrorKind::IsADirectory
+            } else if err.is_instance_of::<exceptions::PyNotADirectoryError>(py) {
+                io::ErrorKind::NotADirectory
             } else {
                 io::ErrorKind::Other
             }
@@ -39,7 +46,7 @@ impl From<PyErr> for io::Error {
 impl From<io::Error> for PyErr {
     fn from(err: io::Error) -> PyErr {
         // If the error wraps a Python error we return it
-        if err.get_ref().map_or(false, |e| e.is::<PyErr>()) {
+        if err.get_ref().is_some_and(|e| e.is::<PyErr>()) {
             return *err.into_inner().unwrap().downcast().unwrap();
         }
         match err.kind() {
@@ -53,14 +60,22 @@ impl From<io::Error> for PyErr {
             io::ErrorKind::AlreadyExists => exceptions::PyFileExistsError::new_err(err),
             io::ErrorKind::WouldBlock => exceptions::PyBlockingIOError::new_err(err),
             io::ErrorKind::TimedOut => exceptions::PyTimeoutError::new_err(err),
+            io::ErrorKind::OutOfMemory => exceptions::PyMemoryError::new_err(err),
+            io::ErrorKind::IsADirectory => exceptions::PyIsADirectoryError::new_err(err),
+            io::ErrorKind::NotADirectory => exceptions::PyNotADirectoryError::new_err(err),
             _ => exceptions::PyOSError::new_err(err),
         }
     }
 }
 
 impl PyErrArguments for io::Error {
-    fn arguments(self, py: Python<'_>) -> PyObject {
-        self.to_string().into_py(py)
+    fn arguments(self, py: Python<'_>) -> Py<PyAny> {
+        //FIXME(icxolu) remove unwrap
+        self.to_string()
+            .into_pyobject(py)
+            .unwrap()
+            .into_any()
+            .unbind()
     }
 }
 
@@ -71,7 +86,7 @@ impl<W> From<io::IntoInnerError<W>> for PyErr {
 }
 
 impl<W: Send + Sync> PyErrArguments for io::IntoInnerError<W> {
-    fn arguments(self, py: Python<'_>) -> PyObject {
+    fn arguments(self, py: Python<'_>) -> Py<PyAny> {
         self.into_error().arguments(py)
     }
 }
@@ -85,8 +100,13 @@ impl From<std::convert::Infallible> for PyErr {
 macro_rules! impl_to_pyerr {
     ($err: ty, $pyexc: ty) => {
         impl PyErrArguments for $err {
-            fn arguments(self, py: Python<'_>) -> PyObject {
-                self.to_string().into_py(py)
+            fn arguments(self, py: Python<'_>) -> $crate::Py<$crate::PyAny> {
+                // FIXME(icxolu) remove unwrap
+                self.to_string()
+                    .into_pyobject(py)
+                    .unwrap()
+                    .into_any()
+                    .unbind()
             }
         }
 
@@ -124,12 +144,14 @@ mod tests {
 
     #[test]
     fn io_errors() {
+        use crate::types::any::PyAnyMethods;
+
         let check_err = |kind, expected_ty| {
-            Python::with_gil(|py| {
+            Python::attach(|py| {
                 let rust_err = io::Error::new(kind, "some error msg");
 
                 let py_err: PyErr = rust_err.into();
-                let py_err_msg = format!("{}: some error msg", expected_ty);
+                let py_err_msg = format!("{expected_ty}: some error msg");
                 assert_eq!(py_err.to_string(), py_err_msg);
                 let py_error_clone = py_err.clone_ref(py);
 
@@ -154,5 +176,7 @@ mod tests {
         check_err(io::ErrorKind::AlreadyExists, "FileExistsError");
         check_err(io::ErrorKind::WouldBlock, "BlockingIOError");
         check_err(io::ErrorKind::TimedOut, "TimeoutError");
+        check_err(io::ErrorKind::IsADirectory, "IsADirectoryError");
+        check_err(io::ErrorKind::NotADirectory, "NotADirectoryError");
     }
 }
diff --git a/src/err/mod.rs b/src/err/mod.rs
index b5e72a71bf9..8c69f82a761 100644
--- a/src/err/mod.rs
+++ b/src/err/mod.rs
@@ -1,22 +1,32 @@
 use crate::instance::Bound;
+#[cfg(Py_3_11)]
+use crate::intern;
 use crate::panic::PanicException;
 use crate::type_object::PyTypeInfo;
 use crate::types::any::PyAnyMethods;
-use crate::types::{PyTraceback, PyType};
-use crate::{
-    exceptions::{self, PyBaseException},
-    ffi,
+#[cfg(Py_3_11)]
+use crate::types::PyString;
+use crate::types::{
+    string::PyStringMethods, traceback::PyTracebackMethods, typeobject::PyTypeMethods, PyTraceback,
+    PyType,
 };
-use crate::{IntoPy, Py, PyAny, PyNativeType, PyObject, Python, ToPyObject};
-use std::borrow::Cow;
-use std::cell::UnsafeCell;
-use std::ffi::CString;
+use crate::{exceptions::PyBaseException, ffi};
+use crate::{BoundObject, Py, PyAny, Python};
+use std::ffi::CStr;
 
+mod cast_error;
+mod downcast_error;
 mod err_state;
 mod impls;
 
-pub use err_state::PyErrArguments;
+use crate::conversion::IntoPyObject;
 use err_state::{PyErrState, PyErrStateLazyFnOutput, PyErrStateNormalized};
+use std::convert::Infallible;
+use std::ptr;
+
+pub use cast_error::{CastError, CastIntoError};
+#[allow(deprecated)]
+pub use downcast_error::{DowncastError, DowncastIntoError};
 
 /// Represents a Python exception.
 ///
@@ -25,86 +35,36 @@ use err_state::{PyErrState, PyErrStateLazyFnOutput, PyErrStateNormalized};
 /// in a lazy fashion, where the full Python object for the exception is created only when needed.
 ///
 /// Accessing the contained exception in any way, such as with [`value`](PyErr::value),
-/// [`get_type`](PyErr::get_type), or [`is_instance`](PyErr::is_instance) will create the full
-/// exception object if it was not already created.
+/// [`get_type`](PyErr::get_type), or [`is_instance`](PyErr::is_instance)
+/// will create the full exception object if it was not already created.
 pub struct PyErr {
-    // Safety: can only hand out references when in the "normalized" state. Will never change
-    // after normalization.
-    //
-    // The state is temporarily removed from the PyErr during normalization, to avoid
-    // concurrent modifications.
-    state: UnsafeCell<Option<PyErrState>>,
+    state: PyErrState,
 }
 
 // The inner value is only accessed through ways that require proving the gil is held
 #[cfg(feature = "nightly")]
 unsafe impl crate::marker::Ungil for PyErr {}
-unsafe impl Send for PyErr {}
-unsafe impl Sync for PyErr {}
 
 /// Represents the result of a Python call.
 pub type PyResult<T> = Result<T, PyErr>;
 
-/// Error that indicates a failure to convert a PyAny to a more specific Python type.
-#[derive(Debug)]
-pub struct PyDowncastError<'a> {
-    from: &'a PyAny,
-    to: Cow<'static, str>,
-}
-
-impl<'a> PyDowncastError<'a> {
-    /// Create a new `PyDowncastError` representing a failure to convert the object
-    /// `from` into the type named in `to`.
-    pub fn new(from: &'a PyAny, to: impl Into<Cow<'static, str>>) -> Self {
-        PyDowncastError {
-            from,
-            to: to.into(),
-        }
-    }
-}
-
-/// Error that indicates a failure to convert a PyAny to a more specific Python type.
-#[derive(Debug)]
-pub struct DowncastError<'a, 'py> {
-    from: &'a Bound<'py, PyAny>,
-    to: Cow<'static, str>,
-}
-
-impl<'a, 'py> DowncastError<'a, 'py> {
-    /// Create a new `PyDowncastError` representing a failure to convert the object
-    /// `from` into the type named in `to`.
-    pub fn new(from: &'a Bound<'py, PyAny>, to: impl Into<Cow<'static, str>>) -> Self {
-        DowncastError {
-            from,
-            to: to.into(),
-        }
-    }
-}
-
-/// Error that indicates a failure to convert a PyAny to a more specific Python type.
-#[derive(Debug)]
-pub struct DowncastIntoError<'py> {
-    from: Bound<'py, PyAny>,
-    to: Cow<'static, str>,
+/// Helper conversion trait that allows to use custom arguments for lazy exception construction.
+pub trait PyErrArguments: Send + Sync {
+    /// Arguments for exception
+    fn arguments(self, py: Python<'_>) -> Py<PyAny>;
 }
 
-impl<'py> DowncastIntoError<'py> {
-    /// Create a new `DowncastIntoError` representing a failure to convert the object
-    /// `from` into the type named in `to`.
-    pub fn new(from: Bound<'py, PyAny>, to: impl Into<Cow<'static, str>>) -> Self {
-        DowncastIntoError {
-            from,
-            to: to.into(),
+impl<T> PyErrArguments for T
+where
+    T: for<'py> IntoPyObject<'py> + Send + Sync,
+{
+    fn arguments(self, py: Python<'_>) -> Py<PyAny> {
+        // FIXME: `arguments` should become fallible
+        match self.into_pyobject(py) {
+            Ok(obj) => obj.into_any().unbind(),
+            Err(e) => panic!("Converting PyErr arguments failed: {}", e.into()),
         }
     }
-
-    /// Consumes this `DowncastIntoError` and returns the original object, allowing continued
-    /// use of it after a failed conversion.
-    ///
-    /// See [`downcast_into`][PyAnyMethods::downcast_into] for an example.
-    pub fn into_inner(self) -> Bound<'py, PyAny> {
-        self.from
-    }
 }
 
 impl PyErr {
@@ -135,7 +95,7 @@ impl PyErr {
     ///     Err(PyErr::new::<PyTypeError, _>("Error message"))
     /// }
     /// #
-    /// # Python::with_gil(|py| {
+    /// # Python::attach(|py| {
     /// #     let fun = pyo3::wrap_pyfunction!(always_throws, py).unwrap();
     /// #     let err = fun.call0().expect_err("called a function that should always return an error but the return value was Ok");
     /// #     assert!(err.is_instance_of::<PyTypeError>(py))
@@ -153,7 +113,7 @@ impl PyErr {
     ///     Err(PyTypeError::new_err("Error message"))
     /// }
     /// #
-    /// # Python::with_gil(|py| {
+    /// # Python::attach(|py| {
     /// #     let fun = pyo3::wrap_pyfunction!(always_throws, py).unwrap();
     /// #     let err = fun.call0().expect_err("called a function that should always return an error but the return value was Ok");
     /// #     assert!(err.is_instance_of::<PyTypeError>(py))
@@ -165,9 +125,9 @@ impl PyErr {
         T: PyTypeInfo,
         A: PyErrArguments + Send + Sync + 'static,
     {
-        PyErr::from_state(PyErrState::Lazy(Box::new(move |py| {
+        PyErr::from_state(PyErrState::lazy(Box::new(move |py| {
             PyErrStateLazyFnOutput {
-                ptype: T::type_object_bound(py).into(),
+                ptype: T::type_object(py).into(),
                 pvalue: args.arguments(py),
             }
         })))
@@ -183,11 +143,11 @@ impl PyErr {
     /// If `ty` does not inherit from `BaseException`, then a `TypeError` will be returned.
     ///
     /// If calling `ty` with `args` raises an exception, that exception will be returned.
-    pub fn from_type<A>(ty: &PyType, args: A) -> PyErr
+    pub fn from_type<A>(ty: Bound<'_, PyType>, args: A) -> PyErr
     where
         A: PyErrArguments + Send + Sync + 'static,
     {
-        PyErr::from_state(PyErrState::lazy(ty, args))
+        PyErr::from_state(PyErrState::lazy_arguments(ty.unbind().into_any(), args))
     }
 
     /// Creates a new PyErr.
@@ -201,62 +161,55 @@ impl PyErr {
     /// # Examples
     /// ```rust
     /// use pyo3::prelude::*;
+    /// use pyo3::PyTypeInfo;
     /// use pyo3::exceptions::PyTypeError;
-    /// use pyo3::types::{PyType, PyString};
+    /// use pyo3::types::PyString;
     ///
-    /// Python::with_gil(|py| {
+    /// Python::attach(|py| {
     ///     // Case #1: Exception object
-    ///     let err = PyErr::from_value(PyTypeError::new_err("some type error").value(py));
+    ///     let err = PyErr::from_value(PyTypeError::new_err("some type error")
+    ///         .value(py).clone().into_any());
     ///     assert_eq!(err.to_string(), "TypeError: some type error");
     ///
     ///     // Case #2: Exception type
-    ///     let err = PyErr::from_value(PyType::new::<PyTypeError>(py));
+    ///     let err = PyErr::from_value(PyTypeError::type_object(py).into_any());
     ///     assert_eq!(err.to_string(), "TypeError: ");
     ///
     ///     // Case #3: Invalid exception value
-    ///     let err = PyErr::from_value(PyString::new_bound(py, "foo").as_gil_ref());
+    ///     let err = PyErr::from_value(PyString::new(py, "foo").into_any());
     ///     assert_eq!(
     ///         err.to_string(),
     ///         "TypeError: exceptions must derive from BaseException"
     ///     );
     /// });
     /// ```
-    pub fn from_value(obj: &PyAny) -> PyErr {
-        let state = if let Ok(obj) = obj.downcast::<PyBaseException>() {
-            PyErrState::normalized(obj)
-        } else {
-            // Assume obj is Type[Exception]; let later normalization handle if this
-            // is not the case
-            PyErrState::lazy(obj, obj.py().None())
+    pub fn from_value(obj: Bound<'_, PyAny>) -> PyErr {
+        let state = match obj.cast_into::<PyBaseException>() {
+            Ok(obj) => PyErrState::normalized(PyErrStateNormalized::new(obj)),
+            Err(err) => {
+                // Assume obj is Type[Exception]; let later normalization handle if this
+                // is not the case
+                let obj = err.into_inner();
+                let py = obj.py();
+                PyErrState::lazy_arguments(obj.unbind(), py.None())
+            }
         };
 
         PyErr::from_state(state)
     }
 
-    /// Deprecated form of [`PyErr::get_type_bound`].
-    #[cfg_attr(
-        not(feature = "gil-refs"),
-        deprecated(
-            since = "0.21.0",
-            note = "`PyErr::get_type` will be replaced by `PyErr::get_type_bound` in a future PyO3 version"
-        )
-    )]
-    pub fn get_type<'py>(&'py self, py: Python<'py>) -> &'py PyType {
-        self.get_type_bound(py).into_gil_ref()
-    }
-
     /// Returns the type of this exception.
     ///
     /// # Examples
     /// ```rust
     /// use pyo3::{prelude::*, exceptions::PyTypeError, types::PyType};
     ///
-    /// Python::with_gil(|py| {
+    /// Python::attach(|py| {
     ///     let err: PyErr = PyTypeError::new_err(("some type error",));
-    ///     assert!(err.get_type_bound(py).is(PyType::new::<PyTypeError>(py)));
+    ///     assert!(err.get_type(py).is(&PyType::new::<PyTypeError>(py)));
     /// });
     /// ```
-    pub fn get_type_bound<'py>(&self, py: Python<'py>) -> Bound<'py, PyType> {
+    pub fn get_type<'py>(&self, py: Python<'py>) -> Bound<'py, PyType> {
         self.normalized(py).ptype(py)
     }
 
@@ -267,14 +220,14 @@ impl PyErr {
     /// ```rust
     /// use pyo3::{exceptions::PyTypeError, PyErr, Python};
     ///
-    /// Python::with_gil(|py| {
+    /// Python::attach(|py| {
     ///     let err: PyErr = PyTypeError::new_err(("some type error",));
     ///     assert!(err.is_instance_of::<PyTypeError>(py));
     ///     assert_eq!(err.value(py).to_string(), "some type error");
     /// });
     /// ```
-    pub fn value<'py>(&'py self, py: Python<'py>) -> &'py PyBaseException {
-        self.normalized(py).pvalue.as_ref(py)
+    pub fn value<'py>(&self, py: Python<'py>) -> &Bound<'py, PyBaseException> {
+        self.normalized(py).pvalue.bind(py)
     }
 
     /// Consumes self to take ownership of the exception value contained in this error.
@@ -292,30 +245,18 @@ impl PyErr {
         exc
     }
 
-    /// Deprecated form of [`PyErr::traceback_bound`].
-    #[cfg_attr(
-        not(feature = "gil-refs"),
-        deprecated(
-            since = "0.21.0",
-            note = "`PyErr::traceback` will be replaced by `PyErr::traceback_bound` in a future PyO3 version"
-        )
-    )]
-    pub fn traceback<'py>(&'py self, py: Python<'py>) -> Option<&'py PyTraceback> {
-        self.normalized(py).ptraceback(py).map(|b| b.into_gil_ref())
-    }
-
     /// Returns the traceback of this exception object.
     ///
     /// # Examples
     /// ```rust
     /// use pyo3::{exceptions::PyTypeError, Python};
     ///
-    /// Python::with_gil(|py| {
+    /// Python::attach(|py| {
     ///     let err = PyTypeError::new_err(("some type error",));
-    ///     assert!(err.traceback_bound(py).is_none());
+    ///     assert!(err.traceback(py).is_none());
     /// });
     /// ```
-    pub fn traceback_bound<'py>(&self, py: Python<'py>) -> Option<Bound<'py, PyTraceback>> {
+    pub fn traceback<'py>(&self, py: Python<'py>) -> Option<Bound<'py, PyTraceback>> {
         self.normalized(py).ptraceback(py)
     }
 
@@ -335,77 +276,20 @@ impl PyErr {
     /// expected to have been set, for example from [`PyErr::occurred`] or by an error return value
     /// from a C FFI function, use [`PyErr::fetch`].
     pub fn take(py: Python<'_>) -> Option<PyErr> {
-        Self::_take(py)
-    }
-
-    #[cfg(not(Py_3_12))]
-    fn _take(py: Python<'_>) -> Option<PyErr> {
-        let (ptype, pvalue, ptraceback) = unsafe {
-            let mut ptype: *mut ffi::PyObject = std::ptr::null_mut();
-            let mut pvalue: *mut ffi::PyObject = std::ptr::null_mut();
-            let mut ptraceback: *mut ffi::PyObject = std::ptr::null_mut();
-            ffi::PyErr_Fetch(&mut ptype, &mut pvalue, &mut ptraceback);
-
-            // Convert to Py immediately so that any references are freed by early return.
-            let ptype = PyObject::from_owned_ptr_or_opt(py, ptype);
-            let pvalue = PyObject::from_owned_ptr_or_opt(py, pvalue);
-            let ptraceback = PyObject::from_owned_ptr_or_opt(py, ptraceback);
-
-            // A valid exception state should always have a non-null ptype, but the other two may be
-            // null.
-            let ptype = match ptype {
-                Some(ptype) => ptype,
-                None => {
-                    debug_assert!(
-                        pvalue.is_none(),
-                        "Exception type was null but value was not null"
-                    );
-                    debug_assert!(
-                        ptraceback.is_none(),
-                        "Exception type was null but traceback was not null"
-                    );
-                    return None;
-                }
-            };
-
-            (ptype, pvalue, ptraceback)
-        };
-
-        if ptype.as_ptr() == PanicException::type_object_raw(py).cast() {
-            let msg = pvalue
-                .as_ref()
-                .and_then(|obj| obj.as_ref(py).str().ok())
-                .map(|py_str| py_str.to_string_lossy().into())
-                .unwrap_or_else(|| String::from("Unwrapped panic from Python code"));
-
-            let state = PyErrState::FfiTuple {
-                ptype,
-                pvalue,
-                ptraceback,
-            };
-            Self::print_panic_and_unwind(py, state, msg)
-        }
-
-        Some(PyErr::from_state(PyErrState::FfiTuple {
-            ptype,
-            pvalue,
-            ptraceback,
-        }))
-    }
-
-    #[cfg(Py_3_12)]
-    fn _take(py: Python<'_>) -> Option<PyErr> {
         let state = PyErrStateNormalized::take(py)?;
-        let pvalue = state.pvalue.as_ref(py);
-        if pvalue.get_type().as_ptr() == PanicException::type_object_raw(py).cast() {
+        let pvalue = state.pvalue.bind(py);
+        if ptr::eq(
+            pvalue.get_type().as_ptr(),
+            PanicException::type_object_raw(py).cast(),
+        ) {
             let msg: String = pvalue
                 .str()
                 .map(|py_str| py_str.to_string_lossy().into())
                 .unwrap_or_else(|_| String::from("Unwrapped panic from Python code"));
-            Self::print_panic_and_unwind(py, PyErrState::Normalized(state), msg)
+            Self::print_panic_and_unwind(py, PyErrState::normalized(state), msg)
         }
 
-        Some(PyErr::from_state(PyErrState::Normalized(state)))
+        Some(PyErr::from_state(PyErrState::normalized(state)))
     }
 
     fn print_panic_and_unwind(py: Python<'_>, state: PyErrState, msg: String) -> ! {
@@ -432,7 +316,7 @@ impl PyErr {
     ///
     /// Use this function when the error is expected to have been set, for example from
     /// [PyErr::occurred] or by an error return value from a C FFI function.
-    #[cfg_attr(all(debug_assertions, track_caller), track_caller)]
+    #[cfg_attr(debug_assertions, track_caller)]
     #[inline]
     pub fn fetch(py: Python<'_>) -> PyErr {
         const FAILED_TO_FETCH: &str = "attempted to fetch exception but none was set";
@@ -441,34 +325,10 @@ impl PyErr {
             #[cfg(debug_assertions)]
             None => panic!("{}", FAILED_TO_FETCH),
             #[cfg(not(debug_assertions))]
-            None => exceptions::PySystemError::new_err(FAILED_TO_FETCH),
+            None => crate::exceptions::PySystemError::new_err(FAILED_TO_FETCH),
         }
     }
 
-    /// Deprecated form of [`PyErr::new_type_bound`]
-    #[cfg_attr(
-        not(feature = "gil-refs"),
-        deprecated(
-            since = "0.21.0",
-            note = "`PyErr::new_type` will be replaced by `PyErr::new_type_bound` in a future PyO3 version"
-        )
-    )]
-    pub fn new_type(
-        py: Python<'_>,
-        name: &str,
-        doc: Option<&str>,
-        base: Option<&PyType>,
-        dict: Option<PyObject>,
-    ) -> PyResult<Py<PyType>> {
-        Self::new_type_bound(
-            py,
-            name,
-            doc,
-            base.map(PyNativeType::as_borrowed).as_deref(),
-            dict,
-        )
-    }
-
     /// Creates a new exception type with the given name and docstring.
     ///
     /// - `base` can be an existing exception type to subclass, or a tuple of classes.
@@ -479,16 +339,12 @@ impl PyErr {
     /// # Errors
     ///
     /// This function returns an error if `name` is not of the form `<module>.<ExceptionName>`.
-    ///
-    /// # Panics
-    ///
-    /// This function will panic if  `name` or `doc` cannot be converted to [`CString`]s.
-    pub fn new_type_bound<'py>(
+    pub fn new_type<'py>(
         py: Python<'py>,
-        name: &str,
-        doc: Option<&str>,
+        name: &CStr,
+        doc: Option<&CStr>,
         base: Option<&Bound<'py, PyType>>,
-        dict: Option<PyObject>,
+        dict: Option<Py<PyAny>>,
     ) -> PyResult<Py<PyType>> {
         let base: *mut ffi::PyObject = match base {
             None => std::ptr::null_mut(),
@@ -500,25 +356,12 @@ impl PyErr {
             Some(obj) => obj.as_ptr(),
         };
 
-        let null_terminated_name =
-            CString::new(name).expect("Failed to initialize nul terminated exception name");
-
-        let null_terminated_doc =
-            doc.map(|d| CString::new(d).expect("Failed to initialize nul terminated docstring"));
-
-        let null_terminated_doc_ptr = match null_terminated_doc.as_ref() {
+        let doc_ptr = match doc.as_ref() {
             Some(c) => c.as_ptr(),
             None => std::ptr::null(),
         };
 
-        let ptr = unsafe {
-            ffi::PyErr_NewExceptionWithDoc(
-                null_terminated_name.as_ptr(),
-                null_terminated_doc_ptr,
-                base,
-                dict,
-            )
-        };
+        let ptr = unsafe { ffi::PyErr_NewExceptionWithDoc(name.as_ptr(), doc_ptr, base, dict) };
 
         unsafe { Py::from_owned_ptr_or_err(py, ptr) }
     }
@@ -536,8 +379,8 @@ impl PyErr {
             // PyErr_Display. if we inline this, the `Bound` will be dropped
             // after the argument got evaluated, leading to call with a dangling
             // pointer.
-            let traceback = self.traceback_bound(py);
-            let type_bound = self.get_type_bound(py);
+            let traceback = self.traceback(py);
+            let type_bound = self.get_type(py);
             ffi::PyErr_Display(
                 type_bound.as_ptr(),
                 self.value(py).as_ptr(),
@@ -566,30 +409,17 @@ impl PyErr {
     ///
     /// If `exc` is a class object, this also returns `true` when `self` is an instance of a subclass.
     /// If `exc` is a tuple, all exceptions in the tuple (and recursively in subtuples) are searched for a match.
-    pub fn matches<T>(&self, py: Python<'_>, exc: T) -> bool
+    pub fn matches<'py, T>(&self, py: Python<'py>, exc: T) -> Result<bool, T::Error>
     where
-        T: ToPyObject,
+        T: IntoPyObject<'py>,
     {
-        self.is_instance_bound(py, exc.to_object(py).bind(py))
-    }
-
-    /// Deprecated form of `PyErr::is_instance_bound`.
-    #[cfg_attr(
-        not(feature = "gil-refs"),
-        deprecated(
-            since = "0.21.0",
-            note = "`PyErr::is_instance` will be replaced by `PyErr::is_instance_bound` in a future PyO3 version"
-        )
-    )]
-    #[inline]
-    pub fn is_instance(&self, py: Python<'_>, ty: &PyAny) -> bool {
-        self.is_instance_bound(py, &ty.as_borrowed())
+        Ok(self.is_instance(py, &exc.into_pyobject(py)?.into_any().as_borrowed()))
     }
 
     /// Returns true if the current exception is instance of `T`.
     #[inline]
-    pub fn is_instance_bound(&self, py: Python<'_>, ty: &Bound<'_, PyAny>) -> bool {
-        let type_bound = self.get_type_bound(py);
+    pub fn is_instance(&self, py: Python<'_>, ty: &Bound<'_, PyAny>) -> bool {
+        let type_bound = self.get_type(py);
         (unsafe { ffi::PyErr_GivenExceptionMatches(type_bound.as_ptr(), ty.as_ptr()) }) != 0
     }
 
@@ -599,30 +429,14 @@ impl PyErr {
     where
         T: PyTypeInfo,
     {
-        self.is_instance_bound(py, &T::type_object_bound(py))
+        self.is_instance(py, &T::type_object(py))
     }
 
     /// Writes the error back to the Python interpreter's global state.
     /// This is the opposite of `PyErr::fetch()`.
     #[inline]
     pub fn restore(self, py: Python<'_>) {
-        self.state
-            .into_inner()
-            .expect("PyErr state should never be invalid outside of normalization")
-            .restore(py)
-    }
-
-    /// Deprecated form of `PyErr::write_unraisable_bound`.
-    #[cfg_attr(
-        not(feature = "gil-refs"),
-        deprecated(
-            since = "0.21.0",
-            note = "`PyErr::write_unraisable` will be replaced by `PyErr::write_unraisable_bound` in a future PyO3 version"
-        )
-    )]
-    #[inline]
-    pub fn write_unraisable(self, py: Python<'_>, obj: Option<&PyAny>) {
-        self.write_unraisable_bound(py, obj.map(PyAny::as_borrowed).as_deref())
+        self.state.restore(py)
     }
 
     /// Reports the error as unraisable.
@@ -637,7 +451,7 @@ impl PyErr {
     ///
     /// Calling this method has the benefit that the error goes back into a standardized callback
     /// in Python which for instance allows unittests to ensure that no unraisable error
-    /// actually happend by hooking `sys.unraisablehook`.
+    /// actually happened by hooking `sys.unraisablehook`.
     ///
     /// Example:
     /// ```rust
@@ -645,32 +459,20 @@ impl PyErr {
     /// # use pyo3::exceptions::PyRuntimeError;
     /// # fn failing_function() -> PyResult<()> { Err(PyRuntimeError::new_err("foo")) }
     /// # fn main() -> PyResult<()> {
-    /// Python::with_gil(|py| {
+    /// Python::attach(|py| {
     ///     match failing_function() {
-    ///         Err(pyerr) => pyerr.write_unraisable_bound(py, None),
+    ///         Err(pyerr) => pyerr.write_unraisable(py, None),
     ///         Ok(..) => { /* do something here */ }
     ///     }
     ///     Ok(())
     /// })
     /// # }
     #[inline]
-    pub fn write_unraisable_bound(self, py: Python<'_>, obj: Option<&Bound<'_, PyAny>>) {
+    pub fn write_unraisable(self, py: Python<'_>, obj: Option<&Bound<'_, PyAny>>) {
         self.restore(py);
         unsafe { ffi::PyErr_WriteUnraisable(obj.map_or(std::ptr::null_mut(), Bound::as_ptr)) }
     }
 
-    /// Deprecated form of [`PyErr::warn_bound`].
-    #[cfg_attr(
-        not(feature = "gil-refs"),
-        deprecated(
-            since = "0.21.0",
-            note = "`PyErr::warn` will be replaced by `PyErr::warn_bound` in a future PyO3 version"
-        )
-    )]
-    pub fn warn(py: Python<'_>, category: &PyAny, message: &str, stacklevel: i32) -> PyResult<()> {
-        Self::warn_bound(py, &category.as_borrowed(), message, stacklevel)
-    }
-
     /// Issues a warning message.
     ///
     /// May return an `Err(PyErr)` if warnings-as-errors is enabled.
@@ -684,21 +486,21 @@ impl PyErr {
     /// Example:
     /// ```rust
     /// # use pyo3::prelude::*;
+    /// # use pyo3::ffi::c_str;
     /// # fn main() -> PyResult<()> {
-    /// Python::with_gil(|py| {
-    ///     let user_warning = py.get_type::<pyo3::exceptions::PyUserWarning>().as_borrowed();
-    ///     PyErr::warn_bound(py, &user_warning, "I am warning you", 0)?;
+    /// Python::attach(|py| {
+    ///     let user_warning = py.get_type::<pyo3::exceptions::PyUserWarning>();
+    ///     PyErr::warn(py, &user_warning, c"I am warning you", 0)?;
     ///     Ok(())
     /// })
     /// # }
     /// ```
-    pub fn warn_bound<'py>(
+    pub fn warn<'py>(
         py: Python<'py>,
         category: &Bound<'py, PyAny>,
-        message: &str,
+        message: &CStr,
         stacklevel: i32,
     ) -> PyResult<()> {
-        let message = CString::new(message)?;
         error_on_minusone(py, unsafe {
             ffi::PyErr_WarnEx(
                 category.as_ptr(),
@@ -708,34 +510,6 @@ impl PyErr {
         })
     }
 
-    /// Deprecated form of [`PyErr::warn_explicit_bound`].
-    #[cfg_attr(
-        not(feature = "gil-refs"),
-        deprecated(
-            since = "0.21.0",
-            note = "`PyErr::warn_explicit` will be replaced by `PyErr::warn_explicit_bound` in a future PyO3 version"
-        )
-    )]
-    pub fn warn_explicit(
-        py: Python<'_>,
-        category: &PyAny,
-        message: &str,
-        filename: &str,
-        lineno: i32,
-        module: Option<&str>,
-        registry: Option<&PyAny>,
-    ) -> PyResult<()> {
-        Self::warn_explicit_bound(
-            py,
-            &category.as_borrowed(),
-            message,
-            filename,
-            lineno,
-            module,
-            registry.map(PyNativeType::as_borrowed).as_deref(),
-        )
-    }
-
     /// Issues a warning message, with more control over the warning attributes.
     ///
     /// May return a `PyErr` if warnings-as-errors is enabled.
@@ -744,18 +518,15 @@ impl PyErr {
     ///
     /// The `category` should be one of the `Warning` classes available in
     /// [`pyo3::exceptions`](crate::exceptions), or a subclass.
-    pub fn warn_explicit_bound<'py>(
+    pub fn warn_explicit<'py>(
         py: Python<'py>,
         category: &Bound<'py, PyAny>,
-        message: &str,
-        filename: &str,
+        message: &CStr,
+        filename: &CStr,
         lineno: i32,
-        module: Option<&str>,
+        module: Option<&CStr>,
         registry: Option<&Bound<'py, PyAny>>,
     ) -> PyResult<()> {
-        let message = CString::new(message)?;
-        let filename = CString::new(filename)?;
-        let module = module.map(CString::new).transpose()?;
         let module_ptr = match module {
             None => std::ptr::null_mut(),
             Some(s) => s.as_ptr(),
@@ -781,28 +552,35 @@ impl PyErr {
     /// # Examples
     /// ```rust
     /// use pyo3::{exceptions::PyTypeError, PyErr, Python, prelude::PyAnyMethods};
-    /// Python::with_gil(|py| {
+    /// Python::attach(|py| {
     ///     let err: PyErr = PyTypeError::new_err(("some type error",));
     ///     let err_clone = err.clone_ref(py);
-    ///     assert!(err.get_type_bound(py).is(&err_clone.get_type_bound(py)));
+    ///     assert!(err.get_type(py).is(&err_clone.get_type(py)));
     ///     assert!(err.value(py).is(err_clone.value(py)));
-    ///     match err.traceback_bound(py) {
-    ///         None => assert!(err_clone.traceback_bound(py).is_none()),
-    ///         Some(tb) => assert!(err_clone.traceback_bound(py).unwrap().is(&tb)),
+    ///     match err.traceback(py) {
+    ///         None => assert!(err_clone.traceback(py).is_none()),
+    ///         Some(tb) => assert!(err_clone.traceback(py).unwrap().is(&tb)),
     ///     }
     /// });
     /// ```
     #[inline]
     pub fn clone_ref(&self, py: Python<'_>) -> PyErr {
-        PyErr::from_state(PyErrState::Normalized(self.normalized(py).clone()))
+        PyErr::from_state(PyErrState::normalized(self.normalized(py).clone_ref(py)))
     }
 
     /// Return the cause (either an exception instance, or None, set by `raise ... from ...`)
     /// associated with the exception, as accessible from Python through `__cause__`.
     pub fn cause(&self, py: Python<'_>) -> Option<PyErr> {
-        let value = self.value(py);
+        use crate::ffi_ptr_ext::FfiPtrExt;
         let obj =
-            unsafe { py.from_owned_ptr_or_opt::<PyAny>(ffi::PyException_GetCause(value.as_ptr())) };
+            unsafe { ffi::PyException_GetCause(self.value(py).as_ptr()).assume_owned_or_opt(py) };
+        // PyException_GetCause is documented as potentially returning PyNone, but only GraalPy seems to actually do that
+        #[cfg(GraalPy)]
+        if let Some(cause) = &obj {
+            if cause.is_none() {
+                return None;
+            }
+        }
         obj.map(Self::from_value)
     }
 
@@ -819,57 +597,49 @@ impl PyErr {
         }
     }
 
+    /// Equivalent to calling `add_note` on the exception in Python.
+    #[cfg(Py_3_11)]
+    pub fn add_note<N: for<'py> IntoPyObject<'py, Target = PyString>>(
+        &self,
+        py: Python<'_>,
+        note: N,
+    ) -> PyResult<()> {
+        self.value(py)
+            .call_method1(intern!(py, "add_note"), (note,))?;
+        Ok(())
+    }
+
     #[inline]
     fn from_state(state: PyErrState) -> PyErr {
-        PyErr {
-            state: UnsafeCell::new(Some(state)),
-        }
+        PyErr { state }
     }
 
     #[inline]
     fn normalized(&self, py: Python<'_>) -> &PyErrStateNormalized {
-        if let Some(PyErrState::Normalized(n)) = unsafe {
-            // Safety: self.state will never be written again once normalized.
-            &*self.state.get()
-        } {
-            return n;
-        }
-
-        self.make_normalized(py)
-    }
-
-    #[cold]
-    fn make_normalized(&self, py: Python<'_>) -> &PyErrStateNormalized {
-        // This process is safe because:
-        // - Access is guaranteed not to be concurrent thanks to `Python` GIL token
-        // - Write happens only once, and then never will change again.
-        // - State is set to None during the normalization process, so that a second
-        //   concurrent normalization attempt will panic before changing anything.
-
-        let state = unsafe {
-            (*self.state.get())
-                .take()
-                .expect("Cannot normalize a PyErr while already normalizing it.")
-        };
-
-        unsafe {
-            let self_state = &mut *self.state.get();
-            *self_state = Some(PyErrState::Normalized(state.normalize(py)));
-            match self_state {
-                Some(PyErrState::Normalized(n)) => n,
-                _ => unreachable!(),
-            }
-        }
+        self.state.as_normalized(py)
     }
 }
 
 impl std::fmt::Debug for PyErr {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             f.debug_struct("PyErr")
-                .field("type", &self.get_type_bound(py))
+                .field("type", &self.get_type(py))
                 .field("value", self.value(py))
-                .field("traceback", &self.traceback_bound(py))
+                .field(
+                    "traceback",
+                    &self.traceback(py).map(|tb| match tb.format() {
+                        Ok(s) => s,
+                        Err(err) => {
+                            err.write_unraisable(py, Some(&tb));
+                            // It would be nice to format what we can of the
+                            // error, but we can't guarantee that the error
+                            // won't have another unformattable traceback inside
+                            // it and we want to avoid an infinite recursion.
+                            format!("<unformattable {tb:?}>")
+                        }
+                    }),
+                )
                 .finish()
         })
     }
@@ -877,10 +647,10 @@ impl std::fmt::Debug for PyErr {
 
 impl std::fmt::Display for PyErr {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let value = self.value(py);
             let type_name = value.get_type().qualname().map_err(|_| std::fmt::Error)?;
-            write!(f, "{}", type_name)?;
+            write!(f, "{type_name}")?;
             if let Ok(s) = value.str() {
                 write!(f, ": {}", &s.to_string_lossy())
             } else {
@@ -892,117 +662,47 @@ impl std::fmt::Display for PyErr {
 
 impl std::error::Error for PyErr {}
 
-impl IntoPy<PyObject> for PyErr {
-    fn into_py(self, py: Python<'_>) -> PyObject {
-        self.into_value(py).into()
-    }
-}
-
-impl ToPyObject for PyErr {
-    fn to_object(&self, py: Python<'_>) -> PyObject {
-        self.clone_ref(py).into_py(py)
-    }
-}
-
-impl<'a> IntoPy<PyObject> for &'a PyErr {
-    fn into_py(self, py: Python<'_>) -> PyObject {
-        self.clone_ref(py).into_py(py)
-    }
-}
-
-struct PyDowncastErrorArguments {
-    from: Py<PyType>,
-    to: Cow<'static, str>,
-}
-
-impl PyErrArguments for PyDowncastErrorArguments {
-    fn arguments(self, py: Python<'_>) -> PyObject {
-        format!(
-            "'{}' object cannot be converted to '{}'",
-            self.from
-                .as_ref(py)
-                .qualname()
-                .as_deref()
-                .unwrap_or("<failed to extract type name>"),
-            self.to
-        )
-        .to_object(py)
-    }
-}
-
-/// Convert `PyDowncastError` to Python `TypeError`.
-impl<'a> std::convert::From<PyDowncastError<'a>> for PyErr {
-    fn from(err: PyDowncastError<'_>) -> PyErr {
-        let args = PyDowncastErrorArguments {
-            from: err.from.get_type().into(),
-            to: err.to,
-        };
-
-        exceptions::PyTypeError::new_err(args)
-    }
-}
-
-impl<'a> std::error::Error for PyDowncastError<'a> {}
-
-impl<'a> std::fmt::Display for PyDowncastError<'a> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
-        display_downcast_error(f, &self.from.as_borrowed(), &self.to)
-    }
-}
+impl<'py> IntoPyObject<'py> for PyErr {
+    type Target = PyBaseException;
+    type Output = Bound<'py, Self::Target>;
+    type Error = Infallible;
 
-/// Convert `DowncastError` to Python `TypeError`.
-impl std::convert::From<DowncastError<'_, '_>> for PyErr {
-    fn from(err: DowncastError<'_, '_>) -> PyErr {
-        let args = PyDowncastErrorArguments {
-            from: err.from.get_type().into(),
-            to: err.to,
-        };
-
-        exceptions::PyTypeError::new_err(args)
-    }
-}
-
-impl std::error::Error for DowncastError<'_, '_> {}
-
-impl std::fmt::Display for DowncastError<'_, '_> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
-        display_downcast_error(f, self.from, &self.to)
+    #[inline]
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        Ok(self.into_value(py).into_bound(py))
     }
 }
 
-/// Convert `DowncastIntoError` to Python `TypeError`.
-impl std::convert::From<DowncastIntoError<'_>> for PyErr {
-    fn from(err: DowncastIntoError<'_>) -> PyErr {
-        let args = PyDowncastErrorArguments {
-            from: err.from.get_type().into(),
-            to: err.to,
-        };
+impl<'py> IntoPyObject<'py> for &PyErr {
+    type Target = PyBaseException;
+    type Output = Bound<'py, Self::Target>;
+    type Error = Infallible;
 
-        exceptions::PyTypeError::new_err(args)
+    #[inline]
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        self.clone_ref(py).into_pyobject(py)
     }
 }
 
-impl std::error::Error for DowncastIntoError<'_> {}
-
-impl std::fmt::Display for DowncastIntoError<'_> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
-        display_downcast_error(f, &self.from, &self.to)
+/// Python exceptions that can be converted to [`PyErr`].
+///
+/// This is used to implement [`From<Bound<'_, T>> for PyErr`].
+///
+/// Users should not need to implement this trait directly. It is implemented automatically in the
+/// [`crate::import_exception!`] and [`crate::create_exception!`] macros.
+pub trait ToPyErr {}
+
+impl<'py, T> std::convert::From<Bound<'py, T>> for PyErr
+where
+    T: ToPyErr,
+{
+    #[inline]
+    fn from(err: Bound<'py, T>) -> PyErr {
+        PyErr::from_value(err.into_any())
     }
 }
 
-fn display_downcast_error(
-    f: &mut std::fmt::Formatter<'_>,
-    from: &Bound<'_, PyAny>,
-    to: &str,
-) -> std::fmt::Result {
-    write!(
-        f,
-        "'{}' object cannot be converted to '{}'",
-        from.get_type().qualname().map_err(|_| std::fmt::Error)?,
-        to
-    )
-}
-
+#[track_caller]
 pub fn panic_after_error(_py: Python<'_>) -> ! {
     unsafe {
         ffi::PyErr_Print();
@@ -1043,17 +743,18 @@ impl_signed_integer!(isize);
 mod tests {
     use super::PyErrState;
     use crate::exceptions::{self, PyTypeError, PyValueError};
-    use crate::types::any::PyAnyMethods;
-    use crate::{PyErr, PyNativeType, PyTypeInfo, Python};
+    use crate::impl_::pyclass::{value_of, IsSend, IsSync};
+    use crate::test_utils::assert_warnings;
+    use crate::{PyErr, PyTypeInfo, Python};
 
     #[test]
     fn no_error() {
-        assert!(Python::with_gil(PyErr::take).is_none());
+        assert!(Python::attach(PyErr::take).is_none());
     }
 
     #[test]
     fn set_valueerror() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let err: PyErr = exceptions::PyValueError::new_err("some exception message");
             assert!(err.is_instance_of::<exceptions::PyValueError>(py));
             err.restore(py);
@@ -1066,7 +767,7 @@ mod tests {
 
     #[test]
     fn invalid_error_type() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let err: PyErr = PyErr::new::<crate::types::PyString, _>(());
             assert!(err.is_instance_of::<exceptions::PyTypeError>(py));
             err.restore(py);
@@ -1082,7 +783,7 @@ mod tests {
 
     #[test]
     fn set_typeerror() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let err: PyErr = exceptions::PyTypeError::new_err(());
             err.restore(py);
             assert!(PyErr::occurred(py));
@@ -1095,7 +796,7 @@ mod tests {
     fn fetching_panic_exception_resumes_unwind() {
         use crate::panic::PanicException;
 
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let err: PyErr = PanicException::new_err("new panic");
             err.restore(py);
             assert!(PyErr::occurred(py));
@@ -1111,7 +812,7 @@ mod tests {
     fn fetching_normalized_panic_exception_resumes_unwind() {
         use crate::panic::PanicException;
 
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let err: PyErr = PanicException::new_err("new panic");
             // Restoring an error doesn't normalize it before Python 3.12,
             // so we have to explicitly test this case.
@@ -1130,27 +831,28 @@ mod tests {
         // PyErr {
         //     type: <class 'Exception'>,
         //     value: Exception('banana'),
-        //     traceback: Some(<traceback object at 0x..)"
+        //     traceback:  Some(\"Traceback (most recent call last):\\n  File \\\"<string>\\\", line 1, in <module>\\n\")
         // }
 
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let err = py
-                .run_bound("raise Exception('banana')", None, None)
+                .run(c"raise Exception('banana')", None, None)
                 .expect_err("raising should have given us an error");
 
-            let debug_str = format!("{:?}", err);
+            let debug_str = format!("{err:?}");
             assert!(debug_str.starts_with("PyErr { "));
             assert!(debug_str.ends_with(" }"));
 
-            // strip "PyErr { " and " }"
-            let mut fields = debug_str["PyErr { ".len()..debug_str.len() - 2].split(", ");
+            // Strip "PyErr { " and " }". Split into 3 substrings to separate type,
+            // value, and traceback while not splitting the string within traceback.
+            let mut fields = debug_str["PyErr { ".len()..debug_str.len() - 2].splitn(3, ", ");
 
             assert_eq!(fields.next().unwrap(), "type: <class 'Exception'>");
             assert_eq!(fields.next().unwrap(), "value: Exception('banana')");
-
-            let traceback = fields.next().unwrap();
-            assert!(traceback.starts_with("traceback: Some(<traceback object at 0x"));
-            assert!(traceback.ends_with(">)"));
+            assert_eq!(
+                fields.next().unwrap(),
+                "traceback: Some(\"Traceback (most recent call last):\\n  File \\\"<string>\\\", line 1, in <module>\\n\")"
+            );
 
             assert!(fields.next().is_none());
         });
@@ -1158,9 +860,9 @@ mod tests {
 
     #[test]
     fn err_display() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let err = py
-                .run_bound("raise Exception('banana')", None, None)
+                .run(c"raise Exception('banana')", None, None)
                 .expect_err("raising should have given us an error");
             assert_eq!(err.to_string(), "Exception: banana");
         });
@@ -1168,52 +870,45 @@ mod tests {
 
     #[test]
     fn test_pyerr_send_sync() {
-        fn is_send<T: Send>() {}
-        fn is_sync<T: Sync>() {}
+        assert!(value_of!(IsSend, PyErr));
+        assert!(value_of!(IsSync, PyErr));
 
-        is_send::<PyErr>();
-        is_sync::<PyErr>();
-
-        is_send::<PyErrState>();
-        is_sync::<PyErrState>();
+        assert!(value_of!(IsSend, PyErrState));
+        assert!(value_of!(IsSync, PyErrState));
     }
 
     #[test]
     fn test_pyerr_matches() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let err = PyErr::new::<PyValueError, _>("foo");
-            assert!(err.matches(py, PyValueError::type_object_bound(py)));
+            assert!(err.matches(py, PyValueError::type_object(py)).unwrap());
 
-            assert!(err.matches(
-                py,
-                (
-                    PyValueError::type_object_bound(py),
-                    PyTypeError::type_object_bound(py)
+            assert!(err
+                .matches(
+                    py,
+                    (PyValueError::type_object(py), PyTypeError::type_object(py))
                 )
-            ));
+                .unwrap());
 
-            assert!(!err.matches(py, PyTypeError::type_object_bound(py)));
+            assert!(!err.matches(py, PyTypeError::type_object(py)).unwrap());
 
             // String is not a valid exception class, so we should get a TypeError
-            let err: PyErr = PyErr::from_type(
-                crate::types::PyString::type_object_bound(py).as_gil_ref(),
-                "foo",
-            );
-            assert!(err.matches(py, PyTypeError::type_object_bound(py)));
+            let err: PyErr = PyErr::from_type(crate::types::PyString::type_object(py), "foo");
+            assert!(err.matches(py, PyTypeError::type_object(py)).unwrap());
         })
     }
 
     #[test]
     fn test_pyerr_cause() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let err = py
-                .run_bound("raise Exception('banana')", None, None)
+                .run(c"raise Exception('banana')", None, None)
                 .expect_err("raising should have given us an error");
             assert!(err.cause(py).is_none());
 
             let err = py
-                .run_bound(
-                    "raise Exception('banana') from Exception('apple')",
+                .run(
+                    c"raise Exception('banana') from Exception('apple')",
                     None,
                     None,
                 )
@@ -1237,47 +932,48 @@ mod tests {
 
     #[test]
     fn warnings() {
+        use crate::types::any::PyAnyMethods;
         // Note: although the warning filter is interpreter global, keeping the
         // GIL locked should prevent effects to be visible to other testing
         // threads.
-        Python::with_gil(|py| {
-            let cls = py.get_type::<exceptions::PyUserWarning>().as_borrowed();
+        Python::attach(|py| {
+            let cls = py.get_type::<exceptions::PyUserWarning>();
 
             // Reset warning filter to default state
-            let warnings = py.import_bound("warnings").unwrap();
+            let warnings = py.import("warnings").unwrap();
             warnings.call_method0("resetwarnings").unwrap();
 
             // First, test the warning is emitted
             assert_warnings!(
                 py,
-                { PyErr::warn_bound(py, &cls, "I am warning you", 0).unwrap() },
+                { PyErr::warn(py, &cls, c"I am warning you", 0).unwrap() },
                 [(exceptions::PyUserWarning, "I am warning you")]
             );
 
             // Test with raising
             warnings
-                .call_method1("simplefilter", ("error", cls))
+                .call_method1("simplefilter", ("error", &cls))
                 .unwrap();
-            PyErr::warn_bound(py, &cls, "I am warning you", 0).unwrap_err();
+            PyErr::warn(py, &cls, c"I am warning you", 0).unwrap_err();
 
             // Test with error for an explicit module
             warnings.call_method0("resetwarnings").unwrap();
             warnings
-                .call_method1("filterwarnings", ("error", "", cls, "pyo3test"))
+                .call_method1("filterwarnings", ("error", "", &cls, "pyo3test"))
                 .unwrap();
 
             // This has the wrong module and will not raise, just be emitted
             assert_warnings!(
                 py,
-                { PyErr::warn_bound(py, &cls, "I am warning you", 0).unwrap() },
+                { PyErr::warn(py, &cls, c"I am warning you", 0).unwrap() },
                 [(exceptions::PyUserWarning, "I am warning you")]
             );
 
-            let err = PyErr::warn_explicit_bound(
+            let err = PyErr::warn_explicit(
                 py,
                 &cls,
-                "I am warning you",
-                "pyo3test.py",
+                c"I am warning you",
+                c"pyo3test.py",
                 427,
                 None,
                 None,
@@ -1296,4 +992,21 @@ mod tests {
             warnings.call_method0("resetwarnings").unwrap();
         });
     }
+
+    #[test]
+    #[cfg(Py_3_11)]
+    fn test_add_note() {
+        use crate::types::any::PyAnyMethods;
+        Python::attach(|py| {
+            let err = PyErr::new::<exceptions::PyValueError, _>("original error");
+            err.add_note(py, "additional context").unwrap();
+
+            let notes = err.value(py).getattr("__notes__").unwrap();
+            assert_eq!(notes.len().unwrap(), 1);
+            assert_eq!(
+                notes.get_item(0).unwrap().extract::<String>().unwrap(),
+                "additional context"
+            );
+        });
+    }
 }
diff --git a/src/exceptions.rs b/src/exceptions.rs
index bcbe91b90c7..56e6d09261d 100644
--- a/src/exceptions.rs
+++ b/src/exceptions.rs
@@ -9,28 +9,21 @@
 //! yourself to import Python classes that are ultimately derived from
 //! `BaseException`.
 
-use crate::{ffi, PyResult, Python};
+use crate::{ffi, Bound, PyResult, Python};
 use std::ffi::CStr;
 use std::ops;
-use std::os::raw::c_char;
 
 /// The boilerplate to convert between a Rust type and a Python exception.
 #[doc(hidden)]
 #[macro_export]
 macro_rules! impl_exception_boilerplate {
     ($name: ident) => {
-        impl ::std::convert::From<&$name> for $crate::PyErr {
-            #[inline]
-            fn from(err: &$name) -> $crate::PyErr {
-                $crate::PyErr::from_value(err)
-            }
-        }
-
         impl $name {
             /// Creates a new [`PyErr`] of this type.
             ///
             /// [`PyErr`]: https://docs.rs/pyo3/latest/pyo3/struct.PyErr.html "PyErr in pyo3"
             #[inline]
+            #[allow(dead_code)]
             pub fn new_err<A>(args: A) -> $crate::PyErr
             where
                 A: $crate::PyErrArguments + ::std::marker::Send + ::std::marker::Sync + 'static,
@@ -39,17 +32,7 @@ macro_rules! impl_exception_boilerplate {
             }
         }
 
-        impl ::std::error::Error for $name {
-            fn source(&self) -> ::std::option::Option<&(dyn ::std::error::Error + 'static)> {
-                unsafe {
-                    let cause: &$crate::exceptions::PyBaseException = self
-                        .py()
-                        .from_owned_ptr_or_opt($crate::ffi::PyException_GetCause(self.as_ptr()))?;
-
-                    ::std::option::Option::Some(cause)
-                }
-            }
-        }
+        impl $crate::ToPyErr for $name {}
     };
 }
 
@@ -70,10 +53,13 @@ macro_rules! impl_exception_boilerplate {
 ///
 /// import_exception!(socket, gaierror);
 ///
-/// Python::with_gil(|py| {
-///     let ctx = [("gaierror", py.get_type::<gaierror>())].into_py_dict_bound(py);
+/// # fn main() -> pyo3::PyResult<()> {
+/// Python::attach(|py| {
+///     let ctx = [("gaierror", py.get_type::<gaierror>())].into_py_dict(py)?;
 ///     pyo3::py_run!(py, *ctx, "import socket; assert gaierror is socket.gaierror");
-/// });
+/// #   Ok(())
+/// })
+/// # }
 ///
 /// ```
 #[macro_export]
@@ -99,39 +85,24 @@ macro_rules! import_exception {
 
         impl $name {
             fn type_object_raw(py: $crate::Python<'_>) -> *mut $crate::ffi::PyTypeObject {
-                use $crate::sync::GILOnceCell;
-                use $crate::prelude::PyTracebackMethods;
-                use $crate::prelude::PyAnyMethods;
-                static TYPE_OBJECT: GILOnceCell<$crate::Py<$crate::types::PyType>> =
-                    GILOnceCell::new();
-
-                TYPE_OBJECT
-                    .get_or_init(py, || {
-                        let imp = py
-                            .import_bound(stringify!($module))
-                            .unwrap_or_else(|err| {
-                                let traceback = err
-                                    .traceback_bound(py)
-                                    .map(|tb| tb.format().expect("raised exception will have a traceback"))
-                                    .unwrap_or_default();
-                                ::std::panic!("Can not import module {}: {}\n{}", stringify!($module), err, traceback);
-                            });
-                        let cls = imp.getattr(stringify!($name)).expect(concat!(
-                            "Can not load exception class: {}.{}",
-                            stringify!($module),
-                            ".",
-                            stringify!($name)
-                        ));
-
-                        cls.extract()
-                            .expect("Imported exception should be a type object")
-                    })
-                    .as_ptr() as *mut _
+                use $crate::types::PyTypeMethods;
+                static TYPE_OBJECT: $crate::impl_::exceptions::ImportedExceptionTypeObject =
+                    $crate::impl_::exceptions::ImportedExceptionTypeObject::new(stringify!($module), stringify!($name));
+                TYPE_OBJECT.get(py).as_type_ptr()
             }
         }
     };
 }
 
+/// Deprecated name for `import_exception!`.
+#[macro_export]
+#[deprecated(since = "0.27.0", note = "renamed to `import_exception!` instead")]
+macro_rules! import_exception_bound {
+    ($module: expr, $name: ident) => {
+        $crate::import_exception!($module, $name);
+    };
+}
+
 /// Defines a new exception type.
 ///
 /// # Syntax
@@ -140,6 +111,7 @@ macro_rules! import_exception {
 /// * `name` is the name of the new exception type.
 /// * `base` is the base class of `MyError`, usually [`PyException`].
 /// * `doc` (optional) is the docstring visible to users (with `.__doc__` and `help()`) and
+///
 /// accompanies your error type in your crate's documentation.
 ///
 /// # Examples
@@ -158,20 +130,20 @@ macro_rules! import_exception {
 /// }
 ///
 /// #[pymodule]
-/// fn my_module(py: Python<'_>, m: &PyModule) -> PyResult<()> {
-///     m.add("MyError", py.get_type::<MyError>())?;
-///     m.add_function(wrap_pyfunction!(raise_myerror, py)?)?;
+/// fn my_module(m: &Bound<'_, PyModule>) -> PyResult<()> {
+///     m.add("MyError", m.py().get_type::<MyError>())?;
+///     m.add_function(wrap_pyfunction!(raise_myerror, m)?)?;
 ///     Ok(())
 /// }
 /// # fn main() -> PyResult<()> {
-/// #     Python::with_gil(|py| -> PyResult<()> {
+/// #     Python::attach(|py| -> PyResult<()> {
 /// #         let fun = wrap_pyfunction!(raise_myerror, py)?;
-/// #         let locals = pyo3::types::PyDict::new_bound(py);
+/// #         let locals = pyo3::types::PyDict::new(py);
 /// #         locals.set_item("MyError", py.get_type::<MyError>())?;
 /// #         locals.set_item("raise_myerror", fun)?;
 /// #
-/// #         py.run_bound(
-/// # "try:
+/// #         py.run(
+/// # c"try:
 /// #     raise_myerror()
 /// # except MyError as e:
 /// #     assert e.__doc__ == 'Some description.'
@@ -206,7 +178,7 @@ macro_rules! create_exception {
 
         $crate::impl_exception_boilerplate!($name);
 
-        $crate::create_exception_type_object!($module, $name, $base, ::std::option::Option::None);
+        $crate::create_exception_type_object!($module, $name, $base, None);
     };
     ($module: expr, $name: ident, $base: ty, $doc: expr) => {
         #[repr(transparent)]
@@ -216,12 +188,7 @@ macro_rules! create_exception {
 
         $crate::impl_exception_boilerplate!($name);
 
-        $crate::create_exception_type_object!(
-            $module,
-            $name,
-            $base,
-            ::std::option::Option::Some($doc)
-        );
+        $crate::create_exception_type_object!($module, $name, $base, Some($doc));
     };
 }
 
@@ -230,6 +197,12 @@ macro_rules! create_exception {
 #[doc(hidden)]
 #[macro_export]
 macro_rules! create_exception_type_object {
+    ($module: expr, $name: ident, $base: ty, None) => {
+        $crate::create_exception_type_object!($module, $name, $base, ::std::option::Option::None);
+    };
+    ($module: expr, $name: ident, $base: ty, Some($doc: expr)) => {
+        $crate::create_exception_type_object!($module, $name, $base, ::std::option::Option::Some($crate::ffi::c_str!($doc)));
+    };
     ($module: expr, $name: ident, $base: ty, $doc: expr) => {
         $crate::pyobject_native_type_core!(
             $name,
@@ -239,18 +212,17 @@ macro_rules! create_exception_type_object {
 
         impl $name {
             fn type_object_raw(py: $crate::Python<'_>) -> *mut $crate::ffi::PyTypeObject {
-                use $crate::sync::GILOnceCell;
-                use $crate::PyNativeType;
-                static TYPE_OBJECT: GILOnceCell<$crate::Py<$crate::types::PyType>> =
-                    GILOnceCell::new();
+                use $crate::sync::PyOnceLock;
+                static TYPE_OBJECT: PyOnceLock<$crate::Py<$crate::types::PyType>> =
+                    PyOnceLock::new();
 
                 TYPE_OBJECT
                     .get_or_init(py, ||
-                        $crate::PyErr::new_type_bound(
+                        $crate::PyErr::new_type(
                             py,
-                            concat!(stringify!($module), ".", stringify!($name)),
+                            $crate::ffi::c_str!(concat!(stringify!($module), ".", stringify!($name))),
                             $doc,
-                            ::std::option::Option::Some(&py.get_type::<$base>().as_borrowed()),
+                            ::std::option::Option::Some(&py.get_type::<$base>()),
                             ::std::option::Option::None,
                         ).expect("Failed to initialize new exception type.")
                 ).as_ptr() as *mut $crate::ffi::PyTypeObject
@@ -262,11 +234,13 @@ macro_rules! create_exception_type_object {
 macro_rules! impl_native_exception (
     ($name:ident, $exc_name:ident, $doc:expr, $layout:path $(, #checkfunction=$checkfunction:path)?) => (
         #[doc = $doc]
+        #[repr(transparent)]
         #[allow(clippy::upper_case_acronyms)]
         pub struct $name($crate::PyAny);
 
         $crate::impl_exception_boilerplate!($name);
         $crate::pyobject_native_type!($name, $layout, |_py| unsafe { $crate::ffi::$exc_name as *mut $crate::ffi::PyTypeObject } $(, #checkfunction=$checkfunction)?);
+        $crate::pyobject_subclassable_native_type!($name, $layout);
     );
     ($name:ident, $exc_name:ident, $doc:expr) => (
         impl_native_exception!($name, $exc_name, $doc, $crate::ffi::PyBaseExceptionObject);
@@ -278,6 +252,7 @@ macro_rules! impl_windows_native_exception (
     ($name:ident, $exc_name:ident, $doc:expr, $layout:path) => (
         #[cfg(windows)]
         #[doc = $doc]
+        #[repr(transparent)]
         #[allow(clippy::upper_case_acronyms)]
         pub struct $name($crate::PyAny);
 
@@ -316,7 +291,7 @@ fn always_throws() -> PyResult<()> {
     Err(Py", $name, "::new_err(message))
 }
 #
-# Python::with_gil(|py| {
+# Python::attach(|py| {
 #     let fun = pyo3::wrap_pyfunction!(always_throws, py).unwrap();
 #     let err = fun.call0().expect_err(\"called a function that should always return an error but the return value was Ok\");
 #     assert!(err.is_instance_of::<Py", $name, ">(py))
@@ -338,9 +313,10 @@ except ", $name, " as e:
 ```
 use pyo3::prelude::*;
 use pyo3::exceptions::Py", $name, ";
+use pyo3::ffi::c_str;
 
-Python::with_gil(|py| {
-    let result: PyResult<()> = py.run_bound(\"raise ", $name, "\", None, None);
+Python::attach(|py| {
+    let result: PyResult<()> = py.run(c_str!(\"raise ", $name, "\"), None, None);
 
     let error_type = match result {
         Ok(_) => \"Not an error\",
@@ -404,14 +380,14 @@ impl_native_exception!(
     PyExc_FloatingPointError,
     native_doc!("FloatingPointError")
 );
-#[cfg(not(PyPy))]
+#[cfg(not(any(PyPy, GraalPy)))]
 impl_native_exception!(
     PyOSError,
     PyExc_OSError,
     native_doc!("OSError"),
     ffi::PyOSErrorObject
 );
-#[cfg(PyPy)]
+#[cfg(any(PyPy, GraalPy))]
 impl_native_exception!(PyOSError, PyExc_OSError, native_doc!("OSError"));
 impl_native_exception!(PyImportError, PyExc_ImportError, native_doc!("ImportError"));
 
@@ -450,14 +426,14 @@ impl_native_exception!(
     PyExc_NotImplementedError,
     native_doc!("NotImplementedError")
 );
-#[cfg(not(PyPy))]
+#[cfg(not(any(PyPy, GraalPy)))]
 impl_native_exception!(
     PySyntaxError,
     PyExc_SyntaxError,
     native_doc!("SyntaxError"),
     ffi::PySyntaxErrorObject
 );
-#[cfg(PyPy)]
+#[cfg(any(PyPy, GraalPy))]
 impl_native_exception!(PySyntaxError, PyExc_SyntaxError, native_doc!("SyntaxError"));
 impl_native_exception!(
     PyReferenceError,
@@ -465,14 +441,14 @@ impl_native_exception!(
     native_doc!("ReferenceError")
 );
 impl_native_exception!(PySystemError, PyExc_SystemError, native_doc!("SystemError"));
-#[cfg(not(PyPy))]
+#[cfg(not(any(PyPy, GraalPy)))]
 impl_native_exception!(
     PySystemExit,
     PyExc_SystemExit,
     native_doc!("SystemExit"),
     ffi::PySystemExitObject
 );
-#[cfg(PyPy)]
+#[cfg(any(PyPy, GraalPy))]
 impl_native_exception!(PySystemExit, PyExc_SystemExit, native_doc!("SystemExit"));
 impl_native_exception!(PyTypeError, PyExc_TypeError, native_doc!("TypeError"));
 impl_native_exception!(
@@ -480,14 +456,14 @@ impl_native_exception!(
     PyExc_UnboundLocalError,
     native_doc!("UnboundLocalError")
 );
-#[cfg(not(PyPy))]
+#[cfg(not(any(PyPy, GraalPy)))]
 impl_native_exception!(
     PyUnicodeError,
     PyExc_UnicodeError,
     native_doc!("UnicodeError"),
     ffi::PyUnicodeErrorObject
 );
-#[cfg(PyPy)]
+#[cfg(any(PyPy, GraalPy))]
 impl_native_exception!(
     PyUnicodeError,
     PyExc_UnicodeError,
@@ -614,23 +590,27 @@ impl_windows_native_exception!(
 
 impl PyUnicodeDecodeError {
     /// Creates a Python `UnicodeDecodeError`.
-    pub fn new<'p>(
-        py: Python<'p>,
+    pub fn new<'py>(
+        py: Python<'py>,
         encoding: &CStr,
         input: &[u8],
         range: ops::Range<usize>,
         reason: &CStr,
-    ) -> PyResult<&'p PyUnicodeDecodeError> {
+    ) -> PyResult<Bound<'py, PyUnicodeDecodeError>> {
+        use crate::ffi_ptr_ext::FfiPtrExt;
+        use crate::py_result_ext::PyResultExt;
         unsafe {
-            py.from_owned_ptr_or_err(ffi::PyUnicodeDecodeError_Create(
+            ffi::PyUnicodeDecodeError_Create(
                 encoding.as_ptr(),
-                input.as_ptr() as *const c_char,
+                input.as_ptr().cast(),
                 input.len() as ffi::Py_ssize_t,
                 range.start as ffi::Py_ssize_t,
                 range.end as ffi::Py_ssize_t,
                 reason.as_ptr(),
-            ))
+            )
+            .assume_owned_or_err(py)
         }
+        .cast_into()
     }
 
     /// Creates a Python `UnicodeDecodeError` from a Rust UTF-8 decoding error.
@@ -638,13 +618,13 @@ impl PyUnicodeDecodeError {
     /// # Examples
     ///
     /// ```
-    /// #![cfg_attr(invalid_from_utf8_lint, allow(invalid_from_utf8))]
     /// use pyo3::prelude::*;
     /// use pyo3::exceptions::PyUnicodeDecodeError;
     ///
     /// # fn main() -> PyResult<()> {
-    /// Python::with_gil(|py| {
+    /// Python::attach(|py| {
     ///     let invalid_utf8 = b"fo\xd8o";
+    /// #   #[allow(invalid_from_utf8)]
     ///     let err = std::str::from_utf8(invalid_utf8).expect_err("should be invalid utf8");
     ///     let decode_err = PyUnicodeDecodeError::new_utf8(py, invalid_utf8, err)?;
     ///     assert_eq!(
@@ -654,19 +634,13 @@ impl PyUnicodeDecodeError {
     ///     Ok(())
     /// })
     /// # }
-    pub fn new_utf8<'p>(
-        py: Python<'p>,
+    pub fn new_utf8<'py>(
+        py: Python<'py>,
         input: &[u8],
         err: std::str::Utf8Error,
-    ) -> PyResult<&'p PyUnicodeDecodeError> {
+    ) -> PyResult<Bound<'py, PyUnicodeDecodeError>> {
         let pos = err.valid_up_to();
-        PyUnicodeDecodeError::new(
-            py,
-            CStr::from_bytes_with_nul(b"utf-8\0").unwrap(),
-            input,
-            pos..(pos + 1),
-            CStr::from_bytes_with_nul(b"invalid utf-8\0").unwrap(),
-        )
+        PyUnicodeDecodeError::new(py, c"utf-8", input, pos..(pos + 1), c"invalid utf-8")
     }
 }
 
@@ -733,8 +707,7 @@ macro_rules! test_exception {
         fn $exc_ty () {
             use super::$exc_ty;
 
-            $crate::Python::with_gil(|py| {
-                use std::error::Error;
+            $crate::Python::attach(|py| {
                 let err: $crate::PyErr = {
                     None
                     $(
@@ -745,13 +718,9 @@ macro_rules! test_exception {
 
                 assert!(err.is_instance_of::<$exc_ty>(py));
 
-                let value: &$exc_ty = err.value(py).downcast().unwrap();
-                assert!(value.source().is_none());
+                let value = err.value(py).as_any().cast::<$exc_ty>().unwrap();
 
-                err.set_cause(py, Some($crate::exceptions::PyValueError::new_err("a cause")));
-                assert!(value.source().is_some());
-
-                assert!($crate::PyErr::from(value).is_instance_of::<$exc_ty>(py));
+                assert!($crate::PyErr::from(value.clone()).is_instance_of::<$exc_ty>(py));
             })
         }
     };
@@ -804,21 +773,21 @@ mod tests {
     use super::*;
     use crate::types::any::PyAnyMethods;
     use crate::types::{IntoPyDict, PyDict};
-    use crate::{PyErr, PyNativeType, Python};
+    use crate::PyErr;
 
     import_exception!(socket, gaierror);
     import_exception!(email.errors, MessageError);
 
     #[test]
     fn test_check_exception() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let err: PyErr = gaierror::new_err(());
             let socket = py
-                .import_bound("socket")
+                .import("socket")
                 .map_err(|e| e.display(py))
                 .expect("could not import socket");
 
-            let d = PyDict::new_bound(py);
+            let d = PyDict::new(py);
             d.set_item("socket", socket)
                 .map_err(|e| e.display(py))
                 .expect("could not setitem");
@@ -827,7 +796,7 @@ mod tests {
                 .map_err(|e| e.display(py))
                 .expect("could not setitem");
 
-            py.run_bound("assert isinstance(exc, socket.gaierror)", None, Some(&d))
+            py.run(c"assert isinstance(exc, socket.gaierror)", None, Some(&d))
                 .map_err(|e| e.display(py))
                 .expect("assertion failed");
         });
@@ -835,14 +804,14 @@ mod tests {
 
     #[test]
     fn test_check_exception_nested() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let err: PyErr = MessageError::new_err(());
             let email = py
-                .import_bound("email")
+                .import("email")
                 .map_err(|e| e.display(py))
                 .expect("could not import email");
 
-            let d = PyDict::new_bound(py);
+            let d = PyDict::new(py);
             d.set_item("email", email)
                 .map_err(|e| e.display(py))
                 .expect("could not setitem");
@@ -850,8 +819,8 @@ mod tests {
                 .map_err(|e| e.display(py))
                 .expect("could not setitem");
 
-            py.run_bound(
-                "assert isinstance(exc, email.errors.MessageError)",
+            py.run(
+                c"assert isinstance(exc, email.errors.MessageError)",
                 None,
                 Some(&d),
             )
@@ -864,22 +833,22 @@ mod tests {
     fn custom_exception() {
         create_exception!(mymodule, CustomError, PyException);
 
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let error_type = py.get_type::<CustomError>();
-            let ctx = [("CustomError", error_type)].into_py_dict_bound(py);
+            let ctx = [("CustomError", error_type)].into_py_dict(py).unwrap();
             let type_description: String = py
-                .eval_bound("str(CustomError)", None, Some(&ctx))
+                .eval(c"str(CustomError)", None, Some(&ctx))
                 .unwrap()
                 .extract()
                 .unwrap();
             assert_eq!(type_description, "<class 'mymodule.CustomError'>");
-            py.run_bound(
-                "assert CustomError('oops').args == ('oops',)",
+            py.run(
+                c"assert CustomError('oops').args == ('oops',)",
                 None,
                 Some(&ctx),
             )
             .unwrap();
-            py.run_bound("assert CustomError.__doc__ is None", None, Some(&ctx))
+            py.run(c"assert CustomError.__doc__ is None", None, Some(&ctx))
                 .unwrap();
         });
     }
@@ -887,11 +856,11 @@ mod tests {
     #[test]
     fn custom_exception_dotted_module() {
         create_exception!(mymodule.exceptions, CustomError, PyException);
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let error_type = py.get_type::<CustomError>();
-            let ctx = [("CustomError", error_type)].into_py_dict_bound(py);
+            let ctx = [("CustomError", error_type)].into_py_dict(py).unwrap();
             let type_description: String = py
-                .eval_bound("str(CustomError)", None, Some(&ctx))
+                .eval(c"str(CustomError)", None, Some(&ctx))
                 .unwrap()
                 .extract()
                 .unwrap();
@@ -906,23 +875,23 @@ mod tests {
     fn custom_exception_doc() {
         create_exception!(mymodule, CustomError, PyException, "Some docs");
 
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let error_type = py.get_type::<CustomError>();
-            let ctx = [("CustomError", error_type)].into_py_dict_bound(py);
+            let ctx = [("CustomError", error_type)].into_py_dict(py).unwrap();
             let type_description: String = py
-                .eval_bound("str(CustomError)", None, Some(&ctx))
+                .eval(c"str(CustomError)", None, Some(&ctx))
                 .unwrap()
                 .extract()
                 .unwrap();
             assert_eq!(type_description, "<class 'mymodule.CustomError'>");
-            py.run_bound(
-                "assert CustomError('oops').args == ('oops',)",
+            py.run(
+                c"assert CustomError('oops').args == ('oops',)",
                 None,
                 Some(&ctx),
             )
             .unwrap();
-            py.run_bound(
-                "assert CustomError.__doc__ == 'Some docs'",
+            py.run(
+                c"assert CustomError.__doc__ == 'Some docs'",
                 None,
                 Some(&ctx),
             )
@@ -939,23 +908,23 @@ mod tests {
             concat!("Some", " more ", stringify!(docs))
         );
 
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let error_type = py.get_type::<CustomError>();
-            let ctx = [("CustomError", error_type)].into_py_dict_bound(py);
+            let ctx = [("CustomError", error_type)].into_py_dict(py).unwrap();
             let type_description: String = py
-                .eval_bound("str(CustomError)", None, Some(&ctx))
+                .eval(c"str(CustomError)", None, Some(&ctx))
                 .unwrap()
                 .extract()
                 .unwrap();
             assert_eq!(type_description, "<class 'mymodule.CustomError'>");
-            py.run_bound(
-                "assert CustomError('oops').args == ('oops',)",
+            py.run(
+                c"assert CustomError('oops').args == ('oops',)",
                 None,
                 Some(&ctx),
             )
             .unwrap();
-            py.run_bound(
-                "assert CustomError.__doc__ == 'Some more docs'",
+            py.run(
+                c"assert CustomError.__doc__ == 'Some more docs'",
                 None,
                 Some(&ctx),
             )
@@ -965,14 +934,14 @@ mod tests {
 
     #[test]
     fn native_exception_debug() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let exc = py
-                .run_bound("raise Exception('banana')", None, None)
+                .run(c"raise Exception('banana')", None, None)
                 .expect_err("raising should have given us an error")
                 .into_value(py)
-                .into_ref(py);
+                .into_bound(py);
             assert_eq!(
-                format!("{:?}", exc),
+                format!("{exc:?}"),
                 exc.repr().unwrap().extract::<String>().unwrap()
             );
         });
@@ -980,12 +949,12 @@ mod tests {
 
     #[test]
     fn native_exception_display() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let exc = py
-                .run_bound("raise Exception('banana')", None, None)
+                .run(c"raise Exception('banana')", None, None)
                 .expect_err("raising should have given us an error")
                 .into_value(py)
-                .into_ref(py);
+                .into_bound(py);
             assert_eq!(
                 exc.to_string(),
                 exc.str().unwrap().extract::<String>().unwrap()
@@ -993,41 +962,15 @@ mod tests {
         });
     }
 
-    #[test]
-    fn native_exception_chain() {
-        use std::error::Error;
-
-        Python::with_gil(|py| {
-            let exc = py
-                .run_bound(
-                    "raise Exception('banana') from TypeError('peach')",
-                    None,
-                    None,
-                )
-                .expect_err("raising should have given us an error")
-                .into_value(py)
-                .into_ref(py);
-
-            assert_eq!(format!("{:?}", exc), "Exception('banana')");
-
-            let source = exc.source().expect("cause should exist");
-
-            assert_eq!(format!("{:?}", source), "TypeError('peach')");
-
-            let source_source = source.source();
-            assert!(source_source.is_none(), "source_source should be None");
-        });
-    }
-
     #[test]
     fn unicode_decode_error() {
         let invalid_utf8 = b"fo\xd8o";
-        #[cfg_attr(invalid_from_utf8_lint, allow(invalid_from_utf8))]
+        #[allow(invalid_from_utf8)]
         let err = std::str::from_utf8(invalid_utf8).expect_err("should be invalid utf8");
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let decode_err = PyUnicodeDecodeError::new_utf8(py, invalid_utf8, err).unwrap();
             assert_eq!(
-                format!("{:?}", decode_err),
+                format!("{decode_err:?}"),
                 "UnicodeDecodeError('utf-8', b'fo\\xd8o', 2, 3, 'invalid utf-8')"
             );
 
@@ -1079,12 +1022,16 @@ mod tests {
     test_exception!(PyUnicodeError);
     test_exception!(PyUnicodeDecodeError, |py| {
         let invalid_utf8 = b"fo\xd8o";
-        #[cfg_attr(invalid_from_utf8_lint, allow(invalid_from_utf8))]
+        #[allow(invalid_from_utf8)]
         let err = std::str::from_utf8(invalid_utf8).expect_err("should be invalid utf8");
-        PyErr::from_value(PyUnicodeDecodeError::new_utf8(py, invalid_utf8, err).unwrap())
+        PyErr::from_value(
+            PyUnicodeDecodeError::new_utf8(py, invalid_utf8, err)
+                .unwrap()
+                .into_any(),
+        )
     });
     test_exception!(PyUnicodeEncodeError, |py| py
-        .eval_bound("chr(40960).encode('ascii')", None, None)
+        .eval(c"chr(40960).encode('ascii')", None, None)
         .unwrap_err());
     test_exception!(PyUnicodeTranslateError, |_| {
         PyUnicodeTranslateError::new_err(("\u{3042}", 0, 1, "ouch"))
diff --git a/src/ffi/mod.rs b/src/ffi/mod.rs
index ce108223fbe..53cb2695b8c 100644
--- a/src/ffi/mod.rs
+++ b/src/ffi/mod.rs
@@ -13,11 +13,10 @@
 //! The functions in this module lack individual safety documentation, but
 //! generally the following apply:
 //! - Pointer arguments have to point to a valid Python object of the correct type,
-//! although null pointers are sometimes valid input.
+//!   although null pointers are sometimes valid input.
 //! - The vast majority can only be used safely while the GIL is held.
 //! - Some functions have additional safety requirements, consult the
-//! [Python/C API Reference Manual][capi]
-//! for more information.
+//!   [Python/C API Reference Manual][capi] for more information.
 //!
 //! [capi]: https://docs.python.org/3/c-api/index.html
 
diff --git a/src/ffi/tests.rs b/src/ffi/tests.rs
index 610edb1c92c..de6bf0d86bf 100644
--- a/src/ffi/tests.rs
+++ b/src/ffi/tests.rs
@@ -2,28 +2,29 @@ use crate::ffi::*;
 use crate::types::any::PyAnyMethods;
 use crate::Python;
 
+#[cfg(all(not(Py_LIMITED_API), any(not(any(PyPy, GraalPy)), feature = "macros")))]
+use crate::types::PyString;
+
 #[cfg(not(Py_LIMITED_API))]
-use crate::{
-    types::{PyDict, PyString},
-    IntoPy, Py, PyAny,
-};
-#[cfg(not(any(Py_3_12, Py_LIMITED_API)))]
+use crate::{types::PyDict, Bound, PyAny};
+#[cfg(not(any(Py_3_12, Py_LIMITED_API, GraalPy)))]
 use libc::wchar_t;
 
 #[cfg(not(Py_LIMITED_API))]
 #[cfg_attr(target_arch = "wasm32", ignore)] // DateTime import fails on wasm for mysterious reasons
 #[test]
 fn test_datetime_fromtimestamp() {
-    Python::with_gil(|py| {
-        let args: Py<PyAny> = (100,).into_py(py);
-        let dt: &PyAny = unsafe {
+    use crate::IntoPyObject;
+    Python::attach(|py| {
+        let args = (100,).into_pyobject(py).unwrap();
+        let dt = unsafe {
             PyDateTime_IMPORT();
-            py.from_owned_ptr(PyDateTime_FromTimestamp(args.as_ptr()))
+            Bound::from_owned_ptr(py, PyDateTime_FromTimestamp(args.as_ptr()))
         };
-        let locals = PyDict::new_bound(py);
+        let locals = PyDict::new(py);
         locals.set_item("dt", dt).unwrap();
-        py.run_bound(
-            "import datetime; assert dt == datetime.datetime.fromtimestamp(100)",
+        py.run(
+            c"import datetime; assert dt == datetime.datetime.fromtimestamp(100)",
             None,
             Some(&locals),
         )
@@ -35,16 +36,17 @@ fn test_datetime_fromtimestamp() {
 #[cfg_attr(target_arch = "wasm32", ignore)] // DateTime import fails on wasm for mysterious reasons
 #[test]
 fn test_date_fromtimestamp() {
-    Python::with_gil(|py| {
-        let args: Py<PyAny> = (100,).into_py(py);
-        let dt: &PyAny = unsafe {
+    use crate::IntoPyObject;
+    Python::attach(|py| {
+        let args = (100,).into_pyobject(py).unwrap();
+        let dt = unsafe {
             PyDateTime_IMPORT();
-            py.from_owned_ptr(PyDate_FromTimestamp(args.as_ptr()))
+            Bound::from_owned_ptr(py, PyDate_FromTimestamp(args.as_ptr()))
         };
-        let locals = PyDict::new_bound(py);
+        let locals = PyDict::new(py);
         locals.set_item("dt", dt).unwrap();
-        py.run_bound(
-            "import datetime; assert dt == datetime.date.fromtimestamp(100)",
+        py.run(
+            c"import datetime; assert dt == datetime.date.fromtimestamp(100)",
             None,
             Some(&locals),
         )
@@ -56,15 +58,15 @@ fn test_date_fromtimestamp() {
 #[cfg_attr(target_arch = "wasm32", ignore)] // DateTime import fails on wasm for mysterious reasons
 #[test]
 fn test_utc_timezone() {
-    Python::with_gil(|py| {
-        let utc_timezone: &PyAny = unsafe {
+    Python::attach(|py| {
+        let utc_timezone: Bound<'_, PyAny> = unsafe {
             PyDateTime_IMPORT();
-            py.from_borrowed_ptr(PyDateTime_TimeZone_UTC())
+            Bound::from_borrowed_ptr(py, PyDateTime_TimeZone_UTC())
         };
-        let locals = PyDict::new_bound(py);
+        let locals = PyDict::new(py);
         locals.set_item("utc_timezone", utc_timezone).unwrap();
-        py.run_bound(
-            "import datetime; assert utc_timezone is datetime.timezone.utc",
+        py.run(
+            c"import datetime; assert utc_timezone is datetime.timezone.utc",
             None,
             Some(&locals),
         )
@@ -79,8 +81,8 @@ fn test_utc_timezone() {
 fn test_timezone_from_offset() {
     use crate::{ffi_ptr_ext::FfiPtrExt, types::PyDelta};
 
-    Python::with_gil(|py| {
-        let delta = PyDelta::new_bound(py, 0, 100, 0, false).unwrap();
+    Python::attach(|py| {
+        let delta = PyDelta::new(py, 0, 100, 0, false).unwrap();
         let tz = unsafe { PyTimeZone_FromOffset(delta.as_ptr()).assume_owned(py) };
         crate::py_run!(
             py,
@@ -97,9 +99,9 @@ fn test_timezone_from_offset() {
 fn test_timezone_from_offset_and_name() {
     use crate::{ffi_ptr_ext::FfiPtrExt, types::PyDelta};
 
-    Python::with_gil(|py| {
-        let delta = PyDelta::new_bound(py, 0, 100, 0, false).unwrap();
-        let tzname = PyString::new_bound(py, "testtz");
+    Python::attach(|py| {
+        let delta = PyDelta::new(py, 0, 100, 0, false).unwrap();
+        let tzname = PyString::new(py, "testtz");
         let tz = unsafe {
             PyTimeZone_FromOffsetAndName(delta.as_ptr(), tzname.as_ptr()).assume_owned(py)
         };
@@ -112,20 +114,22 @@ fn test_timezone_from_offset_and_name() {
 }
 
 #[test]
-#[cfg(not(Py_LIMITED_API))]
+#[cfg(not(any(Py_LIMITED_API, GraalPy)))]
 fn ascii_object_bitfield() {
     let ob_base: PyObject = unsafe { std::mem::zeroed() };
 
+    #[cfg_attr(Py_3_14, allow(unused_mut, unused_variables))]
     let mut o = PyASCIIObject {
         ob_base,
         length: 0,
-        #[cfg(not(PyPy))]
+        #[cfg(any(Py_3_11, not(PyPy)))]
         hash: 0,
         state: 0u32,
         #[cfg(not(Py_3_12))]
         wstr: std::ptr::null_mut() as *mut wchar_t,
     };
 
+    #[cfg(not(Py_3_14))]
     unsafe {
         assert_eq!(o.interned(), 0);
         assert_eq!(o.kind(), 0);
@@ -156,37 +160,45 @@ fn ascii_object_bitfield() {
         o.set_ready(1);
         #[cfg(not(Py_3_12))]
         assert_eq!(o.ready(), 1);
+
+        #[cfg(Py_3_12)]
+        o.set_statically_allocated(1);
+        #[cfg(Py_3_12)]
+        assert_eq!(o.statically_allocated(), 1);
     }
 }
 
 #[test]
-#[cfg(not(Py_LIMITED_API))]
-#[cfg_attr(Py_3_10, allow(deprecated))]
+#[cfg(not(any(Py_LIMITED_API, PyPy, GraalPy)))]
 fn ascii() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         // This test relies on implementation details of PyString.
-        let s = PyString::new_bound(py, "hello, world");
+        let s = PyString::new(py, "hello, world");
         let ptr = s.as_ptr();
 
         unsafe {
-            let ascii_ptr = ptr as *mut PyASCIIObject;
-            let ascii = ascii_ptr.as_ref().unwrap();
-
-            assert_eq!(ascii.interned(), 0);
-            assert_eq!(ascii.kind(), PyUnicode_1BYTE_KIND);
-            assert_eq!(ascii.compact(), 1);
-            assert_eq!(ascii.ascii(), 1);
-            #[cfg(not(Py_3_12))]
-            assert_eq!(ascii.ready(), 1);
-
-            assert_eq!(PyUnicode_IS_ASCII(ptr), 1);
-            assert_eq!(PyUnicode_IS_COMPACT(ptr), 1);
-            assert_eq!(PyUnicode_IS_COMPACT_ASCII(ptr), 1);
+            #[cfg(not(Py_3_14))]
+            {
+                let ascii_ptr = ptr as *mut PyASCIIObject;
+                let ascii = ascii_ptr.as_ref().unwrap();
+
+                assert_eq!(ascii.interned(), 0);
+                assert_eq!(ascii.kind(), PyUnicode_1BYTE_KIND);
+                assert_eq!(ascii.compact(), 1);
+                assert_eq!(ascii.ascii(), 1);
+                #[cfg(not(Py_3_12))]
+                assert_eq!(ascii.ready(), 1);
+
+                assert_eq!(PyUnicode_IS_ASCII(ptr), 1);
+                assert_eq!(PyUnicode_IS_COMPACT(ptr), 1);
+                assert_eq!(PyUnicode_IS_COMPACT_ASCII(ptr), 1);
+            }
 
             assert!(!PyUnicode_1BYTE_DATA(ptr).is_null());
             // 2 and 4 byte macros return nonsense for this string instance.
             assert_eq!(PyUnicode_KIND(ptr), PyUnicode_1BYTE_KIND);
 
+            #[cfg(not(Py_3_14))]
             assert!(!_PyUnicode_COMPACT_DATA(ptr).is_null());
             // _PyUnicode_NONCOMPACT_DATA isn't valid for compact strings.
             assert!(!PyUnicode_DATA(ptr).is_null());
@@ -202,32 +214,34 @@ fn ascii() {
 }
 
 #[test]
-#[cfg(not(Py_LIMITED_API))]
-#[cfg_attr(Py_3_10, allow(deprecated))]
+#[cfg(not(any(Py_LIMITED_API, PyPy, GraalPy)))]
 fn ucs4() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let s = "哈哈🐈";
-        let py_string = PyString::new_bound(py, s);
+        let py_string = PyString::new(py, s);
         let ptr = py_string.as_ptr();
 
         unsafe {
-            let ascii_ptr = ptr as *mut PyASCIIObject;
-            let ascii = ascii_ptr.as_ref().unwrap();
-
-            assert_eq!(ascii.interned(), 0);
-            assert_eq!(ascii.kind(), PyUnicode_4BYTE_KIND);
-            assert_eq!(ascii.compact(), 1);
-            assert_eq!(ascii.ascii(), 0);
-            #[cfg(not(Py_3_12))]
-            assert_eq!(ascii.ready(), 1);
-
-            assert_eq!(PyUnicode_IS_ASCII(ptr), 0);
-            assert_eq!(PyUnicode_IS_COMPACT(ptr), 1);
-            assert_eq!(PyUnicode_IS_COMPACT_ASCII(ptr), 0);
-
+            #[cfg(not(Py_3_14))]
+            {
+                let ascii_ptr = ptr as *mut PyASCIIObject;
+                let ascii = ascii_ptr.as_ref().unwrap();
+
+                assert_eq!(ascii.interned(), 0);
+                assert_eq!(ascii.kind(), PyUnicode_4BYTE_KIND);
+                assert_eq!(ascii.compact(), 1);
+                assert_eq!(ascii.ascii(), 0);
+                #[cfg(not(Py_3_12))]
+                assert_eq!(ascii.ready(), 1);
+
+                assert_eq!(PyUnicode_IS_ASCII(ptr), 0);
+                assert_eq!(PyUnicode_IS_COMPACT(ptr), 1);
+                assert_eq!(PyUnicode_IS_COMPACT_ASCII(ptr), 0);
+            }
             assert!(!PyUnicode_4BYTE_DATA(ptr).is_null());
             assert_eq!(PyUnicode_KIND(ptr), PyUnicode_4BYTE_KIND);
 
+            #[cfg(not(Py_3_14))]
             assert!(!_PyUnicode_COMPACT_DATA(ptr).is_null());
             // _PyUnicode_NONCOMPACT_DATA isn't valid for compact strings.
             assert!(!PyUnicode_DATA(ptr).is_null());
@@ -248,41 +262,38 @@ fn ucs4() {
 #[test]
 #[cfg(not(Py_LIMITED_API))]
 #[cfg_attr(target_arch = "wasm32", ignore)] // DateTime import fails on wasm for mysterious reasons
-#[cfg(not(PyPy))]
 fn test_get_tzinfo() {
-    use crate::types::timezone_utc_bound;
+    use crate::types::PyTzInfo;
 
-    crate::Python::with_gil(|py| {
+    crate::Python::attach(|py| {
         use crate::types::{PyDateTime, PyTime};
-        use crate::PyAny;
 
-        let utc = &timezone_utc_bound(py);
+        let utc: &Bound<'_, _> = &PyTzInfo::utc(py).unwrap();
 
-        let dt = PyDateTime::new_bound(py, 2018, 1, 1, 0, 0, 0, 0, Some(utc)).unwrap();
+        let dt = PyDateTime::new(py, 2018, 1, 1, 0, 0, 0, 0, Some(utc)).unwrap();
 
         assert!(
-            unsafe { py.from_borrowed_ptr::<PyAny>(PyDateTime_DATE_GET_TZINFO(dt.as_ptr())) }
+            unsafe { Bound::from_borrowed_ptr(py, PyDateTime_DATE_GET_TZINFO(dt.as_ptr())) }
                 .is(utc)
         );
 
-        let dt = PyDateTime::new_bound(py, 2018, 1, 1, 0, 0, 0, 0, None).unwrap();
+        let dt = PyDateTime::new(py, 2018, 1, 1, 0, 0, 0, 0, None).unwrap();
 
         assert!(
-            unsafe { py.from_borrowed_ptr::<PyAny>(PyDateTime_DATE_GET_TZINFO(dt.as_ptr())) }
+            unsafe { Bound::from_borrowed_ptr(py, PyDateTime_DATE_GET_TZINFO(dt.as_ptr())) }
                 .is_none()
         );
 
-        let t = PyTime::new_bound(py, 0, 0, 0, 0, Some(utc)).unwrap();
+        let t = PyTime::new(py, 0, 0, 0, 0, Some(utc)).unwrap();
 
         assert!(
-            unsafe { py.from_borrowed_ptr::<PyAny>(PyDateTime_TIME_GET_TZINFO(t.as_ptr())) }
-                .is(utc)
+            unsafe { Bound::from_borrowed_ptr(py, PyDateTime_TIME_GET_TZINFO(t.as_ptr())) }.is(utc)
         );
 
-        let t = PyTime::new_bound(py, 0, 0, 0, 0, None).unwrap();
+        let t = PyTime::new(py, 0, 0, 0, 0, None).unwrap();
 
         assert!(
-            unsafe { py.from_borrowed_ptr::<PyAny>(PyDateTime_TIME_GET_TZINFO(t.as_ptr())) }
+            unsafe { Bound::from_borrowed_ptr(py, PyDateTime_TIME_GET_TZINFO(t.as_ptr())) }
                 .is_none()
         );
     })
@@ -290,8 +301,8 @@ fn test_get_tzinfo() {
 
 #[test]
 fn test_inc_dec_ref() {
-    Python::with_gil(|py| {
-        let obj = py.eval_bound("object()", None, None).unwrap();
+    Python::attach(|py| {
+        let obj = py.eval(c"object()", None, None).unwrap();
 
         let ref_count = obj.get_refcnt();
         let ptr = obj.as_ptr();
@@ -309,7 +320,7 @@ fn test_inc_dec_ref() {
 #[test]
 #[cfg(Py_3_12)]
 fn test_inc_dec_ref_immortal() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let obj = py.None();
 
         let ref_count = obj.get_refcnt(py);
diff --git a/src/ffi_ptr_ext.rs b/src/ffi_ptr_ext.rs
index 8a45f5d70c0..108f088ea18 100644
--- a/src/ffi_ptr_ext.rs
+++ b/src/ffi_ptr_ext.rs
@@ -1,24 +1,25 @@
+use crate::sealed::Sealed;
 use crate::{
     ffi,
     instance::{Borrowed, Bound},
     PyAny, PyResult, Python,
 };
 
-mod sealed {
-    use super::*;
-
-    pub trait Sealed {}
-
-    impl Sealed for *mut ffi::PyObject {}
-}
-
-use sealed::Sealed;
-
 pub(crate) trait FfiPtrExt: Sealed {
+    /// Assumes this pointer carries a Python reference which needs to be decref'd.
+    ///
+    /// If the pointer is NULL, this function will fetch an error.
     unsafe fn assume_owned_or_err(self, py: Python<'_>) -> PyResult<Bound<'_, PyAny>>;
+
+    /// Same as `assume_owned_or_err`, but doesn't fetch an error on NULL.
     unsafe fn assume_owned_or_opt(self, py: Python<'_>) -> Option<Bound<'_, PyAny>>;
+
+    /// Same as `assume_owned_or_err`, but panics on NULL.
     unsafe fn assume_owned(self, py: Python<'_>) -> Bound<'_, PyAny>;
 
+    /// Same as `assume_owned_or_err`, but does not check for NULL.
+    unsafe fn assume_owned_unchecked(self, py: Python<'_>) -> Bound<'_, PyAny>;
+
     /// Assumes this pointer is borrowed from a parent object.
     ///
     /// Warning: the lifetime `'a` is not bounded by the function arguments; the caller is
@@ -39,17 +40,23 @@ pub(crate) trait FfiPtrExt: Sealed {
 impl FfiPtrExt for *mut ffi::PyObject {
     #[inline]
     unsafe fn assume_owned_or_err(self, py: Python<'_>) -> PyResult<Bound<'_, PyAny>> {
-        Bound::from_owned_ptr_or_err(py, self)
+        unsafe { Bound::from_owned_ptr_or_err(py, self) }
     }
 
     #[inline]
     unsafe fn assume_owned_or_opt(self, py: Python<'_>) -> Option<Bound<'_, PyAny>> {
-        Bound::from_owned_ptr_or_opt(py, self)
+        unsafe { Bound::from_owned_ptr_or_opt(py, self) }
     }
 
     #[inline]
+    #[track_caller]
     unsafe fn assume_owned(self, py: Python<'_>) -> Bound<'_, PyAny> {
-        Bound::from_owned_ptr(py, self)
+        unsafe { Bound::from_owned_ptr(py, self) }
+    }
+
+    #[inline]
+    unsafe fn assume_owned_unchecked(self, py: Python<'_>) -> Bound<'_, PyAny> {
+        unsafe { Bound::from_owned_ptr_unchecked(py, self) }
     }
 
     #[inline]
@@ -57,21 +64,22 @@ impl FfiPtrExt for *mut ffi::PyObject {
         self,
         py: Python<'_>,
     ) -> PyResult<Borrowed<'a, '_, PyAny>> {
-        Borrowed::from_ptr_or_err(py, self)
+        unsafe { Borrowed::from_ptr_or_err(py, self) }
     }
 
     #[inline]
     unsafe fn assume_borrowed_or_opt<'a>(self, py: Python<'_>) -> Option<Borrowed<'a, '_, PyAny>> {
-        Borrowed::from_ptr_or_opt(py, self)
+        unsafe { Borrowed::from_ptr_or_opt(py, self) }
     }
 
     #[inline]
+    #[track_caller]
     unsafe fn assume_borrowed<'a>(self, py: Python<'_>) -> Borrowed<'a, '_, PyAny> {
-        Borrowed::from_ptr(py, self)
+        unsafe { Borrowed::from_ptr(py, self) }
     }
 
     #[inline]
     unsafe fn assume_borrowed_unchecked<'a>(self, py: Python<'_>) -> Borrowed<'a, '_, PyAny> {
-        Borrowed::from_ptr_unchecked(py, self)
+        unsafe { Borrowed::from_ptr_unchecked(py, self) }
     }
 }
diff --git a/src/gil.rs b/src/gil.rs
deleted file mode 100644
index 08b1b3f745b..00000000000
--- a/src/gil.rs
+++ /dev/null
@@ -1,929 +0,0 @@
-//! Interaction with Python's global interpreter lock
-
-use crate::impl_::not_send::{NotSend, NOT_SEND};
-use crate::{ffi, Python};
-use parking_lot::{const_mutex, Mutex, Once};
-use std::cell::Cell;
-#[cfg(debug_assertions)]
-use std::cell::RefCell;
-#[cfg(not(debug_assertions))]
-use std::cell::UnsafeCell;
-use std::{mem, ptr::NonNull};
-
-static START: Once = Once::new();
-
-cfg_if::cfg_if! {
-    if #[cfg(thread_local_const_init)] {
-        use std::thread_local as thread_local_const_init;
-    } else {
-        macro_rules! thread_local_const_init {
-            ($($(#[$attr:meta])* static $name:ident: $ty:ty = const { $init:expr };)*) => (
-                thread_local! { $($(#[$attr])* static $name: $ty = $init;)* }
-            )
-        }
-    }
-}
-
-thread_local_const_init! {
-    /// This is an internal counter in pyo3 monitoring whether this thread has the GIL.
-    ///
-    /// It will be incremented whenever a GILGuard or GILPool is created, and decremented whenever
-    /// they are dropped.
-    ///
-    /// As a result, if this thread has the GIL, GIL_COUNT is greater than zero.
-    ///
-    /// Additionally, we sometimes need to prevent safe access to the GIL,
-    /// e.g. when implementing `__traverse__`, which is represented by a negative value.
-    static GIL_COUNT: Cell<isize> = const { Cell::new(0) };
-
-    /// Temporarily hold objects that will be released when the GILPool drops.
-    #[cfg(debug_assertions)]
-    static OWNED_OBJECTS: RefCell<PyObjVec> = const { RefCell::new(Vec::new()) };
-    #[cfg(not(debug_assertions))]
-    static OWNED_OBJECTS: UnsafeCell<PyObjVec> = const { UnsafeCell::new(Vec::new()) };
-}
-
-const GIL_LOCKED_DURING_TRAVERSE: isize = -1;
-
-/// Checks whether the GIL is acquired.
-///
-/// Note: This uses pyo3's internal count rather than PyGILState_Check for two reasons:
-///  1) for performance
-///  2) PyGILState_Check always returns 1 if the sub-interpreter APIs have ever been called,
-///     which could lead to incorrect conclusions that the GIL is held.
-#[inline(always)]
-fn gil_is_acquired() -> bool {
-    GIL_COUNT.try_with(|c| c.get() > 0).unwrap_or(false)
-}
-
-/// Prepares the use of Python in a free-threaded context.
-///
-/// If the Python interpreter is not already initialized, this function will initialize it with
-/// signal handling disabled (Python will not raise the `KeyboardInterrupt` exception). Python
-/// signal handling depends on the notion of a 'main thread', which must be the thread that
-/// initializes the Python interpreter.
-///
-/// If the Python interpreter is already initialized, this function has no effect.
-///
-/// This function is unavailable under PyPy because PyPy cannot be embedded in Rust (or any other
-/// software). Support for this is tracked on the
-/// [PyPy issue tracker](https://foss.heptapod.net/pypy/pypy/-/issues/3286).
-///
-/// # Examples
-/// ```rust
-/// use pyo3::prelude::*;
-///
-/// # fn main() -> PyResult<()> {
-/// pyo3::prepare_freethreaded_python();
-/// Python::with_gil(|py| py.run_bound("print('Hello World')", None, None))
-/// # }
-/// ```
-#[cfg(not(PyPy))]
-pub fn prepare_freethreaded_python() {
-    // Protect against race conditions when Python is not yet initialized and multiple threads
-    // concurrently call 'prepare_freethreaded_python()'. Note that we do not protect against
-    // concurrent initialization of the Python runtime by other users of the Python C API.
-    START.call_once_force(|_| unsafe {
-        // Use call_once_force because if initialization panics, it's okay to try again.
-        if ffi::Py_IsInitialized() == 0 {
-            ffi::Py_InitializeEx(0);
-
-            // Release the GIL.
-            ffi::PyEval_SaveThread();
-        }
-    });
-}
-
-/// Executes the provided closure with an embedded Python interpreter.
-///
-/// This function initializes the Python interpreter, executes the provided closure, and then
-/// finalizes the Python interpreter.
-///
-/// After execution all Python resources are cleaned up, and no further Python APIs can be called.
-/// Because many Python modules implemented in C do not support multiple Python interpreters in a
-/// single process, it is not safe to call this function more than once. (Many such modules will not
-/// initialize correctly on the second run.)
-///
-/// # Panics
-/// - If the Python interpreter is already initialized before calling this function.
-///
-/// # Safety
-/// - This function should only ever be called once per process (usually as part of the `main`
-///   function). It is also not thread-safe.
-/// - No Python APIs can be used after this function has finished executing.
-/// - The return value of the closure must not contain any Python value, _including_ `PyResult`.
-///
-/// # Examples
-///
-/// ```rust
-/// unsafe {
-///     pyo3::with_embedded_python_interpreter(|py| {
-///         if let Err(e) = py.run_bound("print('Hello World')", None, None) {
-///             // We must make sure to not return a `PyErr`!
-///             e.print(py);
-///         }
-///     });
-/// }
-/// ```
-#[cfg(not(PyPy))]
-pub unsafe fn with_embedded_python_interpreter<F, R>(f: F) -> R
-where
-    F: for<'p> FnOnce(Python<'p>) -> R,
-{
-    assert_eq!(
-        ffi::Py_IsInitialized(),
-        0,
-        "called `with_embedded_python_interpreter` but a Python interpreter is already running."
-    );
-
-    ffi::Py_InitializeEx(0);
-
-    // Safety: the GIL is already held because of the Py_IntializeEx call.
-    let pool = GILPool::new();
-
-    // Import the threading module - this ensures that it will associate this thread as the "main"
-    // thread, which is important to avoid an `AssertionError` at finalization.
-    pool.python().import_bound("threading").unwrap();
-
-    // Execute the closure.
-    let result = f(pool.python());
-
-    // Drop the pool before finalizing.
-    drop(pool);
-
-    // Finalize the Python interpreter.
-    ffi::Py_Finalize();
-
-    result
-}
-
-/// RAII type that represents the Global Interpreter Lock acquisition.
-pub(crate) struct GILGuard {
-    gstate: ffi::PyGILState_STATE,
-    pool: mem::ManuallyDrop<GILPool>,
-}
-
-impl GILGuard {
-    /// PyO3 internal API for acquiring the GIL. The public API is Python::with_gil.
-    ///
-    /// If the GIL was already acquired via PyO3, this returns `None`. Otherwise,
-    /// the GIL will be acquired and a new `GILPool` created.
-    pub(crate) fn acquire() -> Option<Self> {
-        if gil_is_acquired() {
-            return None;
-        }
-
-        // Maybe auto-initialize the GIL:
-        //  - If auto-initialize feature set and supported, try to initialize the interpreter.
-        //  - If the auto-initialize feature is set but unsupported, emit hard errors only when the
-        //    extension-module feature is not activated - extension modules don't care about
-        //    auto-initialize so this avoids breaking existing builds.
-        //  - Otherwise, just check the GIL is initialized.
-        cfg_if::cfg_if! {
-            if #[cfg(all(feature = "auto-initialize", not(PyPy)))] {
-                prepare_freethreaded_python();
-            } else {
-                // This is a "hack" to make running `cargo test` for PyO3 convenient (i.e. no need
-                // to specify `--features auto-initialize` manually. Tests within the crate itself
-                // all depend on the auto-initialize feature for conciseness but Cargo does not
-                // provide a mechanism to specify required features for tests.
-                #[cfg(not(PyPy))]
-                if option_env!("CARGO_PRIMARY_PACKAGE").is_some() {
-                    prepare_freethreaded_python();
-                }
-
-                START.call_once_force(|_| unsafe {
-                    // Use call_once_force because if there is a panic because the interpreter is
-                    // not initialized, it's fine for the user to initialize the interpreter and
-                    // retry.
-                    assert_ne!(
-                        ffi::Py_IsInitialized(),
-                        0,
-                        "The Python interpreter is not initialized and the `auto-initialize` \
-                         feature is not enabled.\n\n\
-                         Consider calling `pyo3::prepare_freethreaded_python()` before attempting \
-                         to use Python APIs."
-                    );
-                });
-            }
-        }
-
-        Self::acquire_unchecked()
-    }
-
-    /// Acquires the `GILGuard` without performing any state checking.
-    ///
-    /// This can be called in "unsafe" contexts where the normal interpreter state
-    /// checking performed by `GILGuard::acquire` may fail. This includes calling
-    /// as part of multi-phase interpreter initialization.
-    pub(crate) fn acquire_unchecked() -> Option<Self> {
-        if gil_is_acquired() {
-            return None;
-        }
-
-        let gstate = unsafe { ffi::PyGILState_Ensure() }; // acquire GIL
-        let pool = unsafe { mem::ManuallyDrop::new(GILPool::new()) };
-
-        Some(GILGuard { gstate, pool })
-    }
-}
-
-/// The Drop implementation for `GILGuard` will release the GIL.
-impl Drop for GILGuard {
-    fn drop(&mut self) {
-        unsafe {
-            // Drop the objects in the pool before attempting to release the thread state
-            mem::ManuallyDrop::drop(&mut self.pool);
-
-            ffi::PyGILState_Release(self.gstate);
-        }
-    }
-}
-
-// Vector of PyObject
-type PyObjVec = Vec<NonNull<ffi::PyObject>>;
-
-/// Thread-safe storage for objects which were inc_ref / dec_ref while the GIL was not held.
-struct ReferencePool {
-    // .0 is INCREFs, .1 is DECREFs
-    pointer_ops: Mutex<(PyObjVec, PyObjVec)>,
-}
-
-impl ReferencePool {
-    const fn new() -> Self {
-        Self {
-            pointer_ops: const_mutex((Vec::new(), Vec::new())),
-        }
-    }
-
-    fn register_incref(&self, obj: NonNull<ffi::PyObject>) {
-        self.pointer_ops.lock().0.push(obj);
-    }
-
-    fn register_decref(&self, obj: NonNull<ffi::PyObject>) {
-        self.pointer_ops.lock().1.push(obj);
-    }
-
-    fn update_counts(&self, _py: Python<'_>) {
-        let mut ops = self.pointer_ops.lock();
-        if ops.0.is_empty() && ops.1.is_empty() {
-            return;
-        }
-
-        let (increfs, decrefs) = mem::take(&mut *ops);
-        drop(ops);
-
-        // Always increase reference counts first - as otherwise objects which have a
-        // nonzero total reference count might be incorrectly dropped by Python during
-        // this update.
-        for ptr in increfs {
-            unsafe { ffi::Py_INCREF(ptr.as_ptr()) };
-        }
-
-        for ptr in decrefs {
-            unsafe { ffi::Py_DECREF(ptr.as_ptr()) };
-        }
-    }
-}
-
-unsafe impl Sync for ReferencePool {}
-
-static POOL: ReferencePool = ReferencePool::new();
-
-/// A guard which can be used to temporarily release the GIL and restore on `Drop`.
-pub(crate) struct SuspendGIL {
-    count: isize,
-    tstate: *mut ffi::PyThreadState,
-}
-
-impl SuspendGIL {
-    pub(crate) unsafe fn new() -> Self {
-        let count = GIL_COUNT.with(|c| c.replace(0));
-        let tstate = ffi::PyEval_SaveThread();
-
-        Self { count, tstate }
-    }
-}
-
-impl Drop for SuspendGIL {
-    fn drop(&mut self) {
-        GIL_COUNT.with(|c| c.set(self.count));
-        unsafe {
-            ffi::PyEval_RestoreThread(self.tstate);
-
-            // Update counts of PyObjects / Py that were cloned or dropped while the GIL was released.
-            POOL.update_counts(Python::assume_gil_acquired());
-        }
-    }
-}
-
-/// Used to lock safe access to the GIL
-pub(crate) struct LockGIL {
-    count: isize,
-}
-
-impl LockGIL {
-    /// Lock access to the GIL while an implementation of `__traverse__` is running
-    pub fn during_traverse() -> Self {
-        Self::new(GIL_LOCKED_DURING_TRAVERSE)
-    }
-
-    fn new(reason: isize) -> Self {
-        let count = GIL_COUNT.with(|c| c.replace(reason));
-
-        Self { count }
-    }
-
-    #[cold]
-    fn bail(current: isize) {
-        match current {
-            GIL_LOCKED_DURING_TRAVERSE => panic!(
-                "Access to the GIL is prohibited while a __traverse__ implmentation is running."
-            ),
-            _ => panic!("Access to the GIL is currently prohibited."),
-        }
-    }
-}
-
-impl Drop for LockGIL {
-    fn drop(&mut self) {
-        GIL_COUNT.with(|c| c.set(self.count));
-    }
-}
-
-/// A RAII pool which PyO3 uses to store owned Python references.
-///
-/// See the [Memory Management] chapter of the guide for more information about how PyO3 uses
-/// [`GILPool`] to manage memory.
-
-///
-/// [Memory Management]: https://pyo3.rs/main/memory.html#gil-bound-memory
-pub struct GILPool {
-    /// Initial length of owned objects and anys.
-    /// `Option` is used since TSL can be broken when `new` is called from `atexit`.
-    start: Option<usize>,
-    _not_send: NotSend,
-}
-
-impl GILPool {
-    /// Creates a new [`GILPool`]. This function should only ever be called with the GIL held.
-    ///
-    /// It is recommended not to use this API directly, but instead to use [`Python::new_pool`], as
-    /// that guarantees the GIL is held.
-    ///
-    /// # Safety
-    ///
-    /// As well as requiring the GIL, see the safety notes on [`Python::new_pool`].
-    #[inline]
-    pub unsafe fn new() -> GILPool {
-        increment_gil_count();
-        // Update counts of PyObjects / Py that have been cloned or dropped since last acquisition
-        POOL.update_counts(Python::assume_gil_acquired());
-        GILPool {
-            start: OWNED_OBJECTS
-                .try_with(|owned_objects| {
-                    #[cfg(debug_assertions)]
-                    let len = owned_objects.borrow().len();
-                    #[cfg(not(debug_assertions))]
-                    // SAFETY: This is not re-entrant.
-                    let len = unsafe { (*owned_objects.get()).len() };
-                    len
-                })
-                .ok(),
-            _not_send: NOT_SEND,
-        }
-    }
-
-    /// Gets the Python token associated with this [`GILPool`].
-    #[inline]
-    pub fn python(&self) -> Python<'_> {
-        unsafe { Python::assume_gil_acquired() }
-    }
-}
-
-impl Drop for GILPool {
-    fn drop(&mut self) {
-        if let Some(start) = self.start {
-            let owned_objects = OWNED_OBJECTS.with(|owned_objects| {
-                #[cfg(debug_assertions)]
-                let mut owned_objects = owned_objects.borrow_mut();
-                #[cfg(not(debug_assertions))]
-                // SAFETY: `OWNED_OBJECTS` is released before calling Py_DECREF,
-                // or Py_DECREF may call `GILPool::drop` recursively, resulting in invalid borrowing.
-                let owned_objects = unsafe { &mut *owned_objects.get() };
-                if start < owned_objects.len() {
-                    owned_objects.split_off(start)
-                } else {
-                    Vec::new()
-                }
-            });
-            for obj in owned_objects {
-                unsafe {
-                    ffi::Py_DECREF(obj.as_ptr());
-                }
-            }
-        }
-        decrement_gil_count();
-    }
-}
-
-/// Registers a Python object pointer inside the release pool, to have its reference count increased
-/// the next time the GIL is acquired in pyo3.
-///
-/// If the GIL is held, the reference count will be increased immediately instead of being queued
-/// for later.
-///
-/// # Safety
-/// The object must be an owned Python reference.
-pub unsafe fn register_incref(obj: NonNull<ffi::PyObject>) {
-    if gil_is_acquired() {
-        ffi::Py_INCREF(obj.as_ptr())
-    } else {
-        POOL.register_incref(obj);
-    }
-}
-
-/// Registers a Python object pointer inside the release pool, to have its reference count decreased
-/// the next time the GIL is acquired in pyo3.
-///
-/// If the GIL is held, the reference count will be decreased immediately instead of being queued
-/// for later.
-///
-/// # Safety
-/// The object must be an owned Python reference.
-pub unsafe fn register_decref(obj: NonNull<ffi::PyObject>) {
-    if gil_is_acquired() {
-        ffi::Py_DECREF(obj.as_ptr())
-    } else {
-        POOL.register_decref(obj);
-    }
-}
-
-/// Registers an owned object inside the GILPool, to be released when the GILPool drops.
-///
-/// # Safety
-/// The object must be an owned Python reference.
-pub unsafe fn register_owned(_py: Python<'_>, obj: NonNull<ffi::PyObject>) {
-    debug_assert!(gil_is_acquired());
-    // Ignores the error in case this function called from `atexit`.
-    let _ = OWNED_OBJECTS.try_with(|owned_objects| {
-        #[cfg(debug_assertions)]
-        owned_objects.borrow_mut().push(obj);
-        #[cfg(not(debug_assertions))]
-        // SAFETY: This is not re-entrant.
-        unsafe {
-            (*owned_objects.get()).push(obj);
-        }
-    });
-}
-
-/// Increments pyo3's internal GIL count - to be called whenever GILPool or GILGuard is created.
-#[inline(always)]
-fn increment_gil_count() {
-    // Ignores the error in case this function called from `atexit`.
-    let _ = GIL_COUNT.try_with(|c| {
-        let current = c.get();
-        if current < 0 {
-            LockGIL::bail(current);
-        }
-        c.set(current + 1);
-    });
-}
-
-/// Decrements pyo3's internal GIL count - to be called whenever GILPool or GILGuard is dropped.
-#[inline(always)]
-fn decrement_gil_count() {
-    // Ignores the error in case this function called from `atexit`.
-    let _ = GIL_COUNT.try_with(|c| {
-        let current = c.get();
-        debug_assert!(
-            current > 0,
-            "Negative GIL count detected. Please report this error to the PyO3 repo as a bug."
-        );
-        c.set(current - 1);
-    });
-}
-
-#[cfg(test)]
-mod tests {
-    use super::{gil_is_acquired, GILPool, GIL_COUNT, OWNED_OBJECTS, POOL};
-    use crate::types::any::PyAnyMethods;
-    use crate::{ffi, gil, PyObject, Python, ToPyObject};
-    #[cfg(not(target_arch = "wasm32"))]
-    use parking_lot::{const_mutex, Condvar, Mutex};
-    use std::ptr::NonNull;
-
-    fn get_object(py: Python<'_>) -> PyObject {
-        // Convenience function for getting a single unique object, using `new_pool` so as to leave
-        // the original pool state unchanged.
-        let pool = unsafe { py.new_pool() };
-        let py = pool.python();
-
-        let obj = py.eval_bound("object()", None, None).unwrap();
-        obj.to_object(py)
-    }
-
-    fn owned_object_count() -> usize {
-        #[cfg(debug_assertions)]
-        let len = OWNED_OBJECTS.with(|owned_objects| owned_objects.borrow().len());
-        #[cfg(not(debug_assertions))]
-        let len = OWNED_OBJECTS.with(|owned_objects| unsafe { (*owned_objects.get()).len() });
-        len
-    }
-
-    fn pool_inc_refs_does_not_contain(obj: &PyObject) -> bool {
-        !POOL
-            .pointer_ops
-            .lock()
-            .0
-            .contains(&unsafe { NonNull::new_unchecked(obj.as_ptr()) })
-    }
-
-    fn pool_dec_refs_does_not_contain(obj: &PyObject) -> bool {
-        !POOL
-            .pointer_ops
-            .lock()
-            .1
-            .contains(&unsafe { NonNull::new_unchecked(obj.as_ptr()) })
-    }
-
-    #[cfg(not(target_arch = "wasm32"))]
-    fn pool_dirty_with(
-        inc_refs: Vec<NonNull<ffi::PyObject>>,
-        dec_refs: Vec<NonNull<ffi::PyObject>>,
-    ) -> bool {
-        *POOL.pointer_ops.lock() == (inc_refs, dec_refs)
-    }
-
-    #[test]
-    fn test_owned() {
-        Python::with_gil(|py| {
-            let obj = get_object(py);
-            let obj_ptr = obj.as_ptr();
-            // Ensure that obj does not get freed
-            let _ref = obj.clone_ref(py);
-
-            unsafe {
-                {
-                    let pool = py.new_pool();
-                    gil::register_owned(pool.python(), NonNull::new_unchecked(obj.into_ptr()));
-
-                    assert_eq!(owned_object_count(), 1);
-                    assert_eq!(ffi::Py_REFCNT(obj_ptr), 2);
-                }
-                {
-                    let _pool = py.new_pool();
-                    assert_eq!(owned_object_count(), 0);
-                    assert_eq!(ffi::Py_REFCNT(obj_ptr), 1);
-                }
-            }
-        })
-    }
-
-    #[test]
-    fn test_owned_nested() {
-        Python::with_gil(|py| {
-            let obj = get_object(py);
-            // Ensure that obj does not get freed
-            let _ref = obj.clone_ref(py);
-            let obj_ptr = obj.as_ptr();
-
-            unsafe {
-                {
-                    let _pool = py.new_pool();
-                    assert_eq!(owned_object_count(), 0);
-
-                    gil::register_owned(py, NonNull::new_unchecked(obj.into_ptr()));
-
-                    assert_eq!(owned_object_count(), 1);
-                    assert_eq!(ffi::Py_REFCNT(obj_ptr), 2);
-                    {
-                        let _pool = py.new_pool();
-                        let obj = get_object(py);
-                        gil::register_owned(py, NonNull::new_unchecked(obj.into_ptr()));
-                        assert_eq!(owned_object_count(), 2);
-                    }
-                    assert_eq!(owned_object_count(), 1);
-                }
-                {
-                    assert_eq!(owned_object_count(), 0);
-                    assert_eq!(ffi::Py_REFCNT(obj_ptr), 1);
-                }
-            }
-        });
-    }
-
-    #[test]
-    fn test_pyobject_drop_with_gil_decreases_refcnt() {
-        Python::with_gil(|py| {
-            let obj = get_object(py);
-
-            // Create a reference to drop with the GIL.
-            let reference = obj.clone_ref(py);
-
-            assert_eq!(obj.get_refcnt(py), 2);
-            assert!(pool_inc_refs_does_not_contain(&obj));
-
-            // With the GIL held, reference cound will be decreased immediately.
-            drop(reference);
-
-            assert_eq!(obj.get_refcnt(py), 1);
-            assert!(pool_dec_refs_does_not_contain(&obj));
-        });
-    }
-
-    #[test]
-    #[cfg(not(target_arch = "wasm32"))] // We are building wasm Python with pthreads disabled
-    fn test_pyobject_drop_without_gil_doesnt_decrease_refcnt() {
-        let obj = Python::with_gil(|py| {
-            let obj = get_object(py);
-            // Create a reference to drop without the GIL.
-            let reference = obj.clone_ref(py);
-
-            assert_eq!(obj.get_refcnt(py), 2);
-            assert!(pool_inc_refs_does_not_contain(&obj));
-
-            // Drop reference in a separate thread which doesn't have the GIL.
-            std::thread::spawn(move || drop(reference)).join().unwrap();
-
-            // The reference count should not have changed (the GIL has always
-            // been held by this thread), it is remembered to release later.
-            assert_eq!(obj.get_refcnt(py), 2);
-            assert!(pool_dirty_with(
-                vec![],
-                vec![NonNull::new(obj.as_ptr()).unwrap()]
-            ));
-            obj
-        });
-
-        // Next time the GIL is acquired, the reference is released
-        Python::with_gil(|py| {
-            assert_eq!(obj.get_refcnt(py), 1);
-            let non_null = unsafe { NonNull::new_unchecked(obj.as_ptr()) };
-            assert!(!POOL.pointer_ops.lock().0.contains(&non_null));
-            assert!(!POOL.pointer_ops.lock().1.contains(&non_null));
-        });
-    }
-
-    #[test]
-    fn test_gil_counts() {
-        // Check with_gil and GILPool both increase counts correctly
-        let get_gil_count = || GIL_COUNT.with(|c| c.get());
-
-        assert_eq!(get_gil_count(), 0);
-        Python::with_gil(|_| {
-            assert_eq!(get_gil_count(), 1);
-
-            let pool = unsafe { GILPool::new() };
-            assert_eq!(get_gil_count(), 2);
-
-            let pool2 = unsafe { GILPool::new() };
-            assert_eq!(get_gil_count(), 3);
-
-            drop(pool);
-            assert_eq!(get_gil_count(), 2);
-
-            Python::with_gil(|_| {
-                // nested with_gil doesn't update gil count
-                assert_eq!(get_gil_count(), 2);
-            });
-            assert_eq!(get_gil_count(), 2);
-
-            drop(pool2);
-            assert_eq!(get_gil_count(), 1);
-        });
-        assert_eq!(get_gil_count(), 0);
-    }
-
-    #[test]
-    fn test_allow_threads() {
-        assert!(!gil_is_acquired());
-
-        Python::with_gil(|py| {
-            assert!(gil_is_acquired());
-
-            py.allow_threads(move || {
-                assert!(!gil_is_acquired());
-
-                Python::with_gil(|_| assert!(gil_is_acquired()));
-
-                assert!(!gil_is_acquired());
-            });
-
-            assert!(gil_is_acquired());
-        });
-
-        assert!(!gil_is_acquired());
-    }
-
-    #[test]
-    fn test_allow_threads_updates_refcounts() {
-        Python::with_gil(|py| {
-            // Make a simple object with 1 reference
-            let obj = get_object(py);
-            assert!(obj.get_refcnt(py) == 1);
-            // Clone the object without the GIL to use internal tracking
-            let escaped_ref = py.allow_threads(|| obj.clone());
-            // But after the block the refcounts are updated
-            assert!(obj.get_refcnt(py) == 2);
-            drop(escaped_ref);
-            assert!(obj.get_refcnt(py) == 1);
-            drop(obj);
-        });
-    }
-
-    #[test]
-    fn dropping_gil_does_not_invalidate_references() {
-        // Acquiring GIL for the second time should be safe - see #864
-        Python::with_gil(|py| {
-            let obj = Python::with_gil(|_| py.eval_bound("object()", None, None).unwrap());
-
-            // After gil2 drops, obj should still have a reference count of one
-            assert_eq!(obj.get_refcnt(), 1);
-        })
-    }
-
-    #[test]
-    fn test_clone_with_gil() {
-        Python::with_gil(|py| {
-            let obj = get_object(py);
-            let count = obj.get_refcnt(py);
-
-            // Cloning with the GIL should increase reference count immediately
-            #[allow(clippy::redundant_clone)]
-            let c = obj.clone();
-            assert_eq!(count + 1, c.get_refcnt(py));
-        })
-    }
-
-    #[cfg(not(target_arch = "wasm32"))]
-    struct Event {
-        set: Mutex<bool>,
-        wait: Condvar,
-    }
-
-    #[cfg(not(target_arch = "wasm32"))]
-    impl Event {
-        const fn new() -> Self {
-            Self {
-                set: const_mutex(false),
-                wait: Condvar::new(),
-            }
-        }
-
-        fn set(&self) {
-            *self.set.lock() = true;
-            self.wait.notify_all();
-        }
-
-        fn wait(&self) {
-            let mut set = self.set.lock();
-            while !*set {
-                self.wait.wait(&mut set);
-            }
-        }
-    }
-
-    #[test]
-    #[cfg(not(target_arch = "wasm32"))] // We are building wasm Python with pthreads disabled
-    fn test_clone_without_gil() {
-        use crate::{Py, PyAny};
-        use std::{sync::Arc, thread};
-
-        // Some events for synchronizing
-        static GIL_ACQUIRED: Event = Event::new();
-        static OBJECT_CLONED: Event = Event::new();
-        static REFCNT_CHECKED: Event = Event::new();
-
-        Python::with_gil(|py| {
-            let obj: Arc<Py<PyAny>> = Arc::new(get_object(py));
-            let thread_obj = Arc::clone(&obj);
-
-            let count = obj.get_refcnt(py);
-            println!(
-                "1: The object has been created and its reference count is {}",
-                count
-            );
-
-            let handle = thread::spawn(move || {
-                Python::with_gil(move |py| {
-                    println!("3. The GIL has been acquired on another thread.");
-                    GIL_ACQUIRED.set();
-
-                    // Wait while the main thread registers obj in POOL
-                    OBJECT_CLONED.wait();
-                    println!("5. Checking refcnt");
-                    assert_eq!(thread_obj.get_refcnt(py), count);
-
-                    REFCNT_CHECKED.set();
-                })
-            });
-
-            let cloned = py.allow_threads(|| {
-                println!("2. The GIL has been released.");
-
-                // Wait until the GIL has been acquired on the thread.
-                GIL_ACQUIRED.wait();
-
-                println!("4. The other thread is now hogging the GIL, we clone without it held");
-                // Cloning without GIL should not update reference count
-                let cloned = Py::clone(&*obj);
-                OBJECT_CLONED.set();
-                cloned
-            });
-
-            REFCNT_CHECKED.wait();
-
-            println!("6. The main thread has acquired the GIL again and processed the pool.");
-
-            // Total reference count should be one higher
-            assert_eq!(obj.get_refcnt(py), count + 1);
-
-            // Clone dropped
-            drop(cloned);
-            // Ensure refcount of the arc is 1
-            handle.join().unwrap();
-
-            // Overall count is now back to the original, and should be no pending change
-            assert_eq!(Arc::try_unwrap(obj).unwrap().get_refcnt(py), count);
-        });
-    }
-
-    #[test]
-    #[cfg(not(target_arch = "wasm32"))] // We are building wasm Python with pthreads disabled
-    fn test_clone_in_other_thread() {
-        use crate::Py;
-        use std::{sync::Arc, thread};
-
-        // Some events for synchronizing
-        static OBJECT_CLONED: Event = Event::new();
-
-        let (obj, count, ptr) = Python::with_gil(|py| {
-            let obj = Arc::new(get_object(py));
-            let count = obj.get_refcnt(py);
-            let thread_obj = Arc::clone(&obj);
-
-            // Start a thread which does not have the GIL, and clone it
-            let t = thread::spawn(move || {
-                // Cloning without GIL should not update reference count
-                #[allow(clippy::redundant_clone)]
-                let _ = Py::clone(&*thread_obj);
-                OBJECT_CLONED.set();
-            });
-
-            OBJECT_CLONED.wait();
-            assert_eq!(count, obj.get_refcnt(py));
-
-            t.join().unwrap();
-            let ptr = NonNull::new(obj.as_ptr()).unwrap();
-
-            // The pointer should appear once in the incref pool, and once in the
-            // decref pool (for the clone being created and also dropped)
-            assert!(POOL.pointer_ops.lock().0.contains(&ptr));
-            assert!(POOL.pointer_ops.lock().1.contains(&ptr));
-
-            (obj, count, ptr)
-        });
-
-        Python::with_gil(|py| {
-            // Acquiring the gil clears the pool
-            assert!(!POOL.pointer_ops.lock().0.contains(&ptr));
-            assert!(!POOL.pointer_ops.lock().1.contains(&ptr));
-
-            // Overall count is still unchanged
-            assert_eq!(count, obj.get_refcnt(py));
-        });
-    }
-
-    #[test]
-    fn test_update_counts_does_not_deadlock() {
-        // update_counts can run arbitrary Python code during Py_DECREF.
-        // if the locking is implemented incorrectly, it will deadlock.
-
-        Python::with_gil(|py| {
-            let obj = get_object(py);
-
-            unsafe extern "C" fn capsule_drop(capsule: *mut ffi::PyObject) {
-                // This line will implicitly call update_counts
-                // -> and so cause deadlock if update_counts is not handling recursion correctly.
-                let pool = GILPool::new();
-
-                // Rebuild obj so that it can be dropped
-                PyObject::from_owned_ptr(
-                    pool.python(),
-                    ffi::PyCapsule_GetPointer(capsule, std::ptr::null()) as _,
-                );
-            }
-
-            let ptr = obj.into_ptr();
-
-            let capsule =
-                unsafe { ffi::PyCapsule_New(ptr as _, std::ptr::null(), Some(capsule_drop)) };
-
-            POOL.register_decref(NonNull::new(capsule).unwrap());
-
-            // Updating the counts will call decref on the capsule, which calls capsule_drop
-            POOL.update_counts(py);
-        })
-    }
-}
diff --git a/src/impl_.rs b/src/impl_.rs
index 77f9ff4ea1f..d72a084e48f 100644
--- a/src/impl_.rs
+++ b/src/impl_.rs
@@ -6,16 +6,20 @@
 //! APIs may may change at any time without documentation in the CHANGELOG and without
 //! breaking semver guarantees.
 
-#[cfg(feature = "macros")]
+pub mod callback;
+pub mod concat;
+#[cfg(feature = "experimental-async")]
 pub mod coroutine;
-pub mod deprecations;
+pub mod exceptions;
 pub mod extract_argument;
 pub mod freelist;
 pub mod frompyobject;
-pub(crate) mod not_send;
+#[cfg(feature = "experimental-inspect")]
+pub mod introspection;
 pub mod panic;
 pub mod pycell;
 pub mod pyclass;
+pub mod pyclass_init;
 pub mod pyfunction;
 pub mod pymethods;
 pub mod pymodule;
diff --git a/src/callback.rs b/src/impl_/callback.rs
similarity index 60%
rename from src/callback.rs
rename to src/impl_/callback.rs
index a56b268aa1e..7ce01560aee 100644
--- a/src/callback.rs
+++ b/src/impl_/callback.rs
@@ -3,9 +3,8 @@
 use crate::err::{PyErr, PyResult};
 use crate::exceptions::PyOverflowError;
 use crate::ffi::{self, Py_hash_t};
-use crate::{IntoPy, PyObject, Python};
-use std::isize;
-use std::os::raw::c_int;
+use crate::{BoundObject, IntoPyObject, Py, PyAny, Python};
+use std::ffi::c_int;
 
 /// A type which can be the return type of a python C-API callback
 pub trait PyCallbackOutput: Copy {
@@ -17,7 +16,7 @@ impl PyCallbackOutput for *mut ffi::PyObject {
     const ERR_VALUE: Self = std::ptr::null_mut();
 }
 
-impl PyCallbackOutput for std::os::raw::c_int {
+impl PyCallbackOutput for std::ffi::c_int {
     const ERR_VALUE: Self = -1;
 }
 
@@ -26,17 +25,17 @@ impl PyCallbackOutput for ffi::Py_ssize_t {
 }
 
 /// Convert the result of callback function into the appropriate return value.
-pub trait IntoPyCallbackOutput<Target> {
-    fn convert(self, py: Python<'_>) -> PyResult<Target>;
+pub trait IntoPyCallbackOutput<'py, Target> {
+    fn convert(self, py: Python<'py>) -> PyResult<Target>;
 }
 
-impl<T, E, U> IntoPyCallbackOutput<U> for Result<T, E>
+impl<'py, T, E, U> IntoPyCallbackOutput<'py, U> for Result<T, E>
 where
-    T: IntoPyCallbackOutput<U>,
+    T: IntoPyCallbackOutput<'py, U>,
     E: Into<PyErr>,
 {
     #[inline]
-    fn convert(self, py: Python<'_>) -> PyResult<U> {
+    fn convert(self, py: Python<'py>) -> PyResult<U> {
         match self {
             Ok(v) => v.convert(py),
             Err(e) => Err(e.into()),
@@ -44,78 +43,79 @@ where
     }
 }
 
-impl<T> IntoPyCallbackOutput<*mut ffi::PyObject> for T
+impl<'py, T> IntoPyCallbackOutput<'py, *mut ffi::PyObject> for T
 where
-    T: IntoPy<PyObject>,
+    T: IntoPyObject<'py>,
 {
     #[inline]
-    fn convert(self, py: Python<'_>) -> PyResult<*mut ffi::PyObject> {
-        Ok(self.into_py(py).into_ptr())
+    fn convert(self, py: Python<'py>) -> PyResult<*mut ffi::PyObject> {
+        self.into_pyobject(py)
+            .map(BoundObject::into_ptr)
+            .map_err(Into::into)
     }
 }
 
-impl IntoPyCallbackOutput<Self> for *mut ffi::PyObject {
+impl IntoPyCallbackOutput<'_, Self> for *mut ffi::PyObject {
     #[inline]
     fn convert(self, _: Python<'_>) -> PyResult<Self> {
         Ok(self)
     }
 }
 
-impl IntoPyCallbackOutput<std::os::raw::c_int> for () {
+impl IntoPyCallbackOutput<'_, std::ffi::c_int> for () {
     #[inline]
-    fn convert(self, _: Python<'_>) -> PyResult<std::os::raw::c_int> {
+    fn convert(self, _: Python<'_>) -> PyResult<std::ffi::c_int> {
         Ok(0)
     }
 }
 
-impl IntoPyCallbackOutput<std::os::raw::c_int> for bool {
+impl IntoPyCallbackOutput<'_, std::ffi::c_int> for bool {
     #[inline]
-    fn convert(self, _: Python<'_>) -> PyResult<std::os::raw::c_int> {
+    fn convert(self, _: Python<'_>) -> PyResult<std::ffi::c_int> {
         Ok(self as c_int)
     }
 }
 
-impl IntoPyCallbackOutput<()> for () {
+impl IntoPyCallbackOutput<'_, ()> for () {
     #[inline]
     fn convert(self, _: Python<'_>) -> PyResult<()> {
         Ok(())
     }
 }
 
-impl IntoPyCallbackOutput<ffi::Py_ssize_t> for usize {
+impl IntoPyCallbackOutput<'_, ffi::Py_ssize_t> for usize {
     #[inline]
     fn convert(self, _py: Python<'_>) -> PyResult<ffi::Py_ssize_t> {
-        if self <= (isize::MAX as usize) {
-            Ok(self as isize)
-        } else {
-            Err(PyOverflowError::new_err(()))
-        }
+        self.try_into().map_err(|_err| PyOverflowError::new_err(()))
     }
 }
 
 // Converters needed for `#[pyproto]` implementations
 
-impl IntoPyCallbackOutput<bool> for bool {
+impl IntoPyCallbackOutput<'_, bool> for bool {
     #[inline]
     fn convert(self, _: Python<'_>) -> PyResult<bool> {
         Ok(self)
     }
 }
 
-impl IntoPyCallbackOutput<usize> for usize {
+impl IntoPyCallbackOutput<'_, usize> for usize {
     #[inline]
     fn convert(self, _: Python<'_>) -> PyResult<usize> {
         Ok(self)
     }
 }
 
-impl<T> IntoPyCallbackOutput<PyObject> for T
+impl<'py, T> IntoPyCallbackOutput<'py, Py<PyAny>> for T
 where
-    T: IntoPy<PyObject>,
+    T: IntoPyObject<'py>,
 {
     #[inline]
-    fn convert(self, py: Python<'_>) -> PyResult<PyObject> {
-        Ok(self.into_py(py))
+    fn convert(self, py: Python<'py>) -> PyResult<Py<PyAny>> {
+        self.into_pyobject(py)
+            .map(BoundObject::into_any)
+            .map(BoundObject::unbind)
+            .map_err(Into::into)
     }
 }
 
@@ -146,7 +146,7 @@ wrapping_cast!(i64, Py_hash_t);
 
 pub struct HashCallbackOutput(Py_hash_t);
 
-impl IntoPyCallbackOutput<Py_hash_t> for HashCallbackOutput {
+impl IntoPyCallbackOutput<'_, Py_hash_t> for HashCallbackOutput {
     #[inline]
     fn convert(self, _py: Python<'_>) -> PyResult<Py_hash_t> {
         let hash = self.0;
@@ -158,7 +158,7 @@ impl IntoPyCallbackOutput<Py_hash_t> for HashCallbackOutput {
     }
 }
 
-impl<T> IntoPyCallbackOutput<HashCallbackOutput> for T
+impl<T> IntoPyCallbackOutput<'_, HashCallbackOutput> for T
 where
     T: WrappingCastTo<Py_hash_t>,
 {
@@ -170,9 +170,9 @@ where
 
 #[doc(hidden)]
 #[inline]
-pub fn convert<T, U>(py: Python<'_>, value: T) -> PyResult<U>
+pub fn convert<'py, T, U>(py: Python<'py>, value: T) -> PyResult<U>
 where
-    T: IntoPyCallbackOutput<U>,
+    T: IntoPyCallbackOutput<'py, U>,
 {
     value.convert(py)
 }
diff --git a/src/impl_/concat.rs b/src/impl_/concat.rs
new file mode 100644
index 00000000000..9f2c0e33c17
--- /dev/null
+++ b/src/impl_/concat.rs
@@ -0,0 +1,82 @@
+/// Calculates the total byte length of all byte pieces in the array.
+///
+/// This is a useful utility in order to determine the size needed for the constant
+/// `combine` function.
+pub const fn combined_len(pieces: &[&[u8]]) -> usize {
+    let mut len = 0;
+    let mut pieces_idx = 0;
+    while pieces_idx < pieces.len() {
+        len += pieces[pieces_idx].len();
+        pieces_idx += 1;
+    }
+    len
+}
+
+/// Combines all bytes pieces into a single byte array.
+///
+/// `out` should be a buffer at the correct size of `combined_len(pieces)`, else this will panic.
+const fn combine(pieces: &[&[u8]], mut out: &mut [u8]) {
+    let mut pieces_idx = 0;
+    while pieces_idx < pieces.len() {
+        let piece = pieces[pieces_idx];
+        slice_copy_from_slice(out, piece);
+        // using split_at_mut because range indexing not yet supported in const fn
+        out = out.split_at_mut(piece.len()).1;
+        pieces_idx += 1;
+    }
+    // should be no trailing buffer
+    assert!(out.is_empty(), "output buffer too large");
+}
+
+/// Wrapper around `combine` which has a const generic parameter, this is going to be more codegen
+/// at compile time (?)
+pub const fn combine_to_array<const LEN: usize>(pieces: &[&[u8]]) -> [u8; LEN] {
+    let mut out: [u8; LEN] = [0u8; LEN];
+    combine(pieces, &mut out);
+    out
+}
+
+/// Replacement for `slice::copy_from_slice`, which is const from 1.87
+const fn slice_copy_from_slice(out: &mut [u8], src: &[u8]) {
+    let mut i = 0;
+    while i < src.len() {
+        out[i] = src[i];
+        i += 1;
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_combined_len() {
+        let pieces: [&[u8]; 3] = [b"foo", b"bar", b"baz"];
+        assert_eq!(combined_len(&pieces), 9);
+        let empty: [&[u8]; 0] = [];
+        assert_eq!(combined_len(&empty), 0);
+    }
+
+    #[test]
+    fn test_combine_to_array() {
+        let pieces: [&[u8]; 2] = [b"foo", b"bar"];
+        let combined = combine_to_array::<6>(&pieces);
+        assert_eq!(&combined, b"foobar");
+    }
+
+    #[test]
+    #[should_panic(expected = "index out of bounds")]
+    fn test_combine_to_array_buffer_too_small() {
+        let pieces: [&[u8]; 2] = [b"foo", b"bar"];
+        // Intentionally wrong length
+        let _ = combine_to_array::<5>(&pieces);
+    }
+
+    #[test]
+    #[should_panic(expected = "output buffer too large")]
+    fn test_combine_to_array_buffer_too_big() {
+        let pieces: [&[u8]; 2] = [b"foo", b"bar"];
+        // Intentionally wrong length
+        let _ = combine_to_array::<10>(&pieces);
+    }
+}
diff --git a/src/impl_/coroutine.rs b/src/impl_/coroutine.rs
index c9ca4873c6c..ad3a19d721f 100644
--- a/src/impl_/coroutine.rs
+++ b/src/impl_/coroutine.rs
@@ -1,48 +1,42 @@
 use std::{
     future::Future,
-    mem,
     ops::{Deref, DerefMut},
 };
 
 use crate::{
     coroutine::{cancel::ThrowCallback, Coroutine},
     instance::Bound,
+    pycell::impl_::PyClassBorrowChecker,
     pyclass::boolean_struct::False,
     types::PyString,
-    IntoPy, Py, PyAny, PyCell, PyClass, PyErr, PyObject, PyResult, Python,
+    IntoPyObject, Py, PyAny, PyClass, PyErr, PyResult, Python,
 };
 
-pub fn new_coroutine<F, T, E>(
-    name: &Bound<'_, PyString>,
+pub fn new_coroutine<'py, F, T, E>(
+    name: &Bound<'py, PyString>,
     qualname_prefix: Option<&'static str>,
     throw_callback: Option<ThrowCallback>,
     future: F,
 ) -> Coroutine
 where
     F: Future<Output = Result<T, E>> + Send + 'static,
-    T: IntoPy<PyObject>,
+    T: IntoPyObject<'py>,
     E: Into<PyErr>,
 {
-    Coroutine::new(
-        Some(name.clone().into()),
-        qualname_prefix,
-        throw_callback,
-        future,
-    )
+    Coroutine::new(Some(name.clone()), qualname_prefix, throw_callback, future)
 }
 
 fn get_ptr<T: PyClass>(obj: &Py<T>) -> *mut T {
-    // SAFETY: Py<T> can be casted as *const PyCell<T>
-    unsafe { &*(obj.as_ptr() as *const PyCell<T>) }.get_ptr()
+    obj.get_class_object().get_ptr()
 }
 
 pub struct RefGuard<T: PyClass>(Py<T>);
 
 impl<T: PyClass> RefGuard<T> {
-    pub fn new(obj: &PyAny) -> PyResult<Self> {
-        let owned: Py<T> = obj.extract()?;
-        mem::forget(owned.try_borrow(obj.py())?);
-        Ok(RefGuard(owned))
+    pub fn new(obj: &Bound<'_, PyAny>) -> PyResult<Self> {
+        let bound = obj.cast::<T>()?;
+        bound.get_class_object().borrow_checker().try_borrow()?;
+        Ok(RefGuard(bound.clone().unbind()))
     }
 }
 
@@ -56,17 +50,23 @@ impl<T: PyClass> Deref for RefGuard<T> {
 
 impl<T: PyClass> Drop for RefGuard<T> {
     fn drop(&mut self) {
-        Python::with_gil(|gil| self.0.as_ref(gil).release_ref())
+        Python::attach(|py| {
+            self.0
+                .bind(py)
+                .get_class_object()
+                .borrow_checker()
+                .release_borrow()
+        })
     }
 }
 
 pub struct RefMutGuard<T: PyClass<Frozen = False>>(Py<T>);
 
 impl<T: PyClass<Frozen = False>> RefMutGuard<T> {
-    pub fn new(obj: &PyAny) -> PyResult<Self> {
-        let owned: Py<T> = obj.extract()?;
-        mem::forget(owned.try_borrow_mut(obj.py())?);
-        Ok(RefMutGuard(owned))
+    pub fn new(obj: &Bound<'_, PyAny>) -> PyResult<Self> {
+        let bound = obj.cast::<T>()?;
+        bound.get_class_object().borrow_checker().try_borrow_mut()?;
+        Ok(RefMutGuard(bound.clone().unbind()))
     }
 }
 
@@ -87,6 +87,12 @@ impl<T: PyClass<Frozen = False>> DerefMut for RefMutGuard<T> {
 
 impl<T: PyClass<Frozen = False>> Drop for RefMutGuard<T> {
     fn drop(&mut self) {
-        Python::with_gil(|gil| self.0.as_ref(gil).release_mut())
+        Python::attach(|py| {
+            self.0
+                .bind(py)
+                .get_class_object()
+                .borrow_checker()
+                .release_borrow_mut()
+        })
     }
 }
diff --git a/src/impl_/deprecations.rs b/src/impl_/deprecations.rs
deleted file mode 100644
index 6b9930ac69b..00000000000
--- a/src/impl_/deprecations.rs
+++ /dev/null
@@ -1,4 +0,0 @@
-//! Symbols used to denote deprecated usages of PyO3's proc macros.
-
-#[deprecated(since = "0.20.0", note = "use `#[new]` instead of `#[__new__]`")]
-pub const PYMETHODS_NEW_DEPRECATED_FORM: () = ();
diff --git a/src/impl_/exceptions.rs b/src/impl_/exceptions.rs
new file mode 100644
index 00000000000..546f7e2f318
--- /dev/null
+++ b/src/impl_/exceptions.rs
@@ -0,0 +1,28 @@
+use crate::{sync::PyOnceLock, types::PyType, Bound, Py, Python};
+
+pub struct ImportedExceptionTypeObject {
+    imported_value: PyOnceLock<Py<PyType>>,
+    module: &'static str,
+    name: &'static str,
+}
+
+impl ImportedExceptionTypeObject {
+    pub const fn new(module: &'static str, name: &'static str) -> Self {
+        Self {
+            imported_value: PyOnceLock::new(),
+            module,
+            name,
+        }
+    }
+
+    pub fn get<'py>(&self, py: Python<'py>) -> &Bound<'py, PyType> {
+        self.imported_value
+            .import(py, self.module, self.name)
+            .unwrap_or_else(|e| {
+                panic!(
+                    "failed to import exception {}.{}: {}",
+                    self.module, self.name, e
+                )
+            })
+    }
+}
diff --git a/src/impl_/extract_argument.rs b/src/impl_/extract_argument.rs
index ff1c2436e38..21674e7daad 100644
--- a/src/impl_/extract_argument.rs
+++ b/src/impl_/extract_argument.rs
@@ -1,11 +1,38 @@
+#[cfg(feature = "experimental-inspect")]
+use crate::inspect::TypeHint;
 use crate::{
     exceptions::PyTypeError,
     ffi,
     pyclass::boolean_struct::False,
-    types::{PyDict, PyString, PyTuple},
-    Bound, FromPyObject, PyAny, PyClass, PyErr, PyRef, PyRefMut, PyResult, PyTypeCheck, Python,
+    types::{any::PyAnyMethods, dict::PyDictMethods, tuple::PyTupleMethods, PyDict, PyTuple},
+    Borrowed, Bound, CastError, FromPyObject, PyAny, PyClass, PyClassGuard, PyClassGuardMut, PyErr,
+    PyResult, PyTypeCheck, Python,
 };
 
+/// Helper type used to keep implementation more concise.
+///
+/// (Function argument extraction borrows input arguments.)
+type PyArg<'py> = Borrowed<'py, 'py, PyAny>;
+
+/// Seals `PyFunctionArgument` so that types outside PyO3 cannot implement it.
+///
+/// The public API is `FromPyObject`.
+mod function_argument {
+    use crate::{
+        impl_::extract_argument::PyFunctionArgument, pyclass::boolean_struct::False, FromPyObject,
+        PyClass, PyTypeCheck,
+    };
+
+    pub trait Sealed<const IMPLEMENTS_FROMPYOBJECT: bool> {}
+    impl<'a, 'py, T: FromPyObject<'a, 'py>> Sealed<true> for T {}
+    impl<'py, T: PyTypeCheck + 'py> Sealed<false> for &'_ crate::Bound<'py, T> {}
+    impl<'a, 'holder, 'py, T: PyFunctionArgument<'a, 'holder, 'py, false>> Sealed<false> for Option<T> {}
+    #[cfg(all(Py_LIMITED_API, not(Py_3_10)))]
+    impl Sealed<false> for &'_ str {}
+    impl<T: PyClass> Sealed<false> for &'_ T {}
+    impl<T: PyClass<Frozen = False>> Sealed<false> for &'_ mut T {}
+}
+
 /// A trait which is used to help PyO3 macros extract function arguments.
 ///
 /// `#[pyclass]` structs need to extract as `PyRef<T>` and `PyRefMut<T>`
@@ -14,32 +41,105 @@ use crate::{
 /// will be dropped as soon as the pyfunction call ends.
 ///
 /// There exists a trivial blanket implementation for `T: FromPyObject` with `Holder = ()`.
-pub trait PyFunctionArgument<'a, 'py>: Sized + 'a {
+///
+/// The const generic arg `IMPLEMENTS_FROMPYOBJECT` allows for const generic specialization of
+/// some additional types which don't implement `FromPyObject`, such as `&T` for `#[pyclass]` types.
+/// All types should only implement this trait once; either by the `FromPyObject` blanket or one
+/// of the specialized implementations which needs a `Holder`.
+#[diagnostic::on_unimplemented(
+    message = "`{Self}` cannot be used as a Python function argument",
+    note = "implement `FromPyObject` to enable using `{Self}` as a function argument",
+    note = "`Python<'py>` is also a valid argument type to pass the Python token into `#[pyfunction]`s and `#[pymethods]`"
+)]
+pub trait PyFunctionArgument<'a, 'holder, 'py, const IMPLEMENTS_FROMPYOBJECT: bool>:
+    Sized + function_argument::Sealed<IMPLEMENTS_FROMPYOBJECT>
+{
     type Holder: FunctionArgumentHolder;
-    fn extract(obj: &'py PyAny, holder: &'a mut Self::Holder) -> PyResult<Self>;
+    type Error: Into<PyErr>;
+
+    /// Provides the type hint information for which Python types are allowed.
+    #[cfg(feature = "experimental-inspect")]
+    const INPUT_TYPE: TypeHint;
+
+    fn extract(
+        obj: &'a Bound<'py, PyAny>,
+        holder: &'holder mut Self::Holder,
+    ) -> Result<Self, Self::Error>;
 }
 
-impl<'a, 'py, T> PyFunctionArgument<'a, 'py> for T
+impl<'a, 'py, T> PyFunctionArgument<'a, '_, 'py, true> for T
 where
-    T: FromPyObject<'py> + 'a,
+    T: FromPyObject<'a, 'py>,
 {
     type Holder = ();
+    type Error = T::Error;
+
+    #[cfg(feature = "experimental-inspect")]
+    const INPUT_TYPE: TypeHint = T::INPUT_TYPE;
 
     #[inline]
-    fn extract(obj: &'py PyAny, _: &'a mut ()) -> PyResult<Self> {
+    fn extract(obj: &'a Bound<'py, PyAny>, _: &'_ mut ()) -> Result<Self, Self::Error> {
         obj.extract()
     }
 }
 
-impl<'a, 'py, T> PyFunctionArgument<'a, 'py> for &'a Bound<'py, T>
+impl<'a, 'py, T: 'py> PyFunctionArgument<'a, '_, 'py, false> for &'a Bound<'py, T>
 where
     T: PyTypeCheck,
 {
-    type Holder = Option<Bound<'py, T>>;
+    type Holder = ();
+    type Error = CastError<'a, 'py>;
+
+    #[cfg(feature = "experimental-inspect")]
+    const INPUT_TYPE: TypeHint = T::TYPE_HINT;
 
     #[inline]
-    fn extract(obj: &'py PyAny, holder: &'a mut Option<Bound<'py, T>>) -> PyResult<Self> {
-        Ok(&*holder.insert(obj.extract()?))
+    fn extract(obj: &'a Bound<'py, PyAny>, _: &'_ mut ()) -> Result<Self, Self::Error> {
+        obj.cast()
+    }
+}
+
+/// Allow `Option<T>` to be a function argument also for types which don't implement `FromPyObject`
+impl<'a, 'holder, 'py, T> PyFunctionArgument<'a, 'holder, 'py, false> for Option<T>
+where
+    T: PyFunctionArgument<'a, 'holder, 'py, false>,
+{
+    type Holder = T::Holder;
+    type Error = T::Error;
+
+    #[cfg(feature = "experimental-inspect")]
+    const INPUT_TYPE: TypeHint = TypeHint::union(&[
+        TypeHint::module_attr("typing", "Any"),
+        TypeHint::builtin("None"),
+    ]);
+
+    #[inline]
+    fn extract(
+        obj: &'a Bound<'py, PyAny>,
+        holder: &'holder mut T::Holder,
+    ) -> Result<Self, Self::Error> {
+        if obj.is_none() {
+            Ok(None)
+        } else {
+            Ok(Some(T::extract(obj, holder)?))
+        }
+    }
+}
+
+#[cfg(all(Py_LIMITED_API, not(Py_3_10)))]
+impl<'a, 'holder, 'py> PyFunctionArgument<'a, 'holder, 'py, false> for &'holder str {
+    type Holder = Option<std::borrow::Cow<'a, str>>;
+    type Error = <std::borrow::Cow<'a, str> as FromPyObject<'a, 'py>>::Error;
+
+    #[cfg(feature = "experimental-inspect")]
+    const INPUT_TYPE: TypeHint = TypeHint::builtin("str");
+
+    #[inline]
+    fn extract(
+        obj: &'a Bound<'py, PyAny>,
+        holder: &'holder mut Option<std::borrow::Cow<'a, str>>,
+    ) -> PyResult<Self> {
+        Ok(holder.insert(obj.extract()?))
     }
 }
 
@@ -57,73 +157,76 @@ impl<T> FunctionArgumentHolder for Option<T> {
     const INIT: Self = None;
 }
 
+impl<'a, 'holder, T: PyClass> PyFunctionArgument<'a, 'holder, '_, false> for &'holder T {
+    type Holder = ::std::option::Option<PyClassGuard<'a, T>>;
+    type Error = PyErr;
+
+    #[cfg(feature = "experimental-inspect")]
+    const INPUT_TYPE: TypeHint = T::TYPE_HINT;
+
+    #[inline]
+    fn extract(obj: &'a Bound<'_, PyAny>, holder: &'holder mut Self::Holder) -> PyResult<Self> {
+        extract_pyclass_ref(obj, holder)
+    }
+}
+
+impl<'a, 'holder, T: PyClass<Frozen = False>> PyFunctionArgument<'a, 'holder, '_, false>
+    for &'holder mut T
+{
+    type Holder = ::std::option::Option<PyClassGuardMut<'a, T>>;
+    type Error = PyErr;
+
+    #[cfg(feature = "experimental-inspect")]
+    const INPUT_TYPE: TypeHint = T::TYPE_HINT;
+
+    #[inline]
+    fn extract(obj: &'a Bound<'_, PyAny>, holder: &'holder mut Self::Holder) -> PyResult<Self> {
+        extract_pyclass_ref_mut(obj, holder)
+    }
+}
+
 #[inline]
-pub fn extract_pyclass_ref<'a, 'py: 'a, T: PyClass>(
-    obj: &'py PyAny,
-    holder: &'a mut Option<PyRef<'py, T>>,
-) -> PyResult<&'a T> {
-    Ok(&*holder.insert(obj.extract()?))
+pub fn extract_pyclass_ref<'a, 'holder, T: PyClass>(
+    obj: &'a Bound<'_, PyAny>,
+    holder: &'holder mut Option<PyClassGuard<'a, T>>,
+) -> PyResult<&'holder T> {
+    Ok(&*holder.insert(PyClassGuard::try_borrow(obj.cast()?.as_unbound())?))
 }
 
 #[inline]
-pub fn extract_pyclass_ref_mut<'a, 'py: 'a, T: PyClass<Frozen = False>>(
-    obj: &'py PyAny,
-    holder: &'a mut Option<PyRefMut<'py, T>>,
-) -> PyResult<&'a mut T> {
-    Ok(&mut *holder.insert(obj.extract()?))
+pub fn extract_pyclass_ref_mut<'a, 'holder, T: PyClass<Frozen = False>>(
+    obj: &'a Bound<'_, PyAny>,
+    holder: &'holder mut Option<PyClassGuardMut<'a, T>>,
+) -> PyResult<&'holder mut T> {
+    Ok(&mut *holder.insert(PyClassGuardMut::try_borrow_mut(obj.cast()?.as_unbound())?))
 }
 
 /// The standard implementation of how PyO3 extracts a `#[pyfunction]` or `#[pymethod]` function argument.
 #[doc(hidden)]
-pub fn extract_argument<'a, 'py, T>(
-    obj: &'py PyAny,
-    holder: &'a mut T::Holder,
+pub fn extract_argument<'a, 'holder, 'py, T, const IMPLEMENTS_FROMPYOBJECT: bool>(
+    obj: &'a Bound<'py, PyAny>,
+    holder: &'holder mut T::Holder,
     arg_name: &str,
 ) -> PyResult<T>
 where
-    T: PyFunctionArgument<'a, 'py>,
+    T: PyFunctionArgument<'a, 'holder, 'py, IMPLEMENTS_FROMPYOBJECT>,
 {
     match PyFunctionArgument::extract(obj, holder) {
         Ok(value) => Ok(value),
-        Err(e) => Err(argument_extraction_error(obj.py(), arg_name, e)),
-    }
-}
-
-/// Alternative to [`extract_argument`] used for `Option<T>` arguments. This is necessary because Option<&T>
-/// does not implement `PyFunctionArgument` for `T: PyClass`.
-#[doc(hidden)]
-pub fn extract_optional_argument<'a, 'py, T>(
-    obj: Option<&'py PyAny>,
-    holder: &'a mut T::Holder,
-    arg_name: &str,
-    default: fn() -> Option<T>,
-) -> PyResult<Option<T>>
-where
-    T: PyFunctionArgument<'a, 'py>,
-{
-    match obj {
-        Some(obj) => {
-            if obj.is_none() {
-                // Explicit `None` will result in None being used as the function argument
-                Ok(None)
-            } else {
-                extract_argument(obj, holder, arg_name).map(Some)
-            }
-        }
-        _ => Ok(default()),
+        Err(e) => Err(argument_extraction_error(obj.py(), arg_name, e.into())),
     }
 }
 
 /// Alternative to [`extract_argument`] used when the argument has a default value provided by an annotation.
 #[doc(hidden)]
-pub fn extract_argument_with_default<'a, 'py, T>(
-    obj: Option<&'py PyAny>,
-    holder: &'a mut T::Holder,
+pub fn extract_argument_with_default<'a, 'holder, 'py, T, const IMPLEMENTS_FROMPYOBJECT: bool>(
+    obj: Option<&'a Bound<'py, PyAny>>,
+    holder: &'holder mut T::Holder,
     arg_name: &str,
     default: fn() -> T,
 ) -> PyResult<T>
 where
-    T: PyFunctionArgument<'a, 'py>,
+    T: PyFunctionArgument<'a, 'holder, 'py, IMPLEMENTS_FROMPYOBJECT>,
 {
     match obj {
         Some(obj) => extract_argument(obj, holder, arg_name),
@@ -136,9 +239,9 @@ where
 pub fn from_py_with<'a, 'py, T>(
     obj: &'a Bound<'py, PyAny>,
     arg_name: &str,
-    extractor: impl Into<super::frompyobject::Extractor<'a, 'py, T>>,
+    extractor: fn(&'a Bound<'py, PyAny>) -> PyResult<T>,
 ) -> PyResult<T> {
-    match extractor.into().call(obj) {
+    match extractor(obj) {
         Ok(value) => Ok(value),
         Err(e) => Err(argument_extraction_error(obj.py(), arg_name, e)),
     }
@@ -149,7 +252,7 @@ pub fn from_py_with<'a, 'py, T>(
 pub fn from_py_with_with_default<'a, 'py, T>(
     obj: Option<&'a Bound<'py, PyAny>>,
     arg_name: &str,
-    extractor: impl Into<super::frompyobject::Extractor<'a, 'py, T>>,
+    extractor: fn(&'a Bound<'py, PyAny>) -> PyResult<T>,
     default: fn() -> T,
 ) -> PyResult<T> {
     match obj {
@@ -165,8 +268,7 @@ pub fn from_py_with_with_default<'a, 'py, T>(
 #[doc(hidden)]
 #[cold]
 pub fn argument_extraction_error(py: Python<'_>, arg_name: &str, error: PyErr) -> PyErr {
-    use crate::types::any::PyAnyMethods;
-    if error.get_type_bound(py).is(py.get_type::<PyTypeError>()) {
+    if error.get_type(py).is(py.get_type::<PyTypeError>()) {
         let remapped_error =
             PyTypeError::new_err(format!("argument '{}': {}", arg_name, error.value(py)));
         remapped_error.set_cause(py, error.cause(py));
@@ -183,13 +285,16 @@ pub fn argument_extraction_error(py: Python<'_>, arg_name: &str, error: PyErr) -
 /// `argument` must not be `None`
 #[doc(hidden)]
 #[inline]
-pub unsafe fn unwrap_required_argument(argument: Option<&PyAny>) -> &PyAny {
+pub unsafe fn unwrap_required_argument<'a, 'py>(
+    argument: Option<&'a Bound<'py, PyAny>>,
+) -> &'a Bound<'py, PyAny> {
     match argument {
         Some(value) => value,
         #[cfg(debug_assertions)]
         None => unreachable!("required method argument was not extracted"),
+        // SAFETY: invariant of calling this function. Enforced by the macros.
         #[cfg(not(debug_assertions))]
-        None => std::hint::unreachable_unchecked(),
+        None => unsafe { std::hint::unreachable_unchecked() },
     }
 }
 
@@ -223,14 +328,14 @@ impl FunctionDescription {
     /// - `args` must be a pointer to a C-style array of valid `ffi::PyObject` pointers, or NULL.
     /// - `kwnames` must be a pointer to a PyTuple, or NULL.
     /// - `nargs + kwnames.len()` is the total length of the `args` array.
-    #[cfg(not(Py_LIMITED_API))]
+    #[cfg(any(Py_3_10, not(Py_LIMITED_API)))]
     pub unsafe fn extract_arguments_fastcall<'py, V, K>(
         &self,
         py: Python<'py>,
         args: *const *mut ffi::PyObject,
         nargs: ffi::Py_ssize_t,
         kwnames: *mut ffi::PyObject,
-        output: &mut [Option<&'py PyAny>],
+        output: &mut [Option<PyArg<'py>>],
     ) -> PyResult<(V::Varargs, K::Varkeywords)>
     where
         V: VarargsHandler<'py>,
@@ -247,8 +352,10 @@ impl FunctionDescription {
         );
 
         // Handle positional arguments
-        // Safety: Option<&PyAny> has the same memory layout as `*mut ffi::PyObject`
-        let args: *const Option<&PyAny> = args.cast();
+        // Safety:
+        //  - Option<PyArg> has the same memory layout as `*mut ffi::PyObject`
+        //  - we both have the GIL and can borrow these input references for the `'py` lifetime.
+        let args: *const Option<PyArg<'py>> = args.cast();
         let positional_args_provided = nargs as usize;
         let remaining_positional_args = if args.is_null() {
             debug_assert_eq!(positional_args_provided, 0);
@@ -258,9 +365,10 @@ impl FunctionDescription {
             // the rest are varargs.
             let positional_args_to_consume =
                 num_positional_parameters.min(positional_args_provided);
-            let (positional_parameters, remaining) =
+            let (positional_parameters, remaining) = unsafe {
                 std::slice::from_raw_parts(args, positional_args_provided)
-                    .split_at(positional_args_to_consume);
+                    .split_at(positional_args_to_consume)
+            };
             output[..positional_args_to_consume].copy_from_slice(positional_parameters);
             remaining
         };
@@ -268,13 +376,23 @@ impl FunctionDescription {
 
         // Handle keyword arguments
         let mut varkeywords = K::Varkeywords::default();
-        if let Some(kwnames) = py.from_borrowed_ptr_or_opt::<PyTuple>(kwnames) {
-            // Safety: &PyAny has the same memory layout as `*mut ffi::PyObject`
-            let kwargs =
-                ::std::slice::from_raw_parts((args as *const &PyAny).offset(nargs), kwnames.len());
+
+        // Safety: kwnames is known to be a pointer to a tuple, or null
+        //  - we both have the GIL and can borrow this input reference for the `'py` lifetime.
+        let kwnames: Option<Borrowed<'_, '_, PyTuple>> = unsafe {
+            Borrowed::from_ptr_or_opt(py, kwnames).map(|kwnames| kwnames.cast_unchecked())
+        };
+        if let Some(kwnames) = kwnames {
+            let kwargs = unsafe {
+                ::std::slice::from_raw_parts(
+                    // Safety: PyArg has the same memory layout as `*mut ffi::PyObject`
+                    args.offset(nargs).cast::<PyArg<'py>>(),
+                    kwnames.len(),
+                )
+            };
 
             self.handle_kwargs::<K, _>(
-                kwnames.iter().zip(kwargs.iter().copied()),
+                kwnames.iter_borrowed().zip(kwargs.iter().copied()),
                 &mut varkeywords,
                 num_positional_parameters,
                 output,
@@ -306,14 +424,20 @@ impl FunctionDescription {
         py: Python<'py>,
         args: *mut ffi::PyObject,
         kwargs: *mut ffi::PyObject,
-        output: &mut [Option<&'py PyAny>],
+        output: &mut [Option<PyArg<'py>>],
     ) -> PyResult<(V::Varargs, K::Varkeywords)>
     where
         V: VarargsHandler<'py>,
         K: VarkeywordsHandler<'py>,
     {
-        let args = py.from_borrowed_ptr::<PyTuple>(args);
-        let kwargs: ::std::option::Option<&PyDict> = py.from_borrowed_ptr_or_opt(kwargs);
+        // Safety:
+        //  - `args` is known to be a tuple
+        //  - `kwargs` is known to be a dict or null
+        //  - we both have the GIL and can borrow these input references for the `'py` lifetime.
+        let args: Borrowed<'py, 'py, PyTuple> =
+            unsafe { Borrowed::from_ptr(py, args).cast_unchecked::<PyTuple>() };
+        let kwargs: Option<Borrowed<'py, 'py, PyDict>> =
+            unsafe { Borrowed::from_ptr_or_opt(py, kwargs).map(|kwargs| kwargs.cast_unchecked()) };
 
         let num_positional_parameters = self.positional_parameter_names.len();
 
@@ -325,17 +449,26 @@ impl FunctionDescription {
         );
 
         // Copy positional arguments into output
-        for (i, arg) in args.iter().take(num_positional_parameters).enumerate() {
+        for (i, arg) in args
+            .iter_borrowed()
+            .take(num_positional_parameters)
+            .enumerate()
+        {
             output[i] = Some(arg);
         }
 
         // If any arguments remain, push them to varargs (if possible) or error
-        let varargs = V::handle_varargs_tuple(args, self)?;
+        let varargs = V::handle_varargs_tuple(&args, self)?;
 
         // Handle keyword arguments
         let mut varkeywords = K::Varkeywords::default();
         if let Some(kwargs) = kwargs {
-            self.handle_kwargs::<K, _>(kwargs, &mut varkeywords, num_positional_parameters, output)?
+            self.handle_kwargs::<K, _>(
+                unsafe { kwargs.iter_borrowed() },
+                &mut varkeywords,
+                num_positional_parameters,
+                output,
+            )?
         }
 
         // Once all inputs have been processed, check that all required arguments have been provided.
@@ -352,11 +485,11 @@ impl FunctionDescription {
         kwargs: I,
         varkeywords: &mut K::Varkeywords,
         num_positional_parameters: usize,
-        output: &mut [Option<&'py PyAny>],
+        output: &mut [Option<PyArg<'py>>],
     ) -> PyResult<()>
     where
         K: VarkeywordsHandler<'py>,
-        I: IntoIterator<Item = (&'py PyAny, &'py PyAny)>,
+        I: IntoIterator<Item = (PyArg<'py>, PyArg<'py>)>,
     {
         debug_assert_eq!(
             num_positional_parameters,
@@ -368,11 +501,21 @@ impl FunctionDescription {
         );
         let mut positional_only_keyword_arguments = Vec::new();
         for (kwarg_name_py, value) in kwargs {
-            // All keyword arguments should be UTF-8 strings, but we'll check, just in case.
-            // If it isn't, then it will be handled below as a varkeyword (which may raise an
-            // error if this function doesn't accept **kwargs). Rust source is always UTF-8
-            // and so all argument names in `#[pyfunction]` signature must be UTF-8.
-            if let Ok(kwarg_name) = kwarg_name_py.downcast::<PyString>()?.to_str() {
+            // Safety: All keyword arguments should be UTF-8 strings, but if it's not, `.to_str()`
+            // will return an error anyway.
+            #[cfg(any(Py_3_10, not(Py_LIMITED_API)))]
+            let kwarg_name =
+                unsafe { kwarg_name_py.cast_unchecked::<crate::types::PyString>() }.to_str();
+
+            #[cfg(all(not(Py_3_10), Py_LIMITED_API))]
+            let kwarg_name = kwarg_name_py.extract::<crate::pybacked::PyBackedStr>();
+
+            if let Ok(kwarg_name_owned) = kwarg_name {
+                #[cfg(any(Py_3_10, not(Py_LIMITED_API)))]
+                let kwarg_name = kwarg_name_owned;
+                #[cfg(all(not(Py_3_10), Py_LIMITED_API))]
+                let kwarg_name: &str = &kwarg_name_owned;
+
                 // Try to place parameter in keyword only parameters
                 if let Some(i) = self.find_keyword_parameter_in_keyword_only(kwarg_name) {
                     if output[i + num_positional_parameters]
@@ -391,7 +534,7 @@ impl FunctionDescription {
                         // kwarg to conflict with a postional-only argument - the value
                         // will go into **kwargs anyway.
                         if K::handle_varkeyword(varkeywords, kwarg_name_py, value, self).is_err() {
-                            positional_only_keyword_arguments.push(kwarg_name);
+                            positional_only_keyword_arguments.push(kwarg_name_owned);
                         }
                     } else if output[i].replace(value).is_some() {
                         return Err(self.multiple_values_for_argument(kwarg_name));
@@ -404,6 +547,11 @@ impl FunctionDescription {
         }
 
         if !positional_only_keyword_arguments.is_empty() {
+            #[cfg(all(not(Py_3_10), Py_LIMITED_API))]
+            let positional_only_keyword_arguments: Vec<_> = positional_only_keyword_arguments
+                .iter()
+                .map(std::ops::Deref::deref)
+                .collect();
             return Err(self.positional_only_keyword_arguments(&positional_only_keyword_arguments));
         }
 
@@ -430,7 +578,7 @@ impl FunctionDescription {
     #[inline]
     fn ensure_no_missing_required_positional_arguments(
         &self,
-        output: &[Option<&PyAny>],
+        output: &[Option<PyArg<'_>>],
         positional_args_provided: usize,
     ) -> PyResult<()> {
         if positional_args_provided < self.required_positional_parameters {
@@ -446,7 +594,7 @@ impl FunctionDescription {
     #[inline]
     fn ensure_no_missing_required_keyword_arguments(
         &self,
-        output: &[Option<&PyAny>],
+        output: &[Option<PyArg<'_>>],
     ) -> PyResult<()> {
         let keyword_output = &output[self.positional_parameter_names.len()..];
         for (param, out) in self.keyword_only_parameters.iter().zip(keyword_output) {
@@ -491,11 +639,11 @@ impl FunctionDescription {
     }
 
     #[cold]
-    fn unexpected_keyword_argument(&self, argument: &PyAny) -> PyErr {
+    fn unexpected_keyword_argument(&self, argument: PyArg<'_>) -> PyErr {
         PyTypeError::new_err(format!(
             "{} got an unexpected keyword argument '{}'",
             self.full_name(),
-            argument
+            argument.as_any()
         ))
     }
 
@@ -528,7 +676,7 @@ impl FunctionDescription {
     }
 
     #[cold]
-    fn missing_required_keyword_arguments(&self, keyword_outputs: &[Option<&PyAny>]) -> PyErr {
+    fn missing_required_keyword_arguments(&self, keyword_outputs: &[Option<PyArg<'_>>]) -> PyErr {
         debug_assert_eq!(self.keyword_only_parameters.len(), keyword_outputs.len());
 
         let missing_keyword_only_arguments: Vec<_> = self
@@ -549,7 +697,7 @@ impl FunctionDescription {
     }
 
     #[cold]
-    fn missing_required_positional_arguments(&self, output: &[Option<&PyAny>]) -> PyErr {
+    fn missing_required_positional_arguments(&self, output: &[Option<PyArg<'_>>]) -> PyErr {
         let missing_positional_arguments: Vec<_> = self
             .positional_parameter_names
             .iter()
@@ -569,14 +717,14 @@ pub trait VarargsHandler<'py> {
     /// Called by `FunctionDescription::extract_arguments_fastcall` with any additional arguments.
     fn handle_varargs_fastcall(
         py: Python<'py>,
-        varargs: &[Option<&PyAny>],
+        varargs: &[Option<PyArg<'py>>],
         function_description: &FunctionDescription,
     ) -> PyResult<Self::Varargs>;
     /// Called by `FunctionDescription::extract_arguments_tuple_dict` with the original tuple.
     ///
     /// Additional arguments are those in the tuple slice starting from `function_description.positional_parameter_names.len()`.
     fn handle_varargs_tuple(
-        args: &'py PyTuple,
+        args: &Bound<'py, PyTuple>,
         function_description: &FunctionDescription,
     ) -> PyResult<Self::Varargs>;
 }
@@ -590,7 +738,7 @@ impl<'py> VarargsHandler<'py> for NoVarargs {
     #[inline]
     fn handle_varargs_fastcall(
         _py: Python<'py>,
-        varargs: &[Option<&PyAny>],
+        varargs: &[Option<PyArg<'py>>],
         function_description: &FunctionDescription,
     ) -> PyResult<Self::Varargs> {
         let extra_arguments = varargs.len();
@@ -604,7 +752,7 @@ impl<'py> VarargsHandler<'py> for NoVarargs {
 
     #[inline]
     fn handle_varargs_tuple(
-        args: &'py PyTuple,
+        args: &Bound<'py, PyTuple>,
         function_description: &FunctionDescription,
     ) -> PyResult<Self::Varargs> {
         let positional_parameter_count = function_description.positional_parameter_names.len();
@@ -621,19 +769,19 @@ impl<'py> VarargsHandler<'py> for NoVarargs {
 pub struct TupleVarargs;
 
 impl<'py> VarargsHandler<'py> for TupleVarargs {
-    type Varargs = &'py PyTuple;
+    type Varargs = Bound<'py, PyTuple>;
     #[inline]
     fn handle_varargs_fastcall(
         py: Python<'py>,
-        varargs: &[Option<&PyAny>],
+        varargs: &[Option<PyArg<'py>>],
         _function_description: &FunctionDescription,
     ) -> PyResult<Self::Varargs> {
-        Ok(PyTuple::new_bound(py, varargs).into_gil_ref())
+        PyTuple::new(py, varargs)
     }
 
     #[inline]
     fn handle_varargs_tuple(
-        args: &'py PyTuple,
+        args: &Bound<'py, PyTuple>,
         function_description: &FunctionDescription,
     ) -> PyResult<Self::Varargs> {
         let positional_parameters = function_description.positional_parameter_names.len();
@@ -646,8 +794,8 @@ pub trait VarkeywordsHandler<'py> {
     type Varkeywords: Default;
     fn handle_varkeyword(
         varkeywords: &mut Self::Varkeywords,
-        name: &'py PyAny,
-        value: &'py PyAny,
+        name: PyArg<'py>,
+        value: PyArg<'py>,
         function_description: &FunctionDescription,
     ) -> PyResult<()>;
 }
@@ -660,8 +808,8 @@ impl<'py> VarkeywordsHandler<'py> for NoVarkeywords {
     #[inline]
     fn handle_varkeyword(
         _varkeywords: &mut Self::Varkeywords,
-        name: &'py PyAny,
-        _value: &'py PyAny,
+        name: PyArg<'py>,
+        _value: PyArg<'py>,
         function_description: &FunctionDescription,
     ) -> PyResult<()> {
         Err(function_description.unexpected_keyword_argument(name))
@@ -672,28 +820,29 @@ impl<'py> VarkeywordsHandler<'py> for NoVarkeywords {
 pub struct DictVarkeywords;
 
 impl<'py> VarkeywordsHandler<'py> for DictVarkeywords {
-    type Varkeywords = Option<&'py PyDict>;
+    type Varkeywords = Option<Bound<'py, PyDict>>;
     #[inline]
     fn handle_varkeyword(
         varkeywords: &mut Self::Varkeywords,
-        name: &'py PyAny,
-        value: &'py PyAny,
+        name: PyArg<'py>,
+        value: PyArg<'py>,
         _function_description: &FunctionDescription,
     ) -> PyResult<()> {
         varkeywords
-            .get_or_insert_with(|| PyDict::new_bound(name.py()).into_gil_ref())
+            .get_or_insert_with(|| PyDict::new(name.py()))
             .set_item(name, value)
     }
 }
 
 fn push_parameter_list(msg: &mut String, parameter_names: &[&str]) {
+    let len = parameter_names.len();
     for (i, parameter) in parameter_names.iter().enumerate() {
         if i != 0 {
-            if parameter_names.len() > 2 {
+            if len > 2 {
                 msg.push(',');
             }
 
-            if i == parameter_names.len() - 1 {
+            if i == len - 1 {
                 msg.push_str(" and ")
             } else {
                 msg.push(' ')
@@ -708,10 +857,8 @@ fn push_parameter_list(msg: &mut String, parameter_names: &[&str]) {
 
 #[cfg(test)]
 mod tests {
-    use crate::{
-        types::{IntoPyDict, PyTuple},
-        PyAny, Python,
-    };
+    use crate::types::{IntoPyDict, PyTuple};
+    use crate::Python;
 
     use super::{push_parameter_list, FunctionDescription, NoVarargs, NoVarkeywords};
 
@@ -726,9 +873,9 @@ mod tests {
             keyword_only_parameters: &[],
         };
 
-        Python::with_gil(|py| {
-            let args = PyTuple::new_bound(py, Vec::<&PyAny>::new());
-            let kwargs = [("foo", 0u8)].into_py_dict_bound(py);
+        Python::attach(|py| {
+            let args = PyTuple::empty(py);
+            let kwargs = [("foo", 0u8)].into_py_dict(py).unwrap();
             let err = unsafe {
                 function_description
                     .extract_arguments_tuple_dict::<NoVarargs, NoVarkeywords>(
@@ -757,9 +904,9 @@ mod tests {
             keyword_only_parameters: &[],
         };
 
-        Python::with_gil(|py| {
-            let args = PyTuple::new_bound(py, Vec::<&PyAny>::new());
-            let kwargs = [(1u8, 1u8)].into_py_dict_bound(py);
+        Python::attach(|py| {
+            let args = PyTuple::empty(py);
+            let kwargs = [(1u8, 1u8)].into_py_dict(py).unwrap();
             let err = unsafe {
                 function_description
                     .extract_arguments_tuple_dict::<NoVarargs, NoVarkeywords>(
@@ -772,7 +919,7 @@ mod tests {
             };
             assert_eq!(
                 err.to_string(),
-                "TypeError: 'int' object cannot be converted to 'PyString'"
+                "TypeError: example() got an unexpected keyword argument '1'"
             );
         })
     }
@@ -788,8 +935,8 @@ mod tests {
             keyword_only_parameters: &[],
         };
 
-        Python::with_gil(|py| {
-            let args = PyTuple::new_bound(py, Vec::<&PyAny>::new());
+        Python::attach(|py| {
+            let args = PyTuple::empty(py);
             let mut output = [None, None];
             let err = unsafe {
                 function_description.extract_arguments_tuple_dict::<NoVarargs, NoVarkeywords>(
diff --git a/src/impl_/freelist.rs b/src/impl_/freelist.rs
index 0e611d421d6..713bb3f6464 100644
--- a/src/impl_/freelist.rs
+++ b/src/impl_/freelist.rs
@@ -8,31 +8,37 @@
 //!
 //! [1]: https://en.wikipedia.org/wiki/Free_list
 
+use crate::ffi;
 use std::mem;
 
-/// Represents a slot of a [`FreeList`].
-pub enum Slot<T> {
+/// Represents a slot of a [`PyObjectFreeList`].
+enum PyObjectSlot {
     /// A free slot.
     Empty,
     /// An allocated slot.
-    Filled(T),
+    Filled(*mut ffi::PyObject),
 }
 
-/// A free allocation list.
+// safety: access is guarded by a per-pyclass mutex
+unsafe impl Send for PyObjectSlot {}
+
+/// A free allocation list for PyObject ffi pointers.
 ///
 /// See [the parent module](crate::impl_::freelist) for more details.
-pub struct FreeList<T> {
-    entries: Vec<Slot<T>>,
+pub struct PyObjectFreeList {
+    entries: Box<[PyObjectSlot]>,
     split: usize,
     capacity: usize,
 }
 
-impl<T> FreeList<T> {
-    /// Creates a new `FreeList` instance with specified capacity.
-    pub fn with_capacity(capacity: usize) -> FreeList<T> {
-        let entries = (0..capacity).map(|_| Slot::Empty).collect::<Vec<_>>();
+impl PyObjectFreeList {
+    /// Creates a new `PyObjectFreeList` instance with specified capacity.
+    pub fn with_capacity(capacity: usize) -> PyObjectFreeList {
+        let entries = (0..capacity)
+            .map(|_| PyObjectSlot::Empty)
+            .collect::<Box<[_]>>();
 
-        FreeList {
+        PyObjectFreeList {
             entries,
             split: 0,
             capacity,
@@ -40,26 +46,26 @@ impl<T> FreeList<T> {
     }
 
     /// Pops the first non empty item.
-    pub fn pop(&mut self) -> Option<T> {
+    pub fn pop(&mut self) -> Option<*mut ffi::PyObject> {
         let idx = self.split;
         if idx == 0 {
             None
         } else {
-            match mem::replace(&mut self.entries[idx - 1], Slot::Empty) {
-                Slot::Filled(v) => {
+            match mem::replace(&mut self.entries[idx - 1], PyObjectSlot::Empty) {
+                PyObjectSlot::Filled(v) => {
                     self.split = idx - 1;
                     Some(v)
                 }
-                _ => panic!("FreeList is corrupt"),
+                _ => panic!("PyObjectFreeList is corrupt"),
             }
         }
     }
 
-    /// Inserts a value into the list. Returns `Some(val)` if the `FreeList` is full.
-    pub fn insert(&mut self, val: T) -> Option<T> {
+    /// Inserts a value into the list. Returns `Some(val)` if the `PyObjectFreeList` is full.
+    pub fn insert(&mut self, val: *mut ffi::PyObject) -> Option<*mut ffi::PyObject> {
         let next = self.split + 1;
         if next < self.capacity {
-            self.entries[self.split] = Slot::Filled(val);
+            self.entries[self.split] = PyObjectSlot::Filled(val);
             self.split = next;
             None
         } else {
diff --git a/src/impl_/frompyobject.rs b/src/impl_/frompyobject.rs
index e38ff3c76b2..98d7ad6a702 100644
--- a/src/impl_/frompyobject.rs
+++ b/src/impl_/frompyobject.rs
@@ -2,32 +2,6 @@ use crate::types::any::PyAnyMethods;
 use crate::Bound;
 use crate::{exceptions::PyTypeError, FromPyObject, PyAny, PyErr, PyResult, Python};
 
-pub enum Extractor<'a, 'py, T> {
-    Bound(fn(&'a Bound<'py, PyAny>) -> PyResult<T>),
-    GilRef(fn(&'a PyAny) -> PyResult<T>),
-}
-
-impl<'a, 'py, T> From<fn(&'a Bound<'py, PyAny>) -> PyResult<T>> for Extractor<'a, 'py, T> {
-    fn from(value: fn(&'a Bound<'py, PyAny>) -> PyResult<T>) -> Self {
-        Self::Bound(value)
-    }
-}
-
-impl<'a, T> From<fn(&'a PyAny) -> PyResult<T>> for Extractor<'a, '_, T> {
-    fn from(value: fn(&'a PyAny) -> PyResult<T>) -> Self {
-        Self::GilRef(value)
-    }
-}
-
-impl<'a, 'py, T> Extractor<'a, 'py, T> {
-    pub(crate) fn call(self, obj: &'a Bound<'py, PyAny>) -> PyResult<T> {
-        match self {
-            Extractor::Bound(f) => f(obj),
-            Extractor::GilRef(f) => f(obj.as_gil_ref()),
-        }
-    }
-}
-
 #[cold]
 pub fn failed_to_extract_enum(
     py: Python<'_>,
@@ -62,25 +36,25 @@ fn extract_traceback(py: Python<'_>, mut error: PyErr) -> String {
 
     let mut error_msg = error.to_string();
     while let Some(cause) = error.cause(py) {
-        write!(&mut error_msg, ", caused by {}", cause).unwrap();
+        write!(&mut error_msg, ", caused by {cause}").unwrap();
         error = cause
     }
     error_msg
 }
 
-pub fn extract_struct_field<'py, T>(
-    obj: &Bound<'py, PyAny>,
+pub fn extract_struct_field<'a, 'py, T>(
+    obj: &'a Bound<'py, PyAny>,
     struct_name: &str,
     field_name: &str,
 ) -> PyResult<T>
 where
-    T: FromPyObject<'py>,
+    T: FromPyObject<'a, 'py>,
 {
     match obj.extract() {
         Ok(value) => Ok(value),
         Err(err) => Err(failed_to_extract_struct_field(
             obj.py(),
-            err,
+            err.into(),
             struct_name,
             field_name,
         )),
@@ -88,12 +62,12 @@ where
 }
 
 pub fn extract_struct_field_with<'a, 'py, T>(
-    extractor: impl Into<Extractor<'a, 'py, T>>,
+    extractor: fn(&'a Bound<'py, PyAny>) -> PyResult<T>,
     obj: &'a Bound<'py, PyAny>,
     struct_name: &str,
     field_name: &str,
 ) -> PyResult<T> {
-    match extractor.into().call(obj) {
+    match extractor(obj) {
         Ok(value) => Ok(value),
         Err(err) => Err(failed_to_extract_struct_field(
             obj.py(),
@@ -112,26 +86,25 @@ fn failed_to_extract_struct_field(
     field_name: &str,
 ) -> PyErr {
     let new_err = PyTypeError::new_err(format!(
-        "failed to extract field {}.{}",
-        struct_name, field_name
+        "failed to extract field {struct_name}.{field_name}"
     ));
     new_err.set_cause(py, ::std::option::Option::Some(inner_err));
     new_err
 }
 
-pub fn extract_tuple_struct_field<'py, T>(
-    obj: &Bound<'py, PyAny>,
+pub fn extract_tuple_struct_field<'a, 'py, T>(
+    obj: &'a Bound<'py, PyAny>,
     struct_name: &str,
     index: usize,
 ) -> PyResult<T>
 where
-    T: FromPyObject<'py>,
+    T: FromPyObject<'a, 'py>,
 {
     match obj.extract() {
         Ok(value) => Ok(value),
         Err(err) => Err(failed_to_extract_tuple_struct_field(
             obj.py(),
-            err,
+            err.into(),
             struct_name,
             index,
         )),
@@ -139,12 +112,12 @@ where
 }
 
 pub fn extract_tuple_struct_field_with<'a, 'py, T>(
-    extractor: impl Into<Extractor<'a, 'py, T>>,
+    extractor: fn(&'a Bound<'py, PyAny>) -> PyResult<T>,
     obj: &'a Bound<'py, PyAny>,
     struct_name: &str,
     index: usize,
 ) -> PyResult<T> {
-    match extractor.into().call(obj) {
+    match extractor(obj) {
         Ok(value) => Ok(value),
         Err(err) => Err(failed_to_extract_tuple_struct_field(
             obj.py(),
@@ -162,8 +135,7 @@ fn failed_to_extract_tuple_struct_field(
     struct_name: &str,
     index: usize,
 ) -> PyErr {
-    let new_err =
-        PyTypeError::new_err(format!("failed to extract field {}.{}", struct_name, index));
+    let new_err = PyTypeError::new_err(format!("failed to extract field {struct_name}.{index}"));
     new_err.set_cause(py, ::std::option::Option::Some(inner_err));
     new_err
 }
diff --git a/src/impl_/introspection.rs b/src/impl_/introspection.rs
new file mode 100644
index 00000000000..da217f92ced
--- /dev/null
+++ b/src/impl_/introspection.rs
@@ -0,0 +1,24 @@
+use crate::conversion::IntoPyObject;
+use crate::inspect::TypeHint;
+
+/// Trait to guess a function Python return type
+///
+/// It is useful to properly get the return type `T` when the Rust implementation returns e.g. `PyResult<T>`
+pub trait PyReturnType {
+    /// The function return type
+    const OUTPUT_TYPE: TypeHint;
+}
+
+impl<'a, T: IntoPyObject<'a>> PyReturnType for T {
+    const OUTPUT_TYPE: TypeHint = T::OUTPUT_TYPE;
+}
+
+impl<T: PyReturnType, E> PyReturnType for Result<T, E> {
+    const OUTPUT_TYPE: TypeHint = T::OUTPUT_TYPE;
+}
+
+#[repr(C)]
+pub struct SerializedIntrospectionFragment<const LEN: usize> {
+    pub length: u32,
+    pub fragment: [u8; LEN],
+}
diff --git a/src/impl_/not_send.rs b/src/impl_/not_send.rs
deleted file mode 100644
index 97c2984aff8..00000000000
--- a/src/impl_/not_send.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-use std::marker::PhantomData;
-
-use crate::Python;
-
-/// A marker type that makes the type !Send.
-/// Workaround for lack of !Send on stable (<https://github.com/rust-lang/rust/issues/68318>).
-pub(crate) struct NotSend(PhantomData<*mut Python<'static>>);
-
-pub(crate) const NOT_SEND: NotSend = NotSend(PhantomData);
diff --git a/src/impl_/pycell.rs b/src/impl_/pycell.rs
index 39811aebd29..93514c7bb29 100644
--- a/src/impl_/pycell.rs
+++ b/src/impl_/pycell.rs
@@ -1,2 +1,4 @@
 //! Externally-accessible implementation of pycell
-pub use crate::pycell::impl_::{GetBorrowChecker, PyClassMutability};
+pub use crate::pycell::impl_::{
+    GetBorrowChecker, PyClassMutability, PyClassObject, PyClassObjectBase, PyClassObjectLayout,
+};
diff --git a/src/impl_/pyclass.rs b/src/impl_/pyclass.rs
index 2bd39dda1a0..5f887cce167 100644
--- a/src/impl_/pyclass.rs
+++ b/src/impl_/pyclass.rs
@@ -1,50 +1,70 @@
 use crate::{
-    exceptions::{PyAttributeError, PyNotImplementedError, PyRuntimeError, PyValueError},
+    exceptions::{PyAttributeError, PyNotImplementedError, PyRuntimeError},
     ffi,
-    impl_::freelist::FreeList,
-    impl_::pycell::{GetBorrowChecker, PyClassMutability},
-    internal_tricks::extract_c_string,
-    pycell::PyCellLayout,
-    pyclass_init::PyObjectInit,
-    types::PyBool,
-    Py, PyAny, PyCell, PyClass, PyErr, PyMethodDefType, PyNativeType, PyResult, PyTypeInfo, Python,
+    impl_::{
+        freelist::PyObjectFreeList,
+        pycell::{GetBorrowChecker, PyClassMutability, PyClassObjectLayout},
+        pyclass_init::PyObjectInit,
+        pymethods::{PyGetterDef, PyMethodDefType},
+    },
+    pycell::PyBorrowError,
+    types::{any::PyAnyMethods, PyBool},
+    Borrowed, IntoPyObject, IntoPyObjectExt, Py, PyAny, PyClass, PyClassGuard, PyErr, PyResult,
+    PyTypeInfo, Python,
 };
 use std::{
-    borrow::Cow,
-    ffi::{CStr, CString},
+    ffi::CStr,
     marker::PhantomData,
+    mem::offset_of,
     os::raw::{c_int, c_void},
-    ptr::NonNull,
+    ptr::{self, NonNull},
+    sync::Mutex,
     thread,
 };
 
+mod assertions;
+pub mod doc;
 mod lazy_type_object;
-pub use lazy_type_object::LazyTypeObject;
+#[macro_use]
+mod probes;
+
+pub use assertions::*;
+pub use lazy_type_object::{type_object_init_failed, LazyTypeObject};
+pub use probes::*;
 
 /// Gets the offset of the dictionary from the start of the object in bytes.
 #[inline]
 pub fn dict_offset<T: PyClass>() -> ffi::Py_ssize_t {
-    PyCell::<T>::dict_offset()
+    PyClassObject::<T>::dict_offset()
 }
 
 /// Gets the offset of the weakref list from the start of the object in bytes.
 #[inline]
 pub fn weaklist_offset<T: PyClass>() -> ffi::Py_ssize_t {
-    PyCell::<T>::weaklist_offset()
+    PyClassObject::<T>::weaklist_offset()
+}
+
+mod sealed {
+    pub trait Sealed {}
+
+    impl Sealed for super::PyClassDummySlot {}
+    impl Sealed for super::PyClassDictSlot {}
+    impl Sealed for super::PyClassWeakRefSlot {}
+    impl Sealed for super::ThreadCheckerImpl {}
+    impl<T: Send> Sealed for super::SendablePyClass<T> {}
 }
 
 /// Represents the `__dict__` field for `#[pyclass]`.
-pub trait PyClassDict {
+pub trait PyClassDict: sealed::Sealed {
     /// Initial form of a [PyObject](crate::ffi::PyObject) `__dict__` reference.
     const INIT: Self;
     /// Empties the dictionary of its key-value pairs.
     #[inline]
     fn clear_dict(&mut self, _py: Python<'_>) {}
-    private_decl! {}
 }
 
 /// Represents the `__weakref__` field for `#[pyclass]`.
-pub trait PyClassWeakRef {
+pub trait PyClassWeakRef: sealed::Sealed {
     /// Initializes a `weakref` instance.
     const INIT: Self;
     /// Clears the weak references to the given object.
@@ -54,19 +74,16 @@ pub trait PyClassWeakRef {
     /// - The GIL must be held.
     #[inline]
     unsafe fn clear_weakrefs(&mut self, _obj: *mut ffi::PyObject, _py: Python<'_>) {}
-    private_decl! {}
 }
 
 /// Zero-sized dummy field.
 pub struct PyClassDummySlot;
 
 impl PyClassDict for PyClassDummySlot {
-    private_impl! {}
     const INIT: Self = PyClassDummySlot;
 }
 
 impl PyClassWeakRef for PyClassDummySlot {
-    private_impl! {}
     const INIT: Self = PyClassDummySlot;
 }
 
@@ -74,10 +91,10 @@ impl PyClassWeakRef for PyClassDummySlot {
 ///
 /// `#[pyclass(dict)]` automatically adds this.
 #[repr(transparent)]
+#[allow(dead_code)] // These are constructed in INIT and used by the macro code
 pub struct PyClassDictSlot(*mut ffi::PyObject);
 
 impl PyClassDict for PyClassDictSlot {
-    private_impl! {}
     const INIT: Self = Self(std::ptr::null_mut());
     #[inline]
     fn clear_dict(&mut self, _py: Python<'_>) {
@@ -91,15 +108,15 @@ impl PyClassDict for PyClassDictSlot {
 ///
 /// `#[pyclass(weakref)]` automatically adds this.
 #[repr(transparent)]
+#[allow(dead_code)] // These are constructed in INIT and used by the macro code
 pub struct PyClassWeakRefSlot(*mut ffi::PyObject);
 
 impl PyClassWeakRef for PyClassWeakRefSlot {
-    private_impl! {}
     const INIT: Self = Self(std::ptr::null_mut());
     #[inline]
     unsafe fn clear_weakrefs(&mut self, obj: *mut ffi::PyObject, _py: Python<'_>) {
         if !self.0.is_null() {
-            ffi::PyObject_ClearWeakRefs(obj)
+            unsafe { ffi::PyObject_ClearWeakRefs(obj) }
         }
     }
 }
@@ -153,6 +170,9 @@ pub trait PyClassImpl: Sized + 'static {
     /// #[pyclass(sequence)]
     const IS_SEQUENCE: bool = false;
 
+    /// #[pyclass(immutable_type)]
+    const IS_IMMUTABLE_TYPE: bool = false;
+
     /// Base class
     type BaseType: PyTypeInfo + PyClassBaseType;
 
@@ -167,7 +187,7 @@ pub trait PyClassImpl: Sized + 'static {
 
     /// The closest native ancestor. This is `PyAny` by default, and when you declare
     /// `#[pyclass(extends=PyDict)]`, it's `PyDict`.
-    type BaseNativeType: PyTypeInfo + PyNativeType;
+    type BaseNativeType: PyTypeInfo;
 
     /// This handles following two situations:
     /// 1. In case `T` is `Send`, stub `ThreadChecker` is used and does nothing.
@@ -181,8 +201,16 @@ pub trait PyClassImpl: Sized + 'static {
     #[cfg(feature = "multiple-pymethods")]
     type Inventory: PyClassInventory;
 
-    /// Rendered class doc
-    fn doc(py: Python<'_>) -> PyResult<&'static CStr>;
+    /// Docstring for the class provided on the struct or enum.
+    ///
+    /// This is exposed for `PyClassDocGenerator` to use as a docstring piece.
+    const RAW_DOC: &'static CStr;
+
+    /// Fully rendered class doc, including the `text_signature` if a constructor is defined.
+    ///
+    /// This is constructed at compile-time with const specialization via the proc macros with help
+    /// from the PyClassDocGenerator` type.
+    const DOC: &'static CStr;
 
     fn items_iter() -> PyClassItemsIter;
 
@@ -199,29 +227,6 @@ pub trait PyClassImpl: Sized + 'static {
     fn lazy_type_object() -> &'static LazyTypeObject<Self>;
 }
 
-/// Runtime helper to build a class docstring from the `doc` and `text_signature`.
-///
-/// This is done at runtime because the class text signature is collected via dtolnay
-/// specialization in to the `#[pyclass]` macro from the `#[pymethods]` macro.
-pub fn build_pyclass_doc(
-    class_name: &'static str,
-    doc: &'static str,
-    text_signature: Option<&'static str>,
-) -> PyResult<Cow<'static, CStr>> {
-    if let Some(text_signature) = text_signature {
-        let doc = CString::new(format!(
-            "{}{}\n--\n\n{}",
-            class_name,
-            text_signature,
-            doc.trim_end_matches('\0')
-        ))
-        .map_err(|_| PyValueError::new_err("class doc cannot contain nul bytes"))?;
-        Ok(Cow::Owned(doc))
-    } else {
-        extract_c_string(doc, "class doc cannot contain nul bytes")
-    }
-}
-
 /// Iterator used to process all class items during type instantiation.
 pub struct PyClassItemsIter {
     /// Iteration state
@@ -308,7 +313,7 @@ slot_fragment_trait! {
         slf: *mut ffi::PyObject,
         attr: *mut ffi::PyObject,
     ) -> PyResult<*mut ffi::PyObject> {
-        let res = ffi::PyObject_GenericGetAttr(slf, attr);
+        let res = unsafe { ffi::PyObject_GenericGetAttr(slf, attr) };
         if res.is_null() {
             Err(PyErr::fetch(py))
         } else {
@@ -329,7 +334,7 @@ slot_fragment_trait! {
         attr: *mut ffi::PyObject,
     ) -> PyResult<*mut ffi::PyObject> {
         Err(PyErr::new::<PyAttributeError, _>(
-            (Py::<PyAny>::from_borrowed_ptr(py, attr),)
+            (unsafe {Py::<PyAny>::from_borrowed_ptr(py, attr)},)
         ))
     }
 }
@@ -342,24 +347,26 @@ macro_rules! generate_pyclass_getattro_slot {
             _slf: *mut $crate::ffi::PyObject,
             attr: *mut $crate::ffi::PyObject,
         ) -> *mut $crate::ffi::PyObject {
-            $crate::impl_::trampoline::getattrofunc(_slf, attr, |py, _slf, attr| {
-                use ::std::result::Result::*;
-                use $crate::impl_::pyclass::*;
-                let collector = PyClassImplCollector::<$cls>::new();
-
-                // Strategy:
-                // - Try __getattribute__ first. Its default is PyObject_GenericGetAttr.
-                // - If it returns a result, use it.
-                // - If it fails with AttributeError, try __getattr__.
-                // - If it fails otherwise, reraise.
-                match collector.__getattribute__(py, _slf, attr) {
-                    Ok(obj) => Ok(obj),
-                    Err(e) if e.is_instance_of::<$crate::exceptions::PyAttributeError>(py) => {
-                        collector.__getattr__(py, _slf, attr)
+            unsafe {
+                $crate::impl_::trampoline::getattrofunc(_slf, attr, |py, _slf, attr| {
+                    use ::std::result::Result::*;
+                    use $crate::impl_::pyclass::*;
+                    let collector = PyClassImplCollector::<$cls>::new();
+
+                    // Strategy:
+                    // - Try __getattribute__ first. Its default is PyObject_GenericGetAttr.
+                    // - If it returns a result, use it.
+                    // - If it fails with AttributeError, try __getattr__.
+                    // - If it fails otherwise, reraise.
+                    match collector.__getattribute__(py, _slf, attr) {
+                        Ok(obj) => Ok(obj),
+                        Err(e) if e.is_instance_of::<$crate::exceptions::PyAttributeError>(py) => {
+                            collector.__getattr__(py, _slf, attr)
+                        }
+                        Err(e) => Err(e),
                     }
-                    Err(e) => Err(e),
-                }
-            })
+                })
+            }
         }
         $crate::ffi::PyType_Slot {
             slot: $crate::ffi::Py_tp_getattro,
@@ -425,23 +432,25 @@ macro_rules! define_pyclass_setattr_slot {
                     _slf: *mut $crate::ffi::PyObject,
                     attr: *mut $crate::ffi::PyObject,
                     value: *mut $crate::ffi::PyObject,
-                ) -> ::std::os::raw::c_int {
-                    $crate::impl_::trampoline::setattrofunc(
-                        _slf,
-                        attr,
-                        value,
-                        |py, _slf, attr, value| {
-                            use ::std::option::Option::*;
-                            use $crate::callback::IntoPyCallbackOutput;
-                            use $crate::impl_::pyclass::*;
-                            let collector = PyClassImplCollector::<$cls>::new();
-                            if let Some(value) = ::std::ptr::NonNull::new(value) {
-                                collector.$set(py, _slf, attr, value).convert(py)
-                            } else {
-                                collector.$del(py, _slf, attr).convert(py)
-                            }
-                        },
-                    )
+                ) -> ::std::ffi::c_int {
+                    unsafe {
+                        $crate::impl_::trampoline::setattrofunc(
+                            _slf,
+                            attr,
+                            value,
+                            |py, _slf, attr, value| {
+                                use ::std::option::Option::*;
+                                use $crate::impl_::callback::IntoPyCallbackOutput;
+                                use $crate::impl_::pyclass::*;
+                                let collector = PyClassImplCollector::<$cls>::new();
+                                if let Some(value) = ::std::ptr::NonNull::new(value) {
+                                    collector.$set(py, _slf, attr, value).convert(py)
+                                } else {
+                                    collector.$del(py, _slf, attr).convert(py)
+                                }
+                            },
+                        )
+                    }
                 }
                 $crate::ffi::PyType_Slot {
                     slot: $crate::ffi::$slot,
@@ -541,17 +550,19 @@ macro_rules! define_pyclass_binary_operator_slot {
                     _slf: *mut $crate::ffi::PyObject,
                     _other: *mut $crate::ffi::PyObject,
                 ) -> *mut $crate::ffi::PyObject {
-                    $crate::impl_::trampoline::binaryfunc(_slf, _other, |py, _slf, _other| {
-                        use $crate::impl_::pyclass::*;
-                        let collector = PyClassImplCollector::<$cls>::new();
-                        let lhs_result = collector.$lhs(py, _slf, _other)?;
-                        if lhs_result == $crate::ffi::Py_NotImplemented() {
-                            $crate::ffi::Py_DECREF(lhs_result);
-                            collector.$rhs(py, _other, _slf)
-                        } else {
-                            ::std::result::Result::Ok(lhs_result)
-                        }
-                    })
+                    unsafe {
+                        $crate::impl_::trampoline::binaryfunc(_slf, _other, |py, _slf, _other| {
+                            use $crate::impl_::pyclass::*;
+                            let collector = PyClassImplCollector::<$cls>::new();
+                            let lhs_result = collector.$lhs(py, _slf, _other)?;
+                            if lhs_result == $crate::ffi::Py_NotImplemented() {
+                                $crate::ffi::Py_DECREF(lhs_result);
+                                collector.$rhs(py, _other, _slf)
+                            } else {
+                                ::std::result::Result::Ok(lhs_result)
+                            }
+                        })
+                    }
                 }
                 $crate::ffi::PyType_Slot {
                     slot: $crate::ffi::$slot,
@@ -734,17 +745,24 @@ macro_rules! generate_pyclass_pow_slot {
             _other: *mut $crate::ffi::PyObject,
             _mod: *mut $crate::ffi::PyObject,
         ) -> *mut $crate::ffi::PyObject {
-            $crate::impl_::trampoline::ternaryfunc(_slf, _other, _mod, |py, _slf, _other, _mod| {
-                use $crate::impl_::pyclass::*;
-                let collector = PyClassImplCollector::<$cls>::new();
-                let lhs_result = collector.__pow__(py, _slf, _other, _mod)?;
-                if lhs_result == $crate::ffi::Py_NotImplemented() {
-                    $crate::ffi::Py_DECREF(lhs_result);
-                    collector.__rpow__(py, _other, _slf, _mod)
-                } else {
-                    ::std::result::Result::Ok(lhs_result)
-                }
-            })
+            unsafe {
+                $crate::impl_::trampoline::ternaryfunc(
+                    _slf,
+                    _other,
+                    _mod,
+                    |py, _slf, _other, _mod| {
+                        use $crate::impl_::pyclass::*;
+                        let collector = PyClassImplCollector::<$cls>::new();
+                        let lhs_result = collector.__pow__(py, _slf, _other, _mod)?;
+                        if lhs_result == $crate::ffi::Py_NotImplemented() {
+                            $crate::ffi::Py_DECREF(lhs_result);
+                            collector.__rpow__(py, _other, _slf, _mod)
+                        } else {
+                            ::std::result::Result::Ok(lhs_result)
+                        }
+                    },
+                )
+            }
         }
         $crate::ffi::PyType_Slot {
             slot: $crate::ffi::Py_nb_power,
@@ -811,9 +829,9 @@ slot_fragment_trait! {
         other: *mut ffi::PyObject,
     ) -> PyResult<*mut ffi::PyObject> {
         // By default `__ne__` will try `__eq__` and invert the result
-        let slf: &PyAny = py.from_borrowed_ptr(slf);
-        let other: &PyAny = py.from_borrowed_ptr(other);
-        slf.eq(other).map(|is_eq| PyBool::new_bound(py, !is_eq).to_owned().into_ptr())
+        let slf = unsafe { Borrowed::from_ptr(py, slf)};
+        let other = unsafe { Borrowed::from_ptr(py, other)};
+        slf.eq(other).map(|is_eq| PyBool::new(py, !is_eq).to_owned().into_ptr())
     }
 }
 
@@ -851,26 +869,29 @@ slot_fragment_trait! {
 #[macro_export]
 macro_rules! generate_pyclass_richcompare_slot {
     ($cls:ty) => {{
+        #[allow(unknown_lints, non_local_definitions)]
         impl $cls {
             #[allow(non_snake_case)]
             unsafe extern "C" fn __pymethod___richcmp____(
                 slf: *mut $crate::ffi::PyObject,
                 other: *mut $crate::ffi::PyObject,
-                op: ::std::os::raw::c_int,
+                op: ::std::ffi::c_int,
             ) -> *mut $crate::ffi::PyObject {
-                $crate::impl_::trampoline::richcmpfunc(slf, other, op, |py, slf, other, op| {
-                    use $crate::class::basic::CompareOp;
-                    use $crate::impl_::pyclass::*;
-                    let collector = PyClassImplCollector::<$cls>::new();
-                    match CompareOp::from_raw(op).expect("invalid compareop") {
-                        CompareOp::Lt => collector.__lt__(py, slf, other),
-                        CompareOp::Le => collector.__le__(py, slf, other),
-                        CompareOp::Eq => collector.__eq__(py, slf, other),
-                        CompareOp::Ne => collector.__ne__(py, slf, other),
-                        CompareOp::Gt => collector.__gt__(py, slf, other),
-                        CompareOp::Ge => collector.__ge__(py, slf, other),
-                    }
-                })
+                unsafe {
+                    $crate::impl_::trampoline::richcmpfunc(slf, other, op, |py, slf, other, op| {
+                        use $crate::class::basic::CompareOp;
+                        use $crate::impl_::pyclass::*;
+                        let collector = PyClassImplCollector::<$cls>::new();
+                        match CompareOp::from_raw(op).expect("invalid compareop") {
+                            CompareOp::Lt => collector.__lt__(py, slf, other),
+                            CompareOp::Le => collector.__le__(py, slf, other),
+                            CompareOp::Eq => collector.__eq__(py, slf, other),
+                            CompareOp::Ne => collector.__ne__(py, slf, other),
+                            CompareOp::Gt => collector.__gt__(py, slf, other),
+                            CompareOp::Ge => collector.__ge__(py, slf, other),
+                        }
+                    })
+                }
             }
         }
         $crate::ffi::PyType_Slot {
@@ -881,66 +902,77 @@ macro_rules! generate_pyclass_richcompare_slot {
 }
 pub use generate_pyclass_richcompare_slot;
 
+use super::pycell::PyClassObject;
+
 /// Implements a freelist.
 ///
 /// Do not implement this trait manually. Instead, use `#[pyclass(freelist = N)]`
 /// on a Rust struct to implement it.
 pub trait PyClassWithFreeList: PyClass {
-    fn get_free_list(py: Python<'_>) -> &mut FreeList<*mut ffi::PyObject>;
+    fn get_free_list(py: Python<'_>) -> &'static Mutex<PyObjectFreeList>;
 }
 
 /// Implementation of tp_alloc for `freelist` classes.
 ///
 /// # Safety
 /// - `subtype` must be a valid pointer to the type object of T or a subclass.
-/// - The GIL must be held.
+/// - The calling thread must be attached to the interpreter
 pub unsafe extern "C" fn alloc_with_freelist<T: PyClassWithFreeList>(
     subtype: *mut ffi::PyTypeObject,
     nitems: ffi::Py_ssize_t,
 ) -> *mut ffi::PyObject {
-    let py = Python::assume_gil_acquired();
+    let py = unsafe { Python::assume_attached() };
 
     #[cfg(not(Py_3_8))]
-    bpo_35810_workaround(py, subtype);
+    unsafe {
+        bpo_35810_workaround(py, subtype)
+    };
 
     let self_type = T::type_object_raw(py);
     // If this type is a variable type or the subtype is not equal to this type, we cannot use the
     // freelist
-    if nitems == 0 && subtype == self_type {
-        if let Some(obj) = T::get_free_list(py).pop() {
-            ffi::PyObject_Init(obj, subtype);
+    if nitems == 0 && ptr::eq(subtype, self_type) {
+        let mut free_list = T::get_free_list(py).lock().unwrap();
+        if let Some(obj) = free_list.pop() {
+            drop(free_list);
+            unsafe { ffi::PyObject_Init(obj, subtype) };
+            unsafe { ffi::PyObject_Init(obj, subtype) };
             return obj as _;
         }
     }
 
-    ffi::PyType_GenericAlloc(subtype, nitems)
+    unsafe { ffi::PyType_GenericAlloc(subtype, nitems) }
 }
 
 /// Implementation of tp_free for `freelist` classes.
 ///
 /// # Safety
 /// - `obj` must be a valid pointer to an instance of T (not a subclass).
-/// - The GIL must be held.
+/// - The calling thread must be attached to the interpreter
 pub unsafe extern "C" fn free_with_freelist<T: PyClassWithFreeList>(obj: *mut c_void) {
     let obj = obj as *mut ffi::PyObject;
-    debug_assert_eq!(
-        T::type_object_raw(Python::assume_gil_acquired()),
-        ffi::Py_TYPE(obj)
-    );
-    if let Some(obj) = T::get_free_list(Python::assume_gil_acquired()).insert(obj) {
-        let ty = ffi::Py_TYPE(obj);
-
-        // Deduce appropriate inverse of PyType_GenericAlloc
-        let free = if ffi::PyType_IS_GC(ty) != 0 {
-            ffi::PyObject_GC_Del
-        } else {
-            ffi::PyObject_Free
-        };
-        free(obj as *mut c_void);
-
-        #[cfg(Py_3_8)]
-        if ffi::PyType_HasFeature(ty, ffi::Py_TPFLAGS_HEAPTYPE) != 0 {
-            ffi::Py_DECREF(ty as *mut ffi::PyObject);
+    unsafe {
+        debug_assert_eq!(
+            T::type_object_raw(Python::assume_attached()),
+            ffi::Py_TYPE(obj)
+        );
+        let mut free_list = T::get_free_list(Python::assume_attached()).lock().unwrap();
+        if let Some(obj) = free_list.insert(obj) {
+            drop(free_list);
+            let ty = ffi::Py_TYPE(obj);
+
+            // Deduce appropriate inverse of PyType_GenericAlloc
+            let free = if ffi::PyType_IS_GC(ty) != 0 {
+                ffi::PyObject_GC_Del
+            } else {
+                ffi::PyObject_Free
+            };
+            free(obj as *mut c_void);
+
+            #[cfg(Py_3_8)]
+            if ffi::PyType_HasFeature(ty, ffi::Py_TPFLAGS_HEAPTYPE) != 0 {
+                ffi::Py_DECREF(ty as *mut ffi::PyObject);
+            }
         }
     }
 }
@@ -953,8 +985,8 @@ unsafe fn bpo_35810_workaround(py: Python<'_>, ty: *mut ffi::PyTypeObject) {
     {
         // Must check version at runtime for abi3 wheels - they could run against a higher version
         // than the build config suggests.
-        use crate::sync::GILOnceCell;
-        static IS_PYTHON_3_8: GILOnceCell<bool> = GILOnceCell::new();
+        use crate::sync::PyOnceLock;
+        static IS_PYTHON_3_8: PyOnceLock<bool> = PyOnceLock::new();
 
         if *IS_PYTHON_3_8.get_or_init(py, || py.version_info() >= (3, 8)) {
             // No fix needed - the wheel is running on a sufficiently new interpreter.
@@ -967,11 +999,12 @@ unsafe fn bpo_35810_workaround(py: Python<'_>, ty: *mut ffi::PyTypeObject) {
         let _ = py;
     }
 
-    ffi::Py_INCREF(ty as *mut ffi::PyObject);
+    unsafe { ffi::Py_INCREF(ty as *mut ffi::PyObject) };
 }
 
-/// Implementation detail. Only to be used through our proc macro code.
 /// Method storage for `#[pyclass]`.
+///
+/// Implementation detail. Only to be used through our proc macro code.
 /// Allows arbitrary `#[pymethod]` blocks to submit their methods,
 /// which are eventually collected by `#[pyclass]`.
 #[cfg(feature = "multiple-pymethods")]
@@ -996,27 +1029,14 @@ impl<T> PyMethods<T> for &'_ PyClassImplCollector<T> {
     }
 }
 
-// Text signature for __new__
-pub trait PyClassNewTextSignature<T> {
-    fn new_text_signature(self) -> Option<&'static str>;
-}
-
-impl<T> PyClassNewTextSignature<T> for &'_ PyClassImplCollector<T> {
-    #[inline]
-    fn new_text_signature(self) -> Option<&'static str> {
-        None
-    }
-}
-
 // Thread checkers
 
 #[doc(hidden)]
-pub trait PyClassThreadChecker<T>: Sized {
+pub trait PyClassThreadChecker<T>: Sized + sealed::Sealed {
     fn ensure(&self);
     fn check(&self) -> bool;
     fn can_drop(&self, py: Python<'_>) -> bool;
     fn new() -> Self;
-    private_decl! {}
 }
 
 /// Default thread checker for `#[pyclass]`.
@@ -1039,7 +1059,6 @@ impl<T: Send> PyClassThreadChecker<T> for SendablePyClass<T> {
     fn new() -> Self {
         SendablePyClass(PhantomData)
     }
-    private_impl! {}
 }
 
 /// Thread checker for `#[pyclass(unsendable)]` types.
@@ -1052,8 +1071,7 @@ impl ThreadCheckerImpl {
         assert_eq!(
             thread::current().id(),
             self.0,
-            "{} is unsendable, but sent to another thread",
-            type_name
+            "{type_name} is unsendable, but sent to another thread"
         );
     }
 
@@ -1064,10 +1082,9 @@ impl ThreadCheckerImpl {
     fn can_drop(&self, py: Python<'_>, type_name: &'static str) -> bool {
         if thread::current().id() != self.0 {
             PyRuntimeError::new_err(format!(
-                "{} is unsendable, but is being dropped on another thread",
-                type_name
+                "{type_name} is unsendable, but is being dropped on another thread"
             ))
-            .write_unraisable_bound(py, None);
+            .write_unraisable(py, None);
             return false;
         }
 
@@ -1088,51 +1105,57 @@ impl<T> PyClassThreadChecker<T> for ThreadCheckerImpl {
     fn new() -> Self {
         ThreadCheckerImpl(thread::current().id())
     }
-    private_impl! {}
 }
 
 /// Trait denoting that this class is suitable to be used as a base type for PyClass.
+#[cfg_attr(
+    Py_LIMITED_API,
+    diagnostic::on_unimplemented(
+        message = "pyclass `{Self}` cannot be subclassed",
+        label = "required for `#[pyclass(extends={Self})]`",
+        note = "`{Self}` must have `#[pyclass(subclass)]` to be eligible for subclassing",
+        note = "with the `abi3` feature enabled, PyO3 does not support subclassing native types",
+    )
+)]
+#[cfg_attr(
+    not(Py_LIMITED_API),
+    diagnostic::on_unimplemented(
+        message = "pyclass `{Self}` cannot be subclassed",
+        label = "required for `#[pyclass(extends={Self})]`",
+        note = "`{Self}` must have `#[pyclass(subclass)]` to be eligible for subclassing",
+    )
+)]
 pub trait PyClassBaseType: Sized {
-    type LayoutAsBase: PyCellLayout<Self>;
+    type LayoutAsBase: PyClassObjectLayout<Self>;
     type BaseNativeType;
     type Initializer: PyObjectInit<Self>;
     type PyClassMutability: PyClassMutability;
 }
 
-/// All mutable PyClasses can be used as a base type.
-///
-/// In the future this will be extended to immutable PyClasses too.
-impl<T: PyClass> PyClassBaseType for T {
-    type LayoutAsBase = crate::pycell::PyCell<T>;
-    type BaseNativeType = T::BaseNativeType;
-    type Initializer = crate::pyclass_init::PyClassInitializer<Self>;
-    type PyClassMutability = T::PyClassMutability;
-}
-
 /// Implementation of tp_dealloc for pyclasses without gc
 pub(crate) unsafe extern "C" fn tp_dealloc<T: PyClass>(obj: *mut ffi::PyObject) {
-    crate::impl_::trampoline::dealloc(obj, PyCell::<T>::tp_dealloc)
+    unsafe { crate::impl_::trampoline::dealloc(obj, PyClassObject::<T>::tp_dealloc) }
 }
 
 /// Implementation of tp_dealloc for pyclasses with gc
 pub(crate) unsafe extern "C" fn tp_dealloc_with_gc<T: PyClass>(obj: *mut ffi::PyObject) {
     #[cfg(not(PyPy))]
-    {
+    unsafe {
         ffi::PyObject_GC_UnTrack(obj.cast());
     }
-    crate::impl_::trampoline::dealloc(obj, PyCell::<T>::tp_dealloc)
+    unsafe { crate::impl_::trampoline::dealloc(obj, PyClassObject::<T>::tp_dealloc) }
 }
 
 pub(crate) unsafe extern "C" fn get_sequence_item_from_mapping(
     obj: *mut ffi::PyObject,
     index: ffi::Py_ssize_t,
 ) -> *mut ffi::PyObject {
-    let index = ffi::PyLong_FromSsize_t(index);
+    let index = unsafe { ffi::PyLong_FromSsize_t(index) };
     if index.is_null() {
         return std::ptr::null_mut();
     }
-    let result = ffi::PyObject_GetItem(obj, index);
-    ffi::Py_DECREF(index);
+    let result = unsafe { ffi::PyObject_GetItem(obj, index) };
+    unsafe { ffi::Py_DECREF(index) };
     result
 }
 
@@ -1141,15 +1164,424 @@ pub(crate) unsafe extern "C" fn assign_sequence_item_from_mapping(
     index: ffi::Py_ssize_t,
     value: *mut ffi::PyObject,
 ) -> c_int {
-    let index = ffi::PyLong_FromSsize_t(index);
-    if index.is_null() {
-        return -1;
+    unsafe {
+        let index = ffi::PyLong_FromSsize_t(index);
+        if index.is_null() {
+            return -1;
+        }
+        let result = if value.is_null() {
+            ffi::PyObject_DelItem(obj, index)
+        } else {
+            ffi::PyObject_SetItem(obj, index, value)
+        };
+        ffi::Py_DECREF(index);
+        result
+    }
+}
+
+/// Type which uses specialization on impl blocks to determine how to read a field from a Rust pyclass
+/// as part of a `#[pyo3(get)]` annotation.
+pub struct PyClassGetterGenerator<
+    // structural information about the field: class type, field type, offset of the field within
+    // the class struct
+    ClassT: PyClass,
+    FieldT,
+    const OFFSET: usize,
+    // additional metadata about the field which is used to switch between different implementations
+    // at compile time
+    const IS_PY_T: bool,
+    const IMPLEMENTS_INTOPYOBJECT_REF: bool,
+    const IMPLEMENTS_INTOPYOBJECT: bool,
+>(PhantomData<(ClassT, FieldT)>);
+
+impl<
+        ClassT: PyClass,
+        FieldT,
+        const OFFSET: usize,
+        const IS_PY_T: bool,
+        const IMPLEMENTS_INTOPYOBJECT_REF: bool,
+        const IMPLEMENTS_INTOPYOBJECT: bool,
+    >
+    PyClassGetterGenerator<
+        ClassT,
+        FieldT,
+        OFFSET,
+        IS_PY_T,
+        IMPLEMENTS_INTOPYOBJECT_REF,
+        IMPLEMENTS_INTOPYOBJECT,
+    >
+{
+    /// Safety: constructing this type requires that there exists a value of type FieldT
+    /// at the calculated offset within the type ClassT.
+    pub const unsafe fn new() -> Self {
+        Self(PhantomData)
+    }
+}
+
+impl<
+        ClassT: PyClass,
+        U,
+        const OFFSET: usize,
+        const IMPLEMENTS_INTOPYOBJECT_REF: bool,
+        const IMPLEMENTS_INTOPYOBJECT: bool,
+    >
+    PyClassGetterGenerator<
+        ClassT,
+        Py<U>,
+        OFFSET,
+        true,
+        IMPLEMENTS_INTOPYOBJECT_REF,
+        IMPLEMENTS_INTOPYOBJECT,
+    >
+{
+    /// `Py<T>` fields have a potential optimization to use Python's "struct members" to read
+    /// the field directly from the struct, rather than using a getter function.
+    ///
+    /// This is the most efficient operation the Python interpreter could possibly do to
+    /// read a field, but it's only possible for us to allow this for frozen classes.
+    pub const fn generate(&self, name: &'static CStr, doc: &'static CStr) -> PyMethodDefType {
+        use crate::pyclass::boolean_struct::private::Boolean;
+        if ClassT::Frozen::VALUE {
+            PyMethodDefType::StructMember(ffi::PyMemberDef {
+                name: name.as_ptr(),
+                type_code: ffi::Py_T_OBJECT_EX,
+                offset: (offset_of!(PyClassObject<ClassT>, contents) + OFFSET) as ffi::Py_ssize_t,
+                flags: ffi::Py_READONLY,
+                doc: doc.as_ptr(),
+            })
+        } else {
+            PyMethodDefType::Getter(PyGetterDef {
+                name,
+                meth: pyo3_get_value_into_pyobject_ref::<ClassT, Py<U>, OFFSET>,
+                doc,
+            })
+        }
+    }
+}
+
+/// Field is not `Py<T>`; try to use `IntoPyObject` for `&T` (preferred over `ToPyObject`) to avoid
+/// potentially expensive clones of containers like `Vec`
+impl<ClassT, FieldT, const OFFSET: usize, const IMPLEMENTS_INTOPYOBJECT: bool>
+    PyClassGetterGenerator<ClassT, FieldT, OFFSET, false, true, IMPLEMENTS_INTOPYOBJECT>
+where
+    ClassT: PyClass,
+    for<'a, 'py> &'a FieldT: IntoPyObject<'py>,
+{
+    pub const fn generate(&self, name: &'static CStr, doc: &'static CStr) -> PyMethodDefType {
+        PyMethodDefType::Getter(PyGetterDef {
+            name,
+            meth: pyo3_get_value_into_pyobject_ref::<ClassT, FieldT, OFFSET>,
+            doc,
+        })
+    }
+}
+
+#[diagnostic::on_unimplemented(
+    message = "`{Self}` cannot be converted to a Python object",
+    label = "required by `#[pyo3(get)]` to create a readable property from a field of type `{Self}`",
+    note = "implement `IntoPyObject` for `&{Self}` or `IntoPyObject + Clone` for `{Self}` to define the conversion"
+)]
+pub trait PyO3GetField<'py>: IntoPyObject<'py> + Clone {}
+impl<'py, T> PyO3GetField<'py> for T where T: IntoPyObject<'py> + Clone {}
+
+/// Base case attempts to use IntoPyObject + Clone
+impl<ClassT: PyClass, FieldT, const OFFSET: usize, const IMPLEMENTS_INTOPYOBJECT: bool>
+    PyClassGetterGenerator<ClassT, FieldT, OFFSET, false, false, IMPLEMENTS_INTOPYOBJECT>
+{
+    pub const fn generate(&self, name: &'static CStr, doc: &'static CStr) -> PyMethodDefType
+    // The bound goes here rather than on the block so that this impl is always available
+    // if no specialization is used instead
+    where
+        for<'py> FieldT: PyO3GetField<'py>,
+    {
+        PyMethodDefType::Getter(PyGetterDef {
+            name,
+            meth: pyo3_get_value_into_pyobject::<ClassT, FieldT, OFFSET>,
+            doc,
+        })
+    }
+}
+
+/// ensures `obj` is not mutably aliased
+#[inline]
+unsafe fn ensure_no_mutable_alias<'a, ClassT: PyClass>(
+    _py: Python<'_>,
+    obj: &'a *mut ffi::PyObject,
+) -> Result<PyClassGuard<'a, ClassT>, PyBorrowError> {
+    unsafe { PyClassGuard::try_borrow(NonNull::from(obj).cast::<Py<ClassT>>().as_ref()) }
+}
+
+/// Gets a field value from a pyclass and produces a python value using `IntoPyObject` for `&FieldT`
+///
+/// # Safety
+/// - `obj` must be a valid pointer to an instance of `ClassT`
+/// - there must be a value of type `FieldT` at the calculated offset within `ClassT`
+unsafe fn pyo3_get_value_into_pyobject_ref<ClassT, FieldT, const OFFSET: usize>(
+    py: Python<'_>,
+    obj: *mut ffi::PyObject,
+) -> PyResult<*mut ffi::PyObject>
+where
+    ClassT: PyClass,
+    for<'a, 'py> &'a FieldT: IntoPyObject<'py>,
+{
+    /// Inner function to convert the field value at the given offset
+    ///
+    /// # Safety
+    /// - mutable aliasing is prevented by the caller
+    /// - value of type `FieldT` must exist at the given offset within obj
+    unsafe fn inner<FieldT>(
+        py: Python<'_>,
+        obj: *mut ffi::PyObject,
+        offset: usize,
+    ) -> PyResult<*mut ffi::PyObject>
+    where
+        for<'a, 'py> &'a FieldT: IntoPyObject<'py>,
+    {
+        // SAFETY: caller upholds safety invariants
+        let value = unsafe { &*obj.byte_add(offset).cast::<FieldT>() };
+        value.into_py_any(py).map(Py::into_ptr)
+    }
+
+    // SAFETY: `obj` is a valid pointer to `ClassT`
+    let _holder = unsafe { ensure_no_mutable_alias::<ClassT>(py, &obj)? };
+    // SAFETY: _holder prevents mutable aliasing, caller upholds other safety invariants
+    unsafe {
+        inner::<FieldT>(
+            py,
+            obj,
+            offset_of!(PyClassObject<ClassT>, contents) + OFFSET,
+        )
+    }
+}
+
+/// Gets a field value from a pyclass and produces a python value using `IntoPyObject` for `FieldT`,
+/// after cloning the value.
+///
+/// # Safety
+/// - `obj` must be a valid pointer to an instance of `ClassT`
+/// - there must be a value of type `FieldT` at the calculated offset within `ClassT`
+unsafe fn pyo3_get_value_into_pyobject<ClassT, FieldT, const OFFSET: usize>(
+    py: Python<'_>,
+    obj: *mut ffi::PyObject,
+) -> PyResult<*mut ffi::PyObject>
+where
+    ClassT: PyClass,
+    for<'py> FieldT: IntoPyObject<'py> + Clone,
+{
+    /// Inner function to convert the field value at the given offset
+    ///
+    /// # Safety
+    /// - mutable aliasing is prevented by the caller
+    /// - value of type `FieldT` must exist at the given offset within obj
+    unsafe fn inner<FieldT>(
+        py: Python<'_>,
+        obj: *mut ffi::PyObject,
+        offset: usize,
+    ) -> PyResult<*mut ffi::PyObject>
+    where
+        for<'py> FieldT: IntoPyObject<'py> + Clone,
+    {
+        // SAFETY: caller upholds safety invariants
+        let value = unsafe { &*obj.byte_add(offset).cast::<FieldT>() };
+        value.clone().into_py_any(py).map(Py::into_ptr)
+    }
+
+    // SAFETY: `obj` is a valid pointer to `ClassT`
+    let _holder = unsafe { ensure_no_mutable_alias::<ClassT>(py, &obj)? };
+    // SAFETY: _holder prevents mutable aliasing, caller upholds other safety invariants
+    unsafe {
+        inner::<FieldT>(
+            py,
+            obj,
+            offset_of!(PyClassObject<ClassT>, contents) + OFFSET,
+        )
+    }
+}
+
+pub struct ConvertField<
+    const IMPLEMENTS_INTOPYOBJECT_REF: bool,
+    const IMPLEMENTS_INTOPYOBJECT: bool,
+>;
+
+impl<const IMPLEMENTS_INTOPYOBJECT: bool> ConvertField<true, IMPLEMENTS_INTOPYOBJECT> {
+    #[inline]
+    pub fn convert_field<'a, 'py, T>(obj: &'a T, py: Python<'py>) -> PyResult<Py<PyAny>>
+    where
+        &'a T: IntoPyObject<'py>,
+    {
+        obj.into_py_any(py)
+    }
+}
+
+impl<const IMPLEMENTS_INTOPYOBJECT: bool> ConvertField<false, IMPLEMENTS_INTOPYOBJECT> {
+    #[inline]
+    pub fn convert_field<'py, T>(obj: &T, py: Python<'py>) -> PyResult<Py<PyAny>>
+    where
+        T: PyO3GetField<'py>,
+    {
+        obj.clone().into_py_any(py)
+    }
+}
+
+pub trait ExtractPyClassWithClone {}
+
+#[cfg(test)]
+#[cfg(feature = "macros")]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn get_py_for_frozen_class() {
+        #[crate::pyclass(crate = "crate", frozen)]
+        struct FrozenClass {
+            #[pyo3(get)]
+            value: Py<PyAny>,
+        }
+
+        let mut methods = Vec::new();
+        let mut slots = Vec::new();
+
+        for items in FrozenClass::items_iter() {
+            methods.extend_from_slice(items.methods);
+            slots.extend_from_slice(items.slots);
+        }
+
+        assert_eq!(methods.len(), 1);
+        assert!(slots.is_empty());
+
+        match methods.first() {
+            Some(PyMethodDefType::StructMember(member)) => {
+                assert_eq!(unsafe { CStr::from_ptr(member.name) }, c"value");
+                assert_eq!(member.type_code, ffi::Py_T_OBJECT_EX);
+                assert_eq!(
+                    member.offset,
+                    (offset_of!(PyClassObject<FrozenClass>, contents)
+                        + offset_of!(FrozenClass, value)) as ffi::Py_ssize_t
+                );
+                assert_eq!(member.flags, ffi::Py_READONLY);
+            }
+            _ => panic!("Expected a StructMember"),
+        }
+    }
+
+    #[test]
+    fn get_py_for_non_frozen_class() {
+        #[crate::pyclass(crate = "crate")]
+        struct FrozenClass {
+            #[pyo3(get)]
+            value: Py<PyAny>,
+        }
+
+        let mut methods = Vec::new();
+        let mut slots = Vec::new();
+
+        for items in FrozenClass::items_iter() {
+            methods.extend_from_slice(items.methods);
+            slots.extend_from_slice(items.slots);
+        }
+
+        assert_eq!(methods.len(), 1);
+        assert!(slots.is_empty());
+
+        match methods.first() {
+            Some(PyMethodDefType::Getter(getter)) => {
+                assert_eq!(getter.name, c"value");
+                assert_eq!(getter.doc, c"");
+                // tests for the function pointer are in test_getter_setter.py
+            }
+            _ => panic!("Expected a StructMember"),
+        }
+    }
+
+    #[test]
+    fn test_field_getter_generator() {
+        #[crate::pyclass(crate = "crate")]
+        struct MyClass {
+            my_field: i32,
+        }
+
+        const FIELD_OFFSET: usize = offset_of!(MyClass, my_field);
+
+        // generate for a non-py field using IntoPyObject for &i32
+        // SAFETY: offset is correct
+        let generator = unsafe {
+            PyClassGetterGenerator::<MyClass, i32, FIELD_OFFSET, false, true, false>::new()
+        };
+        let PyMethodDefType::Getter(def) = generator.generate(c"my_field", c"My field doc") else {
+            panic!("Expected a Getter");
+        };
+
+        assert_eq!(def.name, c"my_field");
+        assert_eq!(def.doc, c"My field doc");
+        assert_eq!(
+            def.meth as usize,
+            pyo3_get_value_into_pyobject_ref::<MyClass, i32, FIELD_OFFSET> as usize
+        );
+
+        // generate for a field via `IntoPyObject` + `Clone`
+        // SAFETY: offset is correct
+        let generator = unsafe {
+            PyClassGetterGenerator::<MyClass, String, FIELD_OFFSET, false, false, true>::new()
+        };
+        let PyMethodDefType::Getter(def) = generator.generate(c"my_field", c"My field doc") else {
+            panic!("Expected a Getter");
+        };
+        assert_eq!(def.name, c"my_field");
+        assert_eq!(def.doc, c"My field doc");
+        assert_eq!(
+            def.meth as usize,
+            pyo3_get_value_into_pyobject::<MyClass, String, FIELD_OFFSET> as usize
+        );
+    }
+
+    #[test]
+    fn test_field_getter_generator_py_field_frozen() {
+        #[crate::pyclass(crate = "crate", frozen)]
+        struct MyClass {
+            my_field: Py<PyAny>,
+        }
+
+        const FIELD_OFFSET: usize = offset_of!(MyClass, my_field);
+        // SAFETY: offset is correct
+        let generator = unsafe {
+            PyClassGetterGenerator::<MyClass, Py<PyAny>, FIELD_OFFSET, true, true, true>::new()
+        };
+        let PyMethodDefType::StructMember(def) = generator.generate(c"my_field", c"My field doc")
+        else {
+            panic!("Expected a StructMember");
+        };
+        // SAFETY: def.name originated from a CStr
+        assert_eq!(unsafe { CStr::from_ptr(def.name) }, c"my_field");
+        // SAFETY: def.doc originated from a CStr
+        assert_eq!(unsafe { CStr::from_ptr(def.doc) }, c"My field doc");
+        assert_eq!(def.type_code, ffi::Py_T_OBJECT_EX);
+        assert_eq!(
+            def.offset,
+            (offset_of!(PyClassObject<MyClass>, contents) + FIELD_OFFSET) as ffi::Py_ssize_t
+        );
+        assert_eq!(def.flags, ffi::Py_READONLY);
+    }
+
+    #[test]
+    fn test_field_getter_generator_py_field_non_frozen() {
+        #[crate::pyclass(crate = "crate")]
+        struct MyClass {
+            my_field: Py<PyAny>,
+        }
+
+        const FIELD_OFFSET: usize = offset_of!(MyClass, my_field);
+        // SAFETY: offset is correct
+        let generator = unsafe {
+            PyClassGetterGenerator::<MyClass, Py<PyAny>, FIELD_OFFSET, true, true, true>::new()
+        };
+        let PyMethodDefType::Getter(def) = generator.generate(c"my_field", c"My field doc") else {
+            panic!("Expected a Getter");
+        };
+        assert_eq!(def.name, c"my_field");
+        assert_eq!(def.doc, c"My field doc");
+        assert_eq!(
+            def.meth as usize,
+            pyo3_get_value_into_pyobject_ref::<MyClass, Py<PyAny>, FIELD_OFFSET> as usize
+        );
     }
-    let result = if value.is_null() {
-        ffi::PyObject_DelItem(obj, index)
-    } else {
-        ffi::PyObject_SetItem(obj, index, value)
-    };
-    ffi::Py_DECREF(index);
-    result
 }
diff --git a/src/impl_/pyclass/assertions.rs b/src/impl_/pyclass/assertions.rs
new file mode 100644
index 00000000000..4365e2d52c3
--- /dev/null
+++ b/src/impl_/pyclass/assertions.rs
@@ -0,0 +1,37 @@
+/// Helper function that can be used at compile time to emit a diagnostic if
+/// the type does not implement `Sync` when it should.
+///
+/// The mere act of invoking this function will cause the diagnostic to be
+/// emitted if `T` does not implement `Sync` when it should.
+///
+/// The additional `const IS_SYNC: bool` parameter is used to allow the custom
+/// diagnostic to be emitted; if `PyClassSync`
+#[allow(unused)]
+pub const fn assert_pyclass_sync<T>()
+where
+    T: PyClassSync + Sync,
+{
+}
+
+#[diagnostic::on_unimplemented(
+    message = "the trait `Sync` is not implemented for `{Self}`",
+    label = "required by `#[pyclass]`",
+    note = "replace thread-unsafe fields with thread-safe alternatives",
+    note = "see <TODO INSERT PYO3 GUIDE> for more information"
+)]
+pub trait PyClassSync<T: Sync = Self> {}
+
+impl<T> PyClassSync for T where T: Sync {}
+
+mod tests {
+    #[cfg(feature = "macros")]
+    #[test]
+    fn test_assert_pyclass_sync() {
+        use super::assert_pyclass_sync;
+
+        #[crate::pyclass(crate = "crate")]
+        struct MyClass {}
+
+        assert_pyclass_sync::<MyClass>();
+    }
+}
diff --git a/src/impl_/pyclass/doc.rs b/src/impl_/pyclass/doc.rs
new file mode 100644
index 00000000000..4e7a1ee2060
--- /dev/null
+++ b/src/impl_/pyclass/doc.rs
@@ -0,0 +1,120 @@
+use std::{ffi::CStr, marker::PhantomData};
+
+use crate::{impl_::pyclass::PyClassImpl, PyClass, PyTypeInfo};
+
+/// Trait implemented by classes with a known text signature for instantiation.
+///
+/// This is implemented by the `#[pymethods]` macro when handling expansion for a
+/// `#[new]` method.
+pub trait PyClassNewTextSignature {
+    const TEXT_SIGNATURE: &'static str;
+}
+
+/// Type which uses specialization on impl blocks to facilitate generating the documentation for a
+/// `#[pyclass]` type.
+///
+/// At the moment, this is only used to help lift the `TEXT_SIGNATURE` constant to compile time
+/// providing a base case and a specialized implementation when the signature is known at compile time.
+///
+/// In the future when const eval is more advanced, it will probably be possible to format the whole
+/// class docstring at compile time as part of this type instead of in macro expansion.
+pub struct PyClassDocGenerator<
+    ClassT: PyClass,
+    // switch to determine if a signature for class instantiation is known
+    const HAS_NEW_TEXT_SIGNATURE: bool,
+>(PhantomData<ClassT>);
+
+impl<ClassT: PyClass + PyClassNewTextSignature> PyClassDocGenerator<ClassT, true> {
+    pub const DOC_PIECES: &'static [&'static [u8]] = &[
+        <ClassT as PyTypeInfo>::NAME.as_bytes(),
+        ClassT::TEXT_SIGNATURE.as_bytes(),
+        b"\n--\n\n",
+        <ClassT as PyClassImpl>::RAW_DOC.to_bytes_with_nul(),
+    ];
+}
+
+impl<ClassT: PyClass> PyClassDocGenerator<ClassT, false> {
+    pub const DOC_PIECES: &'static [&'static [u8]] =
+        &[<ClassT as PyClassImpl>::RAW_DOC.to_bytes_with_nul()];
+}
+
+/// Casts bytes to a CStr, ensuring they are valid.
+pub const fn doc_bytes_as_cstr(bytes: &'static [u8]) -> &'static ::std::ffi::CStr {
+    match CStr::from_bytes_with_nul(bytes) {
+        Ok(cstr) => cstr,
+        #[cfg(not(from_bytes_with_nul_error))] // MSRV 1.86
+        Err(_) => panic!("invalid pyclass doc"),
+        #[cfg(from_bytes_with_nul_error)]
+        // This case may happen if the user provides an invalid docstring
+        Err(std::ffi::FromBytesWithNulError::InteriorNul { .. }) => {
+            panic!("pyclass doc contains nul bytes")
+        }
+        // This case shouldn't happen using the macro machinery as long as `PyClassDocGenerator`
+        // uses the RAW_DOC as the final piece, which is nul terminated.
+        #[cfg(from_bytes_with_nul_error)]
+        Err(std::ffi::FromBytesWithNulError::NotNulTerminated) => {
+            panic!("pyclass doc expected to be nul terminated")
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    #[cfg(feature = "macros")]
+    fn test_doc_generator() {
+        use crate::impl_::concat::{combine_to_array, combined_len};
+
+        /// A dummy class with signature.
+        #[crate::pyclass(crate = "crate")]
+        struct MyClass;
+
+        #[crate::pymethods(crate = "crate")]
+        impl MyClass {
+            #[new]
+            fn new(x: i32, y: i32) -> Self {
+                let _ = (x, y); // suppress unused variable warnings
+                MyClass
+            }
+        }
+
+        // simulate what the macro is doing
+        const PIECES: &[&[u8]] = PyClassDocGenerator::<MyClass, true>::DOC_PIECES;
+        assert_eq!(
+            &combine_to_array::<{ combined_len(PIECES) }>(PIECES),
+            b"MyClass(x, y)\n--\n\nA dummy class with signature.\0"
+        );
+
+        // simulate if the macro detected no text signature
+        const PIECES_WITHOUT_SIGNATURE: &[&[u8]] =
+            PyClassDocGenerator::<MyClass, false>::DOC_PIECES;
+        assert_eq!(
+            &combine_to_array::<{ combined_len(PIECES_WITHOUT_SIGNATURE) }>(
+                PIECES_WITHOUT_SIGNATURE
+            ),
+            b"A dummy class with signature.\0"
+        );
+    }
+
+    #[test]
+    fn test_doc_bytes_as_cstr() {
+        let cstr = doc_bytes_as_cstr(b"MyClass\0");
+        assert_eq!(cstr, c"MyClass");
+    }
+
+    #[test]
+    #[cfg(from_bytes_with_nul_error)]
+    #[should_panic(expected = "pyclass doc contains nul bytes")]
+    fn test_doc_bytes_as_cstr_central_nul() {
+        doc_bytes_as_cstr(b"MyClass\0Foo");
+    }
+
+    #[test]
+    #[cfg(from_bytes_with_nul_error)]
+    #[should_panic(expected = "pyclass doc expected to be nul terminated")]
+    fn test_doc_bytes_as_cstr_not_nul_terminated() {
+        doc_bytes_as_cstr(b"MyClass");
+    }
+}
diff --git a/src/impl_/pyclass/lazy_type_object.rs b/src/impl_/pyclass/lazy_type_object.rs
index af52033a702..e6e07174296 100644
--- a/src/impl_/pyclass/lazy_type_object.rs
+++ b/src/impl_/pyclass/lazy_type_object.rs
@@ -1,20 +1,26 @@
 use std::{
-    borrow::Cow,
-    cell::RefCell,
     ffi::CStr,
     marker::PhantomData,
     thread::{self, ThreadId},
 };
 
+#[cfg(Py_3_14)]
+use crate::err::error_on_minusone;
+#[allow(deprecated)]
+use crate::sync::GILOnceCell;
+#[cfg(Py_3_14)]
+use crate::types::PyTypeMethods;
 use crate::{
     exceptions::PyRuntimeError,
     ffi,
+    impl_::pymethods::PyMethodDefType,
     pyclass::{create_type_object, PyClassTypeObject},
-    sync::{GILOnceCell, GILProtected},
     types::PyType,
-    PyClass, PyErr, PyMethodDefType, PyObject, PyResult, Python,
+    Bound, Py, PyAny, PyClass, PyErr, PyResult, Python,
 };
 
+use std::sync::Mutex;
+
 use super::PyClassItemsIter;
 
 /// Lazy type object for PyClass.
@@ -23,21 +29,26 @@ pub struct LazyTypeObject<T>(LazyTypeObjectInner, PhantomData<T>);
 
 // Non-generic inner of LazyTypeObject to keep code size down
 struct LazyTypeObjectInner {
+    #[allow(deprecated)]
     value: GILOnceCell<PyClassTypeObject>,
     // Threads which have begun initialization of the `tp_dict`. Used for
     // reentrant initialization detection.
-    initializing_threads: GILProtected<RefCell<Vec<ThreadId>>>,
-    tp_dict_filled: GILOnceCell<()>,
+    initializing_threads: Mutex<Vec<ThreadId>>,
+    #[allow(deprecated)]
+    fully_initialized_type: GILOnceCell<Py<PyType>>,
 }
 
 impl<T> LazyTypeObject<T> {
     /// Creates an uninitialized `LazyTypeObject`.
+    #[allow(clippy::new_without_default)]
     pub const fn new() -> Self {
         LazyTypeObject(
             LazyTypeObjectInner {
+                #[allow(deprecated)]
                 value: GILOnceCell::new(),
-                initializing_threads: GILProtected::new(RefCell::new(Vec::new())),
-                tp_dict_filled: GILOnceCell::new(),
+                initializing_threads: Mutex::new(Vec::new()),
+                #[allow(deprecated)]
+                fully_initialized_type: GILOnceCell::new(),
             },
             PhantomData,
         )
@@ -46,15 +57,18 @@ impl<T> LazyTypeObject<T> {
 
 impl<T: PyClass> LazyTypeObject<T> {
     /// Gets the type object contained by this `LazyTypeObject`, initializing it if needed.
-    pub fn get_or_init<'py>(&'py self, py: Python<'py>) -> &'py PyType {
-        self.get_or_try_init(py).unwrap_or_else(|err| {
-            err.print(py);
-            panic!("failed to create type object for {}", T::NAME)
-        })
+    #[inline]
+    pub fn get_or_try_init<'py>(&self, py: Python<'py>) -> PyResult<&Bound<'py, PyType>> {
+        if let Some(type_object) = self.0.fully_initialized_type.get(py) {
+            // Fast path
+            return Ok(type_object.bind(py));
+        }
+
+        self.try_init(py)
     }
 
-    /// Fallible version of the above.
-    pub(crate) fn get_or_try_init<'py>(&'py self, py: Python<'py>) -> PyResult<&'py PyType> {
+    #[cold]
+    fn try_init<'py>(&self, py: Python<'py>) -> PyResult<&Bound<'py, PyType>> {
         self.0
             .get_or_try_init(py, create_type_object::<T>, T::NAME, T::items_iter())
     }
@@ -65,33 +79,35 @@ impl LazyTypeObjectInner {
     // so that this code is only instantiated once, instead of for every T
     // like the generic LazyTypeObject<T> methods above.
     fn get_or_try_init<'py>(
-        &'py self,
+        &self,
         py: Python<'py>,
         init: fn(Python<'py>) -> PyResult<PyClassTypeObject>,
         name: &str,
         items_iter: PyClassItemsIter,
-    ) -> PyResult<&'py PyType> {
+    ) -> PyResult<&Bound<'py, PyType>> {
         (|| -> PyResult<_> {
-            let type_object = self
-                .value
-                .get_or_try_init(py, || init(py))?
-                .type_object
-                .as_ref(py);
-            self.ensure_init(type_object, name, items_iter)?;
+            let PyClassTypeObject {
+                type_object,
+                is_immutable_type,
+                ..
+            } = self.value.get_or_try_init(py, || init(py))?;
+            let type_object = type_object.bind(py);
+            self.ensure_init(type_object, *is_immutable_type, name, items_iter)?;
             Ok(type_object)
         })()
         .map_err(|err| {
             wrap_in_runtime_error(
                 py,
                 err,
-                format!("An error occurred while initializing class {}", name),
+                format!("An error occurred while initializing class {name}"),
             )
         })
     }
 
     fn ensure_init(
         &self,
-        type_object: &PyType,
+        type_object: &Bound<'_, PyType>,
+        #[allow(unused_variables)] is_immutable_type: bool,
         name: &str,
         items_iter: PyClassItemsIter,
     ) -> PyResult<()> {
@@ -108,14 +124,14 @@ impl LazyTypeObjectInner {
         // `tp_dict`, it can still request the type object through `get_or_init`,
         // but the `tp_dict` may appear empty of course.
 
-        if self.tp_dict_filled.get(py).is_some() {
+        if self.fully_initialized_type.get(py).is_some() {
             // `tp_dict` is already filled: ok.
             return Ok(());
         }
 
         let thread_id = thread::current().id();
         {
-            let mut threads = self.initializing_threads.get(py).borrow_mut();
+            let mut threads = self.initializing_threads.lock().unwrap();
             if threads.contains(&thread_id) {
                 // Reentrant call: just return the type object, even if the
                 // `tp_dict` is not filled yet.
@@ -125,20 +141,18 @@ impl LazyTypeObjectInner {
         }
 
         struct InitializationGuard<'a> {
-            initializing_threads: &'a GILProtected<RefCell<Vec<ThreadId>>>,
-            py: Python<'a>,
+            initializing_threads: &'a Mutex<Vec<ThreadId>>,
             thread_id: ThreadId,
         }
         impl Drop for InitializationGuard<'_> {
             fn drop(&mut self) {
-                let mut threads = self.initializing_threads.get(self.py).borrow_mut();
+                let mut threads = self.initializing_threads.lock().unwrap();
                 threads.retain(|id| *id != self.thread_id);
             }
         }
 
         let guard = InitializationGuard {
             initializing_threads: &self.initializing_threads,
-            py,
             thread_id,
         };
 
@@ -148,12 +162,10 @@ impl LazyTypeObjectInner {
         // meantime: at worst, we'll just make a useless computation.
         let mut items = vec![];
         for class_items in items_iter {
-            for def in class_items.methods {
-                if let PyMethodDefType::ClassAttribute(attr) = def {
-                    let key = attr.attribute_c_string().unwrap();
-
-                    match (attr.meth.0)(py) {
-                        Ok(val) => items.push((key, val)),
+            for method in class_items.methods {
+                if let PyMethodDefType::ClassAttribute(attr) = method {
+                    match (attr.meth)(py) {
+                        Ok(val) => items.push((attr.name, val)),
                         Err(err) => {
                             return Err(wrap_in_runtime_error(
                                 py,
@@ -161,7 +173,7 @@ impl LazyTypeObjectInner {
                                 format!(
                                     "An error occurred while initializing `{}.{}`",
                                     name,
-                                    attr.name.trim_end_matches('\0')
+                                    attr.name.to_str().unwrap()
                                 ),
                             ))
                         }
@@ -172,21 +184,46 @@ impl LazyTypeObjectInner {
 
         // Now we hold the GIL and we can assume it won't be released until we
         // return from the function.
-        let result = self.tp_dict_filled.get_or_try_init(py, move || {
-            let result = initialize_tp_dict(py, type_object.as_ptr(), items);
+        let result = self.fully_initialized_type.get_or_try_init(py, move || {
+            initialize_tp_dict(py, type_object.as_ptr(), items)?;
+            #[cfg(Py_3_14)]
+            if is_immutable_type {
+                // freeze immutable types after __dict__ is initialized
+                let res = unsafe { ffi::PyType_Freeze(type_object.as_type_ptr()) };
+                error_on_minusone(py, res)?;
+            }
+            #[cfg(all(Py_3_10, not(Py_LIMITED_API), not(Py_3_14)))]
+            if is_immutable_type {
+                use crate::types::PyTypeMethods as _;
+                #[cfg(not(Py_GIL_DISABLED))]
+                unsafe {
+                    (*type_object.as_type_ptr()).tp_flags |= ffi::Py_TPFLAGS_IMMUTABLETYPE
+                };
+                #[cfg(Py_GIL_DISABLED)]
+                unsafe {
+                    (*type_object.as_type_ptr()).tp_flags.fetch_or(
+                        ffi::Py_TPFLAGS_IMMUTABLETYPE,
+                        std::sync::atomic::Ordering::Relaxed,
+                    )
+                };
+                unsafe { ffi::PyType_Modified(type_object.as_type_ptr()) };
+            }
 
             // Initialization successfully complete, can clear the thread list.
             // (No further calls to get_or_init() will try to init, on any thread.)
-            std::mem::forget(guard);
-            self.initializing_threads.get(py).replace(Vec::new());
-            result
+            let mut threads = {
+                drop(guard);
+                self.initializing_threads.lock().unwrap()
+            };
+            threads.clear();
+            Ok(type_object.clone().unbind())
         });
 
         if let Err(err) = result {
             return Err(wrap_in_runtime_error(
                 py,
-                err.clone_ref(py),
-                format!("An error occurred while initializing `{}.__dict__`", name),
+                err,
+                format!("An error occurred while initializing `{name}.__dict__`"),
             ));
         }
 
@@ -197,7 +234,7 @@ impl LazyTypeObjectInner {
 fn initialize_tp_dict(
     py: Python<'_>,
     type_object: *mut ffi::PyObject,
-    items: Vec<(Cow<'static, CStr>, PyObject)>,
+    items: Vec<(&'static CStr, Py<PyAny>)>,
 ) -> PyResult<()> {
     // We hold the GIL: the dictionary update can be considered atomic from
     // the POV of other threads.
@@ -212,6 +249,13 @@ fn initialize_tp_dict(
 // This is necessary for making static `LazyTypeObject`s
 unsafe impl<T> Sync for LazyTypeObject<T> {}
 
+/// Used in the macro-expanded implementation of `type_object_raw` for `#[pyclass]` types
+#[cold]
+pub fn type_object_init_failed(py: Python<'_>, err: PyErr, type_name: &str) -> ! {
+    err.write_unraisable(py, None);
+    panic!("failed to create type object for `{type_name}`")
+}
+
 #[cold]
 fn wrap_in_runtime_error(py: Python<'_>, err: PyErr, message: String) -> PyErr {
     let runtime_err = PyRuntimeError::new_err(message);
diff --git a/src/impl_/pyclass/probes.rs b/src/impl_/pyclass/probes.rs
new file mode 100644
index 00000000000..ac254085dd1
--- /dev/null
+++ b/src/impl_/pyclass/probes.rs
@@ -0,0 +1,86 @@
+use std::marker::PhantomData;
+
+use crate::{conversion::IntoPyObject, FromPyObject, Py};
+
+/// Trait used to combine with zero-sized types to calculate at compile time
+/// some property of a type.
+///
+/// The trick uses the fact that an associated constant has higher priority
+/// than a trait constant, so we can use the trait to define the false case.
+///
+/// The true case is defined in the zero-sized type's impl block, which is
+/// gated on some property like trait bound or only being implemented
+/// for fixed concrete types.
+pub trait Probe {
+    const VALUE: bool = false;
+}
+
+macro_rules! probe {
+    ($name:ident) => {
+        pub struct $name<T>(PhantomData<T>);
+        impl<T> Probe for $name<T> {}
+    };
+}
+
+probe!(IsPyT);
+
+impl<T> IsPyT<Py<T>> {
+    pub const VALUE: bool = true;
+}
+
+probe!(IsIntoPyObjectRef);
+
+impl<'a, 'py, T: 'a> IsIntoPyObjectRef<T>
+where
+    &'a T: IntoPyObject<'py>,
+{
+    pub const VALUE: bool = true;
+}
+
+probe!(IsIntoPyObject);
+
+impl<'py, T> IsIntoPyObject<T>
+where
+    T: IntoPyObject<'py>,
+{
+    pub const VALUE: bool = true;
+}
+
+probe!(IsSend);
+
+impl<T: Send> IsSend<T> {
+    pub const VALUE: bool = true;
+}
+
+probe!(IsSync);
+
+impl<T: Sync> IsSync<T> {
+    pub const VALUE: bool = true;
+}
+
+probe!(IsFromPyObject);
+
+impl<'a, 'py, T> IsFromPyObject<T>
+where
+    T: FromPyObject<'a, 'py>,
+{
+    pub const VALUE: bool = true;
+}
+
+probe!(HasNewTextSignature);
+
+impl<T: super::doc::PyClassNewTextSignature> HasNewTextSignature<T> {
+    pub const VALUE: bool = true;
+}
+
+#[cfg(test)]
+macro_rules! value_of {
+    ($probe:ident, $ty:ty) => {{
+        #[allow(unused_imports)] // probe trait not used if VALUE is true
+        use crate::impl_::pyclass::Probe as _;
+        $probe::<$ty>::VALUE
+    }};
+}
+
+#[cfg(test)]
+pub(crate) use value_of;
diff --git a/src/impl_/pyclass_init.rs b/src/impl_/pyclass_init.rs
new file mode 100644
index 00000000000..c3a112d3db8
--- /dev/null
+++ b/src/impl_/pyclass_init.rs
@@ -0,0 +1,93 @@
+//! Contains initialization utilities for `#[pyclass]`.
+use crate::ffi_ptr_ext::FfiPtrExt;
+use crate::internal::get_slot::TP_ALLOC;
+use crate::types::PyType;
+use crate::{ffi, Borrowed, PyErr, PyResult, Python};
+use crate::{ffi::PyTypeObject, sealed::Sealed, type_object::PyTypeInfo};
+use std::marker::PhantomData;
+use std::ptr;
+
+/// Initializer for Python types.
+///
+/// This trait is intended to use internally for distinguishing `#[pyclass]` and
+/// Python native types.
+pub trait PyObjectInit<T>: Sized + Sealed {
+    /// # Safety
+    /// - `subtype` must be a valid pointer to a type object of T or a subclass.
+    unsafe fn into_new_object(
+        self,
+        py: Python<'_>,
+        subtype: *mut PyTypeObject,
+    ) -> PyResult<*mut ffi::PyObject>;
+
+    #[doc(hidden)]
+    fn can_be_subclassed(&self) -> bool;
+}
+
+/// Initializer for Python native types, like `PyDict`.
+pub struct PyNativeTypeInitializer<T: PyTypeInfo>(pub PhantomData<T>);
+
+impl<T: PyTypeInfo> PyObjectInit<T> for PyNativeTypeInitializer<T> {
+    unsafe fn into_new_object(
+        self,
+        py: Python<'_>,
+        subtype: *mut PyTypeObject,
+    ) -> PyResult<*mut ffi::PyObject> {
+        unsafe fn inner(
+            py: Python<'_>,
+            type_object: *mut PyTypeObject,
+            subtype: *mut PyTypeObject,
+        ) -> PyResult<*mut ffi::PyObject> {
+            // HACK (due to FIXME below): PyBaseObject_Type's tp_new isn't happy with NULL arguments
+            let is_base_object = ptr::eq(type_object, ptr::addr_of!(ffi::PyBaseObject_Type));
+            let subtype_borrowed: Borrowed<'_, '_, PyType> = unsafe {
+                subtype
+                    .cast::<ffi::PyObject>()
+                    .assume_borrowed_unchecked(py)
+                    .cast_unchecked()
+            };
+
+            if is_base_object {
+                let alloc = subtype_borrowed
+                    .get_slot(TP_ALLOC)
+                    .unwrap_or(ffi::PyType_GenericAlloc);
+
+                let obj = unsafe { alloc(subtype, 0) };
+                return if obj.is_null() {
+                    Err(PyErr::fetch(py))
+                } else {
+                    Ok(obj)
+                };
+            }
+
+            #[cfg(Py_LIMITED_API)]
+            unreachable!("subclassing native types is not possible with the `abi3` feature");
+
+            #[cfg(not(Py_LIMITED_API))]
+            {
+                match unsafe { (*type_object).tp_new } {
+                    // FIXME: Call __new__ with actual arguments
+                    Some(newfunc) => {
+                        let obj =
+                            unsafe { newfunc(subtype, std::ptr::null_mut(), std::ptr::null_mut()) };
+                        if obj.is_null() {
+                            Err(PyErr::fetch(py))
+                        } else {
+                            Ok(obj)
+                        }
+                    }
+                    None => Err(crate::exceptions::PyTypeError::new_err(
+                        "base type without tp_new",
+                    )),
+                }
+            }
+        }
+        let type_object = T::type_object_raw(py);
+        unsafe { inner(py, type_object, subtype) }
+    }
+
+    #[inline]
+    fn can_be_subclassed(&self) -> bool {
+        true
+    }
+}
diff --git a/src/impl_/pyfunction.rs b/src/impl_/pyfunction.rs
index 464beeb8ce5..6bf7d4ad099 100644
--- a/src/impl_/pyfunction.rs
+++ b/src/impl_/pyfunction.rs
@@ -1,10 +1,152 @@
-use crate::{derive_utils::PyFunctionArguments, types::PyCFunction, PyResult};
+use std::cell::UnsafeCell;
+
+use crate::{
+    ffi,
+    ffi_ptr_ext::FfiPtrExt,
+    py_result_ext::PyResultExt,
+    types::{PyCFunction, PyModule, PyModuleMethods},
+    Borrowed, Bound, PyResult, Python,
+};
 
 pub use crate::impl_::pymethods::PyMethodDef;
 
-pub fn _wrap_pyfunction<'a>(
-    method_def: &PyMethodDef,
-    py_or_module: impl Into<PyFunctionArguments<'a>>,
-) -> PyResult<&'a PyCFunction> {
-    PyCFunction::internal_new(method_def, py_or_module.into()).map(|x| x.into_gil_ref())
+/// Wrapper around `ffi::PyMethodDef` suitable to use as a static variable for `#[pyfunction]` values.
+///
+/// The `UnsafeCell` is used because the Python interpreter consumes these as `*mut ffi::PyMethodDef`.
+pub struct PyFunctionDef(UnsafeCell<ffi::PyMethodDef>);
+
+// Safety: contents are only ever used by the Python interpreter, which uses global statics in this way.
+unsafe impl Sync for PyFunctionDef {}
+
+impl PyFunctionDef {
+    pub const fn new(def: ffi::PyMethodDef) -> Self {
+        Self(UnsafeCell::new(def))
+    }
+
+    pub const fn from_method_def(def: PyMethodDef) -> Self {
+        Self::new(def.into_raw())
+    }
+
+    pub(crate) fn create_py_c_function<'py>(
+        &'static self,
+        py: Python<'py>,
+        module: Option<&Bound<'py, PyModule>>,
+    ) -> PyResult<Bound<'py, PyCFunction>> {
+        // Safety: self is static
+        unsafe { create_py_c_function(py, self.0.get(), module) }
+    }
+}
+
+/// Trait to enable the use of `wrap_pyfunction` with both `Python` and `PyModule`,
+/// and also to infer the return type of either `&'py PyCFunction` or `Bound<'py, PyCFunction>`.
+pub trait WrapPyFunctionArg<'py, T> {
+    fn wrap_pyfunction(self, function_def: &'static PyFunctionDef) -> PyResult<T>;
+}
+
+impl<'py> WrapPyFunctionArg<'py, Bound<'py, PyCFunction>> for Bound<'py, PyModule> {
+    fn wrap_pyfunction(
+        self,
+        function_def: &'static PyFunctionDef,
+    ) -> PyResult<Bound<'py, PyCFunction>> {
+        function_def.create_py_c_function(self.py(), Some(&self))
+    }
+}
+
+impl<'py> WrapPyFunctionArg<'py, Bound<'py, PyCFunction>> for &'_ Bound<'py, PyModule> {
+    fn wrap_pyfunction(
+        self,
+        function_def: &'static PyFunctionDef,
+    ) -> PyResult<Bound<'py, PyCFunction>> {
+        function_def.create_py_c_function(self.py(), Some(self))
+    }
+}
+
+impl<'py> WrapPyFunctionArg<'py, Bound<'py, PyCFunction>> for Borrowed<'_, 'py, PyModule> {
+    fn wrap_pyfunction(
+        self,
+        function_def: &'static PyFunctionDef,
+    ) -> PyResult<Bound<'py, PyCFunction>> {
+        function_def.create_py_c_function(self.py(), Some(&self))
+    }
+}
+
+impl<'py> WrapPyFunctionArg<'py, Bound<'py, PyCFunction>> for &'_ Borrowed<'_, 'py, PyModule> {
+    fn wrap_pyfunction(
+        self,
+        function_def: &'static PyFunctionDef,
+    ) -> PyResult<Bound<'py, PyCFunction>> {
+        function_def.create_py_c_function(self.py(), Some(self))
+    }
+}
+
+impl<'py> WrapPyFunctionArg<'py, Bound<'py, PyCFunction>> for Python<'py> {
+    fn wrap_pyfunction(
+        self,
+        function_def: &'static PyFunctionDef,
+    ) -> PyResult<Bound<'py, PyCFunction>> {
+        function_def.create_py_c_function(self, None)
+    }
+}
+
+/// Creates a `PyCFunction` object from a `PyMethodDef`.
+///
+/// # Safety
+///
+/// The `method_def` pointer must be valid for the lifetime of the returned `PyCFunction`
+/// (effectively, it must be a static variable).
+pub unsafe fn create_py_c_function<'py>(
+    py: Python<'py>,
+    method_def: *mut ffi::PyMethodDef,
+    module: Option<&Bound<'py, PyModule>>,
+) -> PyResult<Bound<'py, PyCFunction>> {
+    let (mod_ptr, module_name) = if let Some(m) = module {
+        let mod_ptr = m.as_ptr();
+        (mod_ptr, Some(m.name()?))
+    } else {
+        (std::ptr::null_mut(), None)
+    };
+
+    let module_name_ptr = module_name
+        .as_ref()
+        .map_or(std::ptr::null_mut(), Bound::as_ptr);
+
+    unsafe {
+        ffi::PyCFunction_NewEx(method_def, mod_ptr, module_name_ptr)
+            .assume_owned_or_err(py)
+            .cast_into_unchecked()
+    }
+}
+
+#[cfg(test)]
+#[cfg(feature = "macros")]
+mod tests {
+    #[test]
+    fn test_wrap_pyfunction_forms() {
+        use crate::types::{PyAnyMethods, PyModule};
+        use crate::{wrap_pyfunction, Python};
+
+        #[crate::pyfunction(crate = "crate")]
+        fn f() {}
+
+        Python::attach(|py| {
+            let module = PyModule::new(py, "test_wrap_pyfunction_forms").unwrap();
+
+            let func = wrap_pyfunction!(f, module.clone()).unwrap();
+            func.call0().unwrap();
+
+            let func = wrap_pyfunction!(f, &module).unwrap();
+            func.call0().unwrap();
+
+            let module_borrowed = module.as_borrowed();
+
+            let func = wrap_pyfunction!(f, module_borrowed).unwrap();
+            func.call0().unwrap();
+
+            let func = wrap_pyfunction!(f, &module_borrowed).unwrap();
+            func.call0().unwrap();
+
+            let func = wrap_pyfunction!(f, py).unwrap();
+            func.call0().unwrap();
+        });
+    }
 }
diff --git a/src/impl_/pymethods.rs b/src/impl_/pymethods.rs
index eef3b569d08..521914ea392 100644
--- a/src/impl_/pymethods.rs
+++ b/src/impl_/pymethods.rs
@@ -1,19 +1,26 @@
-use crate::callback::IntoPyCallbackOutput;
 use crate::exceptions::PyStopAsyncIteration;
-use crate::gil::LockGIL;
+use crate::impl_::callback::IntoPyCallbackOutput;
 use crate::impl_::panic::PanicTrap;
-use crate::internal_tricks::extract_c_string;
-use crate::types::{any::PyAnyMethods, PyModule, PyType};
+use crate::impl_::pycell::{PyClassObject, PyClassObjectLayout};
+use crate::internal::get_slot::{get_slot, TP_BASE, TP_CLEAR, TP_TRAVERSE};
+use crate::internal::state::ForbidAttaching;
+use crate::pycell::impl_::PyClassBorrowChecker as _;
+use crate::pycell::{PyBorrowError, PyBorrowMutError};
+use crate::pyclass::boolean_struct::False;
+use crate::types::PyType;
 use crate::{
-    ffi, Bound, Py, PyAny, PyCell, PyClass, PyErr, PyObject, PyResult, PyTraverseError, PyVisit,
-    Python,
+    ffi, Bound, CastError, Py, PyAny, PyClass, PyClassGuard, PyClassGuardMut, PyClassInitializer,
+    PyErr, PyRef, PyRefMut, PyResult, PyTraverseError, PyTypeCheck, PyVisit, Python,
 };
-use std::borrow::Cow;
 use std::ffi::CStr;
+use std::ffi::{c_int, c_void};
 use std::fmt;
-use std::os::raw::{c_int, c_void};
+use std::marker::PhantomData;
 use std::panic::{catch_unwind, AssertUnwindSafe};
-use std::ptr::null_mut;
+use std::ptr::{null_mut, NonNull};
+
+use super::trampoline;
+use crate::internal_tricks::{clear_eq, traverse_eq};
 
 /// Python 3.8 and up - __ipow__ has modulo argument correctly populated.
 #[cfg(Py_3_8)]
@@ -36,19 +43,21 @@ pub type ipowfunc = unsafe extern "C" fn(
 impl IPowModulo {
     #[cfg(Py_3_8)]
     #[inline]
-    pub fn to_borrowed_any(self, py: Python<'_>) -> &PyAny {
-        unsafe { py.from_borrowed_ptr::<PyAny>(self.0) }
+    pub fn as_ptr(self) -> *mut ffi::PyObject {
+        self.0
     }
 
     #[cfg(not(Py_3_8))]
     #[inline]
-    pub fn to_borrowed_any(self, py: Python<'_>) -> &PyAny {
-        unsafe { py.from_borrowed_ptr::<PyAny>(ffi::Py_None()) }
+    pub fn as_ptr(self) -> *mut ffi::PyObject {
+        // Safety: returning a borrowed pointer to Python `None` singleton
+        unsafe { ffi::Py_None() }
     }
 }
 
 /// `PyMethodDefType` represents different types of Python callable objects.
 /// It is used by the `#[pymethods]` attribute.
+#[derive(Copy, Clone)]
 pub enum PyMethodDefType {
     /// Represents class method
     Class(PyMethodDef),
@@ -62,112 +71,89 @@ pub enum PyMethodDefType {
     Getter(PyGetterDef),
     /// Represents setter descriptor, used by `#[setter]`
     Setter(PySetterDef),
+    /// Represents a struct member
+    StructMember(ffi::PyMemberDef),
 }
 
 #[derive(Copy, Clone, Debug)]
 pub enum PyMethodType {
-    PyCFunction(PyCFunction),
-    PyCFunctionWithKeywords(PyCFunctionWithKeywords),
-    #[cfg(not(Py_LIMITED_API))]
-    PyCFunctionFastWithKeywords(PyCFunctionFastWithKeywords),
-}
-
-// These newtype structs serve no purpose other than wrapping which are function pointers - because
-// function pointers aren't allowed in const fn, but types wrapping them are!
-#[derive(Clone, Copy, Debug)]
-pub struct PyCFunction(pub ffi::PyCFunction);
-#[derive(Clone, Copy, Debug)]
-pub struct PyCFunctionWithKeywords(pub ffi::PyCFunctionWithKeywords);
-#[cfg(not(Py_LIMITED_API))]
-#[derive(Clone, Copy, Debug)]
-pub struct PyCFunctionFastWithKeywords(pub ffi::_PyCFunctionFastWithKeywords);
-#[derive(Clone, Copy)]
-pub struct PyGetter(pub Getter);
-#[derive(Clone, Copy)]
-pub struct PySetter(pub Setter);
-#[derive(Clone, Copy)]
-pub struct PyClassAttributeFactory(pub for<'p> fn(Python<'p>) -> PyResult<PyObject>);
-
-// TODO: it would be nice to use CStr in these types, but then the constructors can't be const fn
-// until `CStr::from_bytes_with_nul_unchecked` is const fn.
-
-#[derive(Clone, Debug)]
+    PyCFunction(ffi::PyCFunction),
+    PyCFunctionWithKeywords(ffi::PyCFunctionWithKeywords),
+    #[cfg(any(Py_3_10, not(Py_LIMITED_API)))]
+    PyCFunctionFastWithKeywords(ffi::PyCFunctionFastWithKeywords),
+}
+
+pub type PyClassAttributeFactory = for<'p> fn(Python<'p>) -> PyResult<Py<PyAny>>;
+
+#[derive(Copy, Clone, Debug)]
 pub struct PyMethodDef {
-    pub(crate) ml_name: &'static str,
+    pub(crate) ml_name: &'static CStr,
     pub(crate) ml_meth: PyMethodType,
     pub(crate) ml_flags: c_int,
-    pub(crate) ml_doc: &'static str,
+    pub(crate) ml_doc: &'static CStr,
 }
 
 #[derive(Copy, Clone)]
 pub struct PyClassAttributeDef {
-    pub(crate) name: &'static str,
+    pub(crate) name: &'static CStr,
     pub(crate) meth: PyClassAttributeFactory,
 }
 
-impl PyClassAttributeDef {
-    pub(crate) fn attribute_c_string(&self) -> PyResult<Cow<'static, CStr>> {
-        extract_c_string(self.name, "class attribute name cannot contain nul bytes")
-    }
-}
-
-#[derive(Clone)]
+#[derive(Copy, Clone)]
 pub struct PyGetterDef {
-    pub(crate) name: &'static str,
-    pub(crate) meth: PyGetter,
-    pub(crate) doc: &'static str,
+    pub(crate) name: &'static CStr,
+    pub(crate) meth: Getter,
+    pub(crate) doc: &'static CStr,
 }
 
-#[derive(Clone)]
+#[derive(Copy, Clone)]
 pub struct PySetterDef {
-    pub(crate) name: &'static str,
-    pub(crate) meth: PySetter,
-    pub(crate) doc: &'static str,
+    pub(crate) name: &'static CStr,
+    pub(crate) meth: Setter,
+    pub(crate) doc: &'static CStr,
 }
 
-unsafe impl Sync for PyMethodDef {}
-
-unsafe impl Sync for PyGetterDef {}
-
-unsafe impl Sync for PySetterDef {}
-
 impl PyMethodDef {
     /// Define a function with no `*args` and `**kwargs`.
-    pub const fn noargs(name: &'static str, cfunction: PyCFunction, doc: &'static str) -> Self {
+    pub const fn noargs(
+        ml_name: &'static CStr,
+        cfunction: ffi::PyCFunction,
+        ml_doc: &'static CStr,
+    ) -> Self {
         Self {
-            ml_name: name,
+            ml_name,
             ml_meth: PyMethodType::PyCFunction(cfunction),
             ml_flags: ffi::METH_NOARGS,
-            ml_doc: doc,
+            ml_doc,
         }
     }
 
     /// Define a function that can take `*args` and `**kwargs`.
     pub const fn cfunction_with_keywords(
-        name: &'static str,
-        cfunction: PyCFunctionWithKeywords,
-        doc: &'static str,
+        ml_name: &'static CStr,
+        cfunction: ffi::PyCFunctionWithKeywords,
+        ml_doc: &'static CStr,
     ) -> Self {
         Self {
-            ml_name: name,
+            ml_name,
             ml_meth: PyMethodType::PyCFunctionWithKeywords(cfunction),
             ml_flags: ffi::METH_VARARGS | ffi::METH_KEYWORDS,
-            ml_doc: doc,
+            ml_doc,
         }
     }
 
     /// Define a function that can take `*args` and `**kwargs`.
-    #[cfg(not(Py_LIMITED_API))]
+    #[cfg(any(Py_3_10, not(Py_LIMITED_API)))]
     pub const fn fastcall_cfunction_with_keywords(
-        name: &'static str,
-        cfunction: PyCFunctionFastWithKeywords,
-        doc: &'static str,
+        ml_name: &'static CStr,
+        cfunction: ffi::PyCFunctionFastWithKeywords,
+        ml_doc: &'static CStr,
     ) -> Self {
         Self {
-            ml_name: name,
+            ml_name,
             ml_meth: PyMethodType::PyCFunctionFastWithKeywords(cfunction),
             ml_flags: ffi::METH_FASTCALL | ffi::METH_KEYWORDS,
-            ml_doc: doc,
+            ml_doc,
         }
     }
 
@@ -176,37 +162,30 @@ impl PyMethodDef {
         self
     }
 
-    /// Convert `PyMethodDef` to Python method definition struct `ffi::PyMethodDef`
-    pub(crate) fn as_method_def(&self) -> PyResult<(ffi::PyMethodDef, PyMethodDefDestructor)> {
+    pub const fn into_raw(self) -> ffi::PyMethodDef {
         let meth = match self.ml_meth {
-            PyMethodType::PyCFunction(meth) => ffi::PyMethodDefPointer {
-                PyCFunction: meth.0,
-            },
+            PyMethodType::PyCFunction(meth) => ffi::PyMethodDefPointer { PyCFunction: meth },
             PyMethodType::PyCFunctionWithKeywords(meth) => ffi::PyMethodDefPointer {
-                PyCFunctionWithKeywords: meth.0,
+                PyCFunctionWithKeywords: meth,
             },
-            #[cfg(not(Py_LIMITED_API))]
+            #[cfg(any(Py_3_10, not(Py_LIMITED_API)))]
             PyMethodType::PyCFunctionFastWithKeywords(meth) => ffi::PyMethodDefPointer {
-                _PyCFunctionFastWithKeywords: meth.0,
+                PyCFunctionFastWithKeywords: meth,
             },
         };
 
-        let name = get_name(self.ml_name)?;
-        let doc = get_doc(self.ml_doc)?;
-        let def = ffi::PyMethodDef {
-            ml_name: name.as_ptr(),
+        ffi::PyMethodDef {
+            ml_name: self.ml_name.as_ptr(),
             ml_meth: meth,
             ml_flags: self.ml_flags,
-            ml_doc: doc.as_ptr(),
-        };
-        let destructor = PyMethodDefDestructor { name, doc };
-        Ok((def, destructor))
+            ml_doc: self.ml_doc.as_ptr(),
+        }
     }
 }
 
 impl PyClassAttributeDef {
     /// Define a class attribute.
-    pub const fn new(name: &'static str, meth: PyClassAttributeFactory) -> Self {
+    pub const fn new(name: &'static CStr, meth: PyClassAttributeFactory) -> Self {
         Self { name, meth }
     }
 }
@@ -229,7 +208,7 @@ pub(crate) type Setter =
 
 impl PyGetterDef {
     /// Define a getter.
-    pub const fn new(name: &'static str, getter: PyGetter, doc: &'static str) -> Self {
+    pub const fn new(name: &'static CStr, getter: Getter, doc: &'static CStr) -> Self {
         Self {
             name,
             meth: getter,
@@ -240,7 +219,7 @@ impl PyGetterDef {
 
 impl PySetterDef {
     /// Define a setter.
-    pub const fn new(name: &'static str, setter: PySetter, doc: &'static str) -> Self {
+    pub const fn new(name: &'static CStr, setter: Setter, doc: &'static CStr) -> Self {
         Self {
             name,
             meth: setter,
@@ -250,61 +229,224 @@ impl PySetterDef {
 }
 
 /// Calls an implementation of __traverse__ for tp_traverse
+///
+/// NB cannot accept `'static` visitor, this is a sanity check below:
+///
+/// ```rust,compile_fail
+/// use pyo3::prelude::*;
+/// use pyo3::pyclass::{PyTraverseError, PyVisit};
+///
+/// #[pyclass]
+/// struct Foo;
+///
+/// #[pymethods]
+/// impl Foo {
+///     fn __traverse__(&self, _visit: PyVisit<'static>) -> Result<(), PyTraverseError> {
+///         Ok(())
+///     }
+/// }
+/// ```
+///
+/// Elided lifetime should compile ok:
+///
+/// ```rust,no_run
+/// use pyo3::prelude::*;
+/// use pyo3::pyclass::{PyTraverseError, PyVisit};
+///
+/// #[pyclass]
+/// struct Foo;
+///
+/// #[pymethods]
+/// impl Foo {
+///     fn __traverse__(&self, _visit: PyVisit<'_>) -> Result<(), PyTraverseError> {
+///         Ok(())
+///     }
+/// }
+/// ```
 #[doc(hidden)]
 pub unsafe fn _call_traverse<T>(
     slf: *mut ffi::PyObject,
     impl_: fn(&T, PyVisit<'_>) -> Result<(), PyTraverseError>,
     visit: ffi::visitproc,
     arg: *mut c_void,
+    current_traverse: ffi::traverseproc,
 ) -> c_int
 where
     T: PyClass,
 {
-    // It is important the implementation of `__traverse__` cannot safely access the GIL,
-    // c.f. https://github.com/PyO3/pyo3/issues/3165, and hence we do not expose our GIL
-    // token to the user code and lock safe methods for acquiring the GIL.
+    // It is important the implementation of `__traverse__` cannot safely access the interpreter,
+    // c.f. https://github.com/PyO3/pyo3/issues/3165, and hence we do not expose our Python
+    // token to the user code and forbid safe methods for attaching.
     // (This includes enforcing the `&self` method receiver as e.g. `PyRef<Self>` could
-    // reconstruct a GIL token via `PyRef::py`.)
-    // Since we do not create a `GILPool` at all, it is important that our usage of the GIL
-    // token does not produce any owned objects thereby calling into `register_owned`.
+    // reconstruct a Python token via `PyRef::py`.)
     let trap = PanicTrap::new("uncaught panic inside __traverse__ handler");
+    let lock = ForbidAttaching::during_traverse();
 
-    let py = Python::assume_gil_acquired();
-    let slf = py.from_borrowed_ptr::<PyCell<T>>(slf);
-    let borrow = slf.try_borrow_threadsafe();
-    let visit = PyVisit::from_raw(visit, arg, py);
+    let super_retval = unsafe { call_super_traverse(slf, visit, arg, current_traverse) };
+    if super_retval != 0 {
+        return super_retval;
+    }
 
-    let retval = if let Ok(borrow) = borrow {
-        let _lock = LockGIL::during_traverse();
+    // SAFETY: `slf` is a valid Python object pointer to a class object of type T, and
+    // traversal is running so no mutations can occur.
+    let class_object: &PyClassObject<T> = unsafe { &*slf.cast() };
+
+    let retval =
+    // `#[pyclass(unsendable)]` types can only be deallocated by their own thread, so
+    // do not traverse them if not on their owning thread :(
+    if class_object.check_threadsafe().is_ok()
+    // ... and we cannot traverse a type which might be being mutated by a Rust thread
+    && class_object.borrow_checker().try_borrow().is_ok() {
+        struct TraverseGuard<'a, T: PyClass>(&'a PyClassObject<T>);
+        impl<T: PyClass> Drop for TraverseGuard<'_,  T> {
+            fn drop(&mut self) {
+                self.0.borrow_checker().release_borrow()
+            }
+        }
 
-        match catch_unwind(AssertUnwindSafe(move || impl_(&*borrow, visit))) {
-            Ok(res) => match res {
-                Ok(()) => 0,
-                Err(PyTraverseError(value)) => value,
-            },
+        // `.try_borrow()` above created a borrow, we need to release it when we're done
+        // traversing the object. This allows us to read `instance` safely.
+        let _guard = TraverseGuard(class_object);
+        let instance = unsafe {&*class_object.contents.value.get()};
+
+        let visit = PyVisit { visit, arg, _guard: PhantomData };
+
+        match catch_unwind(AssertUnwindSafe(move || impl_(instance, visit))) {
+            Ok(Ok(())) => 0,
+            Ok(Err(traverse_error)) => traverse_error.into_inner(),
             Err(_err) => -1,
         }
     } else {
         0
     };
+
+    // Drop lock before trap just in case dropping lock panics
+    drop(lock);
     trap.disarm();
     retval
 }
 
-pub(crate) struct PyMethodDefDestructor {
-    // These members are just to avoid leaking CStrings when possible
-    #[allow(dead_code)]
-    name: Cow<'static, CStr>,
-    #[allow(dead_code)]
-    doc: Cow<'static, CStr>,
+/// Call super-type traverse method, if necessary.
+///
+/// Adapted from <https://github.com/cython/cython/blob/7acfb375fb54a033f021b0982a3cd40c34fb22ac/Cython/Utility/ExtensionTypes.c#L386>
+///
+/// TODO: There are possible optimizations over looking up the base type in this way
+/// - if the base type is known in this module, can potentially look it up directly in module state
+///   (when we have it)
+/// - if the base type is a Python builtin, can jut call the C function directly
+/// - if the base type is a PyO3 type defined in the same module, can potentially do similar to
+///   tp_alloc where we solve this at compile time
+unsafe fn call_super_traverse(
+    obj: *mut ffi::PyObject,
+    visit: ffi::visitproc,
+    arg: *mut c_void,
+    current_traverse: ffi::traverseproc,
+) -> c_int {
+    // SAFETY: in this function here it's ok to work with raw type objects `ffi::Py_TYPE`
+    // because the GC is running and so
+    // - (a) we cannot do refcounting and
+    // - (b) the type of the object cannot change.
+    let mut ty = unsafe { ffi::Py_TYPE(obj) };
+    let mut traverse: Option<ffi::traverseproc>;
+
+    // First find the current type by the current_traverse function
+    loop {
+        traverse = unsafe { get_slot(ty, TP_TRAVERSE) };
+        if traverse_eq(traverse, current_traverse) {
+            break;
+        }
+        ty = unsafe { get_slot(ty, TP_BASE) };
+        if ty.is_null() {
+            // FIXME: return an error if current type not in the MRO? Should be impossible.
+            return 0;
+        }
+    }
+
+    // Get first base which has a different traverse function
+    while traverse_eq(traverse, current_traverse) {
+        ty = unsafe { get_slot(ty, TP_BASE) };
+        if ty.is_null() {
+            break;
+        }
+        traverse = unsafe { get_slot(ty, TP_TRAVERSE) };
+    }
+
+    // If we found a type with a different traverse function, call it
+    if let Some(traverse) = traverse {
+        return unsafe { traverse(obj, visit, arg) };
+    }
+
+    // FIXME same question as cython: what if the current type is not in the MRO?
+    0
 }
 
-pub(crate) fn get_name(name: &'static str) -> PyResult<Cow<'static, CStr>> {
-    extract_c_string(name, "function name cannot contain NUL byte.")
+/// Calls an implementation of __clear__ for tp_clear
+pub unsafe fn _call_clear(
+    slf: *mut ffi::PyObject,
+    impl_: for<'py> unsafe fn(Python<'py>, *mut ffi::PyObject) -> PyResult<()>,
+    current_clear: ffi::inquiry,
+) -> c_int {
+    unsafe {
+        trampoline::trampoline(move |py| {
+            let super_retval = call_super_clear(py, slf, current_clear);
+            if super_retval != 0 {
+                return Err(PyErr::fetch(py));
+            }
+            impl_(py, slf)?;
+            Ok(0)
+        })
+    }
 }
 
-pub(crate) fn get_doc(doc: &'static str) -> PyResult<Cow<'static, CStr>> {
-    extract_c_string(doc, "function doc cannot contain NUL byte.")
+/// Call super-type traverse method, if necessary.
+///
+/// Adapted from <https://github.com/cython/cython/blob/7acfb375fb54a033f021b0982a3cd40c34fb22ac/Cython/Utility/ExtensionTypes.c#L386>
+///
+/// TODO: There are possible optimizations over looking up the base type in this way
+/// - if the base type is known in this module, can potentially look it up directly in module state
+///   (when we have it)
+/// - if the base type is a Python builtin, can jut call the C function directly
+/// - if the base type is a PyO3 type defined in the same module, can potentially do similar to
+///   tp_alloc where we solve this at compile time
+unsafe fn call_super_clear(
+    py: Python<'_>,
+    obj: *mut ffi::PyObject,
+    current_clear: ffi::inquiry,
+) -> c_int {
+    let mut ty = unsafe { PyType::from_borrowed_type_ptr(py, ffi::Py_TYPE(obj)) };
+    let mut clear: Option<ffi::inquiry>;
+
+    // First find the current type by the current_clear function
+    loop {
+        clear = ty.get_slot(TP_CLEAR);
+        if clear_eq(clear, current_clear) {
+            break;
+        }
+        let base = ty.get_slot(TP_BASE);
+        if base.is_null() {
+            // FIXME: return an error if current type not in the MRO? Should be impossible.
+            return 0;
+        }
+        ty = unsafe { PyType::from_borrowed_type_ptr(py, base) };
+    }
+
+    // Get first base which has a different clear function
+    while clear_eq(clear, current_clear) {
+        let base = ty.get_slot(TP_BASE);
+        if base.is_null() {
+            break;
+        }
+        ty = unsafe { PyType::from_borrowed_type_ptr(py, base) };
+        clear = ty.get_slot(TP_CLEAR);
+    }
+
+    // If we found a type with a different clear function, call it
+    if let Some(clear) = clear {
+        return unsafe { clear(obj) };
+    }
+
+    // FIXME same question as cython: what if the current type is not in the MRO?
+    0
 }
 
 // Autoref-based specialization for handling `__next__` returning `Option`
@@ -313,9 +455,9 @@ pub struct IterBaseTag;
 
 impl IterBaseTag {
     #[inline]
-    pub fn convert<Value, Target>(self, py: Python<'_>, value: Value) -> PyResult<Target>
+    pub fn convert<'py, Value, Target>(self, py: Python<'py>, value: Value) -> PyResult<Target>
     where
-        Value: IntoPyCallbackOutput<Target>,
+        Value: IntoPyCallbackOutput<'py, Target>,
     {
         value.convert(py)
     }
@@ -334,13 +476,13 @@ pub struct IterOptionTag;
 
 impl IterOptionTag {
     #[inline]
-    pub fn convert<Value>(
+    pub fn convert<'py, Value>(
         self,
-        py: Python<'_>,
+        py: Python<'py>,
         value: Option<Value>,
     ) -> PyResult<*mut ffi::PyObject>
     where
-        Value: IntoPyCallbackOutput<*mut ffi::PyObject>,
+        Value: IntoPyCallbackOutput<'py, *mut ffi::PyObject>,
     {
         match value {
             Some(value) => value.convert(py),
@@ -362,13 +504,13 @@ pub struct IterResultOptionTag;
 
 impl IterResultOptionTag {
     #[inline]
-    pub fn convert<Value, Error>(
+    pub fn convert<'py, Value, Error>(
         self,
-        py: Python<'_>,
+        py: Python<'py>,
         value: Result<Option<Value>, Error>,
     ) -> PyResult<*mut ffi::PyObject>
     where
-        Value: IntoPyCallbackOutput<*mut ffi::PyObject>,
+        Value: IntoPyCallbackOutput<'py, *mut ffi::PyObject>,
         Error: Into<PyErr>,
     {
         match value {
@@ -394,9 +536,9 @@ pub struct AsyncIterBaseTag;
 
 impl AsyncIterBaseTag {
     #[inline]
-    pub fn convert<Value, Target>(self, py: Python<'_>, value: Value) -> PyResult<Target>
+    pub fn convert<'py, Value, Target>(self, py: Python<'py>, value: Value) -> PyResult<Target>
     where
-        Value: IntoPyCallbackOutput<Target>,
+        Value: IntoPyCallbackOutput<'py, Target>,
     {
         value.convert(py)
     }
@@ -415,13 +557,13 @@ pub struct AsyncIterOptionTag;
 
 impl AsyncIterOptionTag {
     #[inline]
-    pub fn convert<Value>(
+    pub fn convert<'py, Value>(
         self,
-        py: Python<'_>,
+        py: Python<'py>,
         value: Option<Value>,
     ) -> PyResult<*mut ffi::PyObject>
     where
-        Value: IntoPyCallbackOutput<*mut ffi::PyObject>,
+        Value: IntoPyCallbackOutput<'py, *mut ffi::PyObject>,
     {
         match value {
             Some(value) => value.convert(py),
@@ -443,13 +585,13 @@ pub struct AsyncIterResultOptionTag;
 
 impl AsyncIterResultOptionTag {
     #[inline]
-    pub fn convert<Value, Error>(
+    pub fn convert<'py, Value, Error>(
         self,
-        py: Python<'_>,
+        py: Python<'py>,
         value: Result<Option<Value>, Error>,
     ) -> PyResult<*mut ffi::PyObject>
     where
-        Value: IntoPyCallbackOutput<*mut ffi::PyObject>,
+        Value: IntoPyCallbackOutput<'py, *mut ffi::PyObject>,
         Error: Into<PyErr>,
     {
         match value {
@@ -480,27 +622,65 @@ pub struct BoundRef<'a, 'py, T>(pub &'a Bound<'py, T>);
 
 impl<'a, 'py> BoundRef<'a, 'py, PyAny> {
     pub unsafe fn ref_from_ptr(py: Python<'py>, ptr: &'a *mut ffi::PyObject) -> Self {
-        BoundRef(Bound::ref_from_ptr(py, ptr))
+        unsafe { BoundRef(Bound::ref_from_ptr(py, ptr)) }
+    }
+
+    pub unsafe fn ref_from_ptr_or_opt(
+        py: Python<'py>,
+        ptr: &'a *mut ffi::PyObject,
+    ) -> Option<Self> {
+        unsafe { Bound::ref_from_ptr_or_opt(py, ptr).as_ref().map(BoundRef) }
+    }
+
+    pub unsafe fn ref_from_non_null(py: Python<'py>, ptr: &'a NonNull<ffi::PyObject>) -> Self {
+        unsafe { Self(Bound::ref_from_non_null(py, ptr)) }
+    }
+
+    pub fn cast<T: PyTypeCheck>(self) -> Result<BoundRef<'a, 'py, T>, CastError<'a, 'py>> {
+        self.0.cast::<T>().map(BoundRef)
+    }
+
+    pub unsafe fn cast_unchecked<T>(self) -> BoundRef<'a, 'py, T> {
+        unsafe { BoundRef(self.0.cast_unchecked::<T>()) }
+    }
+}
+
+impl<'a, 'py, T: PyClass> TryFrom<BoundRef<'a, 'py, T>> for PyClassGuard<'a, T> {
+    type Error = PyBorrowError;
+    #[inline]
+    fn try_from(value: BoundRef<'a, 'py, T>) -> Result<Self, Self::Error> {
+        PyClassGuard::try_borrow(value.0.as_unbound())
     }
+}
 
-    pub unsafe fn downcast_unchecked<T>(self) -> BoundRef<'a, 'py, T> {
-        BoundRef(self.0.downcast_unchecked::<T>())
+impl<'a, 'py, T: PyClass<Frozen = False>> TryFrom<BoundRef<'a, 'py, T>> for PyClassGuardMut<'a, T> {
+    type Error = PyBorrowMutError;
+    #[inline]
+    fn try_from(value: BoundRef<'a, 'py, T>) -> Result<Self, Self::Error> {
+        PyClassGuardMut::try_borrow_mut(value.0.as_unbound())
+    }
+}
+
+impl<'a, 'py, T: PyClass> TryFrom<BoundRef<'a, 'py, T>> for PyRef<'py, T> {
+    type Error = PyBorrowError;
+    #[inline]
+    fn try_from(value: BoundRef<'a, 'py, T>) -> Result<Self, Self::Error> {
+        PyRef::try_borrow(value.0)
     }
 }
 
-// GIL Ref implementations for &'a T ran into trouble with orphan rules,
-// so explicit implementations are used instead for the two relevant types.
-impl<'a> From<BoundRef<'a, 'a, PyType>> for &'a PyType {
+impl<'a, 'py, T: PyClass<Frozen = False>> TryFrom<BoundRef<'a, 'py, T>> for PyRefMut<'py, T> {
+    type Error = PyBorrowMutError;
     #[inline]
-    fn from(bound: BoundRef<'a, 'a, PyType>) -> Self {
-        bound.0.as_gil_ref()
+    fn try_from(value: BoundRef<'a, 'py, T>) -> Result<Self, Self::Error> {
+        PyRefMut::try_borrow(value.0)
     }
 }
 
-impl<'a> From<BoundRef<'a, 'a, PyModule>> for &'a PyModule {
+impl<'a, 'py, T> From<BoundRef<'a, 'py, T>> for Bound<'py, T> {
     #[inline]
-    fn from(bound: BoundRef<'a, 'a, PyModule>) -> Self {
-        bound.0.as_gil_ref()
+    fn from(bound: BoundRef<'a, 'py, T>) -> Self {
+        bound.0.clone()
     }
 }
 
@@ -517,3 +697,62 @@ impl<T> From<BoundRef<'_, '_, T>> for Py<T> {
         bound.0.clone().unbind()
     }
 }
+
+impl<'py, T> std::ops::Deref for BoundRef<'_, 'py, T> {
+    type Target = Bound<'py, T>;
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        self.0
+    }
+}
+
+pub unsafe fn tp_new_impl<T: PyClass>(
+    py: Python<'_>,
+    initializer: PyClassInitializer<T>,
+    target_type: *mut ffi::PyTypeObject,
+) -> PyResult<*mut ffi::PyObject> {
+    unsafe {
+        initializer
+            .create_class_object_of_type(py, target_type)
+            .map(Bound::into_ptr)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    #[cfg(any(Py_3_10, not(Py_LIMITED_API)))]
+    fn test_fastcall_function_with_keywords() {
+        use super::PyMethodDef;
+        use crate::impl_::pyfunction::PyFunctionDef;
+        use crate::types::PyAnyMethods;
+        use crate::{ffi, Python};
+
+        Python::attach(|py| {
+            let def =
+                PyFunctionDef::from_method_def(PyMethodDef::fastcall_cfunction_with_keywords(
+                    c"test",
+                    accepts_no_arguments,
+                    c"doc",
+                ));
+            // leak to make it 'static
+            // deliberately done at runtime to have coverage of `PyFunctionDef::from_method_def`
+            let def = Box::leak(Box::new(def));
+
+            unsafe extern "C" fn accepts_no_arguments(
+                _slf: *mut ffi::PyObject,
+                _args: *const *mut ffi::PyObject,
+                nargs: ffi::Py_ssize_t,
+                kwargs: *mut ffi::PyObject,
+            ) -> *mut ffi::PyObject {
+                assert_eq!(nargs, 0);
+                assert!(kwargs.is_null());
+                unsafe { Python::assume_attached().None().into_ptr() }
+            }
+
+            let f = def.create_py_c_function(py, None).unwrap();
+
+            f.call0().unwrap();
+        });
+    }
+}
diff --git a/src/impl_/pymodule.rs b/src/impl_/pymodule.rs
index ff72285558a..7151ad3bad3 100644
--- a/src/impl_/pymodule.rs
+++ b/src/impl_/pymodule.rs
@@ -1,13 +1,35 @@
 //! Implementation details of `#[pymodule]` which need to be accessible from proc-macro generated code.
 
-use std::cell::UnsafeCell;
+use std::{cell::UnsafeCell, ffi::CStr, marker::PhantomData};
 
-#[cfg(all(not(PyPy), Py_3_9, not(all(windows, Py_LIMITED_API, not(Py_3_10)))))]
-use portable_atomic::{AtomicI64, Ordering};
+#[cfg(all(
+    not(any(PyPy, GraalPy)),
+    Py_3_9,
+    not(all(windows, Py_LIMITED_API, not(Py_3_10))),
+    not(target_has_atomic = "64"),
+))]
+use portable_atomic::AtomicI64;
+#[cfg(all(
+    not(any(PyPy, GraalPy)),
+    Py_3_9,
+    not(all(windows, Py_LIMITED_API, not(Py_3_10))),
+    target_has_atomic = "64",
+))]
+use std::sync::atomic::AtomicI64;
+use std::sync::atomic::{AtomicBool, Ordering};
 
-#[cfg(not(PyPy))]
+#[cfg(not(any(PyPy, GraalPy)))]
 use crate::exceptions::PyImportError;
-use crate::{ffi, sync::GILOnceCell, types::PyModule, Py, PyResult, Python};
+use crate::prelude::PyTypeMethods;
+#[cfg(all(not(Py_LIMITED_API), Py_GIL_DISABLED))]
+use crate::PyErr;
+use crate::{
+    ffi,
+    impl_::pyfunction::PyFunctionDef,
+    sync::PyOnceLock,
+    types::{PyModule, PyModuleMethods},
+    Bound, Py, PyClass, PyResult, PyTypeInfo, Python,
+};
 
 /// `Sync` wrapper of `ffi::PyModuleDef`.
 pub struct ModuleDef {
@@ -15,27 +37,31 @@ pub struct ModuleDef {
     ffi_def: UnsafeCell<ffi::PyModuleDef>,
     initializer: ModuleInitializer,
     /// Interpreter ID where module was initialized (not applicable on PyPy).
-    #[cfg(all(not(PyPy), Py_3_9, not(all(windows, Py_LIMITED_API, not(Py_3_10)))))]
+    #[cfg(all(
+        not(any(PyPy, GraalPy)),
+        Py_3_9,
+        not(all(windows, Py_LIMITED_API, not(Py_3_10)))
+    ))]
     interpreter: AtomicI64,
     /// Initialized module object, cached to avoid reinitialization.
-    module: GILOnceCell<Py<PyModule>>,
+    module: PyOnceLock<Py<PyModule>>,
+    /// Whether or not the module supports running without the GIL
+    gil_used: AtomicBool,
 }
 
 /// Wrapper to enable initializer to be used in const fns.
-pub struct ModuleInitializer(pub for<'py> fn(Python<'py>, &PyModule) -> PyResult<()>);
+pub struct ModuleInitializer(pub for<'py> fn(&Bound<'py, PyModule>) -> PyResult<()>);
 
 unsafe impl Sync for ModuleDef {}
 
 impl ModuleDef {
     /// Make new module definition with given module name.
-    ///
-    /// # Safety
-    /// `name` and `doc` must be null-terminated strings.
     pub const unsafe fn new(
-        name: &'static str,
-        doc: &'static str,
+        name: &'static CStr,
+        doc: &'static CStr,
         initializer: ModuleInitializer,
     ) -> Self {
+        #[allow(clippy::declare_interior_mutable_const)]
         const INIT: ffi::PyModuleDef = ffi::PyModuleDef {
             m_base: ffi::PyModuleDef_HEAD_INIT,
             m_name: std::ptr::null(),
@@ -49,8 +75,8 @@ impl ModuleDef {
         };
 
         let ffi_def = UnsafeCell::new(ffi::PyModuleDef {
-            m_name: name.as_ptr() as *const _,
-            m_doc: doc.as_ptr() as *const _,
+            m_name: name.as_ptr(),
+            m_doc: doc.as_ptr(),
             ..INIT
         });
 
@@ -58,34 +84,24 @@ impl ModuleDef {
             ffi_def,
             initializer,
             // -1 is never expected to be a valid interpreter ID
-            #[cfg(all(not(PyPy), Py_3_9, not(all(windows, Py_LIMITED_API, not(Py_3_10)))))]
+            #[cfg(all(
+                not(any(PyPy, GraalPy)),
+                Py_3_9,
+                not(all(windows, Py_LIMITED_API, not(Py_3_10)))
+            ))]
             interpreter: AtomicI64::new(-1),
-            module: GILOnceCell::new(),
+            module: PyOnceLock::new(),
+            gil_used: AtomicBool::new(true),
         }
     }
     /// Builds a module using user given initializer. Used for [`#[pymodule]`][crate::pymodule].
-    pub fn make_module(&'static self, py: Python<'_>) -> PyResult<Py<PyModule>> {
-        #[cfg(all(PyPy, not(Py_3_8)))]
-        {
-            use crate::types::any::PyAnyMethods;
-            const PYPY_GOOD_VERSION: [u8; 3] = [7, 3, 8];
-            let version = py
-                .import_bound("sys")?
-                .getattr("implementation")?
-                .getattr("version")?;
-            if version.lt(crate::types::PyTuple::new_bound(py, PYPY_GOOD_VERSION))? {
-                let warn = py.import_bound("warnings")?.getattr("warn")?;
-                warn.call1((
-                    "PyPy 3.7 versions older than 7.3.8 are known to have binary \
-                        compatibility issues which may cause segfaults. Please upgrade.",
-                ))?;
-            }
-        }
+    #[cfg_attr(any(Py_LIMITED_API, not(Py_GIL_DISABLED)), allow(unused_variables))]
+    pub fn make_module(&'static self, py: Python<'_>, gil_used: bool) -> PyResult<Py<PyModule>> {
         // Check the interpreter ID has not changed, since we currently have no way to guarantee
         // that static data is not reused across interpreters.
         //
         // PyPy does not have subinterpreters, so no need to check interpreter ID.
-        #[cfg(not(PyPy))]
+        #[cfg(not(any(PyPy, GraalPy)))]
         {
             // PyInterpreterState_Get is only available on 3.9 and later, but is missing
             // from python3.dll for Windows stable API on 3.9
@@ -126,18 +142,96 @@ impl ModuleDef {
                         ffi::PyModule_Create(self.ffi_def.get()),
                     )?
                 };
-                (self.initializer.0)(py, module.as_ref(py))?;
+                #[cfg(all(not(Py_LIMITED_API), Py_GIL_DISABLED))]
+                {
+                    let gil_used_ptr = {
+                        if gil_used {
+                            ffi::Py_MOD_GIL_USED
+                        } else {
+                            ffi::Py_MOD_GIL_NOT_USED
+                        }
+                    };
+                    if unsafe { ffi::PyUnstable_Module_SetGIL(module.as_ptr(), gil_used_ptr) } < 0 {
+                        return Err(PyErr::fetch(py));
+                    }
+                }
+                self.initializer.0(module.bind(py))?;
                 Ok(module)
             })
             .map(|py_module| py_module.clone_ref(py))
     }
 }
 
+/// Trait to add an element (class, function...) to a module.
+///
+/// Currently only implemented for classes.
+pub trait PyAddToModule: crate::sealed::Sealed {
+    fn add_to_module(&'static self, module: &Bound<'_, PyModule>) -> PyResult<()>;
+}
+
+/// For adding native types (non-pyclass) to a module.
+pub struct AddTypeToModule<T>(PhantomData<T>);
+
+impl<T> AddTypeToModule<T> {
+    #[allow(clippy::new_without_default)]
+    pub const fn new() -> Self {
+        AddTypeToModule(PhantomData)
+    }
+}
+
+impl<T: PyTypeInfo> PyAddToModule for AddTypeToModule<T> {
+    fn add_to_module(&'static self, module: &Bound<'_, PyModule>) -> PyResult<()> {
+        let object = T::type_object(module.py());
+        module.add(object.name()?, object)
+    }
+}
+
+/// For adding a class to a module.
+pub struct AddClassToModule<T>(PhantomData<T>);
+
+impl<T> AddClassToModule<T> {
+    #[allow(clippy::new_without_default)]
+    pub const fn new() -> Self {
+        AddClassToModule(PhantomData)
+    }
+}
+
+impl<T: PyClass> PyAddToModule for AddClassToModule<T> {
+    fn add_to_module(&'static self, module: &Bound<'_, PyModule>) -> PyResult<()> {
+        module.add_class::<T>()
+    }
+}
+
+/// For adding a function to a module.
+impl PyAddToModule for PyFunctionDef {
+    fn add_to_module(&'static self, module: &Bound<'_, PyModule>) -> PyResult<()> {
+        // safety: self is static
+        module.add_function(self.create_py_c_function(module.py(), Some(module))?)
+    }
+}
+
+/// For adding a module to a module.
+impl PyAddToModule for ModuleDef {
+    fn add_to_module(&'static self, module: &Bound<'_, PyModule>) -> PyResult<()> {
+        module.add_submodule(
+            self.make_module(module.py(), self.gil_used.load(Ordering::Relaxed))?
+                .bind(module.py()),
+        )
+    }
+}
+
 #[cfg(test)]
 mod tests {
-    use std::sync::atomic::{AtomicBool, Ordering};
+    use std::{
+        borrow::Cow,
+        ffi::CStr,
+        sync::atomic::{AtomicBool, Ordering},
+    };
 
-    use crate::{types::PyModule, PyResult, Python};
+    use crate::{
+        types::{any::PyAnyMethods, module::PyModuleMethods, PyModule},
+        Bound, PyResult, Python,
+    };
 
     use super::{ModuleDef, ModuleInitializer};
 
@@ -145,21 +239,21 @@ mod tests {
     fn module_init() {
         static MODULE_DEF: ModuleDef = unsafe {
             ModuleDef::new(
-                "test_module\0",
-                "some doc\0",
-                ModuleInitializer(|_, m| {
+                c"test_module",
+                c"some doc",
+                ModuleInitializer(|m| {
                     m.add("SOME_CONSTANT", 42)?;
                     Ok(())
                 }),
             )
         };
-        Python::with_gil(|py| {
-            let module = MODULE_DEF.make_module(py).unwrap().into_ref(py);
+        Python::attach(|py| {
+            let module = MODULE_DEF.make_module(py, false).unwrap().into_bound(py);
             assert_eq!(
                 module
                     .getattr("__name__")
                     .unwrap()
-                    .extract::<&str>()
+                    .extract::<Cow<'_, str>>()
                     .unwrap(),
                 "test_module",
             );
@@ -167,7 +261,7 @@ mod tests {
                 module
                     .getattr("__doc__")
                     .unwrap()
-                    .extract::<&str>()
+                    .extract::<Cow<'_, str>>()
                     .unwrap(),
                 "some doc",
             );
@@ -186,13 +280,13 @@ mod tests {
     fn module_def_new() {
         // To get coverage for ModuleDef::new() need to create a non-static ModuleDef, however init
         // etc require static ModuleDef, so this test needs to be separated out.
-        static NAME: &str = "test_module\0";
-        static DOC: &str = "some doc\0";
+        static NAME: &CStr = c"test_module";
+        static DOC: &CStr = c"some doc";
 
         static INIT_CALLED: AtomicBool = AtomicBool::new(false);
 
         #[allow(clippy::unnecessary_wraps)]
-        fn init(_: Python<'_>, _: &PyModule) -> PyResult<()> {
+        fn init(_: &Bound<'_, PyModule>) -> PyResult<()> {
             INIT_CALLED.store(true, Ordering::SeqCst);
             Ok(())
         }
@@ -202,9 +296,8 @@ mod tests {
             assert_eq!((*module_def.ffi_def.get()).m_name, NAME.as_ptr() as _);
             assert_eq!((*module_def.ffi_def.get()).m_doc, DOC.as_ptr() as _);
 
-            Python::with_gil(|py| {
-                module_def.initializer.0(py, py.import_bound("builtins").unwrap().into_gil_ref())
-                    .unwrap();
+            Python::attach(|py| {
+                module_def.initializer.0(&py.import("builtins").unwrap()).unwrap();
                 assert!(INIT_CALLED.load(Ordering::SeqCst));
             })
         }
diff --git a/src/impl_/trampoline.rs b/src/impl_/trampoline.rs
index 4b4eac17a15..6bcf71c6ca7 100644
--- a/src/impl_/trampoline.rs
+++ b/src/impl_/trampoline.rs
@@ -9,26 +9,29 @@ use std::{
     panic::{self, UnwindSafe},
 };
 
+use crate::internal::state::AttachGuard;
 use crate::{
-    callback::PyCallbackOutput, ffi, ffi_ptr_ext::FfiPtrExt, impl_::panic::PanicTrap,
-    methods::IPowModulo, panic::PanicException, types::PyModule, GILPool, Py, PyResult, Python,
+    ffi, ffi_ptr_ext::FfiPtrExt, impl_::callback::PyCallbackOutput, impl_::panic::PanicTrap,
+    impl_::pymethods::IPowModulo, panic::PanicException, types::PyModule, Py, PyResult, Python,
 };
 
 #[inline]
 pub unsafe fn module_init(
     f: for<'py> unsafe fn(Python<'py>) -> PyResult<Py<PyModule>>,
 ) -> *mut ffi::PyObject {
-    trampoline(|py| f(py).map(|module| module.into_ptr()))
+    unsafe { trampoline(|py| f(py).map(|module| module.into_ptr())) }
 }
 
 #[inline]
+#[allow(clippy::used_underscore_binding)]
 pub unsafe fn noargs(
     slf: *mut ffi::PyObject,
-    args: *mut ffi::PyObject,
+    _args: *mut ffi::PyObject,
     f: for<'py> unsafe fn(Python<'py>, *mut ffi::PyObject) -> PyResult<*mut ffi::PyObject>,
 ) -> *mut ffi::PyObject {
-    debug_assert!(args.is_null());
-    trampoline(|py| f(py, slf))
+    #[cfg(not(GraalPy))] // this is not specified and GraalPy does not pass null here
+    debug_assert!(_args.is_null());
+    unsafe { trampoline(|py| f(py, slf)) }
 }
 
 macro_rules! trampoline {
@@ -38,7 +41,7 @@ macro_rules! trampoline {
             $($arg_names: $arg_types,)*
             f: for<'py> unsafe fn (Python<'py>, $($arg_types),*) -> PyResult<$ret>,
         ) -> $ret {
-            trampoline(|py| f(py, $($arg_names,)*))
+            unsafe {trampoline(|py| f(py, $($arg_names,)*))}
         }
     }
 }
@@ -131,7 +134,7 @@ pub unsafe fn releasebufferproc(
     buf: *mut ffi::Py_buffer,
     f: for<'py> unsafe fn(Python<'py>, *mut ffi::PyObject, *mut ffi::Py_buffer) -> PyResult<()>,
 ) {
-    trampoline_unraisable(|py| f(py, slf, buf), slf)
+    unsafe { trampoline_unraisable(|py| f(py, slf, buf), slf) }
 }
 
 #[inline]
@@ -143,13 +146,15 @@ pub(crate) unsafe fn dealloc(
     // so pass null_mut() to the context.
     //
     // (Note that we don't allow the implementation `f` to fail.)
-    trampoline_unraisable(
-        |py| {
-            f(py, slf);
-            Ok(())
-        },
-        std::ptr::null_mut(),
-    )
+    unsafe {
+        trampoline_unraisable(
+            |py| {
+                f(py, slf);
+                Ok(())
+            },
+            std::ptr::null_mut(),
+        )
+    }
 }
 
 // Ipowfunc is a unique case where PyO3 has its own type
@@ -163,19 +168,23 @@ trampoline!(
     ) -> *mut ffi::PyObject;
 );
 
-/// Implementation of trampoline functions, which sets up a GILPool and calls F.
+/// Implementation of trampoline functions, which sets up an AttachGuard and calls F.
 ///
 /// Panics during execution are trapped so that they don't propagate through any
 /// outer FFI boundary.
+///
+/// The thread must already be attached to the interpreter when this is called.
 #[inline]
-pub(crate) fn trampoline<F, R>(body: F) -> R
+pub(crate) unsafe fn trampoline<F, R>(body: F) -> R
 where
     F: for<'py> FnOnce(Python<'py>) -> PyResult<R> + UnwindSafe,
     R: PyCallbackOutput,
 {
     let trap = PanicTrap::new("uncaught panic at ffi boundary");
-    let pool = unsafe { GILPool::new() };
-    let py = pool.python();
+
+    // SAFETY: This function requires the thread to already be attached.
+    let guard = unsafe { AttachGuard::assume() };
+    let py = guard.python();
     let out = panic_result_into_callback_output(
         py,
         panic::catch_unwind(move || -> PyResult<_> { body(py) }),
@@ -212,19 +221,23 @@ where
 ///
 /// # Safety
 ///
-/// ctx must be either a valid ffi::PyObject or NULL
+/// - ctx must be either a valid ffi::PyObject or NULL
+/// - The thread must be attached to the interpreter when this is called.
 #[inline]
 unsafe fn trampoline_unraisable<F>(body: F, ctx: *mut ffi::PyObject)
 where
     F: for<'py> FnOnce(Python<'py>) -> PyResult<()> + UnwindSafe,
 {
     let trap = PanicTrap::new("uncaught panic at ffi boundary");
-    let pool = GILPool::new();
-    let py = pool.python();
+
+    // SAFETY: Thread is known to be attached.
+    let guard = unsafe { AttachGuard::assume() };
+    let py = guard.python();
+
     if let Err(py_err) = panic::catch_unwind(move || body(py))
         .unwrap_or_else(|payload| Err(PanicException::from_panic_payload(payload)))
     {
-        py_err.write_unraisable_bound(py, ctx.assume_borrowed_or_opt(py).as_deref());
+        py_err.write_unraisable(py, unsafe { ctx.assume_borrowed_or_opt(py) }.as_deref());
     }
     trap.disarm();
 }
diff --git a/src/impl_/wrap.rs b/src/impl_/wrap.rs
index 2110d8411d0..9d3372cfe60 100644
--- a/src/impl_/wrap.rs
+++ b/src/impl_/wrap.rs
@@ -1,6 +1,8 @@
-use std::convert::Infallible;
+use std::{convert::Infallible, marker::PhantomData, ops::Deref};
 
-use crate::{ffi, IntoPy, PyObject, PyResult, Python};
+use crate::{
+    ffi, types::PyNone, Bound, IntoPyObject, IntoPyObjectExt, Py, PyAny, PyResult, Python,
+};
 
 /// Used to wrap values in `Option<T>` for default arguments.
 pub trait SomeWrap<T> {
@@ -19,52 +21,127 @@ impl<T> SomeWrap<T> for Option<T> {
     }
 }
 
-/// Used to wrap the result of `#[pyfunction]` and `#[pymethods]`.
-pub trait OkWrap<T> {
-    type Error;
-    fn wrap(self) -> Result<T, Self::Error>;
+// Hierarchy of conversions used in the `IntoPy` implementation
+pub struct Converter<T>(EmptyTupleConverter<T>);
+pub struct EmptyTupleConverter<T>(IntoPyObjectConverter<T>);
+pub struct IntoPyObjectConverter<T>(IntoPyConverter<T>);
+pub struct IntoPyConverter<T>(UnknownReturnResultType<T>);
+pub struct UnknownReturnResultType<T>(UnknownReturnType<T>);
+pub struct UnknownReturnType<T>(PhantomData<T>);
+
+pub fn converter<T>(_: &T) -> Converter<T> {
+    Converter(EmptyTupleConverter(IntoPyObjectConverter(IntoPyConverter(
+        UnknownReturnResultType(UnknownReturnType(PhantomData)),
+    ))))
+}
+
+impl<T> Deref for Converter<T> {
+    type Target = EmptyTupleConverter<T>;
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
 }
 
-// The T: IntoPy<PyObject> bound here is necessary to prevent the
-// implementation for Result<T, E> from conflicting
-impl<T> OkWrap<T> for T
-where
-    T: IntoPy<PyObject>,
-{
-    type Error = Infallible;
+impl<T> Deref for EmptyTupleConverter<T> {
+    type Target = IntoPyObjectConverter<T>;
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl<T> Deref for IntoPyObjectConverter<T> {
+    type Target = IntoPyConverter<T>;
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl<T> Deref for IntoPyConverter<T> {
+    type Target = UnknownReturnResultType<T>;
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl<T> Deref for UnknownReturnResultType<T> {
+    type Target = UnknownReturnType<T>;
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl EmptyTupleConverter<PyResult<()>> {
     #[inline]
-    fn wrap(self) -> Result<T, Infallible> {
-        Ok(self)
+    pub fn map_into_ptr(&self, py: Python<'_>, obj: PyResult<()>) -> PyResult<*mut ffi::PyObject> {
+        obj.map(|_| PyNone::get(py).to_owned().into_ptr())
     }
 }
 
-impl<T, E> OkWrap<T> for Result<T, E>
-where
-    T: IntoPy<PyObject>,
-{
-    type Error = E;
+impl<'py, T: IntoPyObject<'py>> IntoPyObjectConverter<T> {
     #[inline]
-    fn wrap(self) -> Result<T, Self::Error> {
-        self
+    pub fn wrap(&self, obj: T) -> Result<T, Infallible> {
+        Ok(obj)
+    }
+}
+
+impl<'py, T: IntoPyObject<'py>, E> IntoPyObjectConverter<Result<T, E>> {
+    #[inline]
+    pub fn wrap(&self, obj: Result<T, E>) -> Result<T, E> {
+        obj
+    }
+
+    #[inline]
+    pub fn map_into_pyobject(&self, py: Python<'py>, obj: PyResult<T>) -> PyResult<Py<PyAny>>
+    where
+        T: IntoPyObject<'py>,
+    {
+        obj.and_then(|obj| obj.into_py_any(py))
+    }
+
+    #[inline]
+    pub fn map_into_ptr(&self, py: Python<'py>, obj: PyResult<T>) -> PyResult<*mut ffi::PyObject>
+    where
+        T: IntoPyObject<'py>,
+    {
+        obj.and_then(|obj| obj.into_bound_py_any(py))
+            .map(Bound::into_ptr)
     }
 }
 
-/// This is a follow-up function to `OkWrap::wrap` that converts the result into
-/// a `*mut ffi::PyObject` pointer.
-pub fn map_result_into_ptr<T: IntoPy<PyObject>>(
-    py: Python<'_>,
-    result: PyResult<T>,
-) -> PyResult<*mut ffi::PyObject> {
-    result.map(|obj| obj.into_py(py).into_ptr())
+impl<T, E> UnknownReturnResultType<Result<T, E>> {
+    #[inline]
+    pub fn wrap<'py>(&self, _: Result<T, E>) -> Result<T, E>
+    where
+        T: IntoPyObject<'py>,
+    {
+        unreachable!("should be handled by IntoPyObjectConverter")
+    }
 }
 
-/// This is a follow-up function to `OkWrap::wrap` that converts the result into
-/// a safe wrapper.
-pub fn map_result_into_py<T: IntoPy<PyObject>>(
-    py: Python<'_>,
-    result: PyResult<T>,
-) -> PyResult<PyObject> {
-    result.map(|err| err.into_py(py))
+impl<T> UnknownReturnType<T> {
+    #[inline]
+    pub fn wrap<'py>(&self, _: T) -> T
+    where
+        T: IntoPyObject<'py>,
+    {
+        unreachable!("should be handled by IntoPyObjectConverter")
+    }
+
+    #[inline]
+    pub fn map_into_pyobject<'py>(&self, _: Python<'py>, _: PyResult<T>) -> PyResult<Py<PyAny>>
+    where
+        T: IntoPyObject<'py>,
+    {
+        unreachable!("should be handled by IntoPyObjectConverter")
+    }
+
+    #[inline]
+    pub fn map_into_ptr<'py>(&self, _: Python<'py>, _: PyResult<T>) -> PyResult<*mut ffi::PyObject>
+    where
+        T: IntoPyObject<'py>,
+    {
+        unreachable!("should be handled by IntoPyObjectConverter")
+    }
 }
 
 #[cfg(test)]
@@ -79,16 +156,4 @@ mod tests {
         let b: Option<u8> = SomeWrap::wrap(None);
         assert_eq!(b, None);
     }
-
-    #[test]
-    fn wrap_result() {
-        let a: Result<u8, _> = OkWrap::wrap(42u8);
-        assert!(matches!(a, Ok(42)));
-
-        let b: PyResult<u8> = OkWrap::wrap(Ok(42u8));
-        assert!(matches!(b, Ok(42)));
-
-        let c: Result<u8, &str> = OkWrap::wrap(Err("error"));
-        assert_eq!(c, Err("error"));
-    }
 }
diff --git a/src/inspect/mod.rs b/src/inspect/mod.rs
index f14f8a2d2ae..1bcc365bda0 100644
--- a/src/inspect/mod.rs
+++ b/src/inspect/mod.rs
@@ -1,4 +1,271 @@
 //! Runtime inspection of objects exposed to Python.
 //!
 //! Tracking issue: <https://github.com/PyO3/pyo3/issues/2454>.
+
+use std::fmt;
+use std::fmt::Formatter;
+
 pub mod types;
+
+/// A [type hint](https://docs.python.org/3/glossary.html#term-type-hint).
+///
+/// This struct aims at being used in `const` contexts like in [`FromPyObject::INPUT_TYPE`](crate::FromPyObject::INPUT_TYPE) and [`IntoPyObject::OUTPUT_TYPE`](crate::IntoPyObject::OUTPUT_TYPE).
+///
+/// ```
+/// use pyo3::inspect::TypeHint;
+///
+/// const T: TypeHint = TypeHint::union(&[TypeHint::builtin("int"), TypeHint::module_attr("b", "B")]);
+/// assert_eq!(T.to_string(), "int | b.B");
+/// ```
+#[derive(Clone, Copy)]
+pub struct TypeHint {
+    inner: TypeHintExpr,
+}
+
+#[derive(Clone, Copy)]
+enum TypeHintExpr {
+    /// A built-name like `list` or `datetime`. Used for built-in types or modules.
+    Builtin { id: &'static str },
+    /// A module member like `datetime.time` where module = `datetime` and attr = `time`
+    ModuleAttribute {
+        module: &'static str,
+        attr: &'static str,
+    },
+    /// A union elts[0] | ... | elts[len]
+    Union { elts: &'static [TypeHint] },
+    /// A subscript main[*args]
+    Subscript {
+        value: &'static TypeHint,
+        slice: &'static [TypeHint],
+    },
+}
+
+impl TypeHint {
+    /// A builtin like `int` or `list`
+    ///
+    /// ```
+    /// use pyo3::inspect::TypeHint;
+    ///
+    /// const T: TypeHint = TypeHint::builtin("int");
+    /// assert_eq!(T.to_string(), "int");
+    /// ```
+    pub const fn builtin(name: &'static str) -> Self {
+        Self {
+            inner: TypeHintExpr::Builtin { id: name },
+        }
+    }
+
+    /// A type contained in a module like `datetime.time`
+    ///
+    /// ```
+    /// use pyo3::inspect::TypeHint;
+    ///
+    /// const T: TypeHint = TypeHint::module_attr("datetime", "time");
+    /// assert_eq!(T.to_string(), "datetime.time");
+    /// ```
+    pub const fn module_attr(module: &'static str, attr: &'static str) -> Self {
+        Self {
+            inner: TypeHintExpr::ModuleAttribute { module, attr },
+        }
+    }
+
+    /// The union of multiple types
+    ///
+    /// ```
+    /// use pyo3::inspect::TypeHint;
+    ///
+    /// const T: TypeHint = TypeHint::union(&[TypeHint::builtin("int"), TypeHint::builtin("float")]);
+    /// assert_eq!(T.to_string(), "int | float");
+    /// ```
+    pub const fn union(elts: &'static [TypeHint]) -> Self {
+        Self {
+            inner: TypeHintExpr::Union { elts },
+        }
+    }
+
+    /// A subscribed type, often a container
+    ///
+    /// ```
+    /// use pyo3::inspect::TypeHint;
+    ///
+    /// const T: TypeHint = TypeHint::subscript(&TypeHint::builtin("dict"), &[TypeHint::builtin("int"), TypeHint::builtin("str")]);
+    /// assert_eq!(T.to_string(), "dict[int, str]");
+    /// ```
+    pub const fn subscript(value: &'static Self, slice: &'static [Self]) -> Self {
+        Self {
+            inner: TypeHintExpr::Subscript { value, slice },
+        }
+    }
+}
+
+/// Serialize the type for introspection and return the number of written bytes
+///
+/// We use the same AST as Python: https://docs.python.org/3/library/ast.html#abstract-grammar
+#[doc(hidden)]
+pub const fn serialize_for_introspection(hint: &TypeHint, mut output: &mut [u8]) -> usize {
+    let original_len = output.len();
+    match &hint.inner {
+        TypeHintExpr::Builtin { id } => {
+            output = write_slice_and_move_forward(b"{\"type\":\"builtin\",\"id\":\"", output);
+            output = write_slice_and_move_forward(id.as_bytes(), output);
+            output = write_slice_and_move_forward(b"\"}", output);
+        }
+        TypeHintExpr::ModuleAttribute { module, attr } => {
+            output = write_slice_and_move_forward(b"{\"type\":\"attribute\",\"module\":\"", output);
+            output = write_slice_and_move_forward(module.as_bytes(), output);
+            output = write_slice_and_move_forward(b"\",\"attr\":\"", output);
+            output = write_slice_and_move_forward(attr.as_bytes(), output);
+            output = write_slice_and_move_forward(b"\"}", output);
+        }
+        TypeHintExpr::Union { elts } => {
+            output = write_slice_and_move_forward(b"{\"type\":\"union\",\"elts\":[", output);
+            let mut i = 0;
+            while i < elts.len() {
+                if i > 0 {
+                    output = write_slice_and_move_forward(b",", output);
+                }
+                output = write_type_hint_and_move_forward(&elts[i], output);
+                i += 1;
+            }
+            output = write_slice_and_move_forward(b"]}", output);
+        }
+        TypeHintExpr::Subscript { value, slice } => {
+            output = write_slice_and_move_forward(b"{\"type\":\"subscript\",\"value\":", output);
+            output = write_type_hint_and_move_forward(value, output);
+            output = write_slice_and_move_forward(b",\"slice\":[", output);
+            let mut i = 0;
+            while i < slice.len() {
+                if i > 0 {
+                    output = write_slice_and_move_forward(b",", output);
+                }
+                output = write_type_hint_and_move_forward(&slice[i], output);
+                i += 1;
+            }
+            output = write_slice_and_move_forward(b"]}", output);
+        }
+    }
+    original_len - output.len()
+}
+
+/// Length required by [`Self::serialize_for_introspection`]
+#[doc(hidden)]
+pub const fn serialized_len_for_introspection(hint: &TypeHint) -> usize {
+    match &hint.inner {
+        TypeHintExpr::Builtin { id } => 26 + id.len(),
+        TypeHintExpr::ModuleAttribute { module, attr } => 42 + module.len() + attr.len(),
+        TypeHintExpr::Union { elts } => {
+            let mut count = 26;
+            let mut i = 0;
+            while i < elts.len() {
+                if i > 0 {
+                    count += 1;
+                }
+                count += serialized_len_for_introspection(&elts[i]);
+                i += 1;
+            }
+            count
+        }
+        TypeHintExpr::Subscript { value, slice } => {
+            let mut count = 40 + serialized_len_for_introspection(value);
+            let mut i = 0;
+            while i < slice.len() {
+                if i > 0 {
+                    count += 1;
+                }
+                count += serialized_len_for_introspection(&slice[i]);
+                i += 1;
+            }
+            count
+        }
+    }
+}
+
+impl fmt::Display for TypeHint {
+    #[inline]
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        match &self.inner {
+            TypeHintExpr::Builtin { id } => id.fmt(f),
+            TypeHintExpr::ModuleAttribute { module, attr } => {
+                module.fmt(f)?;
+                f.write_str(".")?;
+                attr.fmt(f)
+            }
+            TypeHintExpr::Union { elts } => {
+                for (i, elt) in elts.iter().enumerate() {
+                    if i > 0 {
+                        f.write_str(" | ")?;
+                    }
+                    elt.fmt(f)?;
+                }
+                Ok(())
+            }
+            TypeHintExpr::Subscript { value, slice } => {
+                value.fmt(f)?;
+                f.write_str("[")?;
+                for (i, elt) in slice.iter().enumerate() {
+                    if i > 0 {
+                        f.write_str(", ")?;
+                    }
+                    elt.fmt(f)?;
+                }
+                f.write_str("]")
+            }
+        }
+    }
+}
+
+const fn write_slice_and_move_forward<'a>(value: &[u8], output: &'a mut [u8]) -> &'a mut [u8] {
+    // TODO: use copy_from_slice with MSRV 1.87+
+    let mut i = 0;
+    while i < value.len() {
+        output[i] = value[i];
+        i += 1;
+    }
+    output.split_at_mut(value.len()).1
+}
+
+const fn write_type_hint_and_move_forward<'a>(
+    value: &TypeHint,
+    output: &'a mut [u8],
+) -> &'a mut [u8] {
+    let written = serialize_for_introspection(value, output);
+    output.split_at_mut(written).1
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_to_string() {
+        const T: TypeHint = TypeHint::subscript(
+            &TypeHint::builtin("dict"),
+            &[
+                TypeHint::union(&[TypeHint::builtin("int"), TypeHint::builtin("float")]),
+                TypeHint::module_attr("datetime", "time"),
+            ],
+        );
+        assert_eq!(T.to_string(), "dict[int | float, datetime.time]")
+    }
+
+    #[test]
+    fn test_serialize_for_introspection() {
+        const T: TypeHint = TypeHint::subscript(
+            &TypeHint::builtin("dict"),
+            &[
+                TypeHint::union(&[TypeHint::builtin("int"), TypeHint::builtin("float")]),
+                TypeHint::module_attr("datetime", "time"),
+            ],
+        );
+        const SER_LEN: usize = serialized_len_for_introspection(&T);
+        const SER: [u8; SER_LEN] = {
+            let mut out: [u8; SER_LEN] = [0; SER_LEN];
+            serialize_for_introspection(&T, &mut out);
+            out
+        };
+        assert_eq!(
+            std::str::from_utf8(&SER).unwrap(),
+            r#"{"type":"subscript","value":{"type":"builtin","id":"dict"},"slice":[{"type":"union","elts":[{"type":"builtin","id":"int"},{"type":"builtin","id":"float"}]},{"type":"attribute","module":"datetime","attr":"time"}]}"#
+        )
+    }
+}
diff --git a/src/inspect/types.rs b/src/inspect/types.rs
index d8f8e6a19ea..a26ec4beb8e 100644
--- a/src/inspect/types.rs
+++ b/src/inspect/types.rs
@@ -212,7 +212,7 @@ impl Display for TypeInfo {
                         if comma {
                             write!(f, ", ")?;
                         }
-                        write!(f, "{}", arg)?;
+                        write!(f, "{arg}")?;
                         comma = true;
                     }
                     write!(f, "]")?;
@@ -220,7 +220,7 @@ impl Display for TypeInfo {
                     write!(f, "...")?;
                 }
 
-                write!(f, ", {}]", output)
+                write!(f, ", {output}]")
             }
             TypeInfo::Tuple(types) => {
                 write!(f, "Tuple[")?;
@@ -234,7 +234,7 @@ impl Display for TypeInfo {
                             if comma {
                                 write!(f, ", ")?;
                             }
-                            write!(f, "{}", t)?;
+                            write!(f, "{t}")?;
                             comma = true;
                         }
                     }
@@ -244,11 +244,11 @@ impl Display for TypeInfo {
 
                 write!(f, "]")
             }
-            TypeInfo::UnsizedTypedTuple(t) => write!(f, "Tuple[{}, ...]", t),
+            TypeInfo::UnsizedTypedTuple(t) => write!(f, "Tuple[{t}, ...]"),
             TypeInfo::Class {
                 name, type_vars, ..
             } => {
-                write!(f, "{}", name)?;
+                write!(f, "{name}")?;
 
                 if !type_vars.is_empty() {
                     write!(f, "[")?;
@@ -258,7 +258,7 @@ impl Display for TypeInfo {
                         if comma {
                             write!(f, ", ")?;
                         }
-                        write!(f, "{}", var)?;
+                        write!(f, "{var}")?;
                         comma = true;
                     }
 
@@ -277,8 +277,9 @@ mod test {
 
     use crate::inspect::types::{ModuleName, TypeInfo};
 
+    #[track_caller]
     pub fn assert_display(t: &TypeInfo, expected: &str) {
-        assert_eq!(format!("{}", t), expected)
+        assert_eq!(format!("{t}"), expected)
     }
 
     #[test]
@@ -405,7 +406,7 @@ mod conversion {
     use std::collections::{HashMap, HashSet};
 
     use crate::inspect::types::test::assert_display;
-    use crate::{FromPyObject, IntoPy};
+    use crate::{FromPyObject, IntoPyObject};
 
     #[test]
     fn unsigned_int() {
@@ -463,8 +464,12 @@ mod conversion {
         assert_display(&String::type_output(), "str");
         assert_display(&String::type_input(), "str");
 
-        assert_display(&<&[u8]>::type_output(), "bytes");
-        assert_display(&<&[u8]>::type_input(), "bytes");
+        assert_display(&<&[u8]>::type_output(), "Union[bytes, List[int]]");
+        assert_display(&<&[String]>::type_output(), "Union[bytes, List[str]]");
+        assert_display(
+            &<&[u8] as crate::conversion::FromPyObject>::type_input(),
+            "bytes",
+        );
     }
 
     #[test]
diff --git a/src/instance.rs b/src/instance.rs
index ff553c44324..62cbf6c18bb 100644
--- a/src/instance.rs
+++ b/src/instance.rs
@@ -1,69 +1,75 @@
-use crate::err::{self, PyDowncastError, PyErr, PyResult};
-use crate::ffi_ptr_ext::FfiPtrExt;
-use crate::pycell::{PyBorrowError, PyBorrowMutError, PyCell};
+#![warn(clippy::undocumented_unsafe_blocks)] // TODO: remove this when the top-level is "warn" - https://github.com/PyO3/pyo3/issues/5487
+
+use crate::call::PyCallArgs;
+use crate::conversion::IntoPyObject;
+use crate::err::{PyErr, PyResult};
+use crate::impl_::pycell::PyClassObject;
+#[cfg(feature = "experimental-inspect")]
+use crate::inspect::TypeHint;
+use crate::pycell::{PyBorrowError, PyBorrowMutError};
 use crate::pyclass::boolean_struct::{False, True};
-use crate::type_object::HasPyGilRef;
-use crate::types::any::PyAnyMethods;
-use crate::types::string::PyStringMethods;
-use crate::types::{PyDict, PyString, PyTuple};
+use crate::types::{any::PyAnyMethods, string::PyStringMethods, typeobject::PyTypeMethods};
+use crate::types::{DerefToPyAny, PyDict, PyString};
+#[allow(deprecated)]
+use crate::DowncastError;
 use crate::{
-    ffi, AsPyPointer, FromPyObject, IntoPy, PyAny, PyClass, PyClassInitializer, PyRef, PyRefMut,
-    PyTypeInfo, Python, ToPyObject,
+    ffi, CastError, CastIntoError, FromPyObject, PyAny, PyClass, PyClassInitializer, PyRef,
+    PyRefMut, PyTypeInfo, Python,
 };
-use crate::{gil, PyTypeCheck};
+use crate::{internal::state, PyTypeCheck};
 use std::marker::PhantomData;
 use std::mem::ManuallyDrop;
 use std::ops::Deref;
+use std::ptr;
 use std::ptr::NonNull;
 
-/// Types that are built into the Python interpreter.
+/// Owned or borrowed Python smart pointer with a lifetime `'py` signalling
+/// attachment to the Python interpreter.
 ///
-/// PyO3 is designed in a way that all references to those types are bound
-/// to the GIL, which is why you can get a token from all references of those
-/// types.
-///
-/// # Safety
-///
-/// This trait must only be implemented for types which cannot be accessed without the GIL.
-pub unsafe trait PyNativeType: Sized {
-    /// The form of this which is stored inside a `Py<T>` smart pointer.
-    type AsRefSource: HasPyGilRef<AsRefTarget = Self>;
-
-    /// Cast `&self` to a `Borrowed` smart pointer.
-    ///
-    /// `Borrowed<T>` implements `Deref<Target=Bound<T>>`, so can also be used in locations
-    /// where `Bound<T>` is expected.
-    ///
-    /// This is available as a migration tool to adjust code from the deprecated "GIL Refs"
-    /// API to the `Bound` smart pointer API.
-    #[inline]
-    fn as_borrowed(&self) -> Borrowed<'_, '_, Self::AsRefSource> {
-        // Safety: &'py Self is expected to be a Python pointer,
-        // so has the same layout as Borrowed<'py, 'py, T>
-        Borrowed(
-            unsafe { NonNull::new_unchecked(self as *const Self as *mut _) },
-            PhantomData,
-            self.py(),
-        )
-    }
+/// This is implemented for [`Bound`] and [`Borrowed`].
+pub trait BoundObject<'py, T>: bound_object_sealed::Sealed {
+    /// Type erased version of `Self`
+    type Any: BoundObject<'py, PyAny>;
+    /// Borrow this smart pointer.
+    fn as_borrowed(&self) -> Borrowed<'_, 'py, T>;
+    /// Turns this smart pointer into an owned [`Bound<'py, T>`]
+    fn into_bound(self) -> Bound<'py, T>;
+    /// Upcast the target type of this smart pointer
+    fn into_any(self) -> Self::Any;
+    /// Turn this smart pointer into a strong reference pointer
+    fn into_ptr(self) -> *mut ffi::PyObject;
+    /// Turn this smart pointer into a borrowed reference pointer
+    fn as_ptr(&self) -> *mut ffi::PyObject;
+    /// Turn this smart pointer into an owned [`Py<T>`]
+    fn unbind(self) -> Py<T>;
+}
 
-    /// Returns a GIL marker constrained to the lifetime of this type.
-    #[inline]
-    fn py(&self) -> Python<'_> {
-        unsafe { Python::assume_gil_acquired() }
-    }
-    /// Cast `&PyAny` to `&Self` without no type checking.
-    ///
+mod bound_object_sealed {
     /// # Safety
     ///
-    /// `obj` must have the same layout as `*const ffi::PyObject` and must be
-    /// an instance of a type corresponding to `Self`.
-    unsafe fn unchecked_downcast(obj: &PyAny) -> &Self {
-        &*(obj.as_ptr() as *const Self)
-    }
+    /// Type must be layout-compatible with `*mut ffi::PyObject`.
+    pub unsafe trait Sealed {}
+
+    // SAFETY: `Bound` is layout-compatible with `*mut ffi::PyObject`.
+    unsafe impl<T> Sealed for super::Bound<'_, T> {}
+    // SAFETY: `Borrowed` is layout-compatible with `*mut ffi::PyObject`.
+    unsafe impl<T> Sealed for super::Borrowed<'_, '_, T> {}
 }
 
-/// A GIL-attached equivalent to `Py`.
+/// A Python thread-attached equivalent to [`Py<T>`].
+///
+/// This type can be thought of as equivalent to the tuple `(Py<T>, Python<'py>)`. By having the `'py`
+/// lifetime of the [`Python<'py>`] token, this ties the lifetime of the [`Bound<'py, T>`] smart pointer
+/// to the lifetime the thread is attached to the Python interpreter and allows PyO3 to call Python APIs
+/// at maximum efficiency.
+///
+/// To access the object in situations where the thread is not attached, convert it to [`Py<T>`]
+/// using [`.unbind()`][Bound::unbind]. This includes, for example, usage in
+/// [`Python::detach`](crate::Python::detach)'s closure.
+///
+/// See
+#[doc = concat!("[the guide](https://pyo3.rs/v", env!("CARGO_PKG_VERSION"), "/types.html#boundpy-t)")]
+/// for more detail.
 #[repr(transparent)]
 pub struct Bound<'py, T>(Python<'py>, ManuallyDrop<Py<T>>);
 
@@ -82,10 +88,11 @@ where
     /// struct Foo {/* fields omitted */}
     ///
     /// # fn main() -> PyResult<()> {
-    /// Python::with_gil(|py| -> PyResult<Py<Foo>> {
+    /// let foo: Py<Foo> = Python::attach(|py| -> PyResult<_> {
     ///     let foo: Bound<'_, Foo> = Bound::new(py, Foo {})?;
     ///     Ok(foo.into())
     /// })?;
+    /// # Python::attach(move |_py| drop(foo));
     /// # Ok(())
     /// # }
     /// ```
@@ -93,14 +100,234 @@ where
         py: Python<'py>,
         value: impl Into<PyClassInitializer<T>>,
     ) -> PyResult<Bound<'py, T>> {
-        let initializer = value.into();
-        let obj = initializer.create_cell(py)?;
-        let ob = unsafe {
-            obj.cast::<ffi::PyObject>()
-                .assume_owned(py)
-                .downcast_into_unchecked()
-        };
-        Ok(ob)
+        value.into().create_class_object(py)
+    }
+}
+
+impl<'py, T> Bound<'py, T> {
+    /// Cast this to a concrete Python type or pyclass.
+    ///
+    /// Note that you can often avoid casting yourself by just specifying the desired type in
+    /// function or method signatures. However, manual casting is sometimes necessary.
+    ///
+    /// For extracting a Rust-only type, see [`extract`](PyAnyMethods::extract).
+    ///
+    /// This performs a runtime type check using the equivalent of Python's
+    /// `isinstance(self, U)`.
+    ///
+    /// # Example: Casting to a specific Python object
+    ///
+    /// ```rust
+    /// use pyo3::prelude::*;
+    /// use pyo3::types::{PyDict, PyList};
+    ///
+    /// Python::attach(|py| {
+    ///     let dict = PyDict::new(py);
+    ///     assert!(dict.is_instance_of::<PyAny>());
+    ///     let any = dict.as_any();
+    ///
+    ///     assert!(any.cast::<PyDict>().is_ok());
+    ///     assert!(any.cast::<PyList>().is_err());
+    /// });
+    /// ```
+    ///
+    /// # Example: Getting a reference to a pyclass
+    ///
+    /// This is useful if you want to mutate a `Py<PyAny>` that might actually be a pyclass.
+    ///
+    /// ```rust
+    /// # fn main() -> Result<(), pyo3::PyErr> {
+    /// use pyo3::prelude::*;
+    ///
+    /// #[pyclass]
+    /// struct Class {
+    ///     i: i32,
+    /// }
+    ///
+    /// Python::attach(|py| {
+    ///     let class = Bound::new(py, Class { i: 0 })?.into_any();
+    ///
+    ///     let class_bound: &Bound<'_, Class> = class.cast()?;
+    ///
+    ///     class_bound.borrow_mut().i += 1;
+    ///
+    ///     // Alternatively you can get a `PyRefMut` directly
+    ///     let class_ref: PyRefMut<'_, Class> = class.extract()?;
+    ///     assert_eq!(class_ref.i, 1);
+    ///     Ok(())
+    /// })
+    /// # }
+    /// ```
+    #[inline]
+    pub fn cast<U>(&self) -> Result<&Bound<'py, U>, CastError<'_, 'py>>
+    where
+        U: PyTypeCheck,
+    {
+        #[inline]
+        fn inner<'a, 'py, U>(
+            any: &'a Bound<'py, PyAny>,
+        ) -> Result<&'a Bound<'py, U>, CastError<'a, 'py>>
+        where
+            U: PyTypeCheck,
+        {
+            if U::type_check(any) {
+                // Safety: type_check is responsible for ensuring that the type is correct
+                Ok(unsafe { any.cast_unchecked() })
+            } else {
+                Err(CastError::new(
+                    any.as_borrowed(),
+                    U::classinfo_object(any.py()),
+                ))
+            }
+        }
+
+        inner(self.as_any())
+    }
+
+    /// Like [`cast`](Self::cast) but takes ownership of `self`.
+    ///
+    /// In case of an error, it is possible to retrieve `self` again via
+    /// [`CastIntoError::into_inner`].
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use pyo3::prelude::*;
+    /// use pyo3::types::{PyDict, PyList};
+    ///
+    /// Python::attach(|py| {
+    ///     let obj: Bound<'_, PyAny> = PyDict::new(py).into_any();
+    ///
+    ///     let obj: Bound<'_, PyAny> = match obj.cast_into::<PyList>() {
+    ///         Ok(_) => panic!("obj should not be a list"),
+    ///         Err(err) => err.into_inner(),
+    ///     };
+    ///
+    ///     // obj is a dictionary
+    ///     assert!(obj.cast_into::<PyDict>().is_ok());
+    /// })
+    /// ```
+    #[inline]
+    pub fn cast_into<U>(self) -> Result<Bound<'py, U>, CastIntoError<'py>>
+    where
+        U: PyTypeCheck,
+    {
+        #[inline]
+        fn inner<U>(any: Bound<'_, PyAny>) -> Result<Bound<'_, U>, CastIntoError<'_>>
+        where
+            U: PyTypeCheck,
+        {
+            if U::type_check(&any) {
+                // Safety: type_check is responsible for ensuring that the type is correct
+                Ok(unsafe { any.cast_into_unchecked() })
+            } else {
+                let to = U::classinfo_object(any.py());
+                Err(CastIntoError::new(any, to))
+            }
+        }
+
+        inner(self.into_any())
+    }
+
+    /// Cast this to a concrete Python type or pyclass (but not a subclass of it).
+    ///
+    /// It is almost always better to use [`cast`](Self::cast) because it accounts for Python
+    /// subtyping. Use this method only when you do not want to allow subtypes.
+    ///
+    /// The advantage of this method over [`cast`](Self::cast) is that it is faster. The
+    /// implementation of `cast_exact` uses the equivalent of the Python expression `type(self) is
+    /// U`, whereas `cast` uses `isinstance(self, U)`.
+    ///
+    /// For extracting a Rust-only type, see [`extract`](PyAnyMethods::extract).
+    ///
+    /// # Example: Casting to a specific Python object but not a subtype
+    ///
+    /// ```rust
+    /// use pyo3::prelude::*;
+    /// use pyo3::types::{PyBool, PyInt};
+    ///
+    /// Python::attach(|py| {
+    ///     let b = PyBool::new(py, true);
+    ///     assert!(b.is_instance_of::<PyBool>());
+    ///     let any: &Bound<'_, PyAny> = b.as_any();
+    ///
+    ///     // `bool` is a subtype of `int`, so `cast` will accept a `bool` as an `int`
+    ///     // but `cast_exact` will not.
+    ///     assert!(any.cast::<PyInt>().is_ok());
+    ///     assert!(any.cast_exact::<PyInt>().is_err());
+    ///
+    ///     assert!(any.cast_exact::<PyBool>().is_ok());
+    /// });
+    /// ```
+    #[inline]
+    pub fn cast_exact<U>(&self) -> Result<&Bound<'py, U>, CastError<'_, 'py>>
+    where
+        U: PyTypeInfo,
+    {
+        #[inline]
+        fn inner<'a, 'py, U>(
+            any: &'a Bound<'py, PyAny>,
+        ) -> Result<&'a Bound<'py, U>, CastError<'a, 'py>>
+        where
+            U: PyTypeInfo,
+        {
+            if any.is_exact_instance_of::<U>() {
+                // Safety: is_exact_instance_of is responsible for ensuring that the type is correct
+                Ok(unsafe { any.cast_unchecked() })
+            } else {
+                Err(CastError::new(
+                    any.as_borrowed(),
+                    U::type_object(any.py()).into_any(),
+                ))
+            }
+        }
+
+        inner(self.as_any())
+    }
+
+    /// Like [`cast_exact`](Self::cast_exact) but takes ownership of `self`.
+    #[inline]
+    pub fn cast_into_exact<U>(self) -> Result<Bound<'py, U>, CastIntoError<'py>>
+    where
+        U: PyTypeInfo,
+    {
+        #[inline]
+        fn inner<U>(any: Bound<'_, PyAny>) -> Result<Bound<'_, U>, CastIntoError<'_>>
+        where
+            U: PyTypeInfo,
+        {
+            if any.is_exact_instance_of::<U>() {
+                // Safety: is_exact_instance_of is responsible for ensuring that the type is correct
+                Ok(unsafe { any.cast_into_unchecked() })
+            } else {
+                let to = U::type_object(any.py()).into_any();
+                Err(CastIntoError::new(any, to))
+            }
+        }
+
+        inner(self.into_any())
+    }
+
+    /// Converts this to a concrete Python type without checking validity.
+    ///
+    /// # Safety
+    ///
+    /// Callers must ensure that the type is valid or risk type confusion.
+    #[inline]
+    pub unsafe fn cast_unchecked<U>(&self) -> &Bound<'py, U> {
+        // SAFETY: caller has upheld the safety contract, all `Bound` have the same layout
+        unsafe { NonNull::from(self).cast().as_ref() }
+    }
+
+    /// Like [`cast_unchecked`](Self::cast_unchecked) but takes ownership of `self`.
+    ///
+    /// # Safety
+    ///
+    /// Callers must ensure that the type is valid or risk type confusion.
+    #[inline]
+    pub unsafe fn cast_into_unchecked<U>(self) -> Bound<'py, U> {
+        // SAFETY: caller has upheld the safety contract, all `Bound` have the same layout
+        unsafe { std::mem::transmute(self) }
     }
 }
 
@@ -111,18 +338,23 @@ impl<'py> Bound<'py, PyAny> {
     ///
     /// - `ptr` must be a valid pointer to a Python object
     /// - `ptr` must be an owned Python reference, as the `Bound<'py, PyAny>` will assume ownership
+    #[inline]
+    #[track_caller]
     pub unsafe fn from_owned_ptr(py: Python<'py>, ptr: *mut ffi::PyObject) -> Self {
-        Self(py, ManuallyDrop::new(Py::from_owned_ptr(py, ptr)))
+        // SAFETY: caller has upheld the safety contract
+        unsafe { Py::from_owned_ptr(py, ptr) }.into_bound(py)
     }
 
-    /// Constructs a new `Bound<'py, PyAny>` from a pointer. Returns `None`` if `ptr` is null.
+    /// Constructs a new `Bound<'py, PyAny>` from a pointer. Returns `None` if `ptr` is null.
     ///
     /// # Safety
     ///
     /// - `ptr` must be a valid pointer to a Python object, or null
     /// - `ptr` must be an owned Python reference, as the `Bound<'py, PyAny>` will assume ownership
+    #[inline]
     pub unsafe fn from_owned_ptr_or_opt(py: Python<'py>, ptr: *mut ffi::PyObject) -> Option<Self> {
-        Py::from_owned_ptr_or_opt(py, ptr).map(|obj| Self(py, ManuallyDrop::new(obj)))
+        // SAFETY: caller has upheld the safety contract
+        unsafe { Py::from_owned_ptr_or_opt(py, ptr) }.map(|obj| obj.into_bound(py))
     }
 
     /// Constructs a new `Bound<'py, PyAny>` from a pointer. Returns an `Err` by calling `PyErr::fetch`
@@ -132,11 +364,70 @@ impl<'py> Bound<'py, PyAny> {
     ///
     /// - `ptr` must be a valid pointer to a Python object, or null
     /// - `ptr` must be an owned Python reference, as the `Bound<'py, PyAny>` will assume ownership
+    #[inline]
     pub unsafe fn from_owned_ptr_or_err(
         py: Python<'py>,
         ptr: *mut ffi::PyObject,
     ) -> PyResult<Self> {
-        Py::from_owned_ptr_or_err(py, ptr).map(|obj| Self(py, ManuallyDrop::new(obj)))
+        // SAFETY: caller has upheld the safety contract
+        unsafe { Py::from_owned_ptr_or_err(py, ptr) }.map(|obj| obj.into_bound(py))
+    }
+
+    /// Constructs a new `Bound<'py, PyAny>` from a pointer without checking for null.
+    ///
+    /// # Safety
+    ///
+    /// - `ptr` must be a valid pointer to a Python object
+    /// - `ptr` must be a strong/owned reference
+    pub(crate) unsafe fn from_owned_ptr_unchecked(
+        py: Python<'py>,
+        ptr: *mut ffi::PyObject,
+    ) -> Self {
+        // SAFETY: caller has upheld the safety contract
+        unsafe { Py::from_owned_ptr_unchecked(ptr) }.into_bound(py)
+    }
+
+    /// Constructs a new `Bound<'py, PyAny>` from a pointer by creating a new Python reference.
+    /// Panics if `ptr` is null.
+    ///
+    /// # Safety
+    ///
+    /// - `ptr` must be a valid pointer to a Python object
+    #[inline]
+    #[track_caller]
+    pub unsafe fn from_borrowed_ptr(py: Python<'py>, ptr: *mut ffi::PyObject) -> Self {
+        // SAFETY: caller has upheld the safety contract
+        unsafe { Py::from_borrowed_ptr(py, ptr) }.into_bound(py)
+    }
+
+    /// Constructs a new `Bound<'py, PyAny>` from a pointer by creating a new Python reference.
+    /// Returns `None` if `ptr` is null.
+    ///
+    /// # Safety
+    ///
+    /// - `ptr` must be a valid pointer to a Python object, or null
+    #[inline]
+    pub unsafe fn from_borrowed_ptr_or_opt(
+        py: Python<'py>,
+        ptr: *mut ffi::PyObject,
+    ) -> Option<Self> {
+        // SAFETY: caller has upheld the safety contract
+        unsafe { Py::from_borrowed_ptr_or_opt(py, ptr) }.map(|obj| obj.into_bound(py))
+    }
+
+    /// Constructs a new `Bound<'py, PyAny>` from a pointer by creating a new Python reference.
+    /// Returns an `Err` by calling `PyErr::fetch` if `ptr` is null.
+    ///
+    /// # Safety
+    ///
+    /// - `ptr` must be a valid pointer to a Python object, or null
+    #[inline]
+    pub unsafe fn from_borrowed_ptr_or_err(
+        py: Python<'py>,
+        ptr: *mut ffi::PyObject,
+    ) -> PyResult<Self> {
+        // SAFETY: caller has upheld the safety contract
+        unsafe { Py::from_borrowed_ptr_or_err(py, ptr) }.map(|obj| obj.into_bound(py))
     }
 
     /// This slightly strange method is used to obtain `&Bound<PyAny>` from a pointer in macro code
@@ -154,7 +445,45 @@ impl<'py> Bound<'py, PyAny> {
         _py: Python<'py>,
         ptr: &'a *mut ffi::PyObject,
     ) -> &'a Self {
-        &*(ptr as *const *mut ffi::PyObject).cast::<Bound<'py, PyAny>>()
+        let ptr = NonNull::from(ptr).cast();
+        // SAFETY: caller has upheld the safety contract,
+        // and `Bound<PyAny>` is layout-compatible with `*mut ffi::PyObject`.
+        unsafe { ptr.as_ref() }
+    }
+
+    /// Variant of the above which returns `None` for null pointers.
+    ///
+    /// # Safety
+    /// - `ptr` must be a valid pointer to a Python object for the lifetime `'a, or null.
+    #[inline]
+    pub(crate) unsafe fn ref_from_ptr_or_opt<'a>(
+        _py: Python<'py>,
+        ptr: &'a *mut ffi::PyObject,
+    ) -> &'a Option<Self> {
+        let ptr = NonNull::from(ptr).cast();
+        // SAFETY: caller has upheld the safety contract,
+        // and `Option<Bound<PyAny>>` is layout-compatible with `*mut ffi::PyObject`.
+        unsafe { ptr.as_ref() }
+    }
+
+    /// This slightly strange method is used to obtain `&Bound<PyAny>` from a [`NonNull`] in macro
+    /// code where we need to constrain the lifetime `'a` safely.
+    ///
+    /// Note that `'py` is required to outlive `'a` implicitly by the nature of the fact that `&'a
+    /// Bound<'py>` means that `Bound<'py>` exists for at least the lifetime `'a`.
+    ///
+    /// # Safety
+    /// - `ptr` must be a valid pointer to a Python object for the lifetime `'a`. The `ptr` can be
+    ///   either a borrowed reference or an owned reference, it does not matter, as this is just
+    ///   `&Bound` there will never be any ownership transfer.
+    pub(crate) unsafe fn ref_from_non_null<'a>(
+        _py: Python<'py>,
+        ptr: &'a NonNull<ffi::PyObject>,
+    ) -> &'a Self {
+        let ptr = NonNull::from(ptr).cast();
+        // SAFETY: caller has upheld the safety contract,
+        // and `Bound<PyAny>` is layout-compatible with `NonNull<ffi::PyObject>`.
+        unsafe { ptr.as_ref() }
     }
 }
 
@@ -180,7 +509,7 @@ where
     /// }
     ///
     /// # fn main() -> PyResult<()> {
-    /// Python::with_gil(|py| -> PyResult<()> {
+    /// Python::attach(|py| -> PyResult<()> {
     ///     let foo: Bound<'_, Foo> = Bound::new(py, Foo { inner: 73 })?;
     ///     let inner: &u8 = &foo.borrow().inner;
     ///
@@ -195,8 +524,10 @@ where
     ///
     /// Panics if the value is currently mutably borrowed. For a non-panicking variant, use
     /// [`try_borrow`](#method.try_borrow).
-    pub fn borrow(&'py self) -> PyRef<'py, T> {
-        self.get_cell().borrow()
+    #[inline]
+    #[track_caller]
+    pub fn borrow(&self) -> PyRef<'py, T> {
+        PyRef::borrow(self)
     }
 
     /// Mutably borrows the value `T`.
@@ -214,7 +545,7 @@ where
     /// }
     ///
     /// # fn main() -> PyResult<()> {
-    /// Python::with_gil(|py| -> PyResult<()> {
+    /// Python::attach(|py| -> PyResult<()> {
     ///     let foo: Bound<'_, Foo> = Bound::new(py, Foo { inner: 73 })?;
     ///     foo.borrow_mut().inner = 35;
     ///
@@ -228,11 +559,13 @@ where
     /// # Panics
     /// Panics if the value is currently borrowed. For a non-panicking variant, use
     /// [`try_borrow_mut`](#method.try_borrow_mut).
-    pub fn borrow_mut(&'py self) -> PyRefMut<'py, T>
+    #[inline]
+    #[track_caller]
+    pub fn borrow_mut(&self) -> PyRefMut<'py, T>
     where
         T: PyClass<Frozen = False>,
     {
-        self.get_cell().borrow_mut()
+        PyRefMut::borrow(self)
     }
 
     /// Attempts to immutably borrow the value `T`, returning an error if the value is currently mutably borrowed.
@@ -242,8 +575,9 @@ where
     /// This is the non-panicking variant of [`borrow`](#method.borrow).
     ///
     /// For frozen classes, the simpler [`get`][Self::get] is available.
-    pub fn try_borrow(&'py self) -> Result<PyRef<'py, T>, PyBorrowError> {
-        self.get_cell().try_borrow()
+    #[inline]
+    pub fn try_borrow(&self) -> Result<PyRef<'py, T>, PyBorrowError> {
+        PyRef::try_borrow(self)
     }
 
     /// Attempts to mutably borrow the value `T`, returning an error if the value is currently borrowed.
@@ -251,14 +585,15 @@ where
     /// The borrow lasts while the returned [`PyRefMut`] exists.
     ///
     /// This is the non-panicking variant of [`borrow_mut`](#method.borrow_mut).
-    pub fn try_borrow_mut(&'py self) -> Result<PyRefMut<'py, T>, PyBorrowMutError>
+    #[inline]
+    pub fn try_borrow_mut(&self) -> Result<PyRefMut<'py, T>, PyBorrowMutError>
     where
         T: PyClass<Frozen = False>,
     {
-        self.get_cell().try_borrow_mut()
+        PyRefMut::try_borrow(self)
     }
 
-    /// Provide an immutable borrow of the value `T` without acquiring the GIL.
+    /// Provide an immutable borrow of the value `T`.
     ///
     /// This is available if the class is [`frozen`][macro@crate::pyclass] and [`Sync`].
     ///
@@ -273,7 +608,7 @@ where
     ///     value: AtomicUsize,
     /// }
     ///
-    /// Python::with_gil(|py| {
+    /// Python::attach(|py| {
     ///     let counter = FrozenCounter { value: AtomicUsize::new(0) };
     ///
     ///     let py_counter = Bound::new(py, counter).unwrap();
@@ -281,34 +616,132 @@ where
     ///     py_counter.get().value.fetch_add(1, Ordering::Relaxed);
     /// });
     /// ```
+    #[inline]
     pub fn get(&self) -> &T
     where
         T: PyClass<Frozen = True> + Sync,
     {
-        let cell = self.get_cell();
-        // SAFETY: The class itself is frozen and `Sync` and we do not access anything but `cell.contents.value`.
-        unsafe { &*cell.get_ptr() }
+        self.1.get()
     }
 
-    fn get_cell(&'py self) -> &'py PyCell<T> {
-        let cell = self.as_ptr().cast::<PyCell<T>>();
-        // SAFETY: Bound<T> is known to contain an object which is laid out in memory as a
-        // PyCell<T>.
-        //
-        // Strictly speaking for now `&'py PyCell<T>` is part of the "GIL Ref" API, so this
-        // could use some further refactoring later to avoid going through this reference.
-        unsafe { &*cell }
+    /// Upcast this `Bound<PyClass>` to its base type by reference.
+    ///
+    /// If this type defined an explicit base class in its `pyclass` declaration
+    /// (e.g. `#[pyclass(extends = BaseType)]`), the returned type will be
+    /// `&Bound<BaseType>`. If an explicit base class was _not_ declared, the
+    /// return value will be `&Bound<PyAny>` (making this method equivalent
+    /// to [`as_any`]).
+    ///
+    /// This method is particularly useful for calling methods defined in an
+    /// extension trait that has been implemented for `Bound<BaseType>`.
+    ///
+    /// See also the [`into_super`] method to upcast by value, and the
+    /// [`PyRef::as_super`]/[`PyRefMut::as_super`] methods for upcasting a pyclass
+    /// that has already been [`borrow`]ed.
+    ///
+    /// # Example: Calling a method defined on the `Bound` base type
+    ///
+    /// ```rust
+    /// # fn main() {
+    /// use pyo3::prelude::*;
+    ///
+    /// #[pyclass(subclass)]
+    /// struct BaseClass;
+    ///
+    /// trait MyClassMethods<'py> {
+    ///     fn pyrepr(&self) -> PyResult<String>;
+    /// }
+    /// impl<'py> MyClassMethods<'py> for Bound<'py, BaseClass> {
+    ///     fn pyrepr(&self) -> PyResult<String> {
+    ///         self.call_method0("__repr__")?.extract()
+    ///     }
+    /// }
+    ///
+    /// #[pyclass(extends = BaseClass)]
+    /// struct SubClass;
+    ///
+    /// Python::attach(|py| {
+    ///     let obj = Bound::new(py, (SubClass, BaseClass)).unwrap();
+    ///     assert!(obj.as_super().pyrepr().is_ok());
+    /// })
+    /// # }
+    /// ```
+    ///
+    /// [`as_any`]: Bound::as_any
+    /// [`into_super`]: Bound::into_super
+    /// [`borrow`]: Bound::borrow
+    #[inline]
+    pub fn as_super(&self) -> &Bound<'py, T::BaseType> {
+        // SAFETY: a pyclass can always be safely "cast" to its base type
+        unsafe { self.cast_unchecked() }
+    }
+
+    /// Upcast this `Bound<PyClass>` to its base type by value.
+    ///
+    /// If this type defined an explicit base class in its `pyclass` declaration
+    /// (e.g. `#[pyclass(extends = BaseType)]`), the returned type will be
+    /// `Bound<BaseType>`. If an explicit base class was _not_ declared, the
+    /// return value will be `Bound<PyAny>` (making this method equivalent
+    /// to [`into_any`]).
+    ///
+    /// This method is particularly useful for calling methods defined in an
+    /// extension trait that has been implemented for `Bound<BaseType>`.
+    ///
+    /// See also the [`as_super`] method to upcast by reference, and the
+    /// [`PyRef::into_super`]/[`PyRefMut::into_super`] methods for upcasting a pyclass
+    /// that has already been [`borrow`]ed.
+    ///
+    /// # Example: Calling a method defined on the `Bound` base type
+    ///
+    /// ```rust
+    /// # fn main() {
+    /// use pyo3::prelude::*;
+    ///
+    /// #[pyclass(subclass)]
+    /// struct BaseClass;
+    ///
+    /// trait MyClassMethods<'py> {
+    ///     fn pyrepr(self) -> PyResult<String>;
+    /// }
+    /// impl<'py> MyClassMethods<'py> for Bound<'py, BaseClass> {
+    ///     fn pyrepr(self) -> PyResult<String> {
+    ///         self.call_method0("__repr__")?.extract()
+    ///     }
+    /// }
+    ///
+    /// #[pyclass(extends = BaseClass)]
+    /// struct SubClass;
+    ///
+    /// Python::attach(|py| {
+    ///     let obj = Bound::new(py, (SubClass, BaseClass)).unwrap();
+    ///     assert!(obj.into_super().pyrepr().is_ok());
+    /// })
+    /// # }
+    /// ```
+    ///
+    /// [`into_any`]: Bound::into_any
+    /// [`as_super`]: Bound::as_super
+    /// [`borrow`]: Bound::borrow
+    #[inline]
+    pub fn into_super(self) -> Bound<'py, T::BaseType> {
+        // SAFETY: a pyclass can always be safely "cast" to its base type
+        unsafe { self.cast_into_unchecked() }
+    }
+
+    #[inline]
+    pub(crate) fn get_class_object(&self) -> &PyClassObject<T> {
+        self.1.get_class_object()
     }
 }
 
-impl<'py, T> std::fmt::Debug for Bound<'py, T> {
+impl<T> std::fmt::Debug for Bound<'_, T> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
         let any = self.as_any();
         python_format(any, any.repr(), f)
     }
 }
 
-impl<'py, T> std::fmt::Display for Bound<'py, T> {
+impl<T> std::fmt::Display for Bound<'_, T> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
         let any = self.as_any();
         python_format(any, any.str(), f)
@@ -322,18 +755,21 @@ fn python_format(
 ) -> Result<(), std::fmt::Error> {
     match format_result {
         Result::Ok(s) => return f.write_str(&s.to_string_lossy()),
-        Result::Err(err) => err.write_unraisable_bound(any.py(), Some(any)),
+        Result::Err(err) => err.write_unraisable(any.py(), Some(any)),
     }
 
     match any.get_type().name() {
-        Result::Ok(name) => std::write!(f, "<unprintable {} object>", name),
+        Result::Ok(name) => std::write!(f, "<unprintable {name} object>"),
         Result::Err(_err) => f.write_str("<unprintable object>"),
     }
 }
 
+// The trait bound is needed to avoid running into the auto-deref recursion
+// limit (error[E0055]), because `Bound<PyAny>` would deref into itself. See:
+// https://github.com/rust-lang/rust/issues/19509
 impl<'py, T> Deref for Bound<'py, T>
 where
-    T: AsRef<PyAny>,
+    T: DerefToPyAny,
 {
     type Target = Bound<'py, PyAny>;
 
@@ -343,16 +779,20 @@ where
     }
 }
 
-impl<'py, T> AsRef<Bound<'py, PyAny>> for Bound<'py, T>
-where
-    T: AsRef<PyAny>,
-{
+impl<'py, T> AsRef<Bound<'py, PyAny>> for Bound<'py, T> {
     #[inline]
     fn as_ref(&self) -> &Bound<'py, PyAny> {
         self.as_any()
     }
 }
 
+impl<T> AsRef<Py<PyAny>> for Bound<'_, T> {
+    #[inline]
+    fn as_ref(&self) -> &Py<PyAny> {
+        self.as_any().as_unbound()
+    }
+}
+
 impl<T> Clone for Bound<'_, T> {
     #[inline]
     fn clone(&self) -> Self {
@@ -363,12 +803,14 @@ impl<T> Clone for Bound<'_, T> {
 impl<T> Drop for Bound<'_, T> {
     #[inline]
     fn drop(&mut self) {
+        // SAFETY: self is an owned reference and the `Bound` implies the thread
+        // is attached to the interpreter
         unsafe { ffi::Py_DECREF(self.as_ptr()) }
     }
 }
 
 impl<'py, T> Bound<'py, T> {
-    /// Returns the GIL token associated with this object.
+    /// Returns the [`Python`] token associated with this object.
     #[inline]
     pub fn py(&self) -> Python<'py> {
         self.0
@@ -401,9 +843,10 @@ impl<'py, T> Bound<'py, T> {
     /// Helper to cast to `Bound<'py, PyAny>`.
     #[inline]
     pub fn as_any(&self) -> &Bound<'py, PyAny> {
+        let ptr = NonNull::from(self).cast();
         // Safety: all Bound<T> have the same memory layout, and all Bound<T> are valid
         // Bound<PyAny>, so pointer casting is valid.
-        unsafe { &*(self as *const Self).cast::<Bound<'py, PyAny>>() }
+        unsafe { ptr.as_ref() }
     }
 
     /// Helper to cast to `Bound<'py, PyAny>`, transferring ownership.
@@ -416,135 +859,309 @@ impl<'py, T> Bound<'py, T> {
     /// Casts this `Bound<T>` to a `Borrowed<T>` smart pointer.
     #[inline]
     pub fn as_borrowed<'a>(&'a self) -> Borrowed<'a, 'py, T> {
-        Borrowed(
-            unsafe { NonNull::new_unchecked(self.as_ptr()) },
-            PhantomData,
-            self.py(),
-        )
+        // SAFETY: self is known to be a valid pointer to T and will be borrowed from the lifetime 'a
+        unsafe { Borrowed::from_non_null(self.py(), (self.1).0).cast_unchecked() }
     }
 
-    /// Removes the connection for this `Bound<T>` from the GIL, allowing
-    /// it to cross thread boundaries.
+    /// Removes the connection for this `Bound<T>` from the [`Python<'py>`] token,
+    /// allowing it to cross thread boundaries.
     #[inline]
     pub fn unbind(self) -> Py<T> {
-        // Safety: the type T is known to be correct and the ownership of the
-        // pointer is transferred to the new Py<T> instance.
         let non_null = (ManuallyDrop::new(self).1).0;
+        // SAFETY: the type T is known to be correct and the `ManuallyDrop` ensures
+        // the ownership of the reference is transferred into the `Py<T>`.
         unsafe { Py::from_non_null(non_null) }
     }
 
-    /// Casts this `Bound<T>` as the corresponding "GIL Ref" type.
-    ///
-    /// This is a helper to be used for migration from the deprecated "GIL Refs" API.
+    /// Removes the connection for this `Bound<T>` from the [`Python<'py>`] token,
+    /// allowing it to cross thread boundaries, without transferring ownership.
     #[inline]
-    pub fn as_gil_ref(&'py self) -> &'py T::AsRefTarget
-    where
-        T: HasPyGilRef,
-    {
-        unsafe { self.py().from_borrowed_ptr(self.as_ptr()) }
+    pub fn as_unbound(&self) -> &Py<T> {
+        &self.1
     }
+}
 
-    /// Casts this `Bound<T>` as the corresponding "GIL Ref" type, registering the pointer on the
-    /// [release pool](Python::from_owned_ptr).
-    ///
-    /// This is a helper to be used for migration from the deprecated "GIL Refs" API.
-    #[inline]
-    pub fn into_gil_ref(self) -> &'py T::AsRefTarget
-    where
-        T: HasPyGilRef,
-    {
-        unsafe { self.py().from_owned_ptr(self.into_ptr()) }
+impl<'py, T> BoundObject<'py, T> for Bound<'py, T> {
+    type Any = Bound<'py, PyAny>;
+
+    fn as_borrowed(&self) -> Borrowed<'_, 'py, T> {
+        Bound::as_borrowed(self)
+    }
+
+    fn into_bound(self) -> Bound<'py, T> {
+        self
+    }
+
+    fn into_any(self) -> Self::Any {
+        self.into_any()
+    }
+
+    fn into_ptr(self) -> *mut ffi::PyObject {
+        self.into_ptr()
     }
-}
 
-unsafe impl<T> AsPyPointer for Bound<'_, T> {
     fn as_ptr(&self) -> *mut ffi::PyObject {
-        self.1.as_ptr()
+        self.as_ptr()
+    }
+
+    fn unbind(self) -> Py<T> {
+        self.unbind()
     }
 }
 
-/// A borrowed equivalent to `Bound`.
+/// A borrowed equivalent to [`Bound`].
+///
+/// [`Borrowed<'a, 'py, T>`] is an advanced type used just occasionally at the edge of interaction
+/// with the Python interpreter. It can be thought of as analogous to the shared reference `&'a
+/// Bound<'py, T>`, similarly this type is `Copy` and `Clone`. The difference is that [`Borrowed<'a,
+/// 'py, T>`] is just a smart pointer rather than a reference-to-a-smart-pointer. For one this
+/// reduces one level of pointer indirection, but additionally it removes the implicit lifetime
+/// relation that `'py` has to outlive `'a` (`'py: 'a`). This opens the possibility to borrow from
+/// the underlying Python object without necessarily requiring attachment to the interpreter for
+/// that duration. Within PyO3 this is used for example for the byte slice (`&[u8]`) extraction.
 ///
-/// The advantage of this over `&Bound` is that it avoids the need to have a pointer-to-pointer, as Bound
-/// is already a pointer to an `ffi::PyObject``.
+/// [`Borrowed<'a, 'py, T>`] dereferences to [`Bound<'py, T>`], so all methods on [`Bound<'py, T>`]
+/// are available on [`Borrowed<'a, 'py, T>`].
 ///
-/// Similarly, this type is `Copy` and `Clone`, like a shared reference (`&T`).
+/// Some Python C APIs also return "borrowed" pointers, which need to be increfd by the caller to
+/// keep them alive. This can also be modelled using [`Borrowed`]. However with free-threading these
+/// APIs are gradually replaced, because in absense of the GIL it is very hard to guarantee that the
+/// referred to object is not deallocated between receiving the pointer and incrementing the
+/// reference count. When possible APIs which return a "strong" reference (modelled by [`Bound`])
+/// should be using instead and otherwise great care needs to be taken to ensure safety.
 #[repr(transparent)]
 pub struct Borrowed<'a, 'py, T>(NonNull<ffi::PyObject>, PhantomData<&'a Py<T>>, Python<'py>);
 
-impl<'py, T> Borrowed<'_, 'py, T> {
-    /// Creates a new owned `Bound` from this borrowed reference by increasing the reference count.
-    pub(crate) fn to_owned(self) -> Bound<'py, T> {
+impl<'a, 'py, T> Borrowed<'a, 'py, T> {
+    /// Creates a new owned [`Bound<T>`] from this borrowed reference by
+    /// increasing the reference count.
+    ///
+    /// # Example
+    /// ```
+    /// use pyo3::{prelude::*, types::PyTuple};
+    ///
+    /// # fn main() -> PyResult<()> {
+    /// Python::attach(|py| -> PyResult<()> {
+    ///     let tuple = PyTuple::new(py, [1, 2, 3])?;
+    ///
+    ///     // borrows from `tuple`, so can only be
+    ///     // used while `tuple` stays alive
+    ///     let borrowed = tuple.get_borrowed_item(0)?;
+    ///
+    ///     // creates a new owned reference, which
+    ///     // can be used indendently of `tuple`
+    ///     let bound = borrowed.to_owned();
+    ///     drop(tuple);
+    ///
+    ///     assert_eq!(bound.extract::<i32>().unwrap(), 1);
+    ///     Ok(())
+    /// })
+    /// # }
+    pub fn to_owned(self) -> Bound<'py, T> {
         (*self).clone()
     }
+
+    /// Returns the raw FFI pointer represented by self.
+    ///
+    /// # Safety
+    ///
+    /// Callers are responsible for ensuring that the pointer does not outlive self.
+    ///
+    /// The reference is borrowed; callers should not decrease the reference count
+    /// when they are finished with the pointer.
+    #[inline]
+    pub fn as_ptr(self) -> *mut ffi::PyObject {
+        self.0.as_ptr()
+    }
+
+    pub(crate) fn to_any(self) -> Borrowed<'a, 'py, PyAny> {
+        Borrowed(self.0, PhantomData, self.2)
+    }
+
+    /// Extracts some type from the Python object.
+    ///
+    /// This is a wrapper function around [`FromPyObject::extract()`](crate::FromPyObject::extract).
+    pub fn extract<O>(self) -> Result<O, O::Error>
+    where
+        O: FromPyObject<'a, 'py>,
+    {
+        FromPyObject::extract(self.to_any())
+    }
+
+    /// Cast this to a concrete Python type or pyclass.
+    ///
+    /// This performs a runtime type check using the equivalent of Python's
+    /// `isinstance(self, U)`.
+    #[inline]
+    pub fn cast<U>(self) -> Result<Borrowed<'a, 'py, U>, CastError<'a, 'py>>
+    where
+        U: PyTypeCheck,
+    {
+        fn inner<'a, 'py, U>(
+            any: Borrowed<'a, 'py, PyAny>,
+        ) -> Result<Borrowed<'a, 'py, U>, CastError<'a, 'py>>
+        where
+            U: PyTypeCheck,
+        {
+            if U::type_check(&any) {
+                // Safety: type_check is responsible for ensuring that the type is correct
+                Ok(unsafe { any.cast_unchecked() })
+            } else {
+                Err(CastError::new(any, U::classinfo_object(any.py())))
+            }
+        }
+        inner(self.to_any())
+    }
+
+    /// Cast this to a concrete Python type or pyclass (but not a subclass of it).
+    ///
+    /// It is almost always better to use [`cast`](Self::cast) because it accounts for Python
+    /// subtyping. Use this method only when you do not want to allow subtypes.
+    ///
+    /// The advantage of this method over [`cast`](Self::cast) is that it is faster. The
+    /// implementation of `cast_exact` uses the equivalent of the Python expression `type(self) is
+    /// U`, whereas `cast` uses `isinstance(self, U)`.
+    #[inline]
+    pub fn cast_exact<U>(self) -> Result<Borrowed<'a, 'py, U>, CastError<'a, 'py>>
+    where
+        U: PyTypeInfo,
+    {
+        fn inner<'a, 'py, U>(
+            any: Borrowed<'a, 'py, PyAny>,
+        ) -> Result<Borrowed<'a, 'py, U>, CastError<'a, 'py>>
+        where
+            U: PyTypeInfo,
+        {
+            if any.is_exact_instance_of::<U>() {
+                // Safety: is_exact_instance_of is responsible for ensuring that the type is correct
+                Ok(unsafe { any.cast_unchecked() })
+            } else {
+                Err(CastError::new(any, U::classinfo_object(any.py())))
+            }
+        }
+        inner(self.to_any())
+    }
+
+    /// Converts this to a concrete Python type without checking validity.
+    ///
+    /// # Safety
+    /// Callers must ensure that the type is valid or risk type confusion.
+    #[inline]
+    pub unsafe fn cast_unchecked<U>(self) -> Borrowed<'a, 'py, U> {
+        Borrowed(self.0, PhantomData, self.2)
+    }
+}
+
+impl<'a, T: PyClass> Borrowed<'a, '_, T> {
+    /// Get a view on the underlying `PyClass` contents.
+    #[inline]
+    pub(crate) fn get_class_object(self) -> &'a PyClassObject<T> {
+        // Safety: Borrowed<'a, '_, T: PyClass> is known to contain an object
+        // which is laid out in memory as a PyClassObject<T> and lives for at
+        // least 'a.
+        unsafe { &*self.as_ptr().cast::<PyClassObject<T>>() }
+    }
 }
 
 impl<'a, 'py> Borrowed<'a, 'py, PyAny> {
+    /// Constructs a new `Borrowed<'a, 'py, PyAny>` from a pointer. Panics if `ptr` is null.
+    ///
+    /// Prefer to use [`Bound::from_borrowed_ptr`], as that avoids the major safety risk
+    /// of needing to precisely define the lifetime `'a` for which the borrow is valid.
+    ///
     /// # Safety
-    /// This is similar to `std::slice::from_raw_parts`, the lifetime `'a` is completely defined by
-    /// the caller and it's the caller's responsibility to ensure that the reference this is
-    /// derived from is valid for the lifetime `'a`.
-    pub(crate) unsafe fn from_ptr_or_err(
-        py: Python<'py>,
-        ptr: *mut ffi::PyObject,
-    ) -> PyResult<Self> {
-        NonNull::new(ptr).map_or_else(
-            || Err(PyErr::fetch(py)),
-            |ptr| Ok(Self(ptr, PhantomData, py)),
-        )
+    ///
+    /// - `ptr` must be a valid pointer to a Python object
+    /// - similar to `std::slice::from_raw_parts`, the lifetime `'a` is completely defined by
+    ///   the caller and it is the caller's responsibility to ensure that the reference this is
+    ///   derived from is valid for the lifetime `'a`.
+    #[inline]
+    #[track_caller]
+    pub unsafe fn from_ptr(py: Python<'py>, ptr: *mut ffi::PyObject) -> Self {
+        let non_null = NonNull::new(ptr).unwrap_or_else(|| crate::err::panic_after_error(py));
+        // SAFETY: caller has upheld the safety contract
+        unsafe { Self::from_non_null(py, non_null) }
     }
 
+    /// Constructs a new `Borrowed<'a, 'py, PyAny>` from a pointer. Returns `None` if `ptr` is null.
+    ///
+    /// Prefer to use [`Bound::from_borrowed_ptr_or_opt`], as that avoids the major safety risk
+    /// of needing to precisely define the lifetime `'a` for which the borrow is valid.
+    ///
     /// # Safety
-    /// This is similar to `std::slice::from_raw_parts`, the lifetime `'a` is completely defined by
-    /// the caller and it's the caller's responsibility to ensure that the reference this is
-    /// derived from is valid for the lifetime `'a`.
-    pub(crate) unsafe fn from_ptr_or_opt(py: Python<'py>, ptr: *mut ffi::PyObject) -> Option<Self> {
-        NonNull::new(ptr).map(|ptr| Self(ptr, PhantomData, py))
+    ///
+    /// - `ptr` must be a valid pointer to a Python object, or null
+    /// - similar to `std::slice::from_raw_parts`, the lifetime `'a` is completely defined by
+    ///   the caller and it is the caller's responsibility to ensure that the reference this is
+    ///   derived from is valid for the lifetime `'a`.
+    #[inline]
+    pub unsafe fn from_ptr_or_opt(py: Python<'py>, ptr: *mut ffi::PyObject) -> Option<Self> {
+        NonNull::new(ptr).map(|ptr|
+            // SAFETY: caller has upheld the safety contract
+            unsafe { Self::from_non_null(py, ptr) })
     }
 
+    /// Constructs a new `Borrowed<'a, 'py, PyAny>` from a pointer. Returns an `Err` by calling `PyErr::fetch`
+    /// if `ptr` is null.
+    ///
+    /// Prefer to use [`Bound::from_borrowed_ptr_or_err`], as that avoids the major safety risk
+    /// of needing to precisely define the lifetime `'a` for which the borrow is valid.
+    ///
     /// # Safety
-    /// This is similar to `std::slice::from_raw_parts`, the lifetime `'a` is completely defined by
-    /// the caller and it's the caller's responsibility to ensure that the reference this is
-    /// derived from is valid for the lifetime `'a`.
-    pub(crate) unsafe fn from_ptr(py: Python<'py>, ptr: *mut ffi::PyObject) -> Self {
-        Self(
-            NonNull::new(ptr).unwrap_or_else(|| crate::err::panic_after_error(py)),
-            PhantomData,
-            py,
+    ///
+    /// - `ptr` must be a valid pointer to a Python object, or null
+    /// - similar to `std::slice::from_raw_parts`, the lifetime `'a` is completely defined by
+    ///   the caller and it is the caller's responsibility to ensure that the reference this is
+    ///   derived from is valid for the lifetime `'a`.
+    #[inline]
+    pub unsafe fn from_ptr_or_err(py: Python<'py>, ptr: *mut ffi::PyObject) -> PyResult<Self> {
+        NonNull::new(ptr).map_or_else(
+            || Err(PyErr::fetch(py)),
+            |ptr| {
+                Ok(
+                    // SAFETY: ptr is known to be non-null, caller has upheld the safety contract
+                    unsafe { Self::from_non_null(py, ptr) },
+                )
+            },
         )
     }
 
     /// # Safety
-    /// This is similar to `std::slice::from_raw_parts`, the lifetime `'a` is completely defined by
-    /// the caller and it's the caller's responsibility to ensure that the reference this is
-    /// derived from is valid for the lifetime `'a`.
+    ///
+    /// - `ptr` must be a valid pointer to a Python object. It must not be null.
+    /// - similar to `std::slice::from_raw_parts`, the lifetime `'a` is completely defined by
+    ///   the caller and it is the caller's responsibility to ensure that the reference this is
+    ///   derived from is valid for the lifetime `'a`.
+    #[inline]
     pub(crate) unsafe fn from_ptr_unchecked(py: Python<'py>, ptr: *mut ffi::PyObject) -> Self {
-        Self(NonNull::new_unchecked(ptr), PhantomData, py)
+        // SAFETY: caller has upheld the safety contract
+        unsafe { Self::from_non_null(py, NonNull::new_unchecked(ptr)) }
     }
 
-    /// Converts this `PyAny` to a concrete Python type without checking validity.
-    ///
     /// # Safety
-    /// Callers must ensure that the type is valid or risk type confusion.
-    pub(crate) unsafe fn downcast_unchecked<T>(self) -> Borrowed<'a, 'py, T> {
-        Borrowed(self.0, PhantomData, self.2)
+    ///
+    /// - `ptr` must be a valid pointer to a Python object.
+    /// - similar to `std::slice::from_raw_parts`, the lifetime `'a` is completely defined by
+    ///   the caller and it is the caller's responsibility to ensure that the reference this is
+    ///   derived from is valid for the lifetime `'a`.
+    #[inline]
+    pub(crate) unsafe fn from_non_null(py: Python<'py>, ptr: NonNull<ffi::PyObject>) -> Self {
+        Self(ptr, PhantomData, py)
     }
 }
 
 impl<'a, 'py, T> From<&'a Bound<'py, T>> for Borrowed<'a, 'py, T> {
     /// Create borrow on a Bound
+    #[inline]
     fn from(instance: &'a Bound<'py, T>) -> Self {
         instance.as_borrowed()
     }
 }
 
-impl<'py, T> Borrowed<'py, 'py, T>
-where
-    T: HasPyGilRef,
-{
-    pub(crate) fn into_gil_ref(self) -> &'py T::AsRefTarget {
-        // Safety: self is a borrow over `'py`.
-        unsafe { self.py().from_borrowed_ptr(self.0.as_ptr()) }
+impl<T> AsRef<Py<PyAny>> for Borrowed<'_, '_, T> {
+    #[inline]
+    fn as_ref(&self) -> &Py<PyAny> {
+        self.as_any().as_unbound()
     }
 }
 
@@ -559,8 +1176,8 @@ impl<'py, T> Deref for Borrowed<'_, 'py, T> {
 
     #[inline]
     fn deref(&self) -> &Bound<'py, T> {
-        // safety: Bound has the same layout as NonNull<ffi::PyObject>
-        unsafe { &*(&self.0 as *const _ as *const Bound<'py, T>) }
+        // SAFETY: self.0 is a valid object of type T
+        unsafe { Bound::ref_from_non_null(self.2, &self.0).cast_unchecked() }
     }
 }
 
@@ -573,38 +1190,58 @@ impl<T> Clone for Borrowed<'_, '_, T> {
 
 impl<T> Copy for Borrowed<'_, '_, T> {}
 
-impl<T> ToPyObject for Borrowed<'_, '_, T> {
-    /// Converts `Py` instance -> PyObject.
-    #[inline]
-    fn to_object(&self, py: Python<'_>) -> PyObject {
-        (*self).into_py(py)
+impl<'a, 'py, T> BoundObject<'py, T> for Borrowed<'a, 'py, T> {
+    type Any = Borrowed<'a, 'py, PyAny>;
+
+    fn as_borrowed(&self) -> Borrowed<'a, 'py, T> {
+        *self
     }
-}
 
-impl<T> IntoPy<PyObject> for Borrowed<'_, '_, T> {
-    /// Converts `Py` instance -> PyObject.
-    #[inline]
-    fn into_py(self, py: Python<'_>) -> PyObject {
-        self.to_owned().into_py(py)
+    fn into_bound(self) -> Bound<'py, T> {
+        (*self).to_owned()
+    }
+
+    fn into_any(self) -> Self::Any {
+        self.to_any()
+    }
+
+    fn into_ptr(self) -> *mut ffi::PyObject {
+        (*self).to_owned().into_ptr()
+    }
+
+    fn as_ptr(&self) -> *mut ffi::PyObject {
+        (*self).as_ptr()
+    }
+
+    fn unbind(self) -> Py<T> {
+        (*self).to_owned().unbind()
     }
 }
 
-/// A GIL-independent reference to an object allocated on the Python heap.
+/// A reference to an object allocated on the Python heap.
 ///
-/// This type does not auto-dereference to the inner object because you must prove you hold the GIL to access it.
-/// Instead, call one of its methods to access the inner object:
-///  - [`Py::as_ref`], to borrow a GIL-bound reference to the contained object.
+/// To access the contained data use the following methods:
+///  - [`Py::bind`] or [`Py::into_bound`], to bind the reference to the lifetime of the [`Python<'py>`] token.
 ///  - [`Py::borrow`], [`Py::try_borrow`], [`Py::borrow_mut`], or [`Py::try_borrow_mut`],
+///
 /// to get a (mutable) reference to a contained pyclass, using a scheme similar to std's [`RefCell`].
-/// See the [`PyCell` guide entry](https://pyo3.rs/latest/class.html#pycell-and-interior-mutability)
+/// See the
+#[doc = concat!("[guide entry](https://pyo3.rs/v", env!("CARGO_PKG_VERSION"), "/class.html#bound-and-interior-mutability)")]
 /// for more information.
 ///  - You can call methods directly on `Py` with [`Py::call`], [`Py::call_method`] and friends.
+///
 /// These require passing in the [`Python<'py>`](crate::Python) token but are otherwise similar to the corresponding
 /// methods on [`PyAny`].
 ///
-/// # Example: Storing Python objects in structs
+/// # Example: Storing Python objects in `#[pyclass]` structs
+///
+/// Usually `Bound<'py, T>` is recommended for interacting with Python objects as its lifetime `'py`
+/// proves the thread is attached to the Python interpreter and that enables many operations to be
+/// done as efficiently as possible.
+///
+/// However, `#[pyclass]` structs cannot carry a lifetime, so `Py<T>` is the only way to store
+/// a Python object in a `#[pyclass]` struct.
 ///
-/// As all the native Python objects only appear as references, storing them in structs doesn't work well.
 /// For example, this won't compile:
 ///
 /// ```compile_fail
@@ -613,17 +1250,17 @@ impl<T> IntoPy<PyObject> for Borrowed<'_, '_, T> {
 /// #
 /// #[pyclass]
 /// struct Foo<'py> {
-///     inner: &'py PyDict,
+///     inner: Bound<'py, PyDict>,
 /// }
 ///
 /// impl Foo {
 ///     fn new() -> Foo {
-///         let foo = Python::with_gil(|py| {
+///         let foo = Python::attach(|py| {
 ///             // `py` will only last for this scope.
 ///
-///             // `&PyDict` derives its lifetime from `py` and
-///             // so won't be able to outlive this closure.
-///             let dict: &PyDict = PyDict::new(py);
+///             // `Bound<'py, PyDict>` inherits the Python token lifetime from `py`
+///             // and so won't be able to outlive this closure.
+///             let dict: Bound<'_, PyDict> = PyDict::new(py);
 ///
 ///             // because `Foo` contains `dict` its lifetime
 ///             // is now also tied to `py`.
@@ -636,7 +1273,7 @@ impl<T> IntoPy<PyObject> for Borrowed<'_, '_, T> {
 /// }
 /// ```
 ///
-/// [`Py`]`<T>` can be used to get around this by converting `dict` into a GIL-independent reference:
+/// [`Py`]`<T>` can be used to get around this by removing the lifetime from `dict` and with it the proof of attachment.
 ///
 /// ```rust
 /// use pyo3::prelude::*;
@@ -651,21 +1288,21 @@ impl<T> IntoPy<PyObject> for Borrowed<'_, '_, T> {
 /// impl Foo {
 ///     #[new]
 ///     fn __new__() -> Foo {
-///         Python::with_gil(|py| {
-///             let dict: Py<PyDict> = PyDict::new_bound(py).unbind();
+///         Python::attach(|py| {
+///             let dict: Py<PyDict> = PyDict::new(py).unbind();
 ///             Foo { inner: dict }
 ///         })
 ///     }
 /// }
 /// #
 /// # fn main() -> PyResult<()> {
-/// #     Python::with_gil(|py| {
+/// #     Python::attach(|py| {
 /// #         let m = pyo3::types::PyModule::new(py, "test")?;
 /// #         m.add_class::<Foo>()?;
 /// #
-/// #         let foo: &PyCell<Foo> = m.getattr("Foo")?.call0()?.downcast()?;
+/// #         let foo: Bound<'_, Foo> = m.getattr("Foo")?.call0()?.cast_into()?;
 /// #         let dict = &foo.borrow().inner;
-/// #         let dict: &PyDict = dict.as_ref(py);
+/// #         let dict: &Bound<'_, PyDict> = dict.bind(py);
 /// #
 /// #         Ok(())
 /// #     })
@@ -688,7 +1325,7 @@ impl<T> IntoPy<PyObject> for Borrowed<'_, '_, T> {
 /// impl Foo {
 ///     #[new]
 ///     fn __new__() -> PyResult<Foo> {
-///         Python::with_gil(|py| {
+///         Python::attach(|py| {
 ///             let bar: Py<Bar> = Py::new(py, Bar {})?;
 ///             Ok(Foo { inner: bar })
 ///         })
@@ -696,11 +1333,11 @@ impl<T> IntoPy<PyObject> for Borrowed<'_, '_, T> {
 /// }
 /// #
 /// # fn main() -> PyResult<()> {
-/// #     Python::with_gil(|py| {
+/// #     Python::attach(|py| {
 /// #         let m = pyo3::types::PyModule::new(py, "test")?;
 /// #         m.add_class::<Foo>()?;
 /// #
-/// #         let foo: &PyCell<Foo> = m.getattr("Foo")?.call0()?.downcast()?;
+/// #         let foo: Bound<'_, Foo> = m.getattr("Foo")?.call0()?.cast_into()?;
 /// #         let bar = &foo.borrow().inner;
 /// #         let bar: &Bar = &*bar.borrow(py);
 /// #
@@ -715,21 +1352,24 @@ impl<T> IntoPy<PyObject> for Borrowed<'_, '_, T> {
 /// As with [`Rc`]`<T>`, cloning it increases its reference count rather than duplicating
 /// the underlying object.
 ///
-/// This can be done using either [`Py::clone_ref`] or [`Py`]`<T>`'s [`Clone`] trait implementation.
-/// [`Py::clone_ref`] will be faster if you happen to be already holding the GIL.
+/// This can be done using either [`Py::clone_ref`] or [`Py<T>`]'s [`Clone`] trait implementation.
+/// [`Py::clone_ref`] is recommended; the [`Clone`] implementation will panic if the thread
+/// is not attached to the Python interpreter (and is gated behind the `py-clone` feature flag).
 ///
 /// ```rust
 /// use pyo3::prelude::*;
 /// use pyo3::types::PyDict;
 ///
 /// # fn main() {
-/// Python::with_gil(|py| {
-///     let first: Py<PyDict> = PyDict::new_bound(py).unbind();
+/// Python::attach(|py| {
+///     let first: Py<PyDict> = PyDict::new(py).unbind();
 ///
 ///     // All of these are valid syntax
 ///     let second = Py::clone_ref(&first, py);
 ///     let third = first.clone_ref(py);
+///     #[cfg(feature = "py-clone")]
 ///     let fourth = Py::clone(&first);
+///     #[cfg(feature = "py-clone")]
 ///     let fifth = first.clone();
 ///
 ///     // Disposing of our original `Py<PyDict>` just decrements the reference count.
@@ -737,7 +1377,9 @@ impl<T> IntoPy<PyObject> for Borrowed<'_, '_, T> {
 ///
 ///     // They all point to the same object
 ///     assert!(second.is(&third));
+///     #[cfg(feature = "py-clone")]
 ///     assert!(fourth.is(&fifth));
+///     #[cfg(feature = "py-clone")]
 ///     assert!(second.is(&fourth));
 /// });
 /// # }
@@ -756,17 +1398,21 @@ impl<T> IntoPy<PyObject> for Borrowed<'_, '_, T> {
 /// of the pointed-to variable, allowing Python's garbage collector to free
 /// the associated memory, but this may not happen immediately.  This is
 /// because a [`Py`]`<T>` can be dropped at any time, but the Python reference
-/// count can only be modified when the GIL is held.
+/// count can only be modified when the thread is attached to the Python interpreter.
+///
+/// If a [`Py`]`<T>` is dropped while its thread is attached to the Python interpreter
+/// then the Python reference count will be decreased immediately.
+/// Otherwise, the reference count will be decreased the next time the thread is
+/// attached to the interpreter.
 ///
-/// If a [`Py`]`<T>` is dropped while its thread happens to be holding the
-/// GIL then the Python reference count will be decreased immediately.
-/// Otherwise, the reference count will be decreased the next time the GIL is
-/// reacquired.
+/// If you have a [`Python<'py>`] token, [`Py::drop_ref`] will decrease
+/// the Python reference count immediately and will execute slightly faster than
+/// relying on implicit [`Drop`]s.
 ///
 /// # A note on `Send` and `Sync`
 ///
-/// Accessing this object is threadsafe, since any access to its API requires a [`Python<'py>`](crate::Python) token.
-/// As you can only get this by acquiring the GIL, `Py<...>` "implements [`Send`] and [`Sync`].
+/// [`Py<T>`] implements [`Send`] and [`Sync`], as Python allows objects to be freely
+/// shared between threads.
 ///
 /// [`Rc`]: std::rc::Rc
 /// [`RefCell`]: std::cell::RefCell
@@ -774,136 +1420,43 @@ impl<T> IntoPy<PyObject> for Borrowed<'_, '_, T> {
 #[repr(transparent)]
 pub struct Py<T>(NonNull<ffi::PyObject>, PhantomData<T>);
 
-// The inner value is only accessed through ways that require proving the gil is held
 #[cfg(feature = "nightly")]
 unsafe impl<T> crate::marker::Ungil for Py<T> {}
+// SAFETY: Python objects can be sent between threads
 unsafe impl<T> Send for Py<T> {}
+// SAFETY: Python objects can be shared between threads. Any thread safety is
+// implemented in the object type itself; `Py<T>` only allows synchronized access
+// to `T` through:
+// - `borrow`/`borrow_mut` for `#[pyclass]` types
+// - `get()` for frozen `#[pyclass(frozen)]` types
+// - Python native types have their own thread safety mechanisms
 unsafe impl<T> Sync for Py<T> {}
 
 impl<T> Py<T>
 where
     T: PyClass,
 {
-    /// Creates a new instance `Py<T>` of a `#[pyclass]` on the Python heap.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// use pyo3::prelude::*;
-    ///
-    /// #[pyclass]
-    /// struct Foo {/* fields omitted */}
-    ///
-    /// # fn main() -> PyResult<()> {
-    /// Python::with_gil(|py| -> PyResult<Py<Foo>> {
-    ///     let foo: Py<Foo> = Py::new(py, Foo {})?;
-    ///     Ok(foo)
-    /// })?;
-    /// # Ok(())
-    /// # }
-    /// ```
-    pub fn new(py: Python<'_>, value: impl Into<PyClassInitializer<T>>) -> PyResult<Py<T>> {
-        let initializer = value.into();
-        let obj = initializer.create_cell(py)?;
-        let ob = unsafe { Py::from_owned_ptr(py, obj as _) };
-        Ok(ob)
-    }
-}
-
-impl<T> Py<T>
-where
-    T: HasPyGilRef,
-{
-    /// Borrows a GIL-bound reference to the contained `T`.
-    ///
-    /// By binding to the GIL lifetime, this allows the GIL-bound reference to not require
-    /// [`Python<'py>`](crate::Python) for any of its methods, which makes calling methods
-    /// on it more ergonomic.
-    ///
-    /// For native types, this reference is `&T`. For pyclasses, this is `&PyCell<T>`.
-    ///
-    /// Note that the lifetime of the returned reference is the shortest of `&self` and
-    /// [`Python<'py>`](crate::Python).
-    /// Consider using [`Py::into_ref`] instead if this poses a problem.
-    ///
-    /// # Examples
-    ///
-    /// Get access to `&PyList` from `Py<PyList>`:
-    ///
-    /// ```
-    /// # use pyo3::prelude::*;
-    /// # use pyo3::types::PyList;
-    /// #
-    /// Python::with_gil(|py| {
-    ///     let list: Py<PyList> = PyList::empty_bound(py).into();
-    ///     let list: &PyList = list.as_ref(py);
-    ///     assert_eq!(list.len(), 0);
-    /// });
-    /// ```
-    ///
-    /// Get access to `&PyCell<MyClass>` from `Py<MyClass>`:
-    ///
-    /// ```
-    /// # use pyo3::prelude::*;
-    /// #
-    /// #[pyclass]
-    /// struct MyClass {}
-    ///
-    /// Python::with_gil(|py| {
-    ///     let my_class: Py<MyClass> = Py::new(py, MyClass {}).unwrap();
-    ///     let my_class_cell: &PyCell<MyClass> = my_class.as_ref(py);
-    ///     assert!(my_class_cell.try_borrow().is_ok());
-    /// });
-    /// ```
-    pub fn as_ref<'py>(&'py self, _py: Python<'py>) -> &'py T::AsRefTarget {
-        let any = self.as_ptr() as *const PyAny;
-        unsafe { PyNativeType::unchecked_downcast(&*any) }
-    }
-
-    /// Borrows a GIL-bound reference to the contained `T` independently of the lifetime of `T`.
-    ///
-    /// This method is similar to [`as_ref`](#method.as_ref) but consumes `self` and registers the
-    /// Python object reference in PyO3's object storage. The reference count for the Python
-    /// object will not be decreased until the GIL lifetime ends.
-    ///
-    /// You should prefer using [`as_ref`](#method.as_ref) if you can as it'll have less overhead.
-    ///
-    /// # Examples
-    ///
-    /// [`Py::as_ref`]'s lifetime limitation forbids creating a function that references a
-    /// variable created inside the function.
-    ///
-    /// ```rust,compile_fail
-    /// # use pyo3::prelude::*;
-    /// #
-    /// fn new_py_any<'py>(py: Python<'py>, value: impl IntoPy<Py<PyAny>>) -> &'py PyAny {
-    ///     let obj: Py<PyAny> = value.into_py(py);
-    ///
-    ///     // The lifetime of the return value of this function is the shortest
-    ///     // of `obj` and `py`. As `obj` is owned by the current function,
-    ///     // Rust won't let the return value escape this function!
-    ///     obj.as_ref(py)
-    /// }
-    /// ```
+    /// Creates a new instance `Py<T>` of a `#[pyclass]` on the Python heap.
     ///
-    /// This can be solved by using [`Py::into_ref`] instead, which does not suffer from this issue.
-    /// Note that the lifetime of the [`Python<'py>`](crate::Python) token is transferred to
-    /// the returned reference.
+    /// # Examples
     ///
     /// ```rust
-    /// # use pyo3::prelude::*;
-    /// # #[allow(dead_code)] // This is just to show it compiles.
-    /// fn new_py_any<'py>(py: Python<'py>, value: impl IntoPy<Py<PyAny>>) -> &'py PyAny {
-    ///     let obj: Py<PyAny> = value.into_py(py);
-    ///
-    ///     // This reference's lifetime is determined by `py`'s lifetime.
-    ///     // Because that originates from outside this function,
-    ///     // this return value is allowed.
-    ///     obj.into_ref(py)
-    /// }
+    /// use pyo3::prelude::*;
+    ///
+    /// #[pyclass]
+    /// struct Foo {/* fields omitted */}
+    ///
+    /// # fn main() -> PyResult<()> {
+    /// let foo = Python::attach(|py| -> PyResult<_> {
+    ///     let foo: Py<Foo> = Py::new(py, Foo {})?;
+    ///     Ok(foo)
+    /// })?;
+    /// # Python::attach(move |_py| drop(foo));
+    /// # Ok(())
+    /// # }
     /// ```
-    pub fn into_ref(self, py: Python<'_>) -> &T::AsRefTarget {
-        unsafe { py.from_owned_ptr(self.into_ptr()) }
+    pub fn new(py: Python<'_>, value: impl Into<PyClassInitializer<T>>) -> PyResult<Py<T>> {
+        Bound::new(py, value).map(Bound::unbind)
     }
 }
 
@@ -935,9 +1488,10 @@ impl<T> Py<T> {
     /// Helper to cast to `Py<PyAny>`.
     #[inline]
     pub fn as_any(&self) -> &Py<PyAny> {
+        let ptr = NonNull::from(self).cast();
         // Safety: all Py<T> have the same memory layout, and all Py<T> are valid
         // Py<PyAny>, so pointer casting is valid.
-        unsafe { &*(self as *const Self).cast::<Py<PyAny>>() }
+        unsafe { ptr.as_ref() }
     }
 
     /// Helper to cast to `Py<PyAny>`, transferring ownership.
@@ -959,8 +1513,7 @@ where
     ///
     /// For frozen classes, the simpler [`get`][Self::get] is available.
     ///
-    /// Equivalent to `self.as_ref(py).borrow()` -
-    /// see [`PyCell::borrow`](crate::pycell::PyCell::borrow).
+    /// Equivalent to `self.bind(py).borrow()` - see [`Bound::borrow`].
     ///
     /// # Examples
     ///
@@ -973,7 +1526,7 @@ where
     /// }
     ///
     /// # fn main() -> PyResult<()> {
-    /// Python::with_gil(|py| -> PyResult<()> {
+    /// Python::attach(|py| -> PyResult<()> {
     ///     let foo: Py<Foo> = Py::new(py, Foo { inner: 73 })?;
     ///     let inner: &u8 = &foo.borrow(py).inner;
     ///
@@ -988,16 +1541,17 @@ where
     ///
     /// Panics if the value is currently mutably borrowed. For a non-panicking variant, use
     /// [`try_borrow`](#method.try_borrow).
+    #[inline]
+    #[track_caller]
     pub fn borrow<'py>(&'py self, py: Python<'py>) -> PyRef<'py, T> {
-        self.as_ref(py).borrow()
+        self.bind(py).borrow()
     }
 
     /// Mutably borrows the value `T`.
     ///
     /// This borrow lasts while the returned [`PyRefMut`] exists.
     ///
-    /// Equivalent to `self.as_ref(py).borrow_mut()` -
-    /// see [`PyCell::borrow_mut`](crate::pycell::PyCell::borrow_mut).
+    /// Equivalent to `self.bind(py).borrow_mut()` - see [`Bound::borrow_mut`].
     ///
     /// # Examples
     ///
@@ -1010,7 +1564,7 @@ where
     /// }
     ///
     /// # fn main() -> PyResult<()> {
-    /// Python::with_gil(|py| -> PyResult<()> {
+    /// Python::attach(|py| -> PyResult<()> {
     ///     let foo: Py<Foo> = Py::new(py, Foo { inner: 73 })?;
     ///     foo.borrow_mut(py).inner = 35;
     ///
@@ -1024,11 +1578,13 @@ where
     /// # Panics
     /// Panics if the value is currently borrowed. For a non-panicking variant, use
     /// [`try_borrow_mut`](#method.try_borrow_mut).
+    #[inline]
+    #[track_caller]
     pub fn borrow_mut<'py>(&'py self, py: Python<'py>) -> PyRefMut<'py, T>
     where
         T: PyClass<Frozen = False>,
     {
-        self.as_ref(py).borrow_mut()
+        self.bind(py).borrow_mut()
     }
 
     /// Attempts to immutably borrow the value `T`, returning an error if the value is currently mutably borrowed.
@@ -1039,10 +1595,10 @@ where
     ///
     /// For frozen classes, the simpler [`get`][Self::get] is available.
     ///
-    /// Equivalent to `self.as_ref(py).borrow_mut()` -
-    /// see [`PyCell::try_borrow`](crate::pycell::PyCell::try_borrow).
+    /// Equivalent to `self.bind(py).try_borrow()` - see [`Bound::try_borrow`].
+    #[inline]
     pub fn try_borrow<'py>(&'py self, py: Python<'py>) -> Result<PyRef<'py, T>, PyBorrowError> {
-        self.as_ref(py).try_borrow()
+        self.bind(py).try_borrow()
     }
 
     /// Attempts to mutably borrow the value `T`, returning an error if the value is currently borrowed.
@@ -1051,8 +1607,8 @@ where
     ///
     /// This is the non-panicking variant of [`borrow_mut`](#method.borrow_mut).
     ///
-    /// Equivalent to `self.as_ref(py).try_borrow_mut()` -
-    /// see [`PyCell::try_borrow_mut`](crate::pycell::PyCell::try_borrow_mut).
+    /// Equivalent to `self.bind(py).try_borrow_mut()` - see [`Bound::try_borrow_mut`].
+    #[inline]
     pub fn try_borrow_mut<'py>(
         &'py self,
         py: Python<'py>,
@@ -1060,12 +1616,13 @@ where
     where
         T: PyClass<Frozen = False>,
     {
-        self.as_ref(py).try_borrow_mut()
+        self.bind(py).try_borrow_mut()
     }
 
-    /// Provide an immutable borrow of the value `T` without acquiring the GIL.
+    /// Provide an immutable borrow of the value `T`.
     ///
-    /// This is available if the class is [`frozen`][macro@crate::pyclass] and [`Sync`].
+    /// This is available if the class is [`frozen`][macro@crate::pyclass] and [`Sync`], and
+    /// does not require attaching to the Python interpreter.
     ///
     /// # Examples
     ///
@@ -1078,24 +1635,31 @@ where
     ///     value: AtomicUsize,
     /// }
     ///
-    /// let cell  = Python::with_gil(|py| {
+    /// let cell  = Python::attach(|py| {
     ///     let counter = FrozenCounter { value: AtomicUsize::new(0) };
     ///
     ///     Py::new(py, counter).unwrap()
     /// });
     ///
     /// cell.get().value.fetch_add(1, Ordering::Relaxed);
+    /// # Python::attach(move |_py| drop(cell));
     /// ```
+    #[inline]
     pub fn get(&self) -> &T
     where
         T: PyClass<Frozen = True> + Sync,
     {
-        let any = self.as_ptr() as *const PyAny;
-        // SAFETY: The class itself is frozen and `Sync` and we do not access anything but `cell.contents.value`.
-        unsafe {
-            let cell: &PyCell<T> = PyNativeType::unchecked_downcast(&*any);
-            &*cell.get_ptr()
-        }
+        // Safety: The class itself is frozen and `Sync`
+        unsafe { &*self.get_class_object().get_ptr() }
+    }
+
+    /// Get a view on the underlying `PyClass` contents.
+    #[inline]
+    pub(crate) fn get_class_object(&self) -> &PyClassObject<T> {
+        let class_object = self.as_ptr().cast::<PyClassObject<T>>();
+        // Safety: Bound<T: PyClass> is known to contain an object which is laid out in memory as a
+        // PyClassObject<T>.
+        unsafe { &*class_object }
     }
 }
 
@@ -1103,8 +1667,8 @@ impl<T> Py<T> {
     /// Attaches this `Py` to the given Python context, allowing access to further Python APIs.
     #[inline]
     pub fn bind<'py>(&self, _py: Python<'py>) -> &Bound<'py, T> {
-        // Safety: `Bound` has the same layout as `Py`
-        unsafe { &*(self as *const Py<T>).cast() }
+        // SAFETY: `Bound` has the same layout as `Py`
+        unsafe { NonNull::from(self).cast().as_ref() }
     }
 
     /// Same as `bind` but takes ownership of `self`.
@@ -1116,21 +1680,27 @@ impl<T> Py<T> {
     /// Same as `bind` but produces a `Borrowed<T>` instead of a `Bound<T>`.
     #[inline]
     pub fn bind_borrowed<'a, 'py>(&'a self, py: Python<'py>) -> Borrowed<'a, 'py, T> {
-        Borrowed(self.0, PhantomData, py)
+        // NB cannot go via `self.bind(py)` because the `&Bound` would imply `'a: 'py`
+
+        // SAFETY: `self.0` is a valid pointer to a PyObject for the lifetime 'a
+        let borrowed = unsafe { Borrowed::from_non_null(py, self.0) };
+        // SAFETY: object is known to be of type T
+        unsafe { borrowed.cast_unchecked() }
     }
 
     /// Returns whether `self` and `other` point to the same object. To compare
-    /// the equality of two objects (the `==` operator), use [`eq`](PyAny::eq).
+    /// the equality of two objects (the `==` operator), use [`eq`](PyAnyMethods::eq).
     ///
     /// This is equivalent to the Python expression `self is other`.
     #[inline]
-    pub fn is<U: AsPyPointer>(&self, o: &U) -> bool {
-        self.as_ptr() == o.as_ptr()
+    pub fn is<U: AsRef<Py<PyAny>>>(&self, o: U) -> bool {
+        ptr::eq(self.as_ptr(), o.as_ref().as_ptr())
     }
 
     /// Gets the reference count of the `ffi::PyObject` pointer.
     #[inline]
     pub fn get_refcnt(&self, _py: Python<'_>) -> isize {
+        // SAFETY: Self is a valid pointer to a PyObject
         unsafe { ffi::Py_REFCNT(self.0.as_ptr()) }
     }
 
@@ -1138,7 +1708,7 @@ impl<T> Py<T> {
     ///
     /// This creates another pointer to the same object, increasing its reference count.
     ///
-    /// You should prefer using this method over [`Clone`] if you happen to be holding the GIL already.
+    /// You should prefer using this method over [`Clone`].
     ///
     /// # Examples
     ///
@@ -1147,8 +1717,8 @@ impl<T> Py<T> {
     /// use pyo3::types::PyDict;
     ///
     /// # fn main() {
-    /// Python::with_gil(|py| {
-    ///     let first: Py<PyDict> = PyDict::new_bound(py).unbind();
+    /// Python::attach(|py| {
+    ///     let first: Py<PyDict> = PyDict::new(py).unbind();
     ///     let second = Py::clone_ref(&first, py);
     ///
     ///     // Both point to the same object
@@ -1157,50 +1727,70 @@ impl<T> Py<T> {
     /// # }
     /// ```
     #[inline]
-    pub fn clone_ref(&self, py: Python<'_>) -> Py<T> {
-        unsafe { Py::from_borrowed_ptr(py, self.0.as_ptr()) }
-    }
+    pub fn clone_ref(&self, _py: Python<'_>) -> Py<T> {
+        // NB cannot use self.bind(py) because Bound::clone is implemented using Py::clone_ref
+        // (infinite recursion)
 
-    /// Returns whether the object is considered to be None.
-    ///
-    /// This is equivalent to the Python expression `self is None`.
-    pub fn is_none(&self, _py: Python<'_>) -> bool {
-        unsafe { ffi::Py_None() == self.as_ptr() }
+        // SAFETY: object is known to be valid
+        unsafe { ffi::Py_INCREF(self.0.as_ptr()) };
+        // SAFETY: newly created reference is transferred to the new Py<T>
+        unsafe { Self::from_non_null(self.0) }
     }
 
-    /// Returns whether the object is Ellipsis, e.g. `...`.
+    /// Drops `self` and immediately decreases its reference count.
+    ///
+    /// This method is a micro-optimisation over [`Drop`] if you happen to have a [`Python<'py>`]
+    /// token to prove attachment to the Python interpreter.
     ///
-    /// This is equivalent to the Python expression `self is ...`.
-    #[deprecated(since = "0.20.0", note = "use `.is(py.Ellipsis())` instead")]
-    pub fn is_ellipsis(&self) -> bool {
-        unsafe { ffi::Py_Ellipsis() == self.as_ptr() }
+    /// Note that if you are using [`Bound`], you do not need to use [`Self::drop_ref`] since
+    /// [`Bound`] guarantees that the thread is attached to the interpreter.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// use pyo3::prelude::*;
+    /// use pyo3::types::PyDict;
+    ///
+    /// # fn main() {
+    /// Python::attach(|py| {
+    ///     let object: Py<PyDict> = PyDict::new(py).unbind();
+    ///
+    ///     // some usage of object
+    ///
+    ///     object.drop_ref(py);
+    /// });
+    /// # }
+    /// ```
+    #[inline]
+    pub fn drop_ref(self, py: Python<'_>) {
+        let _ = self.into_bound(py);
     }
 
-    /// Returns whether the object is considered to be true.
+    /// Returns whether the object is considered to be None.
     ///
-    /// This is equivalent to the Python expression `bool(self)`.
-    #[deprecated(since = "0.21.0", note = "use `.is_truthy()` instead")]
-    pub fn is_true(&self, py: Python<'_>) -> PyResult<bool> {
-        self.is_truthy(py)
+    /// This is equivalent to the Python expression `self is None`.
+    pub fn is_none(&self, py: Python<'_>) -> bool {
+        self.bind(py).as_any().is_none()
     }
 
     /// Returns whether the object is considered to be true.
     ///
     /// This applies truth value testing equivalent to the Python expression `bool(self)`.
     pub fn is_truthy(&self, py: Python<'_>) -> PyResult<bool> {
-        let v = unsafe { ffi::PyObject_IsTrue(self.as_ptr()) };
-        err::error_on_minusone(py, v)?;
-        Ok(v != 0)
+        self.bind(py).as_any().is_truthy()
     }
 
     /// Extracts some type from the Python object.
     ///
     /// This is a wrapper function around `FromPyObject::extract()`.
-    pub fn extract<'py, D>(&'py self, py: Python<'py>) -> PyResult<D>
+    pub fn extract<'a, 'py, D>(&'a self, py: Python<'py>) -> Result<D, D::Error>
     where
-        D: FromPyObject<'py>,
+        D: FromPyObject<'a, 'py>,
+        // TODO it might be possible to relax this bound in future, to allow
+        // e.g. `.extract::<&str>(py)` where `py` is short-lived.
+        'py: 'a,
     {
-        FromPyObject::extract(unsafe { py.from_borrowed_ptr(self.as_ptr()) })
+        self.bind(py).as_any().extract()
     }
 
     /// Retrieves an attribute value.
@@ -1217,18 +1807,18 @@ impl<T> Py<T> {
     /// # use pyo3::{prelude::*, intern};
     /// #
     /// #[pyfunction]
-    /// fn version(sys: Py<PyModule>, py: Python<'_>) -> PyResult<PyObject> {
+    /// fn version(sys: Py<PyModule>, py: Python<'_>) -> PyResult<Py<PyAny>> {
     ///     sys.getattr(py, intern!(py, "version"))
     /// }
     /// #
-    /// # Python::with_gil(|py| {
-    /// #    let sys = py.import_bound("sys").unwrap().unbind();
+    /// # Python::attach(|py| {
+    /// #    let sys = py.import("sys").unwrap().unbind();
     /// #    version(sys, py).unwrap();
     /// # });
     /// ```
-    pub fn getattr<N>(&self, py: Python<'_>, attr_name: N) -> PyResult<PyObject>
+    pub fn getattr<'py, N>(&self, py: Python<'py>, attr_name: N) -> PyResult<Py<PyAny>>
     where
-        N: IntoPy<Py<PyString>>,
+        N: IntoPyObject<'py, Target = PyString>,
     {
         self.bind(py).as_any().getattr(attr_name).map(Bound::unbind)
     }
@@ -1243,109 +1833,74 @@ impl<T> Py<T> {
     /// # Example: `intern!`ing the attribute name
     ///
     /// ```
-    /// # use pyo3::{intern, pyfunction, types::PyModule, IntoPy, PyObject, Python, PyResult};
+    /// # use pyo3::{intern, pyfunction, types::PyModule, IntoPyObjectExt, Py, PyAny, Python, PyResult};
     /// #
     /// #[pyfunction]
-    /// fn set_answer(ob: PyObject, py: Python<'_>) -> PyResult<()> {
+    /// fn set_answer(ob: Py<PyAny>, py: Python<'_>) -> PyResult<()> {
     ///     ob.setattr(py, intern!(py, "answer"), 42)
     /// }
     /// #
-    /// # Python::with_gil(|py| {
-    /// #    let ob = PyModule::new(py, "empty").unwrap().into_py(py);
+    /// # Python::attach(|py| {
+    /// #    let ob = PyModule::new(py, "empty").unwrap().into_py_any(py).unwrap();
     /// #    set_answer(ob, py).unwrap();
     /// # });
     /// ```
-    pub fn setattr<N, V>(&self, py: Python<'_>, attr_name: N, value: V) -> PyResult<()>
-    where
-        N: IntoPy<Py<PyString>>,
-        V: IntoPy<Py<PyAny>>,
-    {
-        self.bind(py)
-            .as_any()
-            .setattr(attr_name, value.into_py(py).into_bound(py))
-    }
-
-    /// Deprecated form of [`call_bound`][Py::call_bound].
-    #[cfg_attr(
-        not(feature = "gil-refs"),
-        deprecated(
-            since = "0.21.0",
-            note = "`call` will be replaced by `call_bound` in a future PyO3 version"
-        )
-    )]
-    #[inline]
-    pub fn call<A>(&self, py: Python<'_>, args: A, kwargs: Option<&PyDict>) -> PyResult<PyObject>
+    pub fn setattr<'py, N, V>(&self, py: Python<'py>, attr_name: N, value: V) -> PyResult<()>
     where
-        A: IntoPy<Py<PyTuple>>,
+        N: IntoPyObject<'py, Target = PyString>,
+        V: IntoPyObject<'py>,
     {
-        self.call_bound(py, args, kwargs.map(PyDict::as_borrowed).as_deref())
+        self.bind(py).as_any().setattr(attr_name, value)
     }
 
     /// Calls the object.
     ///
     /// This is equivalent to the Python expression `self(*args, **kwargs)`.
-    pub fn call_bound(
+    pub fn call<'py, A>(
         &self,
-        py: Python<'_>,
-        args: impl IntoPy<Py<PyTuple>>,
-        kwargs: Option<&Bound<'_, PyDict>>,
-    ) -> PyResult<PyObject> {
+        py: Python<'py>,
+        args: A,
+        kwargs: Option<&Bound<'py, PyDict>>,
+    ) -> PyResult<Py<PyAny>>
+    where
+        A: PyCallArgs<'py>,
+    {
         self.bind(py).as_any().call(args, kwargs).map(Bound::unbind)
     }
 
     /// Calls the object with only positional arguments.
     ///
     /// This is equivalent to the Python expression `self(*args)`.
-    pub fn call1(&self, py: Python<'_>, args: impl IntoPy<Py<PyTuple>>) -> PyResult<PyObject> {
+    pub fn call1<'py, A>(&self, py: Python<'py>, args: A) -> PyResult<Py<PyAny>>
+    where
+        A: PyCallArgs<'py>,
+    {
         self.bind(py).as_any().call1(args).map(Bound::unbind)
     }
 
     /// Calls the object without arguments.
     ///
     /// This is equivalent to the Python expression `self()`.
-    pub fn call0(&self, py: Python<'_>) -> PyResult<PyObject> {
+    pub fn call0(&self, py: Python<'_>) -> PyResult<Py<PyAny>> {
         self.bind(py).as_any().call0().map(Bound::unbind)
     }
 
-    /// Deprecated form of [`call_method_bound`][Py::call_method_bound].
-    #[cfg_attr(
-        not(feature = "gil-refs"),
-        deprecated(
-            since = "0.21.0",
-            note = "`call_method` will be replaced by `call_method_bound` in a future PyO3 version"
-        )
-    )]
-    #[inline]
-    pub fn call_method<N, A>(
-        &self,
-        py: Python<'_>,
-        name: N,
-        args: A,
-        kwargs: Option<&PyDict>,
-    ) -> PyResult<PyObject>
-    where
-        N: IntoPy<Py<PyString>>,
-        A: IntoPy<Py<PyTuple>>,
-    {
-        self.call_method_bound(py, name, args, kwargs.map(PyDict::as_borrowed).as_deref())
-    }
-
     /// Calls a method on the object.
     ///
     /// This is equivalent to the Python expression `self.name(*args, **kwargs)`.
     ///
     /// To avoid repeated temporary allocations of Python strings, the [`intern!`](crate::intern)
     /// macro can be used to intern `name`.
-    pub fn call_method_bound<N, A>(
+    pub fn call_method<'py, N, A>(
         &self,
-        py: Python<'_>,
+        py: Python<'py>,
         name: N,
         args: A,
-        kwargs: Option<&Bound<'_, PyDict>>,
-    ) -> PyResult<PyObject>
+        kwargs: Option<&Bound<'py, PyDict>>,
+    ) -> PyResult<Py<PyAny>>
     where
-        N: IntoPy<Py<PyString>>,
-        A: IntoPy<Py<PyTuple>>,
+        N: IntoPyObject<'py, Target = PyString>,
+        A: PyCallArgs<'py>,
     {
         self.bind(py)
             .as_any()
@@ -1359,10 +1914,10 @@ impl<T> Py<T> {
     ///
     /// To avoid repeated temporary allocations of Python strings, the [`intern!`](crate::intern)
     /// macro can be used to intern `name`.
-    pub fn call_method1<N, A>(&self, py: Python<'_>, name: N, args: A) -> PyResult<PyObject>
+    pub fn call_method1<'py, N, A>(&self, py: Python<'py>, name: N, args: A) -> PyResult<Py<PyAny>>
     where
-        N: IntoPy<Py<PyString>>,
-        A: IntoPy<Py<PyTuple>>,
+        N: IntoPyObject<'py, Target = PyString>,
+        A: PyCallArgs<'py>,
     {
         self.bind(py)
             .as_any()
@@ -1376,9 +1931,9 @@ impl<T> Py<T> {
     ///
     /// To avoid repeated temporary allocations of Python strings, the [`intern!`](crate::intern)
     /// macro can be used to intern `name`.
-    pub fn call_method0<N>(&self, py: Python<'_>, name: N) -> PyResult<PyObject>
+    pub fn call_method0<'py, N>(&self, py: Python<'py>, name: N) -> PyResult<Py<PyAny>>
     where
-        N: IntoPy<Py<PyString>>,
+        N: IntoPyObject<'py, Target = PyString>,
     {
         self.bind(py).as_any().call_method0(name).map(Bound::unbind)
     }
@@ -1394,9 +1949,13 @@ impl<T> Py<T> {
     /// # Panics
     /// Panics if `ptr` is null.
     #[inline]
+    #[track_caller]
     pub unsafe fn from_owned_ptr(py: Python<'_>, ptr: *mut ffi::PyObject) -> Py<T> {
         match NonNull::new(ptr) {
-            Some(nonnull_ptr) => Py(nonnull_ptr, PhantomData),
+            Some(nonnull_ptr) => {
+                // SAFETY: caller has upheld the safety contract, ptr is known to be non-null
+                unsafe { Self::from_non_null(nonnull_ptr) }
+            }
             None => crate::err::panic_after_error(py),
         }
     }
@@ -1413,7 +1972,10 @@ impl<T> Py<T> {
         ptr: *mut ffi::PyObject,
     ) -> PyResult<Py<T>> {
         match NonNull::new(ptr) {
-            Some(nonnull_ptr) => Ok(Py(nonnull_ptr, PhantomData)),
+            Some(nonnull_ptr) => Ok(
+                // SAFETY: caller has upheld the safety contract, ptr is known to be non-null
+                unsafe { Self::from_non_null(nonnull_ptr) },
+            ),
             None => Err(PyErr::fetch(py)),
         }
     }
@@ -1426,7 +1988,20 @@ impl<T> Py<T> {
     /// If non-null, `ptr` must be a pointer to a Python object of type T.
     #[inline]
     pub unsafe fn from_owned_ptr_or_opt(_py: Python<'_>, ptr: *mut ffi::PyObject) -> Option<Self> {
-        NonNull::new(ptr).map(|nonnull_ptr| Py(nonnull_ptr, PhantomData))
+        NonNull::new(ptr).map(|nonnull_ptr| {
+            // SAFETY: caller has upheld the safety contract
+            unsafe { Self::from_non_null(nonnull_ptr) }
+        })
+    }
+
+    /// Constructs a new `Py<T>` instance by taking ownership of the given FFI pointer.
+    ///
+    /// # Safety
+    ///
+    /// - `ptr` must be a non-null pointer to a Python object of type `T`.
+    pub(crate) unsafe fn from_owned_ptr_unchecked(ptr: *mut ffi::PyObject) -> Self {
+        // SAFETY: caller has upheld the safety contract
+        unsafe { Self::from_non_null(NonNull::new_unchecked(ptr)) }
     }
 
     /// Create a `Py<T>` instance by creating a new reference from the given FFI pointer.
@@ -1437,11 +2012,11 @@ impl<T> Py<T> {
     /// # Panics
     /// Panics if `ptr` is null.
     #[inline]
+    #[track_caller]
     pub unsafe fn from_borrowed_ptr(py: Python<'_>, ptr: *mut ffi::PyObject) -> Py<T> {
-        match Self::from_borrowed_ptr_or_opt(py, ptr) {
-            Some(slf) => slf,
-            None => crate::err::panic_after_error(py),
-        }
+        // SAFETY: caller has upheld the safety contract
+        unsafe { Self::from_borrowed_ptr_or_opt(py, ptr) }
+            .unwrap_or_else(|| crate::err::panic_after_error(py))
     }
 
     /// Create a `Py<T>` instance by creating a new reference from the given FFI pointer.
@@ -1455,7 +2030,8 @@ impl<T> Py<T> {
         py: Python<'_>,
         ptr: *mut ffi::PyObject,
     ) -> PyResult<Self> {
-        Self::from_borrowed_ptr_or_opt(py, ptr).ok_or_else(|| PyErr::fetch(py))
+        // SAFETY: caller has upheld the safety contract
+        unsafe { Self::from_borrowed_ptr_or_opt(py, ptr) }.ok_or_else(|| PyErr::fetch(py))
     }
 
     /// Create a `Py<T>` instance by creating a new reference from the given FFI pointer.
@@ -1463,96 +2039,41 @@ impl<T> Py<T> {
     /// If `ptr` is null then `None` is returned.
     ///
     /// # Safety
-    /// `ptr` must be a pointer to a Python object of type T.
+    /// `ptr` must be a pointer to a Python object of type T, or null.
     #[inline]
     pub unsafe fn from_borrowed_ptr_or_opt(
         _py: Python<'_>,
         ptr: *mut ffi::PyObject,
     ) -> Option<Self> {
         NonNull::new(ptr).map(|nonnull_ptr| {
-            ffi::Py_INCREF(ptr);
-            Py(nonnull_ptr, PhantomData)
+            // SAFETY: ptr is a valid python object, thread is attached to the interpreter
+            unsafe { ffi::Py_INCREF(ptr) };
+            // SAFETY: caller has upheld the safety contract, and object was just made owned
+            unsafe { Self::from_non_null(nonnull_ptr) }
         })
     }
 
     /// For internal conversions.
     ///
     /// # Safety
-    /// `ptr` must point to a Python object of type T.
+    ///
+    /// `ptr` must point to an owned Python object type T.
+    #[inline(always)]
     unsafe fn from_non_null(ptr: NonNull<ffi::PyObject>) -> Self {
         Self(ptr, PhantomData)
     }
 }
 
-impl<T> ToPyObject for Py<T> {
-    /// Converts `Py` instance -> PyObject.
-    #[inline]
-    fn to_object(&self, py: Python<'_>) -> PyObject {
-        self.clone_ref(py).into_any()
-    }
-}
-
-impl<T> IntoPy<PyObject> for Py<T> {
-    /// Converts a `Py` instance to `PyObject`.
-    /// Consumes `self` without calling `Py_DECREF()`.
-    #[inline]
-    fn into_py(self, _py: Python<'_>) -> PyObject {
-        self.into_any()
-    }
-}
-
-impl<T> IntoPy<PyObject> for &'_ Py<T> {
+impl<T> AsRef<Py<PyAny>> for Py<T> {
     #[inline]
-    fn into_py(self, py: Python<'_>) -> PyObject {
-        self.to_object(py)
-    }
-}
-
-impl<T> ToPyObject for Bound<'_, T> {
-    /// Converts `&Bound` instance -> PyObject, increasing the reference count.
-    #[inline]
-    fn to_object(&self, py: Python<'_>) -> PyObject {
-        self.clone().into_py(py)
-    }
-}
-
-impl<T> IntoPy<PyObject> for Bound<'_, T> {
-    /// Converts a `Bound` instance to `PyObject`.
-    #[inline]
-    fn into_py(self, _py: Python<'_>) -> PyObject {
-        self.into_any().unbind()
-    }
-}
-
-impl<T> IntoPy<PyObject> for &Bound<'_, T> {
-    /// Converts `&Bound` instance -> PyObject, increasing the reference count.
-    #[inline]
-    fn into_py(self, py: Python<'_>) -> PyObject {
-        self.to_object(py)
-    }
-}
-
-unsafe impl<T> crate::AsPyPointer for Py<T> {
-    /// Gets the underlying FFI pointer, returns a borrowed pointer.
-    #[inline]
-    fn as_ptr(&self) -> *mut ffi::PyObject {
-        self.0.as_ptr()
-    }
-}
-
-impl<T> std::convert::From<&'_ T> for PyObject
-where
-    T: PyNativeType,
-{
-    #[inline]
-    fn from(obj: &T) -> Self {
-        obj.as_borrowed().to_owned().into_any().unbind()
+    fn as_ref(&self) -> &Py<PyAny> {
+        self.as_any()
     }
 }
 
-impl<T> std::convert::From<Py<T>> for PyObject
+impl<T> std::convert::From<Py<T>> for Py<PyAny>
 where
-    T: AsRef<PyAny>,
+    T: DerefToPyAny,
 {
     #[inline]
     fn from(other: Py<T>) -> Self {
@@ -1560,14 +2081,13 @@ where
     }
 }
 
-impl<T> std::convert::From<Bound<'_, T>> for PyObject
+impl<T> std::convert::From<Bound<'_, T>> for Py<PyAny>
 where
-    T: AsRef<PyAny>,
+    T: DerefToPyAny,
 {
     #[inline]
     fn from(other: Bound<'_, T>) -> Self {
-        let py = other.py();
-        other.into_py(py)
+        other.into_any().unbind()
     }
 }
 
@@ -1578,96 +2098,138 @@ impl<T> std::convert::From<Bound<'_, T>> for Py<T> {
     }
 }
 
-// `&PyCell<T>` can be converted to `Py<T>`
-impl<T> std::convert::From<&PyCell<T>> for Py<T>
-where
-    T: PyClass,
-{
-    fn from(cell: &PyCell<T>) -> Self {
-        cell.as_borrowed().to_owned().unbind()
+impl<T> std::convert::From<Borrowed<'_, '_, T>> for Py<T> {
+    fn from(value: Borrowed<'_, '_, T>) -> Self {
+        value.unbind()
     }
 }
 
-impl<'a, T> std::convert::From<PyRef<'a, T>> for Py<T>
+impl<'py, T> std::convert::From<PyRef<'py, T>> for Py<T>
 where
     T: PyClass,
 {
-    fn from(pyref: PyRef<'a, T>) -> Self {
+    fn from(pyref: PyRef<'py, T>) -> Self {
+        // SAFETY: PyRef::as_ptr returns a borrowed reference to a valid object
         unsafe { Py::from_borrowed_ptr(pyref.py(), pyref.as_ptr()) }
     }
 }
 
-impl<'a, T> std::convert::From<PyRefMut<'a, T>> for Py<T>
+impl<'py, T> std::convert::From<PyRefMut<'py, T>> for Py<T>
 where
     T: PyClass<Frozen = False>,
 {
-    fn from(pyref: PyRefMut<'a, T>) -> Self {
+    fn from(pyref: PyRefMut<'py, T>) -> Self {
+        // SAFETY: PyRefMut::as_ptr returns a borrowed reference to a valid object
         unsafe { Py::from_borrowed_ptr(pyref.py(), pyref.as_ptr()) }
     }
 }
 
-/// If the GIL is held this increments `self`'s reference count.
-/// Otherwise this registers the [`Py`]`<T>` instance to have its reference count
-/// incremented the next time PyO3 acquires the GIL.
+/// If the thread is attached to the Python interpreter this increments `self`'s reference count.
+/// Otherwise, it will panic.
+///
+/// Only available if the `py-clone` feature is enabled.
+#[cfg(feature = "py-clone")]
 impl<T> Clone for Py<T> {
+    #[track_caller]
+    #[inline]
     fn clone(&self) -> Self {
-        unsafe {
-            gil::register_incref(self.0);
+        #[track_caller]
+        #[inline]
+        fn try_incref(obj: NonNull<ffi::PyObject>) {
+            use crate::internal::state::thread_is_attached;
+
+            if thread_is_attached() {
+                // SAFETY: Py_INCREF is safe to call on a valid Python object if the thread is attached.
+                unsafe { ffi::Py_INCREF(obj.as_ptr()) }
+            } else {
+                incref_failed()
+            }
+        }
+
+        #[cold]
+        #[track_caller]
+        fn incref_failed() -> ! {
+            panic!("Cannot clone pointer into Python heap without the thread being attached.");
         }
+
+        try_incref(self.0);
+
         Self(self.0, PhantomData)
     }
 }
 
-/// Dropping a `Py` instance decrements the reference count on the object by 1.
+/// Dropping a `Py` instance decrements the reference count
+/// on the object by one if the thread is attached to the Python interpreter.
+///
+/// Otherwise and by default, this registers the underlying pointer to have its reference count
+/// decremented the next time PyO3 attaches to the Python interpreter.
+///
+/// However, if the `pyo3_disable_reference_pool` conditional compilation flag
+/// is enabled, it will abort the process.
 impl<T> Drop for Py<T> {
+    #[inline]
     fn drop(&mut self) {
-        unsafe {
-            gil::register_decref(self.0);
+        // non generic inlineable inner function to reduce code bloat
+        #[inline]
+        fn inner(obj: NonNull<ffi::PyObject>) {
+            use crate::internal::state::thread_is_attached;
+
+            if thread_is_attached() {
+                // SAFETY: Py_DECREF is safe to call on a valid Python object if the thread is attached.
+                unsafe { ffi::Py_DECREF(obj.as_ptr()) }
+            } else {
+                drop_slow(obj)
+            }
+        }
+
+        #[cold]
+        fn drop_slow(obj: NonNull<ffi::PyObject>) {
+            // SAFETY: handing ownership of the reference to `register_decref`.
+            unsafe {
+                state::register_decref(obj);
+            }
         }
+
+        inner(self.0)
     }
 }
 
-impl<T> FromPyObject<'_> for Py<T>
+impl<'a, 'py, T> FromPyObject<'a, 'py> for Py<T>
 where
-    T: PyTypeCheck,
+    T: PyTypeCheck + 'a,
 {
+    type Error = CastError<'a, 'py>;
+
+    #[cfg(feature = "experimental-inspect")]
+    const INPUT_TYPE: TypeHint = T::TYPE_HINT;
+
     /// Extracts `Self` from the source `PyObject`.
-    fn extract_bound(ob: &Bound<'_, PyAny>) -> PyResult<Self> {
-        ob.extract::<Bound<'_, T>>().map(Bound::unbind)
+    fn extract(ob: Borrowed<'a, 'py, PyAny>) -> Result<Self, Self::Error> {
+        ob.extract::<Bound<'py, T>>().map(Bound::unbind)
     }
 }
 
-impl<'py, T> FromPyObject<'py> for Bound<'py, T>
+impl<'a, 'py, T> FromPyObject<'a, 'py> for Bound<'py, T>
 where
-    T: PyTypeCheck,
+    T: PyTypeCheck + 'a,
 {
+    type Error = CastError<'a, 'py>;
+
+    #[cfg(feature = "experimental-inspect")]
+    const INPUT_TYPE: TypeHint = T::TYPE_HINT;
+
     /// Extracts `Self` from the source `PyObject`.
-    fn extract_bound(ob: &Bound<'py, PyAny>) -> PyResult<Self> {
-        // TODO update MSRV past 1.59 and use .cloned() to make
-        // clippy happy
-        #[allow(clippy::map_clone)]
-        ob.downcast().map(Clone::clone).map_err(Into::into)
+    fn extract(ob: Borrowed<'a, 'py, PyAny>) -> Result<Self, Self::Error> {
+        ob.cast().map(Borrowed::to_owned)
     }
 }
 
-/// `Py<T>` can be used as an error when T is an Error.
-///
-/// However for GIL lifetime reasons, cause() cannot be implemented for `Py<T>`.
-/// Use .as_ref() to get the GIL-scoped error if you need to inspect the cause.
-impl<T> std::error::Error for Py<T>
-where
-    T: std::error::Error + PyTypeInfo,
-    T::AsRefTarget: std::fmt::Display,
-{
-}
-
 impl<T> std::fmt::Display for Py<T>
 where
     T: PyTypeInfo,
-    T::AsRefTarget: std::fmt::Display,
 {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        Python::with_gil(|py| std::fmt::Display::fmt(self.as_ref(py), f))
+        Python::attach(|py| std::fmt::Display::fmt(self.bind(py), f))
     }
 }
 
@@ -1683,37 +2245,38 @@ impl<T> std::fmt::Debug for Py<T> {
 /// safely sent between threads.
 ///
 /// See the documentation for [`Py`](struct.Py.html).
+#[deprecated(since = "0.26.0", note = "use `Py<PyAny>` instead")]
 pub type PyObject = Py<PyAny>;
 
-impl PyObject {
-    /// Downcast this `PyObject` to a concrete Python type or pyclass.
+impl Py<PyAny> {
+    /// Downcast this `Py<PyAny>` to a concrete Python type or pyclass.
     ///
-    /// Note that you can often avoid downcasting yourself by just specifying
-    /// the desired type in function or method signatures.
-    /// However, manual downcasting is sometimes necessary.
+    /// Note that you can often avoid casting yourself by just specifying the desired type in
+    /// function or method signatures. However, manual casting is sometimes necessary.
     ///
-    /// For extracting a Rust-only type, see [`Py::extract`](struct.Py.html#method.extract).
+    /// For extracting a Rust-only type, see [`Py::extract`].
     ///
-    /// # Example: Downcasting to a specific Python object
+    ///  # Example: Downcasting to a specific Python object
     ///
     /// ```rust
+    /// # #![allow(deprecated)]
     /// use pyo3::prelude::*;
     /// use pyo3::types::{PyDict, PyList};
     ///
-    /// Python::with_gil(|py| {
-    ///     let any: PyObject = PyDict::new_bound(py).into();
+    /// Python::attach(|py| {
+    ///     let any = PyDict::new(py).into_any().unbind();
     ///
-    ///     assert!(any.downcast::<PyDict>(py).is_ok());
-    ///     assert!(any.downcast::<PyList>(py).is_err());
+    ///     assert!(any.downcast_bound::<PyDict>(py).is_ok());
+    ///     assert!(any.downcast_bound::<PyList>(py).is_err());
     /// });
     /// ```
     ///
     /// # Example: Getting a reference to a pyclass
     ///
-    /// This is useful if you want to mutate a `PyObject` that
-    /// might actually be a pyclass.
+    /// This is useful if you want to mutate a `Py<PyAny>` that might actually be a pyclass.
     ///
     /// ```rust
+    /// # #![allow(deprecated)]
     /// # fn main() -> Result<(), pyo3::PyErr> {
     /// use pyo3::prelude::*;
     ///
@@ -1722,12 +2285,12 @@ impl PyObject {
     ///     i: i32,
     /// }
     ///
-    /// Python::with_gil(|py| {
-    ///     let class: PyObject = Py::new(py, Class { i: 0 }).unwrap().into_py(py);
+    /// Python::attach(|py| {
+    ///     let class = Py::new(py, Class { i: 0 })?.into_any();
     ///
-    ///     let class_cell: &PyCell<Class> = class.downcast(py)?;
+    ///     let class_bound = class.downcast_bound::<Class>(py)?;
     ///
-    ///     class_cell.borrow_mut().i += 1;
+    ///     class_bound.borrow_mut().i += 1;
     ///
     ///     // Alternatively you can get a `PyRefMut` directly
     ///     let class_ref: PyRefMut<'_, Class> = class.extract(py)?;
@@ -1736,65 +2299,179 @@ impl PyObject {
     /// })
     /// # }
     /// ```
+    #[deprecated(since = "0.27.0", note = "use `Py::cast_bound` instead")]
     #[inline]
-    pub fn downcast<'py, T>(&'py self, py: Python<'py>) -> Result<&'py T, PyDowncastError<'py>>
+    #[allow(deprecated)]
+    pub fn downcast_bound<'py, T>(
+        &self,
+        py: Python<'py>,
+    ) -> Result<&Bound<'py, T>, DowncastError<'_, 'py>>
     where
-        T: PyTypeCheck<AsRefTarget = T>,
+        T: PyTypeCheck,
     {
-        self.as_ref(py).downcast()
+        #[allow(deprecated)]
+        self.bind(py).downcast()
     }
 
-    /// Casts the PyObject to a concrete Python object type without checking validity.
+    /// Casts the `Py<PyAny>` to a concrete Python object type without checking validity.
     ///
     /// # Safety
     ///
     /// Callers must ensure that the type is valid or risk type confusion.
+    #[deprecated(since = "0.27.0", note = "use `Py::cast_bound_unchecked` instead")]
     #[inline]
-    pub unsafe fn downcast_unchecked<'p, T>(&'p self, py: Python<'p>) -> &T
+    pub unsafe fn downcast_bound_unchecked<'py, T>(&self, py: Python<'py>) -> &Bound<'py, T> {
+        // SAFETY: caller has upheld the safety contract
+        unsafe { self.cast_bound_unchecked(py) }
+    }
+}
+
+impl<T> Py<T> {
+    /// Cast this `Py<T>` to a concrete Python type or pyclass.
+    ///
+    /// Note that you can often avoid casting yourself by just specifying the desired type in
+    /// function or method signatures. However, manual casting is sometimes necessary.
+    ///
+    /// For extracting a Rust-only type, see [`Py::extract`].
+    ///
+    /// # Example: Casting to a specific Python object
+    ///
+    /// ```rust
+    /// use pyo3::prelude::*;
+    /// use pyo3::types::{PyDict, PyList};
+    ///
+    /// Python::attach(|py| {
+    ///     let any = PyDict::new(py).into_any().unbind();
+    ///
+    ///     assert!(any.cast_bound::<PyDict>(py).is_ok());
+    ///     assert!(any.cast_bound::<PyList>(py).is_err());
+    /// });
+    /// ```
+    ///
+    /// # Example: Getting a reference to a pyclass
+    ///
+    /// This is useful if you want to mutate a `Py<PyAny>` that might actually be a pyclass.
+    ///
+    /// ```rust
+    /// # fn main() -> Result<(), pyo3::PyErr> {
+    /// use pyo3::prelude::*;
+    ///
+    /// #[pyclass]
+    /// struct Class {
+    ///     i: i32,
+    /// }
+    ///
+    /// Python::attach(|py| {
+    ///     let class = Py::new(py, Class { i: 0 })?.into_any();
+    ///
+    ///     let class_bound = class.cast_bound::<Class>(py)?;
+    ///
+    ///     class_bound.borrow_mut().i += 1;
+    ///
+    ///     // Alternatively you can get a `PyRefMut` directly
+    ///     let class_ref: PyRefMut<'_, Class> = class.extract(py)?;
+    ///     assert_eq!(class_ref.i, 1);
+    ///     Ok(())
+    /// })
+    /// # }
+    /// ```
+    pub fn cast_bound<'py, U>(&self, py: Python<'py>) -> Result<&Bound<'py, U>, CastError<'_, 'py>>
     where
-        T: HasPyGilRef<AsRefTarget = T>,
+        U: PyTypeCheck,
     {
-        self.as_ref(py).downcast_unchecked()
+        self.bind(py).cast()
+    }
+
+    /// Casts the `Py<T>` to a concrete Python object type without checking validity.
+    ///
+    /// # Safety
+    ///
+    /// Callers must ensure that the type is valid or risk type confusion.
+    #[inline]
+    pub unsafe fn cast_bound_unchecked<'py, U>(&self, py: Python<'py>) -> &Bound<'py, U> {
+        // Safety: caller has upheld the safety contract
+        unsafe { self.bind(py).cast_unchecked() }
     }
 }
 
 #[cfg(test)]
-#[cfg_attr(not(feature = "gil-refs"), allow(deprecated))]
 mod tests {
-    use super::{Bound, Py, PyObject};
-    use crate::types::{dict::IntoPyDict, PyDict, PyString};
-    use crate::{PyAny, PyNativeType, PyResult, Python, ToPyObject};
+    use super::{Bound, IntoPyObject, Py};
+    use crate::test_utils::generate_unique_module_name;
+    use crate::types::{dict::IntoPyDict, PyAnyMethods, PyCapsule, PyDict, PyString};
+    use crate::{ffi, Borrowed, IntoPyObjectExt, PyAny, PyResult, Python};
+    use std::ffi::CStr;
 
     #[test]
     fn test_call() {
-        Python::with_gil(|py| {
-            let obj = py.get_type::<PyDict>().to_object(py);
+        Python::attach(|py| {
+            let obj = py.get_type::<PyDict>().into_pyobject(py).unwrap();
 
-            let assert_repr = |obj: &PyAny, expected: &str| {
-                assert_eq!(obj.repr().unwrap().to_str().unwrap(), expected);
+            let assert_repr = |obj: Bound<'_, PyAny>, expected: &str| {
+                assert_eq!(obj.repr().unwrap(), expected);
             };
 
-            assert_repr(obj.call0(py).unwrap().as_ref(py), "{}");
-            assert_repr(obj.call1(py, ()).unwrap().as_ref(py), "{}");
-            assert_repr(obj.call(py, (), None).unwrap().as_ref(py), "{}");
+            assert_repr(obj.call0().unwrap(), "{}");
+            assert_repr(obj.call1(()).unwrap(), "{}");
+            assert_repr(obj.call((), None).unwrap(), "{}");
 
+            assert_repr(obj.call1(((('x', 1),),)).unwrap(), "{'x': 1}");
             assert_repr(
-                obj.call1(py, ((('x', 1),),)).unwrap().as_ref(py),
+                obj.call((), Some(&[('x', 1)].into_py_dict(py).unwrap()))
+                    .unwrap(),
                 "{'x': 1}",
             );
-            assert_repr(
-                obj.call_bound(py, (), Some(&[('x', 1)].into_py_dict_bound(py)))
+        })
+    }
+
+    #[test]
+    fn test_call_tuple_ref() {
+        let assert_repr = |obj: &Bound<'_, PyAny>, expected: &str| {
+            use crate::prelude::PyStringMethods;
+            assert_eq!(
+                obj.repr()
                     .unwrap()
-                    .as_ref(py),
-                "{'x': 1}",
+                    .to_cow()
+                    .unwrap()
+                    .trim_matches(|c| c == '{' || c == '}'),
+                expected.trim_matches(|c| c == ',' || c == ' ')
             );
+        };
+
+        macro_rules! tuple {
+            ($py:ident, $($key: literal => $value: literal),+) => {
+                let ty_obj = $py.get_type::<PyDict>().into_pyobject($py).unwrap();
+                assert!(ty_obj.call1(&(($(($key),)+),)).is_err());
+                let obj = ty_obj.call1(&(($(($key, i32::from($value)),)+),)).unwrap();
+                assert_repr(&obj, concat!($("'", $key, "'", ": ", stringify!($value), ", ",)+));
+                assert!(obj.call_method1("update", &(($(($key),)+),)).is_err());
+                obj.call_method1("update", &(($((i32::from($value), $key),)+),)).unwrap();
+                assert_repr(&obj, concat!(
+                    concat!($("'", $key, "'", ": ", stringify!($value), ", ",)+),
+                    concat!($(stringify!($value), ": ", "'", $key, "'", ", ",)+)
+                ));
+            };
+        }
+
+        Python::attach(|py| {
+            tuple!(py, "a" => 1);
+            tuple!(py, "a" => 1, "b" => 2);
+            tuple!(py, "a" => 1, "b" => 2, "c" => 3);
+            tuple!(py, "a" => 1, "b" => 2, "c" => 3, "d" => 4);
+            tuple!(py, "a" => 1, "b" => 2, "c" => 3, "d" => 4, "e" => 5);
+            tuple!(py, "a" => 1, "b" => 2, "c" => 3, "d" => 4, "e" => 5, "f" => 6);
+            tuple!(py, "a" => 1, "b" => 2, "c" => 3, "d" => 4, "e" => 5, "f" => 6, "g" => 7);
+            tuple!(py, "a" => 1, "b" => 2, "c" => 3, "d" => 4, "e" => 5, "f" => 6, "g" => 7, "h" => 8);
+            tuple!(py, "a" => 1, "b" => 2, "c" => 3, "d" => 4, "e" => 5, "f" => 6, "g" => 7, "h" => 8, "i" => 9);
+            tuple!(py, "a" => 1, "b" => 2, "c" => 3, "d" => 4, "e" => 5, "f" => 6, "g" => 7, "h" => 8, "i" => 9, "j" => 10, "k" => 11);
+            tuple!(py, "a" => 1, "b" => 2, "c" => 3, "d" => 4, "e" => 5, "f" => 6, "g" => 7, "h" => 8, "i" => 9, "j" => 10, "k" => 11, "l" => 12);
         })
     }
 
     #[test]
     fn test_call_for_non_existing_method() {
-        Python::with_gil(|py| {
-            let obj: PyObject = PyDict::new(py).into();
+        Python::attach(|py| {
+            let obj: Py<PyAny> = PyDict::new(py).into();
             assert!(obj.call_method0(py, "asdf").is_err());
             assert!(obj
                 .call_method(py, "nonexistent_method", (1,), None)
@@ -1806,20 +2483,22 @@ mod tests {
 
     #[test]
     fn py_from_dict() {
-        let dict: Py<PyDict> = Python::with_gil(|py| {
+        let dict: Py<PyDict> = Python::attach(|py| {
             let native = PyDict::new(py);
             Py::from(native)
         });
 
-        assert_eq!(Python::with_gil(|py| dict.get_refcnt(py)), 1);
+        Python::attach(move |py| {
+            assert_eq!(dict.get_refcnt(py), 1);
+        });
     }
 
     #[test]
     fn pyobject_from_py() {
-        Python::with_gil(|py| {
-            let dict: Py<PyDict> = PyDict::new(py).into();
+        Python::attach(|py| {
+            let dict: Py<PyDict> = PyDict::new(py).unbind();
             let cnt = dict.get_refcnt(py);
-            let p: PyObject = dict.into();
+            let p: Py<PyAny> = dict.into();
             assert_eq!(p.get_refcnt(py), cnt);
         });
     }
@@ -1828,13 +2507,13 @@ mod tests {
     fn attr() -> PyResult<()> {
         use crate::types::PyModule;
 
-        Python::with_gil(|py| {
-            const CODE: &str = r#"
+        Python::attach(|py| {
+            const CODE: &CStr = cr#"
 class A:
     pass
 a = A()
    "#;
-            let module = PyModule::from_code(py, CODE, "", "")?;
+            let module = PyModule::from_code(py, CODE, c"", &generate_unique_module_name(""))?;
             let instance: Py<PyAny> = module.getattr("a")?.into();
 
             instance.getattr(py, "foo").unwrap_err();
@@ -1843,8 +2522,8 @@ a = A()
 
             assert!(instance
                 .getattr(py, "foo")?
-                .as_ref(py)
-                .eq(PyString::new_bound(py, "bar"))?);
+                .bind(py)
+                .eq(PyString::new(py, "bar"))?);
 
             instance.getattr(py, "foo")?;
             Ok(())
@@ -1855,13 +2534,13 @@ a = A()
     fn pystring_attr() -> PyResult<()> {
         use crate::types::PyModule;
 
-        Python::with_gil(|py| {
-            const CODE: &str = r#"
+        Python::attach(|py| {
+            const CODE: &CStr = cr#"
 class A:
     pass
 a = A()
    "#;
-            let module = PyModule::from_code(py, CODE, "", "")?;
+            let module = PyModule::from_code(py, CODE, c"", &generate_unique_module_name(""))?;
             let instance: Py<PyAny> = module.getattr("a")?.into();
 
             let foo = crate::intern!(py, "foo");
@@ -1869,15 +2548,15 @@ a = A()
 
             instance.getattr(py, foo).unwrap_err();
             instance.setattr(py, foo, bar)?;
-            assert!(instance.getattr(py, foo)?.as_ref(py).eq(bar)?);
+            assert!(instance.getattr(py, foo)?.bind(py).eq(bar)?);
             Ok(())
         })
     }
 
     #[test]
     fn invalid_attr() -> PyResult<()> {
-        Python::with_gil(|py| {
-            let instance: Py<PyAny> = py.eval("object()", None, None)?.into();
+        Python::attach(|py| {
+            let instance: Py<PyAny> = py.eval(c"object()", None, None)?.into();
 
             instance.getattr(py, "foo").unwrap_err();
 
@@ -1889,8 +2568,8 @@ a = A()
 
     #[test]
     fn test_py2_from_py_object() {
-        Python::with_gil(|py| {
-            let instance: &PyAny = py.eval("object()", None, None).unwrap();
+        Python::attach(|py| {
+            let instance = py.eval(c"object()", None, None).unwrap();
             let ptr = instance.as_ptr();
             let instance: Bound<'_, PyAny> = instance.extract().unwrap();
             assert_eq!(instance.as_ptr(), ptr);
@@ -1899,55 +2578,34 @@ a = A()
 
     #[test]
     fn test_py2_into_py_object() {
-        Python::with_gil(|py| {
-            let instance = py
-                .eval("object()", None, None)
-                .unwrap()
-                .as_borrowed()
-                .to_owned();
+        Python::attach(|py| {
+            let instance = py.eval(c"object()", None, None).unwrap();
             let ptr = instance.as_ptr();
-            let instance: PyObject = instance.clone().unbind();
+            let instance: Py<PyAny> = instance.clone().unbind();
             assert_eq!(instance.as_ptr(), ptr);
         })
     }
 
-    #[test]
-    #[allow(deprecated)]
-    fn test_is_ellipsis() {
-        Python::with_gil(|py| {
-            let v = py
-                .eval("...", None, None)
-                .map_err(|e| e.display(py))
-                .unwrap()
-                .to_object(py);
-
-            assert!(v.is_ellipsis());
-
-            let not_ellipsis = 5.to_object(py);
-            assert!(!not_ellipsis.is_ellipsis());
-        });
-    }
-
     #[test]
     fn test_debug_fmt() {
-        Python::with_gil(|py| {
-            let obj = "hello world".to_object(py).into_bound(py);
-            assert_eq!(format!("{:?}", obj), "'hello world'");
+        Python::attach(|py| {
+            let obj = "hello world".into_pyobject(py).unwrap();
+            assert_eq!(format!("{obj:?}"), "'hello world'");
         });
     }
 
     #[test]
     fn test_display_fmt() {
-        Python::with_gil(|py| {
-            let obj = "hello world".to_object(py).into_bound(py);
-            assert_eq!(format!("{}", obj), "hello world");
+        Python::attach(|py| {
+            let obj = "hello world".into_pyobject(py).unwrap();
+            assert_eq!(format!("{obj}"), "hello world");
         });
     }
 
     #[test]
     fn test_bound_as_any() {
-        Python::with_gil(|py| {
-            let obj = PyString::new_bound(py, "hello world");
+        Python::attach(|py| {
+            let obj = PyString::new(py, "hello world");
             let any = obj.as_any();
             assert_eq!(any.as_ptr(), obj.as_ptr());
         });
@@ -1955,17 +2613,143 @@ a = A()
 
     #[test]
     fn test_bound_into_any() {
-        Python::with_gil(|py| {
-            let obj = PyString::new_bound(py, "hello world");
+        Python::attach(|py| {
+            let obj = PyString::new(py, "hello world");
             let any = obj.clone().into_any();
             assert_eq!(any.as_ptr(), obj.as_ptr());
         });
     }
 
+    #[test]
+    fn test_bound_py_conversions() {
+        Python::attach(|py| {
+            let obj: Bound<'_, PyString> = PyString::new(py, "hello world");
+            let obj_unbound: &Py<PyString> = obj.as_unbound();
+            let _: &Bound<'_, PyString> = obj_unbound.bind(py);
+
+            let obj_unbound: Py<PyString> = obj.unbind();
+            let obj: Bound<'_, PyString> = obj_unbound.into_bound(py);
+
+            assert_eq!(obj, "hello world");
+        });
+    }
+
+    #[test]
+    fn test_borrowed_identity() {
+        Python::attach(|py| {
+            let yes = true.into_pyobject(py).unwrap();
+            let no = false.into_pyobject(py).unwrap();
+
+            assert!(yes.is(yes));
+            assert!(!yes.is(no));
+        });
+    }
+
+    #[test]
+    #[allow(clippy::undocumented_unsafe_blocks)] // Doing evil things to try to make `Bound` blow up
+    fn bound_from_borrowed_ptr_constructors() {
+        Python::attach(|py| {
+            fn check_drop<'py>(
+                py: Python<'py>,
+                method: impl FnOnce(*mut ffi::PyObject) -> Bound<'py, PyAny>,
+            ) {
+                let mut dropped = false;
+                let capsule = PyCapsule::new_with_destructor(
+                    py,
+                    (&mut dropped) as *mut _ as usize,
+                    None,
+                    |ptr, _| unsafe { std::ptr::write(ptr as *mut bool, true) },
+                )
+                .unwrap();
+
+                let bound = method(capsule.as_ptr());
+                assert!(!dropped);
+
+                // creating the bound should have increased the refcount
+                drop(capsule);
+                assert!(!dropped);
+
+                // dropping the bound should now also decrease the refcount and free the object
+                drop(bound);
+                assert!(dropped);
+            }
+
+            check_drop(py, |ptr| unsafe { Bound::from_borrowed_ptr(py, ptr) });
+            check_drop(py, |ptr| unsafe {
+                Bound::from_borrowed_ptr_or_opt(py, ptr).unwrap()
+            });
+            check_drop(py, |ptr| unsafe {
+                Bound::from_borrowed_ptr_or_err(py, ptr).unwrap()
+            });
+        })
+    }
+
+    #[test]
+    #[allow(clippy::undocumented_unsafe_blocks)] // Doing evil things to try to make `Borrowed` blow up
+    fn borrowed_ptr_constructors() {
+        Python::attach(|py| {
+            fn check_drop<'py>(
+                py: Python<'py>,
+                method: impl FnOnce(&*mut ffi::PyObject) -> Borrowed<'_, 'py, PyAny>,
+            ) {
+                let mut dropped = false;
+                let capsule = PyCapsule::new_with_destructor(
+                    py,
+                    (&mut dropped) as *mut _ as usize,
+                    None,
+                    |ptr, _| unsafe { std::ptr::write(ptr as *mut bool, true) },
+                )
+                .unwrap();
+
+                let ptr = &capsule.as_ptr();
+                let _borrowed = method(ptr);
+                assert!(!dropped);
+
+                // creating the borrow should not have increased the refcount
+                drop(capsule);
+                assert!(dropped);
+            }
+
+            check_drop(py, |&ptr| unsafe { Borrowed::from_ptr(py, ptr) });
+            check_drop(py, |&ptr| unsafe {
+                Borrowed::from_ptr_or_opt(py, ptr).unwrap()
+            });
+            check_drop(py, |&ptr| unsafe {
+                Borrowed::from_ptr_or_err(py, ptr).unwrap()
+            });
+        })
+    }
+
+    #[test]
+    fn explicit_drop_ref() {
+        Python::attach(|py| {
+            let object: Py<PyDict> = PyDict::new(py).unbind();
+            let object2 = object.clone_ref(py);
+
+            assert_eq!(object.as_ptr(), object2.as_ptr());
+            assert_eq!(object.get_refcnt(py), 2);
+
+            object.drop_ref(py);
+
+            assert_eq!(object2.get_refcnt(py), 1);
+
+            object2.drop_ref(py);
+        });
+    }
+
+    #[test]
+    fn test_py_is_truthy() {
+        Python::attach(|py| {
+            let yes = true.into_py_any(py).unwrap();
+            let no = false.into_py_any(py).unwrap();
+
+            assert!(yes.is_truthy(py).unwrap());
+            assert!(!no.is_truthy(py).unwrap());
+        });
+    }
+
     #[cfg(feature = "macros")]
     mod using_macros {
-        use crate::PyCell;
-
         use super::*;
 
         #[crate::pyclass(crate = "crate")]
@@ -1974,7 +2758,7 @@ a = A()
         #[test]
         fn py_borrow_methods() {
             // More detailed tests of the underlying semantics in pycell.rs
-            Python::with_gil(|py| {
+            Python::attach(|py| {
                 let instance = Py::new(py, SomeClass(0)).unwrap();
                 assert_eq!(instance.borrow(py).0, 0);
                 assert_eq!(instance.try_borrow(py).unwrap().0, 0);
@@ -1993,7 +2777,7 @@ a = A()
         #[test]
         fn bound_borrow_methods() {
             // More detailed tests of the underlying semantics in pycell.rs
-            Python::with_gil(|py| {
+            Python::attach(|py| {
                 let instance = Bound::new(py, SomeClass(0)).unwrap();
                 assert_eq!(instance.borrow().0, 0);
                 assert_eq!(instance.try_borrow().unwrap().0, 0);
@@ -2014,7 +2798,7 @@ a = A()
 
         #[test]
         fn test_frozen_get() {
-            Python::with_gil(|py| {
+            Python::attach(|py| {
                 for i in 0..10 {
                     let instance = Py::new(py, FrozenClass(i)).unwrap();
                     assert_eq!(instance.get().0, i);
@@ -2024,15 +2808,41 @@ a = A()
             })
         }
 
+        #[crate::pyclass(crate = "crate", subclass)]
+        struct BaseClass;
+
+        trait MyClassMethods<'py>: Sized {
+            fn pyrepr_by_ref(&self) -> PyResult<String>;
+            fn pyrepr_by_val(self) -> PyResult<String> {
+                self.pyrepr_by_ref()
+            }
+        }
+        impl<'py> MyClassMethods<'py> for Bound<'py, BaseClass> {
+            fn pyrepr_by_ref(&self) -> PyResult<String> {
+                self.call_method0("__repr__")?.extract()
+            }
+        }
+
+        #[crate::pyclass(crate = "crate", extends = BaseClass)]
+        struct SubClass;
+
+        #[test]
+        fn test_as_super() {
+            Python::attach(|py| {
+                let obj = Bound::new(py, (SubClass, BaseClass)).unwrap();
+                let _: &Bound<'_, BaseClass> = obj.as_super();
+                let _: &Bound<'_, PyAny> = obj.as_super().as_super();
+                assert!(obj.as_super().pyrepr_by_ref().is_ok());
+            })
+        }
+
         #[test]
-        #[allow(deprecated)]
-        fn cell_tryfrom() {
-            use crate::PyTryInto;
-            // More detailed tests of the underlying semantics in pycell.rs
-            Python::with_gil(|py| {
-                let instance: &PyAny = Py::new(py, SomeClass(0)).unwrap().into_ref(py);
-                let _: &PyCell<SomeClass> = PyTryInto::try_into(instance).unwrap();
-                let _: &PyCell<SomeClass> = PyTryInto::try_into_exact(instance).unwrap();
+        fn test_into_super() {
+            Python::attach(|py| {
+                let obj = Bound::new(py, (SubClass, BaseClass)).unwrap();
+                let _: Bound<'_, BaseClass> = obj.clone().into_super();
+                let _: Bound<'_, PyAny> = obj.clone().into_super().into_super();
+                assert!(obj.into_super().pyrepr_by_val().is_ok());
             })
         }
     }
diff --git a/src/internal.rs b/src/internal.rs
new file mode 100644
index 00000000000..7299f90ed03
--- /dev/null
+++ b/src/internal.rs
@@ -0,0 +1,4 @@
+//! Holding place for code which is not intended to be reachable from outside of PyO3.
+
+pub(crate) mod get_slot;
+pub(crate) mod state;
diff --git a/src/internal/get_slot.rs b/src/internal/get_slot.rs
new file mode 100644
index 00000000000..3eeb16b645d
--- /dev/null
+++ b/src/internal/get_slot.rs
@@ -0,0 +1,284 @@
+use crate::{
+    ffi,
+    types::{PyType, PyTypeMethods},
+    Borrowed, Bound,
+};
+use std::ffi::c_int;
+
+impl Bound<'_, PyType> {
+    #[inline]
+    pub(crate) fn get_slot<const S: c_int>(&self, slot: Slot<S>) -> <Slot<S> as GetSlotImpl>::Type
+    where
+        Slot<S>: GetSlotImpl,
+    {
+        // SAFETY: `self` is a valid type object.
+        unsafe {
+            slot.get_slot(
+                self.as_type_ptr(),
+                #[cfg(all(Py_LIMITED_API, not(Py_3_10)))]
+                is_runtime_3_10(self.py()),
+            )
+        }
+    }
+}
+
+impl Borrowed<'_, '_, PyType> {
+    #[inline]
+    pub(crate) fn get_slot<const S: c_int>(self, slot: Slot<S>) -> <Slot<S> as GetSlotImpl>::Type
+    where
+        Slot<S>: GetSlotImpl,
+    {
+        // SAFETY: `self` is a valid type object.
+        unsafe {
+            slot.get_slot(
+                self.as_type_ptr(),
+                #[cfg(all(Py_LIMITED_API, not(Py_3_10)))]
+                is_runtime_3_10(self.py()),
+            )
+        }
+    }
+}
+
+/// Gets a slot from a raw FFI pointer.
+///
+/// Safety:
+///   - `ty` must be a valid non-null pointer to a `PyTypeObject`.
+///   - The Python runtime must be initialized
+pub(crate) unsafe fn get_slot<const S: c_int>(
+    ty: *mut ffi::PyTypeObject,
+    slot: Slot<S>,
+) -> <Slot<S> as GetSlotImpl>::Type
+where
+    Slot<S>: GetSlotImpl,
+{
+    unsafe {
+        slot.get_slot(
+            ty,
+            // SAFETY: the Python runtime is initialized
+            #[cfg(all(Py_LIMITED_API, not(Py_3_10)))]
+            is_runtime_3_10(crate::Python::assume_attached()),
+        )
+    }
+}
+
+pub(crate) trait GetSlotImpl {
+    type Type;
+
+    /// Gets the requested slot from a type object.
+    ///
+    /// Safety:
+    ///  - `ty` must be a valid non-null pointer to a `PyTypeObject`.
+    ///  - `is_runtime_3_10` must be `false` if the runtime is not Python 3.10 or later.
+    unsafe fn get_slot(
+        self,
+        ty: *mut ffi::PyTypeObject,
+        #[cfg(all(Py_LIMITED_API, not(Py_3_10)))] is_runtime_3_10: bool,
+    ) -> Self::Type;
+}
+
+#[derive(Copy, Clone)]
+pub(crate) struct Slot<const S: c_int>;
+
+macro_rules! impl_slots {
+    ($($name:ident: ($slot:ident, $field:ident) -> $tp:ty),+ $(,)?) => {
+        $(
+            pub (crate) const $name: Slot<{ ffi::$slot }> = Slot;
+
+            impl GetSlotImpl for Slot<{ ffi::$slot }> {
+                type Type = $tp;
+
+                #[inline]
+                unsafe fn get_slot(
+                    self,
+                    ty: *mut ffi::PyTypeObject,
+                    #[cfg(all(Py_LIMITED_API, not(Py_3_10)))] is_runtime_3_10: bool
+                ) -> Self::Type {
+                    #[cfg(not(Py_LIMITED_API))]
+                    {
+                        unsafe {(*ty).$field }
+                    }
+
+                    #[cfg(Py_LIMITED_API)]
+                    {
+                        #[cfg(not(Py_3_10))]
+                        {
+                            // Calling PyType_GetSlot on static types is not valid before Python 3.10
+                            // ... so the workaround is to first do a runtime check for these versions
+                            // (3.7, 3.8, 3.9) and then look in the type object anyway. This is only ok
+                            // because we know that the interpreter is not going to change the size
+                            // of the type objects for these historical versions.
+                            if !is_runtime_3_10 && unsafe {ffi::PyType_HasFeature(ty, ffi::Py_TPFLAGS_HEAPTYPE)} == 0
+                            {
+                                return unsafe {(*ty.cast::<PyTypeObject39Snapshot>()).$field};
+                            }
+                        }
+
+                        // SAFETY: slot type is set carefully to be valid
+                        unsafe {std::mem::transmute(ffi::PyType_GetSlot(ty, ffi::$slot))}
+                    }
+                }
+            }
+        )*
+    };
+}
+
+// Slots are implemented on-demand as needed.)
+impl_slots! {
+    TP_ALLOC: (Py_tp_alloc, tp_alloc) -> Option<ffi::allocfunc>,
+    TP_BASE: (Py_tp_base, tp_base) -> *mut ffi::PyTypeObject,
+    TP_CLEAR: (Py_tp_clear, tp_clear) -> Option<ffi::inquiry>,
+    TP_DESCR_GET: (Py_tp_descr_get, tp_descr_get) -> Option<ffi::descrgetfunc>,
+    TP_FREE: (Py_tp_free, tp_free) -> Option<ffi::freefunc>,
+    TP_TRAVERSE: (Py_tp_traverse, tp_traverse) -> Option<ffi::traverseproc>,
+}
+
+#[cfg(all(Py_LIMITED_API, not(Py_3_10)))]
+fn is_runtime_3_10(py: crate::Python<'_>) -> bool {
+    use crate::sync::PyOnceLock;
+
+    static IS_RUNTIME_3_10: PyOnceLock<bool> = PyOnceLock::new();
+    *IS_RUNTIME_3_10.get_or_init(py, || py.version_info() >= (3, 10))
+}
+
+#[repr(C)]
+#[cfg(all(Py_LIMITED_API, not(Py_3_10)))]
+pub struct PyNumberMethods39Snapshot {
+    pub nb_add: Option<ffi::binaryfunc>,
+    pub nb_subtract: Option<ffi::binaryfunc>,
+    pub nb_multiply: Option<ffi::binaryfunc>,
+    pub nb_remainder: Option<ffi::binaryfunc>,
+    pub nb_divmod: Option<ffi::binaryfunc>,
+    pub nb_power: Option<ffi::ternaryfunc>,
+    pub nb_negative: Option<ffi::unaryfunc>,
+    pub nb_positive: Option<ffi::unaryfunc>,
+    pub nb_absolute: Option<ffi::unaryfunc>,
+    pub nb_bool: Option<ffi::inquiry>,
+    pub nb_invert: Option<ffi::unaryfunc>,
+    pub nb_lshift: Option<ffi::binaryfunc>,
+    pub nb_rshift: Option<ffi::binaryfunc>,
+    pub nb_and: Option<ffi::binaryfunc>,
+    pub nb_xor: Option<ffi::binaryfunc>,
+    pub nb_or: Option<ffi::binaryfunc>,
+    pub nb_int: Option<ffi::unaryfunc>,
+    pub nb_reserved: *mut std::ffi::c_void,
+    pub nb_float: Option<ffi::unaryfunc>,
+    pub nb_inplace_add: Option<ffi::binaryfunc>,
+    pub nb_inplace_subtract: Option<ffi::binaryfunc>,
+    pub nb_inplace_multiply: Option<ffi::binaryfunc>,
+    pub nb_inplace_remainder: Option<ffi::binaryfunc>,
+    pub nb_inplace_power: Option<ffi::ternaryfunc>,
+    pub nb_inplace_lshift: Option<ffi::binaryfunc>,
+    pub nb_inplace_rshift: Option<ffi::binaryfunc>,
+    pub nb_inplace_and: Option<ffi::binaryfunc>,
+    pub nb_inplace_xor: Option<ffi::binaryfunc>,
+    pub nb_inplace_or: Option<ffi::binaryfunc>,
+    pub nb_floor_divide: Option<ffi::binaryfunc>,
+    pub nb_true_divide: Option<ffi::binaryfunc>,
+    pub nb_inplace_floor_divide: Option<ffi::binaryfunc>,
+    pub nb_inplace_true_divide: Option<ffi::binaryfunc>,
+    pub nb_index: Option<ffi::unaryfunc>,
+    pub nb_matrix_multiply: Option<ffi::binaryfunc>,
+    pub nb_inplace_matrix_multiply: Option<ffi::binaryfunc>,
+}
+
+#[repr(C)]
+#[cfg(all(Py_LIMITED_API, not(Py_3_10)))]
+pub struct PySequenceMethods39Snapshot {
+    pub sq_length: Option<ffi::lenfunc>,
+    pub sq_concat: Option<ffi::binaryfunc>,
+    pub sq_repeat: Option<ffi::ssizeargfunc>,
+    pub sq_item: Option<ffi::ssizeargfunc>,
+    pub was_sq_slice: *mut std::ffi::c_void,
+    pub sq_ass_item: Option<ffi::ssizeobjargproc>,
+    pub was_sq_ass_slice: *mut std::ffi::c_void,
+    pub sq_contains: Option<ffi::objobjproc>,
+    pub sq_inplace_concat: Option<ffi::binaryfunc>,
+    pub sq_inplace_repeat: Option<ffi::ssizeargfunc>,
+}
+
+#[repr(C)]
+#[cfg(all(Py_LIMITED_API, not(Py_3_10)))]
+pub struct PyMappingMethods39Snapshot {
+    pub mp_length: Option<ffi::lenfunc>,
+    pub mp_subscript: Option<ffi::binaryfunc>,
+    pub mp_ass_subscript: Option<ffi::objobjargproc>,
+}
+
+#[repr(C)]
+#[cfg(all(Py_LIMITED_API, not(Py_3_10)))]
+pub struct PyAsyncMethods39Snapshot {
+    pub am_await: Option<ffi::unaryfunc>,
+    pub am_aiter: Option<ffi::unaryfunc>,
+    pub am_anext: Option<ffi::unaryfunc>,
+}
+
+#[repr(C)]
+#[cfg(all(Py_LIMITED_API, not(Py_3_10)))]
+pub struct PyBufferProcs39Snapshot {
+    // not available in limited api, but structure needs to have the right size
+    pub bf_getbuffer: *mut std::ffi::c_void,
+    pub bf_releasebuffer: *mut std::ffi::c_void,
+}
+
+/// Snapshot of the structure of PyTypeObject for Python 3.7 through 3.9.
+///
+/// This is used as a fallback for static types in abi3 when the Python version is less than 3.10;
+/// this is a bit of a hack but there's no better option and the structure of the type object is
+/// not going to change for those historical versions.
+#[repr(C)]
+#[cfg(all(Py_LIMITED_API, not(Py_3_10)))]
+struct PyTypeObject39Snapshot {
+    pub ob_base: ffi::PyVarObject,
+    pub tp_name: *const std::ffi::c_char,
+    pub tp_basicsize: ffi::Py_ssize_t,
+    pub tp_itemsize: ffi::Py_ssize_t,
+    pub tp_dealloc: Option<ffi::destructor>,
+    #[cfg(not(Py_3_8))]
+    pub tp_print: *mut std::ffi::c_void, // stubbed out, not available in limited API
+    #[cfg(Py_3_8)]
+    pub tp_vectorcall_offset: ffi::Py_ssize_t,
+    pub tp_getattr: Option<ffi::getattrfunc>,
+    pub tp_setattr: Option<ffi::setattrfunc>,
+    pub tp_as_async: *mut PyAsyncMethods39Snapshot,
+    pub tp_repr: Option<ffi::reprfunc>,
+    pub tp_as_number: *mut PyNumberMethods39Snapshot,
+    pub tp_as_sequence: *mut PySequenceMethods39Snapshot,
+    pub tp_as_mapping: *mut PyMappingMethods39Snapshot,
+    pub tp_hash: Option<ffi::hashfunc>,
+    pub tp_call: Option<ffi::ternaryfunc>,
+    pub tp_str: Option<ffi::reprfunc>,
+    pub tp_getattro: Option<ffi::getattrofunc>,
+    pub tp_setattro: Option<ffi::setattrofunc>,
+    pub tp_as_buffer: *mut PyBufferProcs39Snapshot,
+    pub tp_flags: std::ffi::c_ulong,
+    pub tp_doc: *const std::ffi::c_char,
+    pub tp_traverse: Option<ffi::traverseproc>,
+    pub tp_clear: Option<ffi::inquiry>,
+    pub tp_richcompare: Option<ffi::richcmpfunc>,
+    pub tp_weaklistoffset: ffi::Py_ssize_t,
+    pub tp_iter: Option<ffi::getiterfunc>,
+    pub tp_iternext: Option<ffi::iternextfunc>,
+    pub tp_methods: *mut ffi::PyMethodDef,
+    pub tp_members: *mut ffi::PyMemberDef,
+    pub tp_getset: *mut ffi::PyGetSetDef,
+    pub tp_base: *mut ffi::PyTypeObject,
+    pub tp_dict: *mut ffi::PyObject,
+    pub tp_descr_get: Option<ffi::descrgetfunc>,
+    pub tp_descr_set: Option<ffi::descrsetfunc>,
+    pub tp_dictoffset: ffi::Py_ssize_t,
+    pub tp_init: Option<ffi::initproc>,
+    pub tp_alloc: Option<ffi::allocfunc>,
+    pub tp_new: Option<ffi::newfunc>,
+    pub tp_free: Option<ffi::freefunc>,
+    pub tp_is_gc: Option<ffi::inquiry>,
+    pub tp_bases: *mut ffi::PyObject,
+    pub tp_mro: *mut ffi::PyObject,
+    pub tp_cache: *mut ffi::PyObject,
+    pub tp_subclasses: *mut ffi::PyObject,
+    pub tp_weaklist: *mut ffi::PyObject,
+    pub tp_del: Option<ffi::destructor>,
+    pub tp_version_tag: std::ffi::c_uint,
+    pub tp_finalize: Option<ffi::destructor>,
+    #[cfg(Py_3_8)]
+    pub tp_vectorcall: Option<ffi::vectorcallfunc>,
+}
diff --git a/src/internal/state.rs b/src/internal/state.rs
new file mode 100644
index 00000000000..9d9194f3e7d
--- /dev/null
+++ b/src/internal/state.rs
@@ -0,0 +1,593 @@
+//! Interaction with attachment of the current thread to the Python interpreter.
+
+#[cfg(pyo3_disable_reference_pool)]
+use crate::impl_::panic::PanicTrap;
+use crate::{ffi, Python};
+
+use std::cell::Cell;
+#[cfg(not(pyo3_disable_reference_pool))]
+use std::sync::OnceLock;
+#[cfg_attr(pyo3_disable_reference_pool, allow(unused_imports))]
+use std::{mem, ptr::NonNull, sync};
+
+std::thread_local! {
+    /// This is an internal counter in pyo3 monitoring whether this thread is attached to the interpreter.
+    ///
+    /// It will be incremented whenever an AttachGuard is created, and decremented whenever
+    /// they are dropped.
+    ///
+    /// As a result, if this thread is attached to the interpreter, ATTACH_COUNT is greater than zero.
+    ///
+    /// Additionally, we sometimes need to prevent safe access to the Python interpreter,
+    /// e.g. when implementing `__traverse__`, which is represented by a negative value.
+    static ATTACH_COUNT: Cell<isize> = const { Cell::new(0) };
+}
+
+const ATTACH_FORBIDDEN_DURING_TRAVERSE: isize = -1;
+
+/// Checks whether the thread is attached to the Python interpreter.
+///
+/// Note: This uses pyo3's internal count rather than PyGILState_Check for two reasons:
+///  1) for performance
+///  2) PyGILState_Check always returns 1 if the sub-interpreter APIs have ever been called,
+///     which could lead to incorrect conclusions that the thread is attached.
+#[inline(always)]
+pub(crate) fn thread_is_attached() -> bool {
+    ATTACH_COUNT.try_with(|c| c.get() > 0).unwrap_or(false)
+}
+
+/// RAII type that represents thread attachment to the interpreter.
+pub(crate) enum AttachGuard {
+    /// Indicates the thread was already attached when this AttachGuard was acquired.
+    Assumed,
+    /// Indicates that we attached when this AttachGuard was acquired
+    Ensured { gstate: ffi::PyGILState_STATE },
+}
+
+/// Possible error when calling `try_attach()`
+pub(crate) enum AttachError {
+    /// Forbidden during GC traversal.
+    ForbiddenDuringTraverse,
+    /// The interpreter is not initialized.
+    NotInitialized,
+    #[cfg(Py_3_13)]
+    /// The interpreter is finalizing.
+    Finalizing,
+}
+
+impl AttachGuard {
+    /// PyO3 internal API for attaching to the Python interpreter. The public API is Python::attach.
+    ///
+    /// If the thread was already attached via PyO3, this returns
+    /// `AttachGuard::Assumed`. Otherwise, the thread will attach now and
+    /// `AttachGuard::Ensured` will be returned.
+    pub(crate) fn attach() -> Self {
+        match Self::try_attach() {
+            Ok(guard) => guard,
+            Err(AttachError::ForbiddenDuringTraverse) => {
+                panic!("{}", ForbidAttaching::FORBIDDEN_DURING_TRAVERSE)
+            }
+            Err(AttachError::NotInitialized) => {
+                // try to initialize the interpreter and try again
+                crate::interpreter_lifecycle::ensure_initialized();
+                unsafe { Self::do_attach_unchecked() }
+            }
+            #[cfg(Py_3_13)]
+            Err(AttachError::Finalizing) => {
+                panic!("Cannot attach to the Python interpreter while it is finalizing.");
+            }
+        }
+    }
+
+    /// Variant of the above which will will return gracefully if the interpreter cannot be attached to.
+    pub(crate) fn try_attach() -> Result<Self, AttachError> {
+        match ATTACH_COUNT.try_with(|c| c.get()) {
+            Ok(i) if i > 0 => {
+                // SAFETY: We just checked that the thread is already attached.
+                return Ok(unsafe { Self::assume() });
+            }
+            // Cannot attach during GC traversal.
+            Ok(ATTACH_FORBIDDEN_DURING_TRAVERSE) => {
+                return Err(AttachError::ForbiddenDuringTraverse)
+            }
+            // other cases handled below
+            _ => {}
+        }
+
+        // SAFETY: always safe to call this
+        if unsafe { ffi::Py_IsInitialized() } == 0 {
+            return Err(AttachError::NotInitialized);
+        }
+
+        // Calling `PyGILState_Ensure` while finalizing may crash CPython in unpredictable
+        // ways, we'll make a best effort attempt here to avoid that. (There's a time of
+        // check to time-of-use issue, but it's better than nothing.)
+        //
+        // SAFETY: always safe to call this
+        #[cfg(Py_3_13)]
+        if unsafe { ffi::Py_IsFinalizing() } != 0 {
+            // If the interpreter is not initialized, we cannot attach.
+            return Err(AttachError::Finalizing);
+        }
+
+        // SAFETY: We have done everything reasonable to ensure we're in a safe state to
+        // attach to the Python interpreter.
+        Ok(unsafe { Self::do_attach_unchecked() })
+    }
+
+    /// Acquires the `AttachGuard` without performing any state checking.
+    ///
+    /// This can be called in "unsafe" contexts where the normal interpreter state
+    /// checking performed by `AttachGuard::try_attach` may fail. This includes calling
+    /// as part of multi-phase interpreter initialization.
+    ///
+    /// # Safety
+    ///
+    /// The caller must ensure that the Python interpreter is sufficiently initialized
+    /// for a thread to be able to attach to it.
+    pub(crate) unsafe fn attach_unchecked() -> Self {
+        if thread_is_attached() {
+            return unsafe { Self::assume() };
+        }
+
+        unsafe { Self::do_attach_unchecked() }
+    }
+
+    /// Attach to the interpreter, without a fast-path to check if the thread is already attached.
+    #[cold]
+    unsafe fn do_attach_unchecked() -> Self {
+        // SAFETY: interpreter is sufficiently initialized to attach a thread.
+        let gstate = unsafe { ffi::PyGILState_Ensure() };
+        increment_attach_count();
+        // SAFETY: just attached to the interpreter
+        drop_deferred_references(unsafe { Python::assume_attached() });
+        AttachGuard::Ensured { gstate }
+    }
+
+    /// Acquires the `AttachGuard` while assuming that the thread is already attached
+    /// to the interpreter.
+    pub(crate) unsafe fn assume() -> Self {
+        increment_attach_count();
+        // SAFETY: invariant of calling this function
+        drop_deferred_references(unsafe { Python::assume_attached() });
+        AttachGuard::Assumed
+    }
+
+    /// Gets the Python token associated with this [`AttachGuard`].
+    #[inline]
+    pub(crate) fn python(&self) -> Python<'_> {
+        // SAFETY: this guard guarantees the thread is attached
+        unsafe { Python::assume_attached() }
+    }
+}
+
+/// The Drop implementation for `AttachGuard` will decrement the attach count (and potentially detach).
+impl Drop for AttachGuard {
+    fn drop(&mut self) {
+        match self {
+            AttachGuard::Assumed => {}
+            AttachGuard::Ensured { gstate } => unsafe {
+                // Drop the objects in the pool before attempting to release the thread state
+                ffi::PyGILState_Release(*gstate);
+            },
+        }
+        decrement_attach_count();
+    }
+}
+
+#[cfg(not(pyo3_disable_reference_pool))]
+type PyObjVec = Vec<NonNull<ffi::PyObject>>;
+
+#[cfg(not(pyo3_disable_reference_pool))]
+/// Thread-safe storage for objects which were dec_ref while not attached.
+struct ReferencePool {
+    pending_decrefs: sync::Mutex<PyObjVec>,
+}
+
+#[cfg(not(pyo3_disable_reference_pool))]
+impl ReferencePool {
+    const fn new() -> Self {
+        Self {
+            pending_decrefs: sync::Mutex::new(Vec::new()),
+        }
+    }
+
+    fn register_decref(&self, obj: NonNull<ffi::PyObject>) {
+        self.pending_decrefs.lock().unwrap().push(obj);
+    }
+
+    fn drop_deferred_references(&self, _py: Python<'_>) {
+        let mut pending_decrefs = self.pending_decrefs.lock().unwrap();
+        if pending_decrefs.is_empty() {
+            return;
+        }
+
+        let decrefs = mem::take(&mut *pending_decrefs);
+        drop(pending_decrefs);
+
+        for ptr in decrefs {
+            unsafe { ffi::Py_DECREF(ptr.as_ptr()) };
+        }
+    }
+}
+
+#[cfg(not(pyo3_disable_reference_pool))]
+unsafe impl Send for ReferencePool {}
+
+#[cfg(not(pyo3_disable_reference_pool))]
+unsafe impl Sync for ReferencePool {}
+
+#[cfg(not(pyo3_disable_reference_pool))]
+static POOL: OnceLock<ReferencePool> = OnceLock::new();
+
+#[cfg(not(pyo3_disable_reference_pool))]
+fn get_pool() -> &'static ReferencePool {
+    POOL.get_or_init(ReferencePool::new)
+}
+
+#[cfg_attr(pyo3_disable_reference_pool, inline(always))]
+#[cfg_attr(pyo3_disable_reference_pool, allow(unused_variables))]
+fn drop_deferred_references(py: Python<'_>) {
+    #[cfg(not(pyo3_disable_reference_pool))]
+    if let Some(pool) = POOL.get() {
+        pool.drop_deferred_references(py);
+    }
+}
+
+/// A guard which can be used to temporarily detach from the interpreter and restore on `Drop`.
+pub(crate) struct SuspendAttach {
+    count: isize,
+    tstate: *mut ffi::PyThreadState,
+}
+
+impl SuspendAttach {
+    pub(crate) unsafe fn new() -> Self {
+        let count = ATTACH_COUNT.with(|c| c.replace(0));
+        let tstate = unsafe { ffi::PyEval_SaveThread() };
+
+        Self { count, tstate }
+    }
+}
+
+impl Drop for SuspendAttach {
+    fn drop(&mut self) {
+        ATTACH_COUNT.with(|c| c.set(self.count));
+        unsafe {
+            ffi::PyEval_RestoreThread(self.tstate);
+
+            // Update counts of `Py<T>` that were dropped while not attached.
+            #[cfg(not(pyo3_disable_reference_pool))]
+            if let Some(pool) = POOL.get() {
+                pool.drop_deferred_references(Python::assume_attached());
+            }
+        }
+    }
+}
+
+/// Used to lock safe access to the interpreter
+pub(crate) struct ForbidAttaching {
+    count: isize,
+}
+
+impl ForbidAttaching {
+    const FORBIDDEN_DURING_TRAVERSE: &'static str = "Attaching a thread to the interpreter is prohibited while a __traverse__ implementation is running.";
+
+    /// Lock access to the interpreter while an implementation of `__traverse__` is running
+    pub fn during_traverse() -> Self {
+        Self::new(ATTACH_FORBIDDEN_DURING_TRAVERSE)
+    }
+
+    fn new(reason: isize) -> Self {
+        let count = ATTACH_COUNT.with(|c| c.replace(reason));
+
+        Self { count }
+    }
+
+    #[cold]
+    fn bail(current: isize) {
+        match current {
+            ATTACH_FORBIDDEN_DURING_TRAVERSE => panic!("{}", Self::FORBIDDEN_DURING_TRAVERSE),
+            _ => panic!("Attaching a thread to the interpreter is currently prohibited."),
+        }
+    }
+}
+
+impl Drop for ForbidAttaching {
+    fn drop(&mut self) {
+        ATTACH_COUNT.with(|c| c.set(self.count));
+    }
+}
+
+/// Registers a Python object pointer inside the release pool, to have its reference count decreased
+/// the next time the thread is attached in pyo3.
+///
+/// If the thread is attached, the reference count will be decreased immediately instead of being queued
+/// for later.
+///
+/// # Safety
+/// - The object must be an owned Python reference.
+/// - The reference must not be used after calling this function.
+#[inline]
+pub unsafe fn register_decref(obj: NonNull<ffi::PyObject>) {
+    #[cfg(not(pyo3_disable_reference_pool))]
+    {
+        get_pool().register_decref(obj);
+    }
+    #[cfg(all(
+        pyo3_disable_reference_pool,
+        not(pyo3_leak_on_drop_without_reference_pool)
+    ))]
+    {
+        let _trap = PanicTrap::new("Aborting the process to avoid panic-from-drop.");
+        panic!("Cannot drop pointer into Python heap without the thread being attached.");
+    }
+}
+
+/// Private helper function to check if we are currently in a GC traversal (as detected by PyO3).
+#[cfg(any(not(Py_LIMITED_API), Py_3_11))]
+pub(crate) fn is_in_gc_traversal() -> bool {
+    ATTACH_COUNT
+        .try_with(|c| c.get() == ATTACH_FORBIDDEN_DURING_TRAVERSE)
+        .unwrap_or(false)
+}
+
+/// Increments pyo3's internal attach count - to be called whenever an AttachGuard is created.
+#[inline(always)]
+fn increment_attach_count() {
+    // Ignores the error in case this function called from `atexit`.
+    let _ = ATTACH_COUNT.try_with(|c| {
+        let current = c.get();
+        if current < 0 {
+            ForbidAttaching::bail(current);
+        }
+        c.set(current + 1);
+    });
+}
+
+/// Decrements pyo3's internal attach count - to be called whenever AttachGuard is dropped.
+#[inline(always)]
+fn decrement_attach_count() {
+    // Ignores the error in case this function called from `atexit`.
+    let _ = ATTACH_COUNT.try_with(|c| {
+        let current = c.get();
+        debug_assert!(
+            current > 0,
+            "Negative attach count detected. Please report this error to the PyO3 repo as a bug."
+        );
+        c.set(current - 1);
+    });
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    use crate::{types::PyAnyMethods, Py, PyAny, Python};
+
+    fn get_object(py: Python<'_>) -> Py<PyAny> {
+        py.eval(c"object()", None, None).unwrap().unbind()
+    }
+
+    #[cfg(not(pyo3_disable_reference_pool))]
+    fn pool_dec_refs_does_not_contain(obj: &Py<PyAny>) -> bool {
+        !get_pool()
+            .pending_decrefs
+            .lock()
+            .unwrap()
+            .contains(&unsafe { NonNull::new_unchecked(obj.as_ptr()) })
+    }
+
+    // With free-threading, threads can empty the POOL at any time, so this
+    // function does not test anything meaningful
+    #[cfg(not(any(pyo3_disable_reference_pool, Py_GIL_DISABLED)))]
+    fn pool_dec_refs_contains(obj: &Py<PyAny>) -> bool {
+        get_pool()
+            .pending_decrefs
+            .lock()
+            .unwrap()
+            .contains(&unsafe { NonNull::new_unchecked(obj.as_ptr()) })
+    }
+
+    #[test]
+    fn test_pyobject_drop_attached_decreases_refcnt() {
+        Python::attach(|py| {
+            let obj = get_object(py);
+
+            // Create a reference to drop while attached.
+            let reference = obj.clone_ref(py);
+
+            assert_eq!(obj.get_refcnt(py), 2);
+            #[cfg(not(pyo3_disable_reference_pool))]
+            assert!(pool_dec_refs_does_not_contain(&obj));
+
+            // While attached, reference count will be decreased immediately.
+            drop(reference);
+
+            assert_eq!(obj.get_refcnt(py), 1);
+            #[cfg(not(any(pyo3_disable_reference_pool)))]
+            assert!(pool_dec_refs_does_not_contain(&obj));
+        });
+    }
+
+    #[test]
+    #[cfg(all(not(pyo3_disable_reference_pool), not(target_arch = "wasm32")))] // We are building wasm Python with pthreads disabled
+    fn test_pyobject_drop_detached_doesnt_decrease_refcnt() {
+        let obj = Python::attach(|py| {
+            let obj = get_object(py);
+            // Create a reference to drop while detached.
+            let reference = obj.clone_ref(py);
+
+            assert_eq!(obj.get_refcnt(py), 2);
+            assert!(pool_dec_refs_does_not_contain(&obj));
+
+            // Drop reference in a separate (detached) thread.
+            std::thread::spawn(move || drop(reference)).join().unwrap();
+
+            // The reference count should not have changed, it is remembered
+            // to release later.
+            assert_eq!(obj.get_refcnt(py), 2);
+            #[cfg(not(Py_GIL_DISABLED))]
+            assert!(pool_dec_refs_contains(&obj));
+            obj
+        });
+
+        // On next attach, the reference is released
+        #[allow(unused)]
+        Python::attach(|py| {
+            // With free-threading, another thread could still be processing
+            // DECREFs after releasing the lock on the POOL, so the
+            // refcnt could still be 2 when this assert happens
+            #[cfg(not(Py_GIL_DISABLED))]
+            assert_eq!(obj.get_refcnt(py), 1);
+            assert!(pool_dec_refs_does_not_contain(&obj));
+        });
+    }
+
+    #[test]
+    #[allow(deprecated)]
+    fn test_attach_counts() {
+        // Check `attach` and AttachGuard both increase counts correctly
+        let get_attach_count = || ATTACH_COUNT.with(|c| c.get());
+
+        assert_eq!(get_attach_count(), 0);
+        Python::attach(|_| {
+            assert_eq!(get_attach_count(), 1);
+
+            let pool = unsafe { AttachGuard::assume() };
+            assert_eq!(get_attach_count(), 2);
+
+            let pool2 = unsafe { AttachGuard::assume() };
+            assert_eq!(get_attach_count(), 3);
+
+            drop(pool);
+            assert_eq!(get_attach_count(), 2);
+
+            Python::attach(|_| {
+                // nested `attach` updates attach count
+                assert_eq!(get_attach_count(), 3);
+            });
+            assert_eq!(get_attach_count(), 2);
+
+            drop(pool2);
+            assert_eq!(get_attach_count(), 1);
+        });
+        assert_eq!(get_attach_count(), 0);
+    }
+
+    #[test]
+    fn test_detach() {
+        assert!(!thread_is_attached());
+
+        Python::attach(|py| {
+            assert!(thread_is_attached());
+
+            py.detach(move || {
+                assert!(!thread_is_attached());
+
+                Python::attach(|_| assert!(thread_is_attached()));
+
+                assert!(!thread_is_attached());
+            });
+
+            assert!(thread_is_attached());
+        });
+
+        assert!(!thread_is_attached());
+    }
+
+    #[cfg(feature = "py-clone")]
+    #[test]
+    #[should_panic]
+    fn test_detach_updates_refcounts() {
+        Python::attach(|py| {
+            // Make a simple object with 1 reference
+            let obj = get_object(py);
+            assert_eq!(obj.get_refcnt(py), 1);
+            // Cloning the object when detached should panic
+            py.detach(|| obj.clone());
+        });
+    }
+
+    #[test]
+    fn recursive_attach_ok() {
+        Python::attach(|py| {
+            let obj = Python::attach(|_| py.eval(c"object()", None, None).unwrap());
+            assert_eq!(obj.get_refcnt(), 1);
+        })
+    }
+
+    #[cfg(feature = "py-clone")]
+    #[test]
+    fn test_clone_attached() {
+        Python::attach(|py| {
+            let obj = get_object(py);
+            let count = obj.get_refcnt(py);
+
+            // Cloning when attached should increase reference count immediately
+            #[allow(clippy::redundant_clone)]
+            let c = obj.clone();
+            assert_eq!(count + 1, c.get_refcnt(py));
+        })
+    }
+
+    #[test]
+    #[cfg(not(pyo3_disable_reference_pool))]
+    fn test_drop_deferred_references_does_not_deadlock() {
+        // drop_deferred_references can run arbitrary Python code during Py_DECREF.
+        // if the locking is implemented incorrectly, it will deadlock.
+
+        use crate::ffi;
+
+        Python::attach(|py| {
+            let obj = get_object(py);
+
+            unsafe extern "C" fn capsule_drop(capsule: *mut ffi::PyObject) {
+                // This line will implicitly call drop_deferred_references
+                // -> and so cause deadlock if drop_deferred_references is not handling recursion correctly.
+                let pool = unsafe { AttachGuard::assume() };
+
+                // Rebuild obj so that it can be dropped
+                unsafe {
+                    Py::<PyAny>::from_owned_ptr(
+                        pool.python(),
+                        ffi::PyCapsule_GetPointer(capsule, std::ptr::null()) as _,
+                    )
+                };
+            }
+
+            let ptr = obj.into_ptr();
+
+            let capsule =
+                unsafe { ffi::PyCapsule_New(ptr as _, std::ptr::null(), Some(capsule_drop)) };
+
+            get_pool().register_decref(NonNull::new(capsule).unwrap());
+
+            // Updating the counts will call decref on the capsule, which calls capsule_drop
+            get_pool().drop_deferred_references(py);
+        })
+    }
+
+    #[test]
+    #[cfg(not(pyo3_disable_reference_pool))]
+    fn test_attach_guard_drop_deferred_references() {
+        Python::attach(|py| {
+            let obj = get_object(py);
+
+            // For AttachGuard::attach
+
+            get_pool().register_decref(NonNull::new(obj.clone_ref(py).into_ptr()).unwrap());
+            #[cfg(not(Py_GIL_DISABLED))]
+            assert!(pool_dec_refs_contains(&obj));
+            let _guard = AttachGuard::attach();
+            assert!(pool_dec_refs_does_not_contain(&obj));
+
+            // For AttachGuard::assume
+
+            get_pool().register_decref(NonNull::new(obj.clone_ref(py).into_ptr()).unwrap());
+            #[cfg(not(Py_GIL_DISABLED))]
+            assert!(pool_dec_refs_contains(&obj));
+            let _guard2 = unsafe { AttachGuard::assume() };
+            assert!(pool_dec_refs_does_not_contain(&obj));
+        })
+    }
+}
diff --git a/src/internal_tricks.rs b/src/internal_tricks.rs
index 551ddf5a910..1c7b7a802a1 100644
--- a/src/internal_tricks.rs
+++ b/src/internal_tricks.rs
@@ -1,30 +1,4 @@
-use std::{
-    borrow::Cow,
-    ffi::{CStr, CString},
-};
-
-use crate::{
-    exceptions::PyValueError,
-    ffi::{Py_ssize_t, PY_SSIZE_T_MAX},
-    PyResult,
-};
-pub struct PrivateMarker;
-
-macro_rules! private_decl {
-    () => {
-        /// This trait is private to implement; this method exists to make it
-        /// impossible to implement outside the crate.
-        fn __private__(&self) -> crate::internal_tricks::PrivateMarker;
-    };
-}
-
-macro_rules! private_impl {
-    () => {
-        fn __private__(&self) -> crate::internal_tricks::PrivateMarker {
-            crate::internal_tricks::PrivateMarker
-        }
-    };
-}
+use crate::ffi::{self, Py_ssize_t, PY_SSIZE_T_MAX};
 
 macro_rules! pyo3_exception {
     ($doc: expr, $name: ident, $base: ty) => {
@@ -45,170 +19,32 @@ pub(crate) fn get_ssize_index(index: usize) -> Py_ssize_t {
     index.min(PY_SSIZE_T_MAX as usize) as Py_ssize_t
 }
 
-/// Implementations used for slice indexing PySequence, PyTuple, and PyList
-macro_rules! index_impls {
-    (
-        $ty:ty,
-        $ty_name:literal,
-        $len:expr,
-        $get_slice:expr $(,)?
-    ) => {
-        impl std::ops::Index<usize> for $ty {
-            // Always PyAny output (even if the slice operation returns something else)
-            type Output = PyAny;
-
-            #[track_caller]
-            fn index(&self, index: usize) -> &Self::Output {
-                self.get_item(index).unwrap_or_else(|_| {
-                    crate::internal_tricks::index_len_fail(index, $ty_name, $len(self))
-                })
-            }
-        }
-
-        impl std::ops::Index<std::ops::Range<usize>> for $ty {
-            type Output = $ty;
-
-            #[track_caller]
-            fn index(
-                &self,
-                std::ops::Range { start, end }: std::ops::Range<usize>,
-            ) -> &Self::Output {
-                let len = $len(self);
-                if start > len {
-                    crate::internal_tricks::slice_start_index_len_fail(start, $ty_name, len)
-                } else if end > len {
-                    crate::internal_tricks::slice_end_index_len_fail(end, $ty_name, len)
-                } else if start > end {
-                    crate::internal_tricks::slice_index_order_fail(start, end)
-                } else {
-                    $get_slice(self, start, end)
-                }
-            }
-        }
-
-        impl std::ops::Index<std::ops::RangeFrom<usize>> for $ty {
-            type Output = $ty;
-
-            #[track_caller]
-            fn index(
-                &self,
-                std::ops::RangeFrom { start }: std::ops::RangeFrom<usize>,
-            ) -> &Self::Output {
-                let len = $len(self);
-                if start > len {
-                    crate::internal_tricks::slice_start_index_len_fail(start, $ty_name, len)
-                } else {
-                    $get_slice(self, start, len)
-                }
-            }
-        }
-
-        impl std::ops::Index<std::ops::RangeFull> for $ty {
-            type Output = $ty;
-
-            #[track_caller]
-            fn index(&self, _: std::ops::RangeFull) -> &Self::Output {
-                let len = $len(self);
-                $get_slice(self, 0, len)
-            }
-        }
-
-        impl std::ops::Index<std::ops::RangeInclusive<usize>> for $ty {
-            type Output = $ty;
-
-            #[track_caller]
-            fn index(&self, range: std::ops::RangeInclusive<usize>) -> &Self::Output {
-                let exclusive_end = range
-                    .end()
-                    .checked_add(1)
-                    .expect("range end exceeds Python limit");
-                &self[*range.start()..exclusive_end]
-            }
-        }
-
-        impl std::ops::Index<std::ops::RangeTo<usize>> for $ty {
-            type Output = $ty;
-
-            #[track_caller]
-            fn index(&self, std::ops::RangeTo { end }: std::ops::RangeTo<usize>) -> &Self::Output {
-                &self[0..end]
-            }
-        }
-
-        impl std::ops::Index<std::ops::RangeToInclusive<usize>> for $ty {
-            type Output = $ty;
-
-            #[track_caller]
-            fn index(
-                &self,
-                std::ops::RangeToInclusive { end }: std::ops::RangeToInclusive<usize>,
-            ) -> &Self::Output {
-                &self[0..=end]
-            }
-        }
-    };
-}
-
-// these error messages are shamelessly "borrowed" from std.
-
-#[inline(never)]
-#[cold]
-#[track_caller]
-pub(crate) fn index_len_fail(index: usize, ty_name: &str, len: usize) -> ! {
-    panic!(
-        "index {} out of range for {} of length {}",
-        index, ty_name, len
-    );
-}
-
-#[inline(never)]
-#[cold]
-#[track_caller]
-pub(crate) fn slice_start_index_len_fail(index: usize, ty_name: &str, len: usize) -> ! {
-    panic!(
-        "range start index {} out of range for {} of length {}",
-        index, ty_name, len
-    );
-}
-
-#[inline(never)]
-#[cold]
-#[track_caller]
-pub(crate) fn slice_end_index_len_fail(index: usize, ty_name: &str, len: usize) -> ! {
-    panic!(
-        "range end index {} out of range for {} of length {}",
-        index, ty_name, len
-    );
-}
-
-#[inline(never)]
-#[cold]
-#[track_caller]
-pub(crate) fn slice_index_order_fail(index: usize, end: usize) -> ! {
-    panic!("slice index starts at {} but ends at {}", index, end);
-}
-
-pub(crate) fn extract_c_string(
-    src: &'static str,
-    err_msg: &'static str,
-) -> PyResult<Cow<'static, CStr>> {
-    let bytes = src.as_bytes();
-    let cow = match bytes {
-        [] => {
-            // Empty string, we can trivially refer to a static "\0" string
-            Cow::Borrowed(unsafe { CStr::from_bytes_with_nul_unchecked(b"\0") })
-        }
-        [.., 0] => {
-            // Last byte is a nul; try to create as a CStr
-            let c_str =
-                CStr::from_bytes_with_nul(bytes).map_err(|_| PyValueError::new_err(err_msg))?;
-            Cow::Borrowed(c_str)
-        }
-        _ => {
-            // Allocate a new CString for this
-            let c_string = CString::new(bytes).map_err(|_| PyValueError::new_err(err_msg))?;
-            Cow::Owned(c_string)
-        }
-    };
-    Ok(cow)
+// TODO: use ptr::fn_addr_eq on MSRV 1.85
+pub(crate) fn clear_eq(f: Option<ffi::inquiry>, g: ffi::inquiry) -> bool {
+    #[cfg(fn_ptr_eq)]
+    #[allow(clippy::incompatible_msrv)]
+    {
+        let Some(f) = f else { return false };
+        std::ptr::fn_addr_eq(f, g)
+    }
+
+    #[cfg(not(fn_ptr_eq))]
+    {
+        f == Some(g)
+    }
+}
+
+// TODO: use ptr::fn_addr_eq on MSRV 1.85
+pub(crate) fn traverse_eq(f: Option<ffi::traverseproc>, g: ffi::traverseproc) -> bool {
+    #[cfg(fn_ptr_eq)]
+    #[allow(clippy::incompatible_msrv)]
+    {
+        let Some(f) = f else { return false };
+        std::ptr::fn_addr_eq(f, g)
+    }
+
+    #[cfg(not(fn_ptr_eq))]
+    {
+        f == Some(g)
+    }
 }
diff --git a/src/interpreter_lifecycle.rs b/src/interpreter_lifecycle.rs
new file mode 100644
index 00000000000..0ffbff7f0d4
--- /dev/null
+++ b/src/interpreter_lifecycle.rs
@@ -0,0 +1,127 @@
+#[cfg(not(any(PyPy, GraalPy)))]
+use crate::{ffi, internal::state::AttachGuard, Python};
+
+static START: std::sync::Once = std::sync::Once::new();
+
+#[cfg(not(any(PyPy, GraalPy)))]
+pub(crate) fn initialize() {
+    // Protect against race conditions when Python is not yet initialized and multiple threads
+    // concurrently call 'initialize()'. Note that we do not protect against
+    // concurrent initialization of the Python runtime by other users of the Python C API.
+    START.call_once_force(|_| unsafe {
+        // Use call_once_force because if initialization panics, it's okay to try again.
+        if ffi::Py_IsInitialized() == 0 {
+            ffi::Py_InitializeEx(0);
+
+            // Release the GIL.
+            ffi::PyEval_SaveThread();
+        }
+    });
+}
+
+/// See [Python::initialize]
+#[cfg(not(any(PyPy, GraalPy)))]
+#[inline]
+#[deprecated(note = "use `Python::initialize` instead", since = "0.26.0")]
+pub fn prepare_freethreaded_python() {
+    initialize();
+}
+
+/// Executes the provided closure with an embedded Python interpreter.
+///
+/// This function initializes the Python interpreter, executes the provided closure, and then
+/// finalizes the Python interpreter.
+///
+/// After execution all Python resources are cleaned up, and no further Python APIs can be called.
+/// Because many Python modules implemented in C do not support multiple Python interpreters in a
+/// single process, it is not safe to call this function more than once. (Many such modules will not
+/// initialize correctly on the second run.)
+///
+/// # Panics
+/// - If the Python interpreter is already initialized before calling this function.
+///
+/// # Safety
+/// - This function should only ever be called once per process (usually as part of the `main`
+///   function). It is also not thread-safe.
+/// - No Python APIs can be used after this function has finished executing.
+/// - The return value of the closure must not contain any Python value, _including_ `PyResult`.
+///
+/// # Examples
+///
+/// ```rust
+/// unsafe {
+///     pyo3::with_embedded_python_interpreter(|py| {
+///         if let Err(e) = py.run(c"print('Hello World')", None, None) {
+///             // We must make sure to not return a `PyErr`!
+///             e.print(py);
+///         }
+///     });
+/// }
+/// ```
+#[cfg(not(any(PyPy, GraalPy)))]
+pub unsafe fn with_embedded_python_interpreter<F, R>(f: F) -> R
+where
+    F: for<'p> FnOnce(Python<'p>) -> R,
+{
+    assert_eq!(
+        unsafe { ffi::Py_IsInitialized() },
+        0,
+        "called `with_embedded_python_interpreter` but a Python interpreter is already running."
+    );
+
+    unsafe { ffi::Py_InitializeEx(0) };
+
+    let result = {
+        let guard = unsafe { AttachGuard::assume() };
+        let py = guard.python();
+        // Import the threading module - this ensures that it will associate this thread as the "main"
+        // thread, which is important to avoid an `AssertionError` at finalization.
+        py.import("threading").unwrap();
+
+        // Execute the closure.
+        f(py)
+    };
+
+    // Finalize the Python interpreter.
+    unsafe { ffi::Py_Finalize() };
+
+    result
+}
+
+pub(crate) fn ensure_initialized() {
+    // Maybe auto-initialize the interpreter:
+    //  - If auto-initialize feature set and supported, try to initialize the interpreter.
+    //  - If the auto-initialize feature is set but unsupported, emit hard errors only when the
+    //    extension-module feature is not activated - extension modules don't care about
+    //    auto-initialize so this avoids breaking existing builds.
+    //  - Otherwise, just check the interpreter is initialized.
+    #[cfg(all(feature = "auto-initialize", not(any(PyPy, GraalPy))))]
+    {
+        initialize();
+    }
+    #[cfg(not(all(feature = "auto-initialize", not(any(PyPy, GraalPy)))))]
+    {
+        // This is a "hack" to make running `cargo test` for PyO3 convenient (i.e. no need
+        // to specify `--features auto-initialize` manually). Tests within the crate itself
+        // all depend on the auto-initialize feature for conciseness but Cargo does not
+        // provide a mechanism to specify required features for tests.
+        #[cfg(not(any(PyPy, GraalPy)))]
+        if option_env!("CARGO_PRIMARY_PACKAGE").is_some() {
+            initialize();
+        }
+
+        START.call_once_force(|_| unsafe {
+            // Use call_once_force because if there is a panic because the interpreter is
+            // not initialized, it's fine for the user to initialize the interpreter and
+            // retry.
+            assert_ne!(
+                crate::ffi::Py_IsInitialized(),
+                0,
+                "The Python interpreter is not initialized and the `auto-initialize` \
+                        feature is not enabled.\n\n\
+                        Consider calling `Python::initialize()` before attempting \
+                        to use Python APIs."
+            );
+        });
+    }
+}
diff --git a/src/lib.rs b/src/lib.rs
index 0a0b4eae684..ab2fb3de5d5 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,6 +1,10 @@
 #![warn(missing_docs)]
-#![cfg_attr(feature = "nightly", feature(auto_traits, negative_impls))]
-#![cfg_attr(docsrs, feature(doc_cfg, doc_auto_cfg))]
+#![cfg_attr(
+    feature = "nightly",
+    feature(auto_traits, negative_impls, try_trait_v2, iter_advance_by)
+)]
+#![cfg_attr(docsrs, feature(doc_cfg))]
+#![warn(unsafe_op_in_unsafe_fn)]
 // Deny some lints in doctests.
 // Use `#[allow(...)]` locally to override.
 #![doc(test(attr(
@@ -10,7 +14,15 @@
         rust_2021_prelude_collisions,
         warnings
     ),
-    allow(unused_variables, unused_assignments, unused_extern_crates)
+    allow(
+        unused_imports,  // to make imports already in the prelude explicit
+        unused_variables,
+        unused_assignments,
+        unused_extern_crates,
+        // FIXME https://github.com/rust-lang/rust/issues/121621#issuecomment-1965156376
+        unknown_lints,
+        non_local_definitions,
+    )
 )))]
 
 //! Rust bindings to the Python interpreter.
@@ -23,28 +35,37 @@
 //!
 //! PyO3 has several core types that you should familiarize yourself with:
 //!
-//! ## The Python<'py> object
+//! ## The `Python<'py>` object, and the `'py` lifetime
 //!
-//! Holding the [global interpreter lock] (GIL) is modeled with the [`Python<'py>`](crate::Python)
-//! token. All APIs that require that the GIL is held require this token as proof that you really
-//! are holding the GIL. It can be explicitly acquired and is also implicitly acquired by PyO3 as
-//! it wraps Rust functions and structs into Python functions and objects.
+//! Holding the [global interpreter lock] (GIL) is modeled with the [`Python<'py>`](Python) token. Many
+//! Python APIs require that the GIL is held, and PyO3 uses this token as proof that these APIs
+//! can be called safely. It can be explicitly acquired and is also implicitly acquired by PyO3
+//! as it wraps Rust functions and structs into Python functions and objects.
 //!
-//! ## The GIL-dependent types
+//! The [`Python<'py>`](Python) token's lifetime `'py` is common to many PyO3 APIs:
+//! - Types that also have the `'py` lifetime, such as the [`Bound<'py, T>`](Bound) smart pointer, are
+//!   bound to the Python GIL and rely on this to offer their functionality. These types often
+//!   have a [`.py()`](Bound::py) method to get the associated [`Python<'py>`](Python) token.
+//! - Functions which depend on the `'py` lifetime, such as [`PyList::new`](types::PyList::new),
+//!   require a [`Python<'py>`](Python) token as an input. Sometimes the token is passed implicitly by
+//!   taking a [`Bound<'py, T>`](Bound) or other type which is bound to the `'py` lifetime.
+//! - Traits which depend on the `'py` lifetime, such as [`FromPyObject<'py>`](FromPyObject), usually have
+//!   inputs or outputs which depend on the lifetime. Adding the lifetime to the trait allows
+//!   these inputs and outputs to express their binding to the GIL in the Rust type system.
 //!
-//! For example `&`[`PyAny`]. These are only ever seen as references, with a lifetime that is only
-//! valid for as long as the GIL is held, which is why using them doesn't require a
-//! [`Python<'py>`](crate::Python) token. The underlying Python object, if mutable, can be mutated
-//! through any reference.
+//! ## Python object smart pointers
 //!
-//! See the [guide][types] for an explanation of the different Python object types.
+//! PyO3 has two core smart pointers to refer to Python objects, [`Py<T>`](Py) and its GIL-bound
+//! form [`Bound<'py, T>`](Bound) which carries the `'py` lifetime. (There is also
+//! [`Borrowed<'a, 'py, T>`](instance::Borrowed), but it is used much more rarely).
 //!
-//! ## The GIL-independent types
+//! The type parameter `T` in these smart pointers can be filled by:
+//!   - [`PyAny`], e.g. `Py<PyAny>` or `Bound<'py, PyAny>`, where the Python object type is not
+//!     known.
+//!   - Concrete Python types like [`PyList`](types::PyList) or [`PyTuple`](types::PyTuple).
+//!   - Rust types which are exposed to Python using the [`#[pyclass]`](macro@pyclass) macro.
 //!
-//! When wrapped in [`Py`]`<...>`, like with [`Py`]`<`[`PyAny`]`>` or [`Py`]`<SomePyClass>`, Python
-//! objects no longer have a limited lifetime which makes them easier to store in structs and pass
-//! between functions. However, you cannot do much with them without a
-//! [`Python<'py>`](crate::Python) token, for which you’d need to reacquire the GIL.
+//! See the [guide][types] for an explanation of the different Python object types.
 //!
 //! ## PyErr
 //!
@@ -70,7 +91,7 @@
 //!
 //! - `abi3`: Restricts PyO3's API to a subset of the full Python API which is guaranteed by
 //! [PEP 384] to be forward-compatible with future Python versions.
-//! - `auto-initialize`: Changes [`Python::with_gil`] to automatically initialize the Python
+//! - `auto-initialize`: Changes [`Python::attach`] to automatically initialize the Python
 //! interpreter if needed.
 //! - `extension-module`: This will tell the linker to keep the Python symbols unresolved, so that
 //! your module can also be used with statically linked Python interpreters. Use this feature when
@@ -92,6 +113,8 @@
 //! [`BigUint`] types.
 //! - [`num-complex`]: Enables conversions between Python objects and [num-complex]'s [`Complex`]
 //!  type.
+//! - [`num-rational`]: Enables conversions between Python's fractions.Fraction and [num-rational]'s types
+//! - [`ordered-float`]: Enables conversions between Python's float and [ordered-float]'s types
 //! - [`rust_decimal`]: Enables conversions between Python's decimal.Decimal and [rust_decimal]'s
 //! [`Decimal`] type.
 //! - [`serde`]: Allows implementing [serde]'s [`Serialize`] and [`Deserialize`] traits for
@@ -103,20 +126,34 @@
 //! - `nightly`: Uses  `#![feature(auto_traits, negative_impls)]` to define [`Ungil`] as an auto trait.
 //
 //! ## `rustc` environment flags
-//!
-//! PyO3 uses `rustc`'s `--cfg` flags to enable or disable code used for different Python versions.
-//! If you want to do this for your own crate, you can do so with the [`pyo3-build-config`] crate.
-//!
-//! - `Py_3_7`, `Py_3_8`, `Py_3_9`, `Py_3_10`: Marks code that is only enabled when
-//!  compiling for a given minimum Python version.
+//! - `Py_3_7`, `Py_3_8`, `Py_3_9`, `Py_3_10`, `Py_3_11`, `Py_3_12`, `Py_3_13`: Marks code that is
+//!    only enabled when compiling for a given minimum Python version.
 //! - `Py_LIMITED_API`: Marks code enabled when the `abi3` feature flag is enabled.
+//! - `Py_GIL_DISABLED`: Marks code that runs only in the free-threaded build of CPython.
 //! - `PyPy` - Marks code enabled when compiling for PyPy.
+//! - `GraalPy` - Marks code enabled when compiling for GraalPy.
+//!
+//! Additionally, you can query for the values `Py_DEBUG`, `Py_REF_DEBUG`,
+//! `Py_TRACE_REFS`, and `COUNT_ALLOCS` from `py_sys_config` to query for the
+//! corresponding C build-time defines. For example, to conditionally define
+//! debug code using `Py_DEBUG`, you could do:
+//!
+//! ```rust,ignore
+//! #[cfg(py_sys_config = "Py_DEBUG")]
+//! println!("only runs if python was compiled with Py_DEBUG")
+//! ```
+//! To use these attributes, add [`pyo3-build-config`] as a build dependency in
+//! your `Cargo.toml` and call `pyo3_build_config::use_pyo3_cfgs()` in a
+//! `build.rs` file.
 //!
 //! # Minimum supported Rust and Python versions
 //!
-//! PyO3 supports the following software versions:
-//!   - Python 3.7 and up (CPython and PyPy)
-//!   - Rust 1.56 and up
+//! Requires Rust 1.63 or greater.
+//!
+//! PyO3 supports the following Python distributions:
+//!   - CPython 3.7 or greater
+//!   - PyPy 7.3 (Python 3.11+)
+//!   - GraalPy 24.0 or greater (Python 3.10+)
 //!
 //! # Example: Building a native Python module
 //!
@@ -150,7 +187,7 @@
 //! ```
 //!
 //! **`src/lib.rs`**
-//! ```rust
+//! ```rust,no_run
 //! use pyo3::prelude::*;
 //!
 //! /// Formats the sum of two numbers as string.
@@ -161,7 +198,7 @@
 //!
 //! /// A Python module implemented in Rust.
 //! #[pymodule]
-//! fn string_sum(py: Python<'_>, m: &PyModule) -> PyResult<()> {
+//! fn string_sum(m: &Bound<'_, PyModule>) -> PyResult<()> {
 //!     m.add_function(wrap_pyfunction!(sum_as_string, m)?)?;
 //!
 //!     Ok(())
@@ -215,15 +252,16 @@
 //! ```rust
 //! use pyo3::prelude::*;
 //! use pyo3::types::IntoPyDict;
+//! use pyo3::ffi::c_str;
 //!
 //! fn main() -> PyResult<()> {
-//!     Python::with_gil(|py| {
-//!         let sys = py.import_bound("sys")?;
+//!     Python::attach(|py| {
+//!         let sys = py.import("sys")?;
 //!         let version: String = sys.getattr("version")?.extract()?;
 //!
-//!         let locals = [("os", py.import_bound("os")?)].into_py_dict_bound(py);
-//!         let code = "os.getenv('USER') or os.getenv('USERNAME') or 'Unknown'";
-//!         let user: String = py.eval_bound(code, None, Some(&locals))?.extract()?;
+//!         let locals = [("os", py.import("os")?)].into_py_dict(py)?;
+//!         let code = c"os.getenv('USER') or os.getenv('USERNAME') or 'Unknown'";
+//!         let user: String = py.eval(code, None, Some(&locals))?.extract()?;
 //!
 //!         println!("Hello {}, I'm Python {}", user, version);
 //!         Ok(())
@@ -251,6 +289,7 @@
 //! [`HashMap`]: https://docs.rs/hashbrown/latest/hashbrown/struct.HashMap.html
 //! [`HashSet`]: https://docs.rs/hashbrown/latest/hashbrown/struct.HashSet.html
 //! [`SmallVec`]: https://docs.rs/smallvec/latest/smallvec/struct.SmallVec.html
+//! [`Uuid`]: https://docs.rs/uuid/latest/uuid/struct.Uuid.html
 //! [`IndexMap`]: https://docs.rs/indexmap/latest/indexmap/map/struct.IndexMap.html
 //! [`BigInt`]: https://docs.rs/num-bigint/latest/num_bigint/struct.BigInt.html
 //! [`BigUint`]: https://docs.rs/num-bigint/latest/num_bigint/struct.BigUint.html
@@ -272,44 +311,51 @@
 //! [`maturin`]: https://github.com/PyO3/maturin "Build and publish crates with pyo3, rust-cpython and cffi bindings as well as rust binaries as python packages"
 //! [`num-bigint`]: ./num_bigint/index.html "Documentation about the `num-bigint` feature."
 //! [`num-complex`]: ./num_complex/index.html "Documentation about the `num-complex` feature."
+//! [`num-rational`]: ./num_rational/index.html "Documentation about the `num-rational` feature."
+//! [`ordered-float`]: ./ordered_float/index.html "Documentation about the `ordered-float` feature."
 //! [`pyo3-build-config`]: https://docs.rs/pyo3-build-config
 //! [rust_decimal]: https://docs.rs/rust_decimal
-//! [`rust_decimal`]: ./rust_decimal/index.html "Documenation about the `rust_decimal` feature."
+//! [`rust_decimal`]: ./rust_decimal/index.html "Documentation about the `rust_decimal` feature."
 //! [`Decimal`]: https://docs.rs/rust_decimal/latest/rust_decimal/struct.Decimal.html
 //! [`serde`]: <./serde/index.html> "Documentation about the `serde` feature."
-//! [calling_rust]: https://pyo3.rs/latest/python_from_rust.html "Calling Python from Rust - PyO3 user guide"
+#![doc = concat!("[calling_rust]: https://pyo3.rs/v", env!("CARGO_PKG_VERSION"), "/python-from-rust.html \"Calling Python from Rust - PyO3 user guide\"")]
 //! [examples subdirectory]: https://github.com/PyO3/pyo3/tree/main/examples
 //! [feature flags]: https://doc.rust-lang.org/cargo/reference/features.html "Features - The Cargo Book"
 //! [global interpreter lock]: https://docs.python.org/3/glossary.html#term-global-interpreter-lock
 //! [hashbrown]: https://docs.rs/hashbrown
 //! [smallvec]: https://docs.rs/smallvec
+//! [uuid]: https://docs.rs/uuid
 //! [indexmap]: https://docs.rs/indexmap
-//! [manual_builds]: https://pyo3.rs/latest/building_and_distribution.html#manual-builds "Manual builds - Building and Distribution - PyO3 user guide"
+#![doc = concat!("[manual_builds]: https://pyo3.rs/v", env!("CARGO_PKG_VERSION"), "/building-and-distribution.html#manual-builds \"Manual builds - Building and Distribution - PyO3 user guide\"")]
 //! [num-bigint]: https://docs.rs/num-bigint
 //! [num-complex]: https://docs.rs/num-complex
+//! [num-rational]: https://docs.rs/num-rational
+//! [ordered-float]: https://docs.rs/ordered-float
 //! [serde]: https://docs.rs/serde
 //! [setuptools-rust]: https://github.com/PyO3/setuptools-rust "Setuptools plugin for Rust extensions"
 //! [the guide]: https://pyo3.rs "PyO3 user guide"
-//! [types]: https://pyo3.rs/latest/types.html "GIL lifetimes, mutability and Python object types"
+#![doc = concat!("[types]: https://pyo3.rs/v", env!("CARGO_PKG_VERSION"), "/types.html \"GIL lifetimes, mutability and Python object types\"")]
 //! [PEP 384]: https://www.python.org/dev/peps/pep-0384 "PEP 384 -- Defining a Stable ABI"
 //! [Python from Rust]: https://github.com/PyO3/pyo3#using-python-from-rust
 //! [Rust from Python]: https://github.com/PyO3/pyo3#using-rust-from-python
-//! [Features chapter of the guide]: https://pyo3.rs/latest/features.html#features-reference "Features Reference - PyO3 user guide"
+#![doc = concat!("[Features chapter of the guide]: https://pyo3.rs/v", env!("CARGO_PKG_VERSION"), "/features.html#features-reference \"Features Reference - PyO3 user guide\"")]
 //! [`Ungil`]: crate::marker::Ungil
 pub use crate::class::*;
-pub use crate::conversion::{AsPyPointer, FromPyObject, FromPyPointer, IntoPy, ToPyObject};
+pub use crate::conversion::{FromPyObject, IntoPyObject, IntoPyObjectExt};
+pub use crate::err::{CastError, CastIntoError, PyErr, PyErrArguments, PyResult, ToPyErr};
+#[allow(deprecated)]
+pub use crate::err::{DowncastError, DowncastIntoError};
+#[allow(deprecated)]
+pub use crate::instance::PyObject;
+pub use crate::instance::{Borrowed, Bound, BoundObject, Py};
+#[cfg(not(any(PyPy, GraalPy)))]
 #[allow(deprecated)]
-pub use crate::conversion::{PyTryFrom, PyTryInto};
-pub use crate::err::{
-    DowncastError, DowncastIntoError, PyDowncastError, PyErr, PyErrArguments, PyResult,
+pub use crate::interpreter_lifecycle::{
+    prepare_freethreaded_python, with_embedded_python_interpreter,
 };
-pub use crate::gil::GILPool;
-#[cfg(not(PyPy))]
-pub use crate::gil::{prepare_freethreaded_python, with_embedded_python_interpreter};
-pub use crate::instance::{Borrowed, Bound, Py, PyNativeType, PyObject};
 pub use crate::marker::Python;
-pub use crate::pycell::{PyCell, PyRef, PyRefMut};
-pub use crate::pyclass::PyClass;
+pub use crate::pycell::{PyRef, PyRefMut};
+pub use crate::pyclass::{PyClass, PyClassGuard, PyClassGuardMut};
 pub use crate::pyclass_init::PyClassInitializer;
 pub use crate::type_object::{PyTypeCheck, PyTypeInfo};
 pub use crate::types::PyAny;
@@ -317,6 +363,7 @@ pub use crate::version::PythonVersionInfo;
 
 pub(crate) mod ffi_ptr_ext;
 pub(crate) mod py_result_ext;
+pub(crate) mod sealed;
 
 /// Old module which contained some implementation details of the `#[pyproto]` module.
 ///
@@ -326,16 +373,8 @@ pub(crate) mod py_result_ext;
 /// For compatibility reasons this has not yet been removed, however will be done so
 /// once <https://github.com/rust-lang/rust/issues/30827> is resolved.
 pub mod class {
-    #[doc(hidden)]
-    pub use crate::impl_::pymethods as methods;
-
     pub use self::gc::{PyTraverseError, PyVisit};
 
-    #[doc(hidden)]
-    pub use self::methods::{
-        PyClassAttributeDef, PyGetterDef, PyMethodDef, PyMethodDefType, PyMethodType, PySetterDef,
-    };
-
     /// Old module which contained some implementation details of the `#[pyproto]` module.
     ///
     /// Prefer using the same content from `pyo3::pyclass`, e.g. `use pyo3::pyclass::CompareOp` instead
@@ -347,30 +386,6 @@ pub mod class {
         pub use crate::pyclass::CompareOp;
     }
 
-    /// Old module which contained some implementation details of the `#[pyproto]` module.
-    ///
-    /// Prefer using the same content from `pyo3::pyclass`, e.g. `use pyo3::pyclass::IterANextOutput` instead
-    /// of `use pyo3::class::pyasync::IterANextOutput`.
-    ///
-    /// For compatibility reasons this has not yet been removed, however will be done so
-    /// once <https://github.com/rust-lang/rust/issues/30827> is resolved.
-    pub mod pyasync {
-        #[allow(deprecated)]
-        pub use crate::pyclass::{IterANextOutput, PyIterANextOutput};
-    }
-
-    /// Old module which contained some implementation details of the `#[pyproto]` module.
-    ///
-    /// Prefer using the same content from `pyo3::pyclass`, e.g. `use pyo3::pyclass::IterNextOutput` instead
-    /// of `use pyo3::class::pyasync::IterNextOutput`.
-    ///
-    /// For compatibility reasons this has not yet been removed, however will be done so
-    /// once <https://github.com/rust-lang/rust/issues/30827> is resolved.
-    pub mod iter {
-        #[allow(deprecated)]
-        pub use crate::pyclass::{IterNextOutput, PyIterNextOutput};
-    }
-
     /// Old module which contained some implementation details of the `#[pyproto]` module.
     ///
     /// Prefer using the same content from `pyo3::pyclass`, e.g. `use pyo3::pyclass::PyTraverseError` instead
@@ -397,35 +412,35 @@ pub use inventory; // Re-exported for `#[pyclass]` and `#[pymethods]` with `mult
 /// Tests and helpers which reside inside PyO3's main library. Declared first so that macros
 /// are available in unit tests.
 #[cfg(test)]
-#[macro_use]
+mod test_utils;
+#[cfg(test)]
 mod tests;
 
+// Macro dependencies, also contains macros exported for use across the codebase and
+// in expanded macros.
+#[doc(hidden)]
+pub mod impl_;
+
 #[macro_use]
 mod internal_tricks;
+mod internal;
 
 pub mod buffer;
-#[doc(hidden)]
-pub mod callback;
+pub mod call;
 pub mod conversion;
 mod conversions;
-#[cfg(feature = "macros")]
+#[cfg(feature = "experimental-async")]
 pub mod coroutine;
-#[macro_use]
-#[doc(hidden)]
-pub mod derive_utils;
 mod err;
 pub mod exceptions;
 pub mod ffi;
-mod gil;
-#[doc(hidden)]
-pub mod impl_;
 mod instance;
+mod interpreter_lifecycle;
 pub mod marker;
 pub mod marshal;
 #[macro_use]
 pub mod sync;
 pub mod panic;
-pub mod prelude;
 pub mod pybacked;
 pub mod pycell;
 pub mod pyclass;
@@ -439,16 +454,18 @@ mod version;
 pub use crate::conversions::*;
 
 #[cfg(feature = "macros")]
-pub use pyo3_macros::{pyfunction, pymethods, pymodule, FromPyObject};
+pub use pyo3_macros::{
+    pyfunction, pymethods, pymodule, FromPyObject, IntoPyObject, IntoPyObjectRef,
+};
 
 /// A proc macro used to expose Rust structs and fieldless enums as Python objects.
 ///
-#[doc = include_str!("../guide/pyclass_parameters.md")]
+#[doc = include_str!("../guide/pyclass-parameters.md")]
 ///
 /// For more on creating Python classes,
 /// see the [class section of the guide][1].
 ///
-/// [1]: https://pyo3.rs/latest/class.html
+#[doc = concat!("[1]: https://pyo3.rs/v", env!("CARGO_PKG_VERSION"), "/class.html")]
 #[cfg(feature = "macros")]
 pub use pyo3_macros::pyclass;
 
@@ -459,6 +476,10 @@ mod macros;
 #[cfg(feature = "experimental-inspect")]
 pub mod inspect;
 
+// Putting the declaration of prelude at the end seems to help encourage rustc and rustdoc to prefer using
+// other paths to the same items. (e.g. `pyo3::types::PyAnyMethods` instead of `pyo3::prelude::PyAnyMethods`).
+pub mod prelude;
+
 /// Test readme and user guide
 #[cfg(doctest)]
 pub mod doc_test {
@@ -475,13 +496,14 @@ pub mod doc_test {
         "README.md" => readme_md,
         "guide/src/advanced.md" => guide_advanced_md,
         "guide/src/async-await.md" => guide_async_await_md,
-        "guide/src/building_and_distribution.md" => guide_building_and_distribution_md,
-        "guide/src/building_and_distribution/multiple_python_versions.md" => guide_bnd_multiple_python_versions_md,
+        "guide/src/building-and-distribution.md" => guide_building_and_distribution_md,
+        "guide/src/building-and-distribution/multiple-python-versions.md" => guide_bnd_multiple_python_versions_md,
         "guide/src/class.md" => guide_class_md,
         "guide/src/class/call.md" => guide_class_call,
         "guide/src/class/object.md" => guide_class_object,
         "guide/src/class/numeric.md" => guide_class_numeric,
         "guide/src/class/protocols.md" => guide_class_protocols_md,
+        "guide/src/class/thread-safety.md" => guide_class_thread_safety_md,
         "guide/src/conversions.md" => guide_conversions_md,
         "guide/src/conversions/tables.md" => guide_conversions_tables_md,
         "guide/src/conversions/traits.md" => guide_conversions_traits_md,
@@ -493,17 +515,20 @@ pub mod doc_test {
         "guide/src/exception.md" => guide_exception_md,
         "guide/src/faq.md" => guide_faq_md,
         "guide/src/features.md" => guide_features_md,
+        "guide/src/free-threading.md" => guide_free_threading_md,
         "guide/src/function.md" => guide_function_md,
-        "guide/src/function/error_handling.md" => guide_function_error_handling_md,
+        "guide/src/function/error-handling.md" => guide_function_error_handling_md,
         "guide/src/function/signature.md" => guide_function_signature_md,
-        "guide/src/memory.md" => guide_memory_md,
         "guide/src/migration.md" => guide_migration_md,
         "guide/src/module.md" => guide_module_md,
         "guide/src/parallelism.md" => guide_parallelism_md,
         "guide/src/performance.md" => guide_performance_md,
-        "guide/src/python_from_rust.md" => guide_python_from_rust_md,
-        "guide/src/python_typing_hints.md" => guide_python_typing_hints_md,
-        "guide/src/trait_bounds.md" => guide_trait_bounds_md,
+        "guide/src/python-from-rust.md" => guide_python_from_rust_md,
+        "guide/src/python-from-rust/calling-existing-code.md" => guide_pfr_calling_existing_code_md,
+        "guide/src/python-from-rust/function-calls.md" => guide_pfr_function_calls_md,
+        "guide/src/python-typing-hints.md" => guide_python_typing_hints_md,
+        "guide/src/rust-from-python.md" => guide_rust_from_python_md,
+        "guide/src/trait-bounds.md" => guide_trait_bounds_md,
         "guide/src/types.md" => guide_types_md,
     }
 }
diff --git a/src/macros.rs b/src/macros.rs
index d5fbbdc3dfc..4b3d158c141 100644
--- a/src/macros.rs
+++ b/src/macros.rs
@@ -11,10 +11,13 @@
 /// ```
 /// use pyo3::{prelude::*, py_run, types::PyList};
 ///
-/// Python::with_gil(|py| {
-///     let list = PyList::new_bound(py, &[1, 2, 3]);
+/// # fn main() -> PyResult<()> {
+/// Python::attach(|py| {
+///     let list = PyList::new(py, &[1, 2, 3])?;
 ///     py_run!(py, list, "assert list == [1, 2, 3]");
-/// });
+/// # Ok(())
+/// })
+/// # }
 /// ```
 ///
 /// You can use this macro to test pyfunctions or pyclasses quickly.
@@ -44,8 +47,8 @@
 ///     }
 /// }
 ///
-/// Python::with_gil(|py| {
-///     let time = PyCell::new(py, Time {hour: 8, minute: 43, second: 16}).unwrap();
+/// Python::attach(|py| {
+///     let time = Py::new(py, Time {hour: 8, minute: 43, second: 16}).unwrap();
 ///     let time_as_tuple = (8, 43, 16);
 ///     py_run!(py, time time_as_tuple, r#"
 ///         assert time.hour == 8
@@ -72,10 +75,13 @@
 ///     }
 /// }
 ///
-/// Python::with_gil(|py| {
-///     let locals = [("C", py.get_type::<MyClass>())].into_py_dict_bound(py);
+/// # fn main() -> PyResult<()> {
+/// Python::attach(|py| {
+///     let locals = [("C", py.get_type::<MyClass>())].into_py_dict(py)?;
 ///     pyo3::py_run!(py, *locals, "c = C()");
-/// });
+/// #   Ok(())
+/// })
+/// # }
 /// ```
 #[macro_export]
 macro_rules! py_run {
@@ -83,13 +89,13 @@ macro_rules! py_run {
         $crate::py_run_impl!($py, $($val)+, $crate::indoc::indoc!($code))
     }};
     ($py:expr, $($val:ident)+, $code:expr) => {{
-        $crate::py_run_impl!($py, $($val)+, &$crate::unindent::unindent($code))
+        $crate::py_run_impl!($py, $($val)+, $crate::unindent::unindent($code))
     }};
     ($py:expr, *$dict:expr, $code:literal) => {{
         $crate::py_run_impl!($py, *$dict, $crate::indoc::indoc!($code))
     }};
     ($py:expr, *$dict:expr, $code:expr) => {{
-        $crate::py_run_impl!($py, *$dict, &$crate::unindent::unindent($code))
+        $crate::py_run_impl!($py, *$dict, $crate::unindent::unindent($code))
     }};
 }
 
@@ -98,20 +104,20 @@ macro_rules! py_run {
 macro_rules! py_run_impl {
     ($py:expr, $($val:ident)+, $code:expr) => {{
         use $crate::types::IntoPyDict;
-        use $crate::ToPyObject;
-        let d = [$((stringify!($val), $val.to_object($py)),)+].into_py_dict_bound($py);
+        use $crate::conversion::IntoPyObject;
+        use $crate::BoundObject;
+        let d = [$((stringify!($val), (&$val).into_pyobject($py).unwrap().into_any().into_bound()),)+].into_py_dict($py).unwrap();
         $crate::py_run_impl!($py, *d, $code)
     }};
     ($py:expr, *$dict:expr, $code:expr) => {{
         use ::std::option::Option::*;
         #[allow(unused_imports)]
-        use $crate::PyNativeType;
-        if let ::std::result::Result::Err(e) = $py.run_bound($code, None, Some(&$dict.as_borrowed())) {
+        if let ::std::result::Result::Err(e) = $py.run(&::std::ffi::CString::new($code).unwrap(), None, Some(&$dict)) {
             e.print($py);
             // So when this c api function the last line called printed the error to stderr,
             // the output is only written into a buffer which is never flushed because we
             // panic before flushing. This is where this hack comes into place
-            $py.run_bound("import sys; sys.stderr.flush()", None, None)
+            $py.run(c"import sys; sys.stderr.flush()", None, None)
                 .unwrap();
             ::std::panic!("{}", $code)
         }
@@ -120,19 +126,26 @@ macro_rules! py_run_impl {
 
 /// Wraps a Rust function annotated with [`#[pyfunction]`](macro@crate::pyfunction).
 ///
-/// This can be used with [`PyModule::add_function`](crate::types::PyModule::add_function) to add free
-/// functions to a [`PyModule`](crate::types::PyModule) - see its documentation for more information.
+/// This can be used with [`PyModule::add_function`](crate::types::PyModuleMethods::add_function) to
+/// add free functions to a [`PyModule`](crate::types::PyModule) - see its documentation for more
+/// information.
 #[macro_export]
 macro_rules! wrap_pyfunction {
     ($function:path) => {
         &|py_or_module| {
             use $function as wrapped_pyfunction;
-            $crate::impl_::pyfunction::_wrap_pyfunction(&wrapped_pyfunction::DEF, py_or_module)
+            $crate::impl_::pyfunction::WrapPyFunctionArg::wrap_pyfunction(
+                py_or_module,
+                &wrapped_pyfunction::_PYO3_DEF,
+            )
         }
     };
     ($function:path, $py_or_module:expr) => {{
         use $function as wrapped_pyfunction;
-        $crate::impl_::pyfunction::_wrap_pyfunction(&wrapped_pyfunction::DEF, $py_or_module)
+        $crate::impl_::pyfunction::WrapPyFunctionArg::wrap_pyfunction(
+            $py_or_module,
+            &wrapped_pyfunction::_PYO3_DEF,
+        )
     }};
 }
 
@@ -140,14 +153,14 @@ macro_rules! wrap_pyfunction {
 /// Python module.
 ///
 /// Use this together with [`#[pymodule]`](crate::pymodule) and
-/// [`PyModule::add_wrapped`](crate::types::PyModule::add_wrapped).
+/// [`PyModule::add_wrapped`](crate::types::PyModuleMethods::add_wrapped).
 #[macro_export]
 macro_rules! wrap_pymodule {
     ($module:path) => {
         &|py| {
             use $module as wrapped_pymodule;
-            wrapped_pymodule::DEF
-                .make_module(py)
+            wrapped_pymodule::_PYO3_DEF
+                .make_module(py, wrapped_pymodule::__PYO3_GIL_USED)
                 .expect("failed to wrap pymodule")
         }
     };
@@ -156,9 +169,9 @@ macro_rules! wrap_pymodule {
 /// Add the module to the initialization table in order to make embedded Python code to use it.
 /// Module name is the argument.
 ///
-/// Use it before [`prepare_freethreaded_python`](crate::prepare_freethreaded_python) and
+/// Use it before [`Python::initialize`](crate::marker::Python::initialize) and
 /// leave feature `auto-initialize` off
-#[cfg(not(PyPy))]
+#[cfg(not(any(PyPy, GraalPy)))]
 #[macro_export]
 macro_rules! append_to_inittab {
     ($module:ident) => {
@@ -169,8 +182,8 @@ macro_rules! append_to_inittab {
                 );
             }
             $crate::ffi::PyImport_AppendInittab(
-                $module::NAME.as_ptr() as *const ::std::os::raw::c_char,
-                ::std::option::Option::Some($module::init),
+                $module::__PYO3_NAME.as_ptr(),
+                ::std::option::Option::Some($module::__pyo3_init),
             );
         }
     };
diff --git a/src/marker.rs b/src/marker.rs
index fc84ca54c90..4c4cc7d7a82 100644
--- a/src/marker.rs
+++ b/src/marker.rs
@@ -1,6 +1,6 @@
 //! Fundamental properties of objects tied to the Python interpreter.
 //!
-//! The Python interpreter is not threadsafe. To protect the Python interpreter in multithreaded
+//! The Python interpreter is not thread-safe. To protect the Python interpreter in multithreaded
 //! scenarios there is a global lock, the *global interpreter lock* (hereafter referred to as *GIL*)
 //! that must be held to safely interact with Python objects. This is why in PyO3 when you acquire
 //! the GIL you get a [`Python`] marker token that carries the *lifetime* of holding the GIL and all
@@ -11,14 +11,14 @@
 //! It also supports this pattern that many extension modules employ:
 //! - Drop the GIL, so that other Python threads can acquire it and make progress themselves
 //! - Do something independently of the Python interpreter, like IO, a long running calculation or
-//! awaiting a future
+//!   awaiting a future
 //! - Once that is done, reacquire the GIL
 //!
-//! That API is provided by [`Python::allow_threads`] and enforced via the [`Ungil`] bound on the
+//! That API is provided by [`Python::detach`] and enforced via the [`Ungil`] bound on the
 //! closure and the return type. This is done by relying on the [`Send`] auto trait. `Ungil` is
 //! defined as the following:
 //!
-//! ```rust
+//! ```rust,no_run
 //! # #![allow(dead_code)]
 //! pub unsafe trait Ungil {}
 //!
@@ -34,7 +34,7 @@
 //! ## Drawbacks
 //!
 //! There is no reason to prevent `!Send` types like [`Rc`] from crossing the closure. After all,
-//! [`Python::allow_threads`] just lets other Python threads run - it does not itself launch a new
+//! [`Python::detach`] just lets other Python threads run - it does not itself launch a new
 //! thread.
 //!
 //! ```rust, compile_fail
@@ -44,10 +44,10 @@
 //! use std::rc::Rc;
 //!
 //! fn main() {
-//!     Python::with_gil(|py| {
+//!     Python::attach(|py| {
 //!         let rc = Rc::new(5);
 //!
-//!         py.allow_threads(|| {
+//!         py.detach(|| {
 //!             // This would actually be fine...
 //!             println!("{:?}", *rc);
 //!         });
@@ -72,12 +72,12 @@
 //! use pyo3::types::PyString;
 //! use send_wrapper::SendWrapper;
 //!
-//! Python::with_gil(|py| {
-//!     let string = PyString::new_bound(py, "foo");
+//! Python::attach(|py| {
+//!     let string = PyString::new(py, "foo");
 //!
 //!     let wrapped = SendWrapper::new(string);
 //!
-//!     py.allow_threads(|| {
+//!     py.detach(|| {
 //! # #[cfg(not(feature = "nightly"))]
 //! # {
 //!         // 💥 Unsound! 💥
@@ -95,8 +95,8 @@
 //! However on nightly Rust and when PyO3's `nightly` feature is
 //! enabled, `Ungil` is defined as the following:
 //!
-//! ```rust
-//! # #[cfg(FALSE)]
+//! ```rust,no_run
+//! # #[cfg(any())]
 //! # {
 //! #![feature(auto_traits, negative_impls)]
 //!
@@ -116,23 +116,18 @@
 //! [`SendWrapper`]: https://docs.rs/send_wrapper/latest/send_wrapper/struct.SendWrapper.html
 //! [`Rc`]: std::rc::Rc
 //! [`Py`]: crate::Py
-use crate::err::{self, PyDowncastError, PyErr, PyResult};
-use crate::ffi_ptr_ext::FfiPtrExt;
-use crate::gil::{GILGuard, GILPool, SuspendGIL};
-use crate::impl_::not_send::NotSend;
-use crate::py_result_ext::PyResultExt;
-use crate::type_object::HasPyGilRef;
+use crate::conversion::IntoPyObject;
+use crate::err::{self, PyResult};
+use crate::internal::state::{AttachGuard, SuspendAttach};
 use crate::types::any::PyAnyMethods;
 use crate::types::{
-    PyAny, PyDict, PyEllipsis, PyModule, PyNone, PyNotImplemented, PyString, PyType,
+    PyAny, PyCode, PyCodeMethods, PyDict, PyEllipsis, PyModule, PyNone, PyNotImplemented, PyString,
+    PyType,
 };
 use crate::version::PythonVersionInfo;
-use crate::{
-    ffi, Bound, FromPyPointer, IntoPy, Py, PyNativeType, PyObject, PyTypeCheck, PyTypeInfo,
-};
-use std::ffi::{CStr, CString};
+use crate::{ffi, Bound, Py, PyTypeInfo};
+use std::ffi::CStr;
 use std::marker::PhantomData;
-use std::os::raw::c_int;
 
 /// Types that are safe to access while the GIL is not held.
 ///
@@ -152,16 +147,16 @@ use std::os::raw::c_int;
 /// # use pyo3::prelude::*;
 /// use std::rc::Rc;
 ///
-/// Python::with_gil(|py| {
+/// Python::attach(|py| {
 ///     let rc = Rc::new(42);
 ///
-///     py.allow_threads(|| {
+///     py.detach(|| {
 ///         println!("{:?}", rc);
 ///     });
 /// });
 /// ```
 ///
-/// This also implies that the interplay between `with_gil` and `allow_threads` is unsound, for example
+/// This also implies that the interplay between `attach` and `detach` is unsound, for example
 /// one can circumvent this protection using the [`send_wrapper`](https://docs.rs/send_wrapper/) crate:
 ///
 /// ```no_run
@@ -169,12 +164,12 @@ use std::os::raw::c_int;
 /// # use pyo3::types::PyString;
 /// use send_wrapper::SendWrapper;
 ///
-/// Python::with_gil(|py| {
-///     let string = PyString::new_bound(py, "foo");
+/// Python::attach(|py| {
+///     let string = PyString::new(py, "foo");
 ///
 ///     let wrapped = SendWrapper::new(string);
 ///
-///     py.allow_threads(|| {
+///     py.detach(|| {
 ///         let sneaky: &Bound<'_, PyString> = &*wrapped;
 ///
 ///         println!("{:?}", sneaky);
@@ -215,21 +210,21 @@ mod nightly {
         /// ```compile_fail
         /// # use pyo3::prelude::*;
         /// # use pyo3::types::PyString;
-        /// Python::with_gil(|py| {
-        ///     let string = PyString::new_bound(py, "foo");
+        /// Python::attach(|py| {
+        ///     let string = PyString::new(py, "foo");
         ///
-        ///     py.allow_threads(|| {
+        ///     py.detach(|| {
         ///         println!("{:?}", string);
         ///     });
         /// });
         /// ```
         ///
-        /// This applies to the GIL token `Python` itself as well, e.g.
+        /// This applies to the [`Python`] token itself as well, e.g.
         ///
         /// ```compile_fail
         /// # use pyo3::prelude::*;
-        /// Python::with_gil(|py| {
-        ///     py.allow_threads(|| {
+        /// Python::attach(|py| {
+        ///     py.detach(|| {
         ///         drop(py);
         ///     });
         /// });
@@ -243,12 +238,12 @@ mod nightly {
         /// # use pyo3::types::PyString;
         /// use send_wrapper::SendWrapper;
         ///
-        /// Python::with_gil(|py| {
-        ///     let string = PyString::new_bound(py, "foo");
+        /// Python::attach(|py| {
+        ///     let string = PyString::new(py, "foo");
         ///
         ///     let wrapped = SendWrapper::new(string);
         ///
-        ///     py.allow_threads(|| {
+        ///     py.detach(|| {
         ///         let sneaky: &PyString = *wrapped;
         ///
         ///         println!("{:?}", sneaky);
@@ -256,17 +251,17 @@ mod nightly {
         /// });
         /// ```
         ///
-        /// This also enables using non-[`Send`] types in `allow_threads`,
+        /// This also enables using non-[`Send`] types in `detach`,
         /// at least if they are not also bound to the GIL:
         ///
         /// ```rust
         /// # use pyo3::prelude::*;
         /// use std::rc::Rc;
         ///
-        /// Python::with_gil(|py| {
+        /// Python::attach(|py| {
         ///     let rc = Rc::new(42);
         ///
-        ///     py.allow_threads(|| {
+        ///     py.detach(|| {
         ///         println!("{:?}", rc);
         ///     });
         /// });
@@ -279,8 +274,6 @@ mod nightly {
     // This means that PyString, PyList, etc all inherit !Ungil from  this.
     impl !Ungil for crate::PyAny {}
 
-    // All the borrowing wrappers
-    impl<T> !Ungil for crate::PyCell<T> {}
     impl<T> !Ungil for crate::PyRef<'_, T> {}
     impl<T> !Ungil for crate::PyRefMut<'_, T> {}
 
@@ -307,9 +300,9 @@ pub use nightly::Ungil;
 /// It serves three main purposes:
 /// - It provides a global API for the Python interpreter, such as [`Python::eval`].
 /// - It can be passed to functions that require a proof of holding the GIL, such as
-/// [`Py::clone_ref`].
+///   [`Py::clone_ref`](crate::Py::clone_ref).
 /// - Its lifetime represents the scope of holding the GIL which can be used to create Rust
-/// references that are bound to it, such as `&`[`PyAny`].
+///   references that are bound to it, such as [`Bound<'py, PyAny>`].
 ///
 /// Note that there are some caveats to using it that you might need to be aware of. See the
 /// [Deadlocks](#deadlocks) and [Releasing and freeing memory](#releasing-and-freeing-memory)
@@ -317,13 +310,16 @@ pub use nightly::Ungil;
 ///
 /// # Obtaining a Python token
 ///
-/// The following are the recommended ways to obtain a [`Python`] token, in order of preference:
+/// The following are the recommended ways to obtain a [`Python<'py>`] token, in order of preference:
+/// - If you already have something with a lifetime bound to the GIL, such as [`Bound<'py, PyAny>`], you can
+///   use its `.py()` method to get a token.
 /// - In a function or method annotated with [`#[pyfunction]`](crate::pyfunction) or [`#[pymethods]`](crate::pymethods) you can declare it
-/// as a parameter, and PyO3 will pass in the token when Python code calls it.
-/// - If you already have something with a lifetime bound to the GIL, such as `&`[`PyAny`], you can
-/// use its [`.py()`][PyAny::py] method to get a token.
+///   as a parameter, and PyO3 will pass in the token when Python code calls it.
 /// - When you need to acquire the GIL yourself, such as when calling Python code from Rust, you
-/// should call [`Python::with_gil`] to do that and pass your code as a closure to it.
+///   should call [`Python::attach`] to do that and pass your code as a closure to it.
+///
+/// The first two options are zero-cost; [`Python::attach`] requires runtime checking and may need to block
+/// to acquire the GIL.
 ///
 /// # Deadlocks
 ///
@@ -347,63 +343,45 @@ pub use nightly::Ungil;
 ///  * Thread 1's Python interpreter call blocks trying to reacquire the GIL held by thread 2
 ///
 /// To avoid deadlocking, you should release the GIL before trying to lock a mutex or `await`ing in
-/// asynchronous code, e.g. with [`Python::allow_threads`].
+/// asynchronous code, e.g. with [`Python::detach`].
 ///
 /// # Releasing and freeing memory
 ///
-/// The [`Python`] type can be used to create references to variables owned by the Python
-/// interpreter, using functions such as [`Python::eval`] and [`PyModule::import`]. These
-/// references are tied to a [`GILPool`] whose references are not cleared until it is dropped.
-/// This can cause apparent "memory leaks" if it is kept around for a long time.
-///
-/// ```rust
-/// use pyo3::prelude::*;
-/// use pyo3::types::PyString;
-///
-/// # fn main () -> PyResult<()> {
-/// Python::with_gil(|py| -> PyResult<()> {
-///     for _ in 0..10 {
-///         let hello = py.eval_bound("\"Hello World!\"", None, None)?.downcast_into::<PyString>()?;
-///         println!("Python says: {}", hello.to_cow()?);
-///         // Normally variables in a loop scope are dropped here, but `hello` is a reference to
-///         // something owned by the Python interpreter. Dropping this reference does nothing.
-///     }
-///     Ok(())
-/// })
-/// // This is where the `hello`'s reference counts start getting decremented.
-/// # }
-/// ```
-///
-/// The variable `hello` is dropped at the end of each loop iteration, but the lifetime of the
-/// pointed-to memory is bound to [`Python::with_gil`]'s [`GILPool`] which will not be dropped until
-/// the end of [`Python::with_gil`]'s scope. Only then is each `hello`'s Python reference count
-/// decreased. This means that at the last line of the example there are 10 copies of `hello` in
-/// Python's memory, not just one at a time as we might expect from Rust's [scoping rules].
-///
-/// See the [Memory Management] chapter of the guide for more information about how PyO3 uses
-/// [`GILPool`] to manage memory.
-///
-/// [scoping rules]: https://doc.rust-lang.org/stable/book/ch04-01-what-is-ownership.html#ownership-rules
-/// [`Py::clone_ref`]: crate::Py::clone_ref
-/// [Memory Management]: https://pyo3.rs/main/memory.html#gil-bound-memory
+/// The [`Python<'py>`] type can be used to create references to variables owned by the Python
+/// interpreter, using functions such as [`Python::eval`] and [`PyModule::import`].
 #[derive(Copy, Clone)]
-pub struct Python<'py>(PhantomData<(&'py GILGuard, NotSend)>);
+pub struct Python<'py>(PhantomData<&'py AttachGuard>, PhantomData<NotSend>);
+
+/// A marker type that makes the type !Send.
+/// Workaround for lack of !Send on stable (<https://github.com/rust-lang/rust/issues/68318>).
+struct NotSend(PhantomData<*mut Python<'static>>);
 
 impl Python<'_> {
+    /// See [Python::attach]
+    #[inline]
+    #[track_caller]
+    #[deprecated(note = "use `Python::attach` instead", since = "0.26.0")]
+    pub fn with_gil<F, R>(f: F) -> R
+    where
+        F: for<'py> FnOnce(Python<'py>) -> R,
+    {
+        Self::attach(f)
+    }
+
     /// Acquires the global interpreter lock, allowing access to the Python interpreter. The
     /// provided closure `F` will be executed with the acquired `Python` marker token.
     ///
     /// If implementing [`#[pymethods]`](crate::pymethods) or [`#[pyfunction]`](crate::pyfunction),
     /// declare `py: Python` as an argument. PyO3 will pass in the token to grant access to the GIL
-    /// context in which the function is running, avoiding the need to call `with_gil`.
+    /// context in which the function is running, avoiding the need to call `attach`.
     ///
     /// If the [`auto-initialize`] feature is enabled and the Python runtime is not already
     /// initialized, this function will initialize it. See
     #[cfg_attr(
-        not(PyPy),
-        doc = "[`prepare_freethreaded_python`](crate::prepare_freethreaded_python)"
+        not(any(PyPy, GraalPy)),
+        doc = "[`Python::initialize`](crate::marker::Python::initialize)"
     )]
-    #[cfg_attr(PyPy, doc = "`prepare_freethreaded_python`")]
+    #[cfg_attr(PyPy, doc = "`Python::initialize")]
     /// for details.
     ///
     /// If the current thread does not yet have a Python "thread state" associated with it,
@@ -414,15 +392,22 @@ impl Python<'_> {
     ///
     /// - If the [`auto-initialize`] feature is not enabled and the Python interpreter is not
     ///   initialized.
+    /// - If the Python interpreter is in the process of [shutting down].
+    /// - If the current thread is currently in the middle of a GC traversal (i.e. called from
+    ///   within a `__traverse__` method).
+    ///
+    /// To avoid possible initialization or panics if calling in a context where the Python
+    /// interpreter might be unavailable, consider using [`Python::try_attach`].
     ///
     /// # Examples
     ///
     /// ```
     /// use pyo3::prelude::*;
+    /// use pyo3::ffi::c_str;
     ///
     /// # fn main() -> PyResult<()> {
-    /// Python::with_gil(|py| -> PyResult<()> {
-    ///     let x: i32 = py.eval_bound("5", None, None)?.extract()?;
+    /// Python::attach(|py| -> PyResult<()> {
+    ///     let x: i32 = py.eval(c"5", None, None)?.extract()?;
     ///     assert_eq!(x, 5);
     ///     Ok(())
     /// })
@@ -430,53 +415,121 @@ impl Python<'_> {
     /// ```
     ///
     /// [`auto-initialize`]: https://pyo3.rs/main/features.html#auto-initialize
+    /// [shutting down]: https://docs.python.org/3/glossary.html#term-interpreter-shutdown
     #[inline]
-    pub fn with_gil<F, R>(f: F) -> R
+    #[track_caller]
+    pub fn attach<F, R>(f: F) -> R
     where
         F: for<'py> FnOnce(Python<'py>) -> R,
     {
-        let _guard = GILGuard::acquire();
+        let guard = AttachGuard::attach();
+        f(guard.python())
+    }
 
-        // SAFETY: Either the GIL was already acquired or we just created a new `GILGuard`.
-        f(unsafe { Python::assume_gil_acquired() })
+    /// Variant of [`Python::attach`] which will return without attaching to the Python
+    /// interpreter if the interpreter is in a state where it cannot be attached to:
+    ///
+    /// - If the Python interpreter is not initialized.
+    /// - If the Python interpreter is in the process of [shutting down].
+    /// - If the current thread is currently in the middle of a GC traversal (i.e. called from
+    ///   within a `__traverse__` method).
+    ///
+    /// Unlike `Python::attach`, this function will not initialize the Python interpreter,
+    /// even if the [`auto-initialize`] feature is enabled.
+    ///
+    /// Note that due to the nature of the underlying Python APIs used to implement this,
+    /// the behavior is currently provided on a best-effort basis; it is expected that a
+    /// future CPython version will introduce APIs which guarantee this behaviour. This
+    /// function is still recommended for use in the meanwhile as it provides the best
+    /// possible behaviour and should transparently change to an optimal implementation
+    /// once such APIs are available.
+    ///
+    /// [`auto-initialize`]: https://pyo3.rs/main/features.html#auto-initialize
+    /// [shutting down]: https://docs.python.org/3/glossary.html#term-interpreter-shutdown
+    #[inline]
+    #[track_caller]
+    pub fn try_attach<F, R>(f: F) -> Option<R>
+    where
+        F: for<'py> FnOnce(Python<'py>) -> R,
+    {
+        let guard = AttachGuard::try_attach().ok()?;
+        Some(f(guard.python()))
     }
 
-    /// Like [`Python::with_gil`] except Python interpreter state checking is skipped.
+    /// Prepares the use of Python.
     ///
-    /// Normally when the GIL is acquired, we check that the Python interpreter is an
-    /// appropriate state (e.g. it is fully initialized). This function skips those
-    /// checks.
+    /// If the Python interpreter is not already initialized, this function will initialize it with
+    /// signal handling disabled (Python will not raise the `KeyboardInterrupt` exception). Python
+    /// signal handling depends on the notion of a 'main thread', which must be the thread that
+    /// initializes the Python interpreter.
     ///
-    /// # Safety
+    /// If the Python interpreter is already initialized, this function has no effect.
     ///
-    /// If [`Python::with_gil`] would succeed, it is safe to call this function.
+    /// This function is unavailable under PyPy because PyPy cannot be embedded in Rust (or any other
+    /// software). Support for this is tracked on the
+    /// [PyPy issue tracker](https://github.com/pypy/pypy/issues/3836).
     ///
-    /// In most cases, you should use [`Python::with_gil`].
+    /// # Examples
+    /// ```rust
+    /// use pyo3::prelude::*;
     ///
-    /// A justified scenario for calling this function is during multi-phase interpreter
-    /// initialization when [`Python::with_gil`] would fail before
-    // this link is only valid on 3.8+not pypy and up.
-    #[cfg_attr(
-        all(Py_3_8, not(PyPy)),
-        doc = "[`_Py_InitializeMain`](crate::ffi::_Py_InitializeMain)"
-    )]
-    #[cfg_attr(any(not(Py_3_8), PyPy), doc = "`_Py_InitializeMain`")]
-    /// is called because the interpreter is only partially initialized.
+    /// # fn main() -> PyResult<()> {
+    /// Python::initialize();
+    /// Python::attach(|py| py.run(c"print('Hello World')", None, None))
+    /// # }
+    /// ```
+    #[cfg(not(any(PyPy, GraalPy)))]
+    pub fn initialize() {
+        crate::interpreter_lifecycle::initialize();
+    }
+
+    /// See [Python::attach_unchecked]
+    /// # Safety
     ///
-    /// Behavior in other scenarios is not documented.
+    /// If [`Python::attach`] would succeed, it is safe to call this function.
     #[inline]
+    #[track_caller]
+    #[deprecated(note = "use `Python::attach_unchecked` instead", since = "0.26.0")]
     pub unsafe fn with_gil_unchecked<F, R>(f: F) -> R
     where
         F: for<'py> FnOnce(Python<'py>) -> R,
     {
-        let _guard = GILGuard::acquire_unchecked();
+        unsafe { Self::attach_unchecked(f) }
+    }
 
-        // SAFETY: Either the GIL was already acquired or we just created a new `GILGuard`.
-        f(Python::assume_gil_acquired())
+    /// Like [`Python::attach`] except Python interpreter state checking is skipped.
+    ///
+    /// Normally when attaching to the Python interpreter, PyO3 checks that it is in
+    /// an appropriate state (e.g. it is fully initialized). This function skips
+    /// those checks.
+    ///
+    /// # Safety
+    ///
+    /// If [`Python::attach`] would succeed, it is safe to call this function.
+    #[inline]
+    #[track_caller]
+    pub unsafe fn attach_unchecked<F, R>(f: F) -> R
+    where
+        F: for<'py> FnOnce(Python<'py>) -> R,
+    {
+        let guard = unsafe { AttachGuard::attach_unchecked() };
+
+        f(guard.python())
     }
 }
 
 impl<'py> Python<'py> {
+    /// See [Python::detach]
+    #[inline]
+    #[deprecated(note = "use `Python::detach` instead", since = "0.26.0")]
+    pub fn allow_threads<T, F>(self, f: F) -> T
+    where
+        F: Ungil + FnOnce() -> T,
+        T: Ungil,
+    {
+        self.detach(f)
+    }
+
     /// Temporarily releases the GIL, thus allowing other Python threads to run. The GIL will be
     /// reacquired when `F`'s scope ends.
     ///
@@ -499,7 +552,7 @@ impl<'py> Python<'py> {
     /// #[pyfunction]
     /// fn sum_numbers(py: Python<'_>, numbers: Vec<u32>) -> PyResult<u32> {
     ///     // We release the GIL here so any other Python threads get a chance to run.
-    ///     py.allow_threads(move || {
+    ///     py.detach(move || {
     ///         // An example of an "expensive" Rust calculation
     ///         let sum = numbers.iter().sum();
     ///
@@ -508,7 +561,7 @@ impl<'py> Python<'py> {
     /// }
     /// #
     /// # fn main() -> PyResult<()> {
-    /// #     Python::with_gil(|py| -> PyResult<()> {
+    /// #     Python::attach(|py| -> PyResult<()> {
     /// #         let fun = pyo3::wrap_pyfunction!(sum_numbers, py)?;
     /// #         let res = fun.call1((vec![1_u32, 2, 3],))?;
     /// #         assert_eq!(res.extract::<u32>()?, 6_u32);
@@ -518,7 +571,7 @@ impl<'py> Python<'py> {
     /// ```
     ///
     /// Please see the [Parallelism] chapter of the guide for a thorough discussion of using
-    /// [`Python::allow_threads`] in this manner.
+    /// [`Python::detach`] in this manner.
     ///
     /// # Example: Passing borrowed Python references into the closure is not allowed
     ///
@@ -527,8 +580,8 @@ impl<'py> Python<'py> {
     /// use pyo3::types::PyString;
     ///
     /// fn parallel_print(py: Python<'_>) {
-    ///     let s = PyString::new_bound(py, "This object cannot be accessed without holding the GIL >_<");
-    ///     py.allow_threads(move || {
+    ///     let s = PyString::new(py, "This object cannot be accessed without holding the GIL >_<");
+    ///     py.detach(move || {
     ///         println!("{:?}", s); // This causes a compile error.
     ///     });
     /// }
@@ -538,7 +591,7 @@ impl<'py> Python<'py> {
     /// [`PyString`]: crate::types::PyString
     /// [auto-traits]: https://doc.rust-lang.org/nightly/unstable-book/language-features/auto-traits.html
     /// [Parallelism]: https://pyo3.rs/main/parallelism.html
-    pub fn allow_threads<T, F>(self, f: F) -> T
+    pub fn detach<T, F>(self, f: F) -> T
     where
         F: Ungil + FnOnce() -> T,
         T: Ungil,
@@ -547,32 +600,10 @@ impl<'py> Python<'py> {
         // so that the GIL will be reacquired even if `f` panics.
         // The `Send` bound on the closure prevents the user from
         // transferring the `Python` token into the closure.
-        let _guard = unsafe { SuspendGIL::new() };
+        let _guard = unsafe { SuspendAttach::new() };
         f()
     }
 
-    /// Deprecated version of [`Python::eval_bound`]
-    #[cfg_attr(
-        not(feature = "gil-refs"),
-        deprecated(
-            since = "0.21.0",
-            note = "`Python::eval` will be replaced by `Python::eval_bound` in a future PyO3 version"
-        )
-    )]
-    pub fn eval(
-        self,
-        code: &str,
-        globals: Option<&'py PyDict>,
-        locals: Option<&'py PyDict>,
-    ) -> PyResult<&'py PyAny> {
-        self.eval_bound(
-            code,
-            globals.map(PyNativeType::as_borrowed).as_deref(),
-            locals.map(PyNativeType::as_borrowed).as_deref(),
-        )
-        .map(Bound::into_gil_ref)
-    }
-
     /// Evaluates a Python expression in the given context and returns the result.
     ///
     /// If `globals` is `None`, it defaults to Python module `__main__`.
@@ -585,40 +616,21 @@ impl<'py> Python<'py> {
     ///
     /// ```
     /// # use pyo3::prelude::*;
-    /// # Python::with_gil(|py| {
-    /// let result = py.eval_bound("[i * 10 for i in range(5)]", None, None).unwrap();
+    /// # use pyo3::ffi::c_str;
+    /// # Python::attach(|py| {
+    /// let result = py.eval(c"[i * 10 for i in range(5)]", None, None).unwrap();
     /// let res: Vec<i64> = result.extract().unwrap();
     /// assert_eq!(res, vec![0, 10, 20, 30, 40])
     /// # });
     /// ```
-    pub fn eval_bound(
+    pub fn eval(
         self,
-        code: &str,
+        code: &CStr,
         globals: Option<&Bound<'py, PyDict>>,
         locals: Option<&Bound<'py, PyDict>>,
     ) -> PyResult<Bound<'py, PyAny>> {
-        self.run_code(code, ffi::Py_eval_input, globals, locals)
-    }
-
-    /// Deprecated version of [`Python::run_bound`]
-    #[cfg_attr(
-        not(feature = "gil-refs"),
-        deprecated(
-            since = "0.21.0",
-            note = "`Python::run` will be replaced by `Python::run_bound` in a future PyO3 version"
-        )
-    )]
-    pub fn run(
-        self,
-        code: &str,
-        globals: Option<&PyDict>,
-        locals: Option<&PyDict>,
-    ) -> PyResult<()> {
-        self.run_bound(
-            code,
-            globals.map(PyNativeType::as_borrowed).as_deref(),
-            locals.map(PyNativeType::as_borrowed).as_deref(),
-        )
+        let code = PyCode::compile(self, code, c"<string>", crate::types::PyCodeInput::Eval)?;
+        code.run(globals, locals)
     }
 
     /// Executes one or more Python statements in the given context.
@@ -634,11 +646,11 @@ impl<'py> Python<'py> {
     /// use pyo3::{
     ///     prelude::*,
     ///     types::{PyBytes, PyDict},
+    ///     ffi::c_str,
     /// };
-    /// Python::with_gil(|py| {
-    ///     let locals = PyDict::new_bound(py);
-    ///     py.run_bound(
-    ///         r#"
+    /// Python::attach(|py| {
+    ///     let locals = PyDict::new(py);
+    ///     py.run(cr#"
     /// import base64
     /// s = 'Hello Rust!'
     /// ret = base64.b64encode(s.encode('utf-8'))
@@ -648,140 +660,61 @@ impl<'py> Python<'py> {
     ///     )
     ///     .unwrap();
     ///     let ret = locals.get_item("ret").unwrap().unwrap();
-    ///     let b64 = ret.downcast::<PyBytes>().unwrap();
+    ///     let b64 = ret.cast::<PyBytes>().unwrap();
     ///     assert_eq!(b64.as_bytes(), b"SGVsbG8gUnVzdCE=");
     /// });
     /// ```
     ///
     /// You can use [`py_run!`](macro.py_run.html) for a handy alternative of `run`
     /// if you don't need `globals` and unwrapping is OK.
-    pub fn run_bound(
+    pub fn run(
         self,
-        code: &str,
+        code: &CStr,
         globals: Option<&Bound<'py, PyDict>>,
         locals: Option<&Bound<'py, PyDict>>,
     ) -> PyResult<()> {
-        let res = self.run_code(code, ffi::Py_file_input, globals, locals);
-        res.map(|obj| {
+        let code = PyCode::compile(self, code, c"<string>", crate::types::PyCodeInput::File)?;
+        code.run(globals, locals).map(|obj| {
             debug_assert!(obj.is_none());
         })
     }
 
-    /// Runs code in the given context.
-    ///
-    /// `start` indicates the type of input expected: one of `Py_single_input`,
-    /// `Py_file_input`, or `Py_eval_input`.
-    ///
-    /// If `globals` is `None`, it defaults to Python module `__main__`.
-    /// If `locals` is `None`, it defaults to the value of `globals`.
-    fn run_code(
-        self,
-        code: &str,
-        start: c_int,
-        globals: Option<&Bound<'py, PyDict>>,
-        locals: Option<&Bound<'py, PyDict>>,
-    ) -> PyResult<Bound<'py, PyAny>> {
-        let code = CString::new(code)?;
-        unsafe {
-            let mptr = ffi::PyImport_AddModule("__main__\0".as_ptr() as *const _);
-            if mptr.is_null() {
-                return Err(PyErr::fetch(self));
-            }
-
-            let globals = globals
-                .map(|dict| dict.as_ptr())
-                .unwrap_or_else(|| ffi::PyModule_GetDict(mptr));
-            let locals = locals.map(|dict| dict.as_ptr()).unwrap_or(globals);
-
-            // If `globals` don't provide `__builtins__`, most of the code will fail if Python
-            // version is <3.10. That's probably not what user intended, so insert `__builtins__`
-            // for them.
-            //
-            // See also:
-            // - https://github.com/python/cpython/pull/24564 (the same fix in CPython 3.10)
-            // - https://github.com/PyO3/pyo3/issues/3370
-            let builtins_s = crate::intern!(self, "__builtins__").as_ptr();
-            let has_builtins = ffi::PyDict_Contains(globals, builtins_s);
-            if has_builtins == -1 {
-                return Err(PyErr::fetch(self));
-            }
-            if has_builtins == 0 {
-                // Inherit current builtins.
-                let builtins = ffi::PyEval_GetBuiltins();
-
-                // `PyDict_SetItem` doesn't take ownership of `builtins`, but `PyEval_GetBuiltins`
-                // seems to return a borrowed reference, so no leak here.
-                if ffi::PyDict_SetItem(globals, builtins_s, builtins) == -1 {
-                    return Err(PyErr::fetch(self));
-                }
-            }
-
-            let code_obj = ffi::Py_CompileString(code.as_ptr(), "<string>\0".as_ptr() as _, start);
-            if code_obj.is_null() {
-                return Err(PyErr::fetch(self));
-            }
-            let res_ptr = ffi::PyEval_EvalCode(code_obj, globals, locals);
-            ffi::Py_DECREF(code_obj);
-
-            res_ptr.assume_owned_or_err(self).downcast_into_unchecked()
-        }
-    }
-
     /// Gets the Python type object for type `T`.
     #[inline]
-    pub fn get_type<T>(self) -> &'py PyType
+    pub fn get_type<T>(self) -> Bound<'py, PyType>
     where
         T: PyTypeInfo,
     {
-        T::type_object_bound(self).into_gil_ref()
-    }
-
-    /// Deprecated form of [`Python::import_bound`]
-    #[cfg_attr(
-        not(feature = "gil-refs"),
-        deprecated(
-            since = "0.21.0",
-            note = "`Python::import` will be replaced by `Python::import_bound` in a future PyO3 version"
-        )
-    )]
-    pub fn import<N>(self, name: N) -> PyResult<&'py PyModule>
-    where
-        N: IntoPy<Py<PyString>>,
-    {
-        PyModule::import(self, name)
+        T::type_object(self)
     }
 
     /// Imports the Python module with the specified name.
-    pub fn import_bound<N>(self, name: N) -> PyResult<Bound<'py, PyModule>>
+    pub fn import<N>(self, name: N) -> PyResult<Bound<'py, PyModule>>
     where
-        N: IntoPy<Py<PyString>>,
+        N: IntoPyObject<'py, Target = PyString>,
     {
-        // FIXME: This should be replaced by `PyModule::import_bound` once thats
-        // implemented.
         PyModule::import(self, name)
-            .map(PyNativeType::as_borrowed)
-            .map(crate::Borrowed::to_owned)
     }
 
     /// Gets the Python builtin value `None`.
     #[allow(non_snake_case)] // the Python keyword starts with uppercase
     #[inline]
-    pub fn None(self) -> PyObject {
-        PyNone::get_bound(self).into_py(self)
+    pub fn None(self) -> Py<PyAny> {
+        PyNone::get(self).to_owned().into_any().unbind()
     }
 
     /// Gets the Python builtin value `Ellipsis`, or `...`.
     #[allow(non_snake_case)] // the Python keyword starts with uppercase
     #[inline]
-    pub fn Ellipsis(self) -> PyObject {
-        PyEllipsis::get_bound(self).into_py(self)
+    pub fn Ellipsis(self) -> Py<PyAny> {
+        PyEllipsis::get(self).to_owned().into_any().unbind()
     }
 
     /// Gets the Python builtin value `NotImplemented`.
     #[allow(non_snake_case)] // the Python keyword starts with uppercase
     #[inline]
-    pub fn NotImplemented(self) -> PyObject {
-        PyNotImplemented::get_bound(self).into_py(self)
+    pub fn NotImplemented(self) -> Py<PyAny> {
+        PyNotImplemented::get(self).to_owned().into_any().unbind()
     }
 
     /// Gets the running Python interpreter version as a string.
@@ -789,7 +722,7 @@ impl<'py> Python<'py> {
     /// # Examples
     /// ```rust
     /// # use pyo3::Python;
-    /// Python::with_gil(|py| {
+    /// Python::attach(|py| {
     ///     // The full string could be, for example:
     ///     // "3.10.0 (tags/v3.10.0:b494f59, Oct  4 2021, 19:00:18) [MSC v.1929 64 bit (AMD64)]"
     ///     assert!(py.version().starts_with("3."));
@@ -809,7 +742,7 @@ impl<'py> Python<'py> {
     /// # Examples
     /// ```rust
     /// # use pyo3::Python;
-    /// Python::with_gil(|py| {
+    /// Python::attach(|py| {
     ///     // PyO3 supports Python 3.7 and up.
     ///     assert!(py.version_info() >= (3, 7));
     ///     assert!(py.version_info() >= (3, 7, 0));
@@ -825,122 +758,10 @@ impl<'py> Python<'py> {
         PythonVersionInfo::from_str(version_number_str).unwrap()
     }
 
-    /// Registers the object in the release pool, and tries to downcast to specific type.
-    pub fn checked_cast_as<T>(self, obj: PyObject) -> Result<&'py T, PyDowncastError<'py>>
-    where
-        T: PyTypeCheck<AsRefTarget = T>,
-    {
-        obj.into_ref(self).downcast()
-    }
-
-    /// Registers the object in the release pool, and does an unchecked downcast
-    /// to the specific type.
-    ///
-    /// # Safety
-    ///
-    /// Callers must ensure that ensure that the cast is valid.
-    pub unsafe fn cast_as<T>(self, obj: PyObject) -> &'py T
-    where
-        T: HasPyGilRef<AsRefTarget = T>,
-    {
-        obj.into_ref(self).downcast_unchecked()
-    }
-
-    /// Registers the object pointer in the release pool,
-    /// and does an unchecked downcast to the specific type.
-    ///
-    /// # Safety
-    ///
-    /// Callers must ensure that ensure that the cast is valid.
-    #[allow(clippy::wrong_self_convention)]
-    pub unsafe fn from_owned_ptr<T>(self, ptr: *mut ffi::PyObject) -> &'py T
-    where
-        T: FromPyPointer<'py>,
-    {
-        FromPyPointer::from_owned_ptr(self, ptr)
-    }
-
-    /// Registers the owned object pointer in the release pool.
-    ///
-    /// Returns `Err(PyErr)` if the pointer is NULL.
-    /// Does an unchecked downcast to the specific type.
-    ///
-    /// # Safety
-    ///
-    /// Callers must ensure that ensure that the cast is valid.
-    #[allow(clippy::wrong_self_convention)]
-    pub unsafe fn from_owned_ptr_or_err<T>(self, ptr: *mut ffi::PyObject) -> PyResult<&'py T>
-    where
-        T: FromPyPointer<'py>,
-    {
-        FromPyPointer::from_owned_ptr_or_err(self, ptr)
-    }
-
-    /// Registers the owned object pointer in release pool.
-    ///
-    /// Returns `None` if the pointer is NULL.
-    /// Does an unchecked downcast to the specific type.
-    ///
-    /// # Safety
-    ///
-    /// Callers must ensure that ensure that the cast is valid.
-    #[allow(clippy::wrong_self_convention)]
-    pub unsafe fn from_owned_ptr_or_opt<T>(self, ptr: *mut ffi::PyObject) -> Option<&'py T>
-    where
-        T: FromPyPointer<'py>,
-    {
-        FromPyPointer::from_owned_ptr_or_opt(self, ptr)
-    }
-
-    /// Does an unchecked downcast to the specific type.
-    ///
-    /// Panics if the pointer is NULL.
-    ///
-    /// # Safety
-    ///
-    /// Callers must ensure that ensure that the cast is valid.
-    #[allow(clippy::wrong_self_convention)]
-    pub unsafe fn from_borrowed_ptr<T>(self, ptr: *mut ffi::PyObject) -> &'py T
-    where
-        T: FromPyPointer<'py>,
-    {
-        FromPyPointer::from_borrowed_ptr(self, ptr)
-    }
-
-    /// Does an unchecked downcast to the specific type.
-    ///
-    /// Returns `Err(PyErr)` if the pointer is NULL.
-    ///
-    /// # Safety
-    ///
-    /// Callers must ensure that ensure that the cast is valid.
-    #[allow(clippy::wrong_self_convention)]
-    pub unsafe fn from_borrowed_ptr_or_err<T>(self, ptr: *mut ffi::PyObject) -> PyResult<&'py T>
-    where
-        T: FromPyPointer<'py>,
-    {
-        FromPyPointer::from_borrowed_ptr_or_err(self, ptr)
-    }
-
-    /// Does an unchecked downcast to the specific type.
-    ///
-    /// Returns `None` if the pointer is NULL.
-    ///
-    /// # Safety
-    ///
-    /// Callers must ensure that ensure that the cast is valid.
-    #[allow(clippy::wrong_self_convention)]
-    pub unsafe fn from_borrowed_ptr_or_opt<T>(self, ptr: *mut ffi::PyObject) -> Option<&'py T>
-    where
-        T: FromPyPointer<'py>,
-    {
-        FromPyPointer::from_borrowed_ptr_or_opt(self, ptr)
-    }
-
     /// Lets the Python interpreter check and handle any pending signals. This will invoke the
     /// corresponding signal handlers registered in Python (if any).
     ///
-    /// Returns `Err(`[`PyErr`]`)` if any signal handler raises an exception.
+    /// Returns `Err(`[`PyErr`](crate::PyErr)`)` if any signal handler raises an exception.
     ///
     /// These signals include `SIGINT` (normally raised by CTRL + C), which by default raises
     /// `KeyboardInterrupt`. For this reason it is good practice to call this function regularly
@@ -948,7 +769,7 @@ impl<'py> Python<'py> {
     ///
     /// # Example
     ///
-    /// ```rust
+    /// ```rust,no_run
     /// # #![allow(dead_code)] // this example is quite impractical to test
     /// use pyo3::prelude::*;
     ///
@@ -982,180 +803,65 @@ impl<'py> Python<'py> {
     pub fn check_signals(self) -> PyResult<()> {
         err::error_on_minusone(self, unsafe { ffi::PyErr_CheckSignals() })
     }
-
-    /// Create a new pool for managing PyO3's owned references.
-    ///
-    /// When this `GILPool` is dropped, all PyO3 owned references created after this `GILPool` will
-    /// all have their Python reference counts decremented, potentially allowing Python to drop
-    /// the corresponding Python objects.
-    ///
-    /// Typical usage of PyO3 will not need this API, as [`Python::with_gil`] automatically creates
-    /// a `GILPool` where appropriate.
-    ///
-    /// Advanced uses of PyO3 which perform long-running tasks which never free the GIL may need
-    /// to use this API to clear memory, as PyO3 usually does not clear memory until the GIL is
-    /// released.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// # use pyo3::prelude::*;
-    /// Python::with_gil(|py| {
-    ///     // Some long-running process like a webserver, which never releases the GIL.
-    ///     loop {
-    ///         // Create a new pool, so that PyO3 can clear memory at the end of the loop.
-    ///         let pool = unsafe { py.new_pool() };
-    ///
-    ///         // It is recommended to *always* immediately set py to the pool's Python, to help
-    ///         // avoid creating references with invalid lifetimes.
-    ///         let py = pool.python();
-    ///
-    ///         // do stuff...
-    /// #       break;  // Exit the loop so that doctest terminates!
-    ///     }
-    /// });
-    /// ```
-    ///
-    /// # Safety
-    ///
-    /// Extreme care must be taken when using this API, as misuse can lead to accessing invalid
-    /// memory. In addition, the caller is responsible for guaranteeing that the GIL remains held
-    /// for the entire lifetime of the returned `GILPool`.
-    ///
-    /// Two best practices are required when using this API:
-    /// - From the moment `new_pool()` is called, only the `Python` token from the returned
-    ///   `GILPool` (accessible using [`.python()`]) should be used in PyO3 APIs. All other older
-    ///   `Python` tokens with longer lifetimes are unsafe to use until the `GILPool` is dropped,
-    ///   because they can be used to create PyO3 owned references which have lifetimes which
-    ///   outlive the `GILPool`.
-    /// - Similarly, methods on existing owned references will implicitly refer back to the
-    ///   `Python` token which that reference was originally created with. If the returned values
-    ///   from these methods are owned references they will inherit the same lifetime. As a result,
-    ///   Rust's lifetime rules may allow them to outlive the `GILPool`, even though this is not
-    ///   safe for reasons discussed above. Care must be taken to never access these return values
-    ///   after the `GILPool` is dropped, unless they are converted to `Py<T>` *before* the pool
-    ///   is dropped.
-    ///
-    /// [`.python()`]: crate::GILPool::python
-    #[inline]
-    pub unsafe fn new_pool(self) -> GILPool {
-        GILPool::new()
-    }
 }
 
-impl Python<'_> {
-    /// Creates a scope using a new pool for managing PyO3's owned references.
-    ///
-    /// This is a safe alterantive to [`new_pool`][Self::new_pool] as
-    /// it limits the closure to using the new GIL token at the cost of
-    /// being unable to capture existing GIL-bound references.
-    ///
-    /// Note that on stable Rust, this API suffers from the same the `SendWrapper` loophole
-    /// as [`allow_threads`][Self::allow_threads], c.f. the documentation of the [`Ungil`] trait,
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// # use pyo3::prelude::*;
-    /// Python::with_gil(|py| {
-    ///     // Some long-running process like a webserver, which never releases the GIL.
-    ///     loop {
-    ///         // Create a new scope, so that PyO3 can clear memory at the end of the loop.
-    ///         py.with_pool(|py| {
-    ///             // do stuff...
-    ///         });
-    /// #       break;  // Exit the loop so that doctest terminates!
-    ///     }
-    /// });
-    /// ```
-    ///
-    /// The `Ungil` bound on the closure does prevent hanging on to existing GIL-bound references
-    ///
-    /// ```compile_fail
-    /// # #![allow(deprecated)]
-    /// # use pyo3::prelude::*;
-    /// # use pyo3::types::PyString;
-    ///
-    /// Python::with_gil(|py| {
-    ///     let old_str = PyString::new(py, "a message from the past");
-    ///
-    ///     py.with_pool(|_py| {
-    ///         print!("{:?}", old_str);
-    ///     });
-    /// });
-    /// ```
-    ///
-    /// or continuing to use the old GIL token
-    ///
-    /// ```compile_fail
-    /// # use pyo3::prelude::*;
+impl<'unbound> Python<'unbound> {
+    /// Deprecated version of [`Python::assume_attached`]
     ///
-    /// Python::with_gil(|old_py| {
-    ///     old_py.with_pool(|_new_py| {
-    ///         let _none = old_py.None();
-    ///     });
-    /// });
-    /// ```
+    /// # Safety
+    /// See [`Python::assume_attached`]
     #[inline]
-    pub fn with_pool<F, R>(&self, f: F) -> R
-    where
-        F: for<'py> FnOnce(Python<'py>) -> R + Ungil,
-    {
-        // SAFETY: The closure is `Ungil`,
-        // i.e. it does not capture any GIL-bound references
-        // and accesses only the newly created GIL token.
-        let pool = unsafe { GILPool::new() };
-
-        f(pool.python())
+    #[deprecated(since = "0.26.0", note = "use `Python::assume_attached` instead")]
+    pub unsafe fn assume_gil_acquired() -> Python<'unbound> {
+        unsafe { Self::assume_attached() }
     }
-}
-
-impl<'unbound> Python<'unbound> {
     /// Unsafely creates a Python token with an unbounded lifetime.
     ///
-    /// Many of PyO3 APIs use `Python<'_>` as proof that the GIL is held, but this function can be
-    /// used to call them unsafely.
+    /// Many of PyO3 APIs use [`Python<'_>`] as proof that the calling thread is attached to the
+    /// interpreter, but this function can be used to call them unsafely.
     ///
     /// # Safety
     ///
     /// - This token and any borrowed Python references derived from it can only be safely used
-    /// whilst the currently executing thread is actually holding the GIL.
+    ///   whilst the currently executing thread is actually attached to the interpreter.
     /// - This function creates a token with an *unbounded* lifetime. Safe code can assume that
-    /// holding a `Python<'py>` token means the GIL is and stays acquired for the lifetime `'py`.
-    /// If you let it or borrowed Python references escape to safe code you are
-    /// responsible for bounding the lifetime `'unbound` appropriately. For more on unbounded
-    /// lifetimes, see the [nomicon].
+    ///   holding a [`Python<'py>`] token means the thread is attached and stays attached for the
+    ///   lifetime `'py`. If you let it or borrowed Python references escape to safe code you are
+    ///   responsible for bounding the lifetime `'unbound` appropriately. For more on unbounded
+    ///   lifetimes, see the [nomicon].
     ///
     /// [nomicon]: https://doc.rust-lang.org/nomicon/unbounded-lifetimes.html
     #[inline]
-    pub unsafe fn assume_gil_acquired() -> Python<'unbound> {
-        Python(PhantomData)
+    pub unsafe fn assume_attached() -> Python<'unbound> {
+        Python(PhantomData, PhantomData)
     }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::types::{any::PyAnyMethods, IntoPyDict, PyDict, PyList};
-    use std::sync::Arc;
+    use crate::{
+        internal::state::ForbidAttaching,
+        types::{IntoPyDict, PyList},
+    };
 
     #[test]
     fn test_eval() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             // Make sure builtin names are accessible
             let v: i32 = py
-                .eval_bound("min(1, 2)", None, None)
+                .eval(c"min(1, 2)", None, None)
                 .map_err(|e| e.display(py))
                 .unwrap()
                 .extract()
                 .unwrap();
             assert_eq!(v, 1);
 
-            let d = [("foo", 13)].into_py_dict_bound(py);
+            let d = [("foo", 13)].into_py_dict(py).unwrap();
 
             // Inject our own global namespace
             let v: i32 = py
-                .eval_bound("foo + 29", Some(&d), None)
+                .eval(c"foo + 29", Some(&d), None)
                 .unwrap()
                 .extract()
                 .unwrap();
@@ -1163,7 +869,7 @@ mod tests {
 
             // Inject our own local namespace
             let v: i32 = py
-                .eval_bound("foo + 29", None, Some(&d))
+                .eval(c"foo + 29", None, Some(&d))
                 .unwrap()
                 .extract()
                 .unwrap();
@@ -1171,7 +877,7 @@ mod tests {
 
             // Make sure builtin names are still accessible when using a local namespace
             let v: i32 = py
-                .eval_bound("min(foo, 2)", None, Some(&d))
+                .eval(c"min(foo, 2)", None, Some(&d))
                 .unwrap()
                 .extract()
                 .unwrap();
@@ -1181,21 +887,21 @@ mod tests {
 
     #[test]
     #[cfg(not(target_arch = "wasm32"))] // We are building wasm Python with pthreads disabled
-    fn test_allow_threads_releases_and_acquires_gil() {
-        Python::with_gil(|py| {
+    fn test_detach_releases_and_acquires_gil() {
+        Python::attach(|py| {
             let b = std::sync::Arc::new(std::sync::Barrier::new(2));
 
             let b2 = b.clone();
-            std::thread::spawn(move || Python::with_gil(|_| b2.wait()));
+            std::thread::spawn(move || Python::attach(|_| b2.wait()));
 
-            py.allow_threads(|| {
-                // If allow_threads does not release the GIL, this will deadlock because
+            py.detach(|| {
+                // If `detach` does not release the GIL, this will deadlock because
                 // the thread spawned above will never be able to acquire the GIL.
                 b.wait();
             });
 
             unsafe {
-                // If the GIL is not reacquired at the end of allow_threads, this call
+                // If the GIL is not reacquired at the end of `detach`, this call
                 // will crash the Python interpreter.
                 let tstate = ffi::PyEval_SaveThread();
                 ffi::PyEval_RestoreThread(tstate);
@@ -1204,11 +910,11 @@ mod tests {
     }
 
     #[test]
-    fn test_allow_threads_panics_safely() {
-        Python::with_gil(|py| {
+    fn test_detach_panics_safely() {
+        Python::attach(|py| {
             let result = std::panic::catch_unwind(|| unsafe {
-                let py = Python::assume_gil_acquired();
-                py.allow_threads(|| {
+                let py = Python::assume_attached();
+                py.detach(|| {
                     panic!("There was a panic!");
                 });
             });
@@ -1216,21 +922,22 @@ mod tests {
             // Check panic was caught
             assert!(result.is_err());
 
-            // If allow_threads is implemented correctly, this thread still owns the GIL here
+            // If `detach` is implemented correctly, this thread still owns the GIL here
             // so the following Python calls should not cause crashes.
-            let list = PyList::new_bound(py, [1, 2, 3, 4]);
+            let list = PyList::new(py, [1, 2, 3, 4]).unwrap();
             assert_eq!(list.extract::<Vec<i32>>().unwrap(), vec![1, 2, 3, 4]);
         });
     }
 
+    #[cfg(not(pyo3_disable_reference_pool))]
     #[test]
-    fn test_allow_threads_pass_stuff_in() {
-        let list = Python::with_gil(|py| PyList::new_bound(py, vec!["foo", "bar"]).unbind());
+    fn test_detach_pass_stuff_in() {
+        let list = Python::attach(|py| PyList::new(py, vec!["foo", "bar"]).unwrap().unbind());
         let mut v = vec![1, 2, 3];
-        let a = Arc::new(String::from("foo"));
+        let a = std::sync::Arc::new(String::from("foo"));
 
-        Python::with_gil(|py| {
-            py.allow_threads(|| {
+        Python::attach(|py| {
+            py.detach(|| {
                 drop((list, &mut v, a));
             });
         });
@@ -1239,13 +946,20 @@ mod tests {
     #[test]
     #[cfg(not(Py_LIMITED_API))]
     fn test_acquire_gil() {
+        use std::ffi::c_int;
+
         const GIL_NOT_HELD: c_int = 0;
         const GIL_HELD: c_int = 1;
 
+        // Before starting the interpreter the state of calling `PyGILState_Check`
+        // seems to be undefined, so let's ensure that Python is up.
+        #[cfg(not(any(PyPy, GraalPy)))]
+        Python::initialize();
+
         let state = unsafe { crate::ffi::PyGILState_Check() };
         assert_eq!(state, GIL_NOT_HELD);
 
-        Python::with_gil(|_| {
+        Python::attach(|_| {
             let state = unsafe { crate::ffi::PyGILState_Check() };
             assert_eq!(state, GIL_HELD);
         });
@@ -1256,11 +970,11 @@ mod tests {
 
     #[test]
     fn test_ellipsis() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             assert_eq!(py.Ellipsis().to_string(), "Ellipsis");
 
             let v = py
-                .eval_bound("...", None, None)
+                .eval(c"...", None, None)
                 .map_err(|e| e.display(py))
                 .unwrap();
 
@@ -1272,12 +986,90 @@ mod tests {
     fn test_py_run_inserts_globals() {
         use crate::types::dict::PyDictMethods;
 
-        Python::with_gil(|py| {
-            let namespace = PyDict::new_bound(py);
-            py.run_bound("class Foo: pass", Some(&namespace), Some(&namespace))
-                .unwrap();
+        Python::attach(|py| {
+            let namespace = PyDict::new(py);
+            py.run(
+                c"class Foo: pass\na = int(3)",
+                Some(&namespace),
+                Some(&namespace),
+            )
+            .unwrap();
             assert!(matches!(namespace.get_item("Foo"), Ok(Some(..))));
+            assert!(matches!(namespace.get_item("a"), Ok(Some(..))));
+            // 3.9 and older did not automatically insert __builtins__ if it wasn't inserted "by hand"
+            #[cfg(not(Py_3_10))]
             assert!(matches!(namespace.get_item("__builtins__"), Ok(Some(..))));
         })
     }
+
+    #[cfg(feature = "macros")]
+    #[test]
+    fn test_py_run_inserts_globals_2() {
+        use std::ffi::CString;
+
+        #[crate::pyclass(crate = "crate")]
+        #[derive(Clone)]
+        struct CodeRunner {
+            code: CString,
+        }
+
+        impl CodeRunner {
+            fn reproducer(&mut self, py: Python<'_>) -> PyResult<()> {
+                let variables = PyDict::new(py);
+                variables.set_item("cls", crate::Py::new(py, self.clone())?)?;
+
+                py.run(self.code.as_c_str(), Some(&variables), None)?;
+                Ok(())
+            }
+        }
+
+        #[crate::pymethods(crate = "crate")]
+        impl CodeRunner {
+            fn func(&mut self, py: Python<'_>) -> PyResult<()> {
+                py.import("math")?;
+                Ok(())
+            }
+        }
+
+        let mut runner = CodeRunner {
+            code: CString::new(
+                r#"
+cls.func()
+"#
+                .to_string(),
+            )
+            .unwrap(),
+        };
+
+        Python::attach(|py| {
+            runner.reproducer(py).unwrap();
+        });
+    }
+
+    #[test]
+    fn python_is_zst() {
+        assert_eq!(std::mem::size_of::<Python<'_>>(), 0);
+    }
+
+    #[test]
+    fn test_try_attach_fail_during_gc() {
+        Python::attach(|_| {
+            assert!(Python::try_attach(|_| {}).is_some());
+
+            let guard = ForbidAttaching::during_traverse();
+            assert!(Python::try_attach(|_| {}).is_none());
+            drop(guard);
+
+            assert!(Python::try_attach(|_| {}).is_some());
+        })
+    }
+
+    #[test]
+    fn test_try_attach_ok_when_detached() {
+        Python::attach(|py| {
+            py.detach(|| {
+                assert!(Python::try_attach(|_| {}).is_some());
+            });
+        });
+    }
 }
diff --git a/src/marshal.rs b/src/marshal.rs
index 9526813976b..6866a7cc1c0 100644
--- a/src/marshal.rs
+++ b/src/marshal.rs
@@ -6,28 +6,12 @@ use crate::ffi_ptr_ext::FfiPtrExt;
 use crate::py_result_ext::PyResultExt;
 use crate::types::{PyAny, PyBytes};
 use crate::{ffi, Bound};
-use crate::{AsPyPointer, PyResult, Python};
-use std::os::raw::c_int;
+use crate::{PyResult, Python};
+use std::ffi::c_int;
 
 /// The current version of the marshal binary format.
 pub const VERSION: i32 = 4;
 
-/// Deprecated form of [`dumps_bound`]
-#[cfg_attr(
-    not(feature = "gil-refs"),
-    deprecated(
-        since = "0.21.0",
-        note = "`dumps` will be replaced by `dumps_bound` in a future PyO3 version"
-    )
-)]
-pub fn dumps<'py>(
-    py: Python<'py>,
-    object: &impl AsPyPointer,
-    version: i32,
-) -> PyResult<&'py PyBytes> {
-    dumps_bound(py, object, version).map(Bound::into_gil_ref)
-}
-
 /// Serialize an object to bytes using the Python built-in marshal module.
 ///
 /// The built-in marshalling only supports a limited range of objects.
@@ -39,44 +23,25 @@ pub fn dumps<'py>(
 /// # Examples
 /// ```
 /// # use pyo3::{marshal, types::PyDict, prelude::PyDictMethods};
-/// # pyo3::Python::with_gil(|py| {
-/// let dict = PyDict::new_bound(py);
+/// # pyo3::Python::attach(|py| {
+/// let dict = PyDict::new(py);
 /// dict.set_item("aap", "noot").unwrap();
 /// dict.set_item("mies", "wim").unwrap();
 /// dict.set_item("zus", "jet").unwrap();
 ///
-/// let bytes = marshal::dumps_bound(py, &dict, marshal::VERSION);
+/// let bytes = marshal::dumps(&dict, marshal::VERSION);
 /// # });
 /// ```
-pub fn dumps_bound<'py>(
-    py: Python<'py>,
-    object: &impl AsPyPointer,
-    version: i32,
-) -> PyResult<Bound<'py, PyBytes>> {
+pub fn dumps<'py>(object: &Bound<'py, PyAny>, version: i32) -> PyResult<Bound<'py, PyBytes>> {
     unsafe {
         ffi::PyMarshal_WriteObjectToString(object.as_ptr(), version as c_int)
-            .assume_owned_or_err(py)
-            .downcast_into_unchecked()
+            .assume_owned_or_err(object.py())
+            .cast_into_unchecked()
     }
 }
 
-/// Deprecated form of [`loads_bound`]
-#[cfg_attr(
-    not(feature = "gil-refs"),
-    deprecated(
-        since = "0.21.0",
-        note = "`loads` will be replaced by `loads_bound` in a future PyO3 version"
-    )
-)]
-pub fn loads<'py, B>(py: Python<'py>, data: &B) -> PyResult<&'py PyAny>
-where
-    B: AsRef<[u8]> + ?Sized,
-{
-    loads_bound(py, data).map(Bound::into_gil_ref)
-}
-
 /// Deserialize an object from bytes using the Python built-in marshal module.
-pub fn loads_bound<'py, B>(py: Python<'py>, data: &B) -> PyResult<Bound<'py, PyAny>>
+pub fn loads<'py, B>(py: Python<'py>, data: &B) -> PyResult<Bound<'py, PyAny>>
 where
     B: AsRef<[u8]> + ?Sized,
 {
@@ -90,24 +55,20 @@ where
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::types::{bytes::PyBytesMethods, dict::PyDictMethods, PyDict};
+    use crate::types::{bytes::PyBytesMethods, dict::PyDictMethods, PyAnyMethods, PyDict};
 
     #[test]
     fn marshal_roundtrip() {
-        Python::with_gil(|py| {
-            let dict = PyDict::new_bound(py);
+        Python::attach(|py| {
+            let dict = PyDict::new(py);
             dict.set_item("aap", "noot").unwrap();
             dict.set_item("mies", "wim").unwrap();
             dict.set_item("zus", "jet").unwrap();
 
-            let pybytes = dumps_bound(py, &dict, VERSION).expect("marshalling failed");
-            let deserialized = loads_bound(py, pybytes.as_bytes()).expect("unmarshalling failed");
+            let pybytes = dumps(&dict, VERSION).expect("marshalling failed");
+            let deserialized = loads(py, pybytes.as_bytes()).expect("unmarshalling failed");
 
-            assert!(equal(py, &dict, &deserialized));
+            assert!(dict.eq(&deserialized).unwrap());
         });
     }
-
-    fn equal(_py: Python<'_>, a: &impl AsPyPointer, b: &impl AsPyPointer) -> bool {
-        unsafe { ffi::PyObject_RichCompareBool(a.as_ptr(), b.as_ptr(), ffi::Py_EQ) != 0 }
-    }
 }
diff --git a/src/prelude.rs b/src/prelude.rs
index 47951aedcce..ccde0c902c3 100644
--- a/src/prelude.rs
+++ b/src/prelude.rs
@@ -8,19 +8,20 @@
 //! use pyo3::prelude::*;
 //! ```
 
-pub use crate::conversion::{FromPyObject, IntoPy, ToPyObject};
-#[allow(deprecated)]
-pub use crate::conversion::{PyTryFrom, PyTryInto};
+pub use crate::conversion::{FromPyObject, FromPyObjectOwned, IntoPyObject};
 pub use crate::err::{PyErr, PyResult};
-pub use crate::instance::{Borrowed, Bound, Py, PyObject};
+#[allow(deprecated)]
+pub use crate::instance::PyObject;
+pub use crate::instance::{Borrowed, Bound, Py};
 pub use crate::marker::Python;
-pub use crate::pycell::{PyCell, PyRef, PyRefMut};
+pub use crate::pycell::{PyRef, PyRefMut};
 pub use crate::pyclass_init::PyClassInitializer;
 pub use crate::types::{PyAny, PyModule};
-pub use crate::PyNativeType;
 
 #[cfg(feature = "macros")]
-pub use pyo3_macros::{pyclass, pyfunction, pymethods, pymodule, FromPyObject};
+pub use pyo3_macros::{
+    pyclass, pyfunction, pymethods, pymodule, FromPyObject, IntoPyObject, IntoPyObjectRef,
+};
 
 #[cfg(feature = "macros")]
 pub use crate::wrap_pyfunction;
@@ -30,14 +31,19 @@ pub use crate::types::boolobject::PyBoolMethods;
 pub use crate::types::bytearray::PyByteArrayMethods;
 pub use crate::types::bytes::PyBytesMethods;
 pub use crate::types::capsule::PyCapsuleMethods;
+pub use crate::types::complex::PyComplexMethods;
 pub use crate::types::dict::PyDictMethods;
 pub use crate::types::float::PyFloatMethods;
 pub use crate::types::frozenset::PyFrozenSetMethods;
 pub use crate::types::list::PyListMethods;
 pub use crate::types::mapping::PyMappingMethods;
+pub use crate::types::mappingproxy::PyMappingProxyMethods;
 pub use crate::types::module::PyModuleMethods;
 pub use crate::types::sequence::PySequenceMethods;
 pub use crate::types::set::PySetMethods;
+pub use crate::types::slice::PySliceMethods;
 pub use crate::types::string::PyStringMethods;
 pub use crate::types::traceback::PyTracebackMethods;
 pub use crate::types::tuple::PyTupleMethods;
+pub use crate::types::typeobject::PyTypeMethods;
+pub use crate::types::weakref::PyWeakrefMethods;
diff --git a/src/py_result_ext.rs b/src/py_result_ext.rs
index 66309988dc4..c5370b8c8b8 100644
--- a/src/py_result_ext.rs
+++ b/src/py_result_ext.rs
@@ -1,28 +1,18 @@
-use crate::{types::any::PyAnyMethods, Bound, PyAny, PyResult, PyTypeCheck};
+use crate::{Bound, PyAny, PyResult, PyTypeCheck};
 
-mod sealed {
-    use super::*;
-
-    pub trait Sealed {}
-
-    impl Sealed for PyResult<Bound<'_, PyAny>> {}
-}
-
-use sealed::Sealed;
-
-pub(crate) trait PyResultExt<'py>: Sealed {
-    fn downcast_into<T: PyTypeCheck>(self) -> PyResult<Bound<'py, T>>;
-    unsafe fn downcast_into_unchecked<T>(self) -> PyResult<Bound<'py, T>>;
+pub(crate) trait PyResultExt<'py>: crate::sealed::Sealed {
+    fn cast_into<T: PyTypeCheck>(self) -> PyResult<Bound<'py, T>>;
+    unsafe fn cast_into_unchecked<T>(self) -> PyResult<Bound<'py, T>>;
 }
 
 impl<'py> PyResultExt<'py> for PyResult<Bound<'py, PyAny>> {
     #[inline]
-    fn downcast_into<T: PyTypeCheck>(self) -> PyResult<Bound<'py, T>> where {
-        self.and_then(|instance| instance.downcast_into().map_err(Into::into))
+    fn cast_into<T: PyTypeCheck>(self) -> PyResult<Bound<'py, T>> where {
+        self.and_then(|instance| instance.cast_into().map_err(Into::into))
     }
 
     #[inline]
-    unsafe fn downcast_into_unchecked<T>(self) -> PyResult<Bound<'py, T>> {
-        self.map(|instance| instance.downcast_into_unchecked())
+    unsafe fn cast_into_unchecked<T>(self) -> PyResult<Bound<'py, T>> {
+        self.map(|instance| unsafe { instance.cast_into_unchecked() })
     }
 }
diff --git a/src/pybacked.rs b/src/pybacked.rs
index bd29c830e65..95f34620c6f 100644
--- a/src/pybacked.rs
+++ b/src/pybacked.rs
@@ -1,49 +1,75 @@
 //! Contains types for working with Python objects that own the underlying data.
 
-use std::{ops::Deref, ptr::NonNull};
+use std::{convert::Infallible, ops::Deref, ptr::NonNull, sync::Arc};
 
 use crate::{
     types::{
-        any::PyAnyMethods, bytearray::PyByteArrayMethods, bytes::PyBytesMethods,
-        string::PyStringMethods, PyByteArray, PyBytes, PyString,
+        bytearray::PyByteArrayMethods, bytes::PyBytesMethods, string::PyStringMethods, PyByteArray,
+        PyBytes, PyString, PyTuple,
     },
-    Bound, DowncastError, FromPyObject, Py, PyAny, PyErr, PyResult,
+    Borrowed, Bound, CastError, FromPyObject, IntoPyObject, Py, PyAny, PyErr, PyTypeInfo, Python,
 };
 
 /// A wrapper around `str` where the storage is owned by a Python `bytes` or `str` object.
 ///
 /// This type gives access to the underlying data via a `Deref` implementation.
+#[cfg_attr(feature = "py-clone", derive(Clone))]
 pub struct PyBackedStr {
     #[allow(dead_code)] // only held so that the storage is not dropped
     storage: Py<PyAny>,
-    data: NonNull<[u8]>,
+    data: NonNull<str>,
 }
 
 impl Deref for PyBackedStr {
     type Target = str;
     fn deref(&self) -> &str {
-        // Safety: `data` is known to be immutable utf8 string and owned by self
-        unsafe { std::str::from_utf8_unchecked(self.data.as_ref()) }
+        // Safety: `data` is known to be immutable and owned by self
+        unsafe { self.data.as_ref() }
+    }
+}
+
+impl AsRef<str> for PyBackedStr {
+    fn as_ref(&self) -> &str {
+        self
     }
 }
 
+impl AsRef<[u8]> for PyBackedStr {
+    fn as_ref(&self) -> &[u8] {
+        self.as_bytes()
+    }
+}
+
+// Safety: the underlying Python str (or bytes) is immutable and
+// safe to share between threads
+unsafe impl Send for PyBackedStr {}
+unsafe impl Sync for PyBackedStr {}
+
+impl std::fmt::Display for PyBackedStr {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        self.deref().fmt(f)
+    }
+}
+
+impl_traits!(PyBackedStr, str);
+
 impl TryFrom<Bound<'_, PyString>> for PyBackedStr {
     type Error = PyErr;
     fn try_from(py_string: Bound<'_, PyString>) -> Result<Self, Self::Error> {
         #[cfg(any(Py_3_10, not(Py_LIMITED_API)))]
         {
             let s = py_string.to_str()?;
-            let data = NonNull::from(s.as_bytes());
+            let data = NonNull::from(s);
             Ok(Self {
-                storage: py_string.as_any().to_owned().unbind(),
+                storage: py_string.into_any().unbind(),
                 data,
             })
         }
         #[cfg(not(any(Py_3_10, not(Py_LIMITED_API))))]
         {
             let bytes = py_string.encode_utf8()?;
-            let b = bytes.as_bytes();
-            let data = NonNull::from(b);
+            let s = unsafe { std::str::from_utf8_unchecked(bytes.as_bytes()) };
+            let data = NonNull::from(s);
             Ok(Self {
                 storage: bytes.into_any().unbind(),
                 data,
@@ -52,16 +78,51 @@ impl TryFrom<Bound<'_, PyString>> for PyBackedStr {
     }
 }
 
-impl FromPyObject<'_> for PyBackedStr {
-    fn extract_bound(obj: &Bound<'_, PyAny>) -> PyResult<Self> {
-        let py_string = obj.downcast::<PyString>()?.to_owned();
+impl FromPyObject<'_, '_> for PyBackedStr {
+    type Error = PyErr;
+
+    fn extract(obj: Borrowed<'_, '_, PyAny>) -> Result<Self, Self::Error> {
+        let py_string = obj.cast::<PyString>()?.to_owned();
         Self::try_from(py_string)
     }
 }
 
+impl<'py> IntoPyObject<'py> for PyBackedStr {
+    type Target = PyAny;
+    type Output = Bound<'py, Self::Target>;
+    type Error = Infallible;
+
+    #[cfg(any(Py_3_10, not(Py_LIMITED_API)))]
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        Ok(self.storage.into_bound(py))
+    }
+
+    #[cfg(not(any(Py_3_10, not(Py_LIMITED_API))))]
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        Ok(PyString::new(py, &self).into_any())
+    }
+}
+
+impl<'py> IntoPyObject<'py> for &PyBackedStr {
+    type Target = PyAny;
+    type Output = Bound<'py, Self::Target>;
+    type Error = Infallible;
+
+    #[cfg(any(Py_3_10, not(Py_LIMITED_API)))]
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        Ok(self.storage.bind(py).to_owned())
+    }
+
+    #[cfg(not(any(Py_3_10, not(Py_LIMITED_API))))]
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        Ok(PyString::new(py, self).into_any())
+    }
+}
+
 /// A wrapper around `[u8]` where the storage is either owned by a Python `bytes` object, or a Rust `Box<[u8]>`.
 ///
 /// This type gives access to the underlying data via a `Deref` implementation.
+#[cfg_attr(feature = "py-clone", derive(Clone))]
 pub struct PyBackedBytes {
     #[allow(dead_code)] // only held so that the storage is not dropped
     storage: PyBackedBytesStorage,
@@ -69,9 +130,10 @@ pub struct PyBackedBytes {
 }
 
 #[allow(dead_code)]
+#[cfg_attr(feature = "py-clone", derive(Clone))]
 enum PyBackedBytesStorage {
     Python(Py<PyBytes>),
-    Rust(Box<[u8]>),
+    Rust(Arc<[u8]>),
 }
 
 impl Deref for PyBackedBytes {
@@ -82,6 +144,43 @@ impl Deref for PyBackedBytes {
     }
 }
 
+impl AsRef<[u8]> for PyBackedBytes {
+    fn as_ref(&self) -> &[u8] {
+        self
+    }
+}
+
+// Safety: the underlying Python bytes or Rust bytes is immutable and
+// safe to share between threads
+unsafe impl Send for PyBackedBytes {}
+unsafe impl Sync for PyBackedBytes {}
+
+impl<const N: usize> PartialEq<[u8; N]> for PyBackedBytes {
+    fn eq(&self, other: &[u8; N]) -> bool {
+        self.deref() == other
+    }
+}
+
+impl<const N: usize> PartialEq<PyBackedBytes> for [u8; N] {
+    fn eq(&self, other: &PyBackedBytes) -> bool {
+        self == other.deref()
+    }
+}
+
+impl<const N: usize> PartialEq<&[u8; N]> for PyBackedBytes {
+    fn eq(&self, other: &&[u8; N]) -> bool {
+        self.deref() == *other
+    }
+}
+
+impl<const N: usize> PartialEq<PyBackedBytes> for &[u8; N] {
+    fn eq(&self, other: &PyBackedBytes) -> bool {
+        self == &other.deref()
+    }
+}
+
+impl_traits!(PyBackedBytes, [u8]);
+
 impl From<Bound<'_, PyBytes>> for PyBackedBytes {
     fn from(py_bytes: Bound<'_, PyBytes>) -> Self {
         let b = py_bytes.as_bytes();
@@ -95,7 +194,7 @@ impl From<Bound<'_, PyBytes>> for PyBackedBytes {
 
 impl From<Bound<'_, PyByteArray>> for PyBackedBytes {
     fn from(py_bytearray: Bound<'_, PyByteArray>) -> Self {
-        let s = py_bytearray.to_vec().into_boxed_slice();
+        let s = Arc::<[u8]>::from(py_bytearray.to_vec());
         let data = NonNull::from(s.as_ref());
         Self {
             storage: PyBackedBytesStorage::Rust(s),
@@ -104,27 +203,143 @@ impl From<Bound<'_, PyByteArray>> for PyBackedBytes {
     }
 }
 
-impl FromPyObject<'_> for PyBackedBytes {
-    fn extract_bound(obj: &Bound<'_, PyAny>) -> PyResult<Self> {
-        if let Ok(bytes) = obj.downcast::<PyBytes>() {
+impl<'a, 'py> FromPyObject<'a, 'py> for PyBackedBytes {
+    type Error = CastError<'a, 'py>;
+
+    fn extract(obj: Borrowed<'a, 'py, PyAny>) -> Result<Self, Self::Error> {
+        if let Ok(bytes) = obj.cast::<PyBytes>() {
             Ok(Self::from(bytes.to_owned()))
-        } else if let Ok(bytearray) = obj.downcast::<PyByteArray>() {
+        } else if let Ok(bytearray) = obj.cast::<PyByteArray>() {
             Ok(Self::from(bytearray.to_owned()))
         } else {
-            Err(DowncastError::new(obj, "`bytes` or `bytearray`").into())
+            Err(CastError::new(
+                obj,
+                PyTuple::new(
+                    obj.py(),
+                    [
+                        PyBytes::type_object(obj.py()),
+                        PyByteArray::type_object(obj.py()),
+                    ],
+                )
+                .unwrap()
+                .into_any(),
+            ))
+        }
+    }
+}
+
+impl<'py> IntoPyObject<'py> for PyBackedBytes {
+    type Target = PyBytes;
+    type Output = Bound<'py, Self::Target>;
+    type Error = Infallible;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        match self.storage {
+            PyBackedBytesStorage::Python(bytes) => Ok(bytes.into_bound(py)),
+            PyBackedBytesStorage::Rust(bytes) => Ok(PyBytes::new(py, &bytes)),
+        }
+    }
+}
+
+impl<'py> IntoPyObject<'py> for &PyBackedBytes {
+    type Target = PyBytes;
+    type Output = Bound<'py, Self::Target>;
+    type Error = Infallible;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        match &self.storage {
+            PyBackedBytesStorage::Python(bytes) => Ok(bytes.bind(py).clone()),
+            PyBackedBytesStorage::Rust(bytes) => Ok(PyBytes::new(py, bytes)),
         }
     }
 }
 
+macro_rules! impl_traits {
+    ($slf:ty, $equiv:ty) => {
+        impl std::fmt::Debug for $slf {
+            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                self.deref().fmt(f)
+            }
+        }
+
+        impl PartialEq for $slf {
+            fn eq(&self, other: &Self) -> bool {
+                self.deref() == other.deref()
+            }
+        }
+
+        impl PartialEq<$equiv> for $slf {
+            fn eq(&self, other: &$equiv) -> bool {
+                self.deref() == other
+            }
+        }
+
+        impl PartialEq<&$equiv> for $slf {
+            fn eq(&self, other: &&$equiv) -> bool {
+                self.deref() == *other
+            }
+        }
+
+        impl PartialEq<$slf> for $equiv {
+            fn eq(&self, other: &$slf) -> bool {
+                self == other.deref()
+            }
+        }
+
+        impl PartialEq<$slf> for &$equiv {
+            fn eq(&self, other: &$slf) -> bool {
+                self == &other.deref()
+            }
+        }
+
+        impl Eq for $slf {}
+
+        impl PartialOrd for $slf {
+            fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+                Some(self.cmp(other))
+            }
+        }
+
+        impl PartialOrd<$equiv> for $slf {
+            fn partial_cmp(&self, other: &$equiv) -> Option<std::cmp::Ordering> {
+                self.deref().partial_cmp(other)
+            }
+        }
+
+        impl PartialOrd<$slf> for $equiv {
+            fn partial_cmp(&self, other: &$slf) -> Option<std::cmp::Ordering> {
+                self.partial_cmp(other.deref())
+            }
+        }
+
+        impl Ord for $slf {
+            fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+                self.deref().cmp(other.deref())
+            }
+        }
+
+        impl std::hash::Hash for $slf {
+            fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+                self.deref().hash(state)
+            }
+        }
+    };
+}
+use impl_traits;
+
 #[cfg(test)]
 mod test {
     use super::*;
-    use crate::Python;
+    use crate::impl_::pyclass::{value_of, IsSend, IsSync};
+    use crate::types::PyAnyMethods as _;
+    use crate::{IntoPyObject, Python};
+    use std::collections::hash_map::DefaultHasher;
+    use std::hash::{Hash, Hasher};
 
     #[test]
     fn py_backed_str_empty() {
-        Python::with_gil(|py| {
-            let s = PyString::new_bound(py, "");
+        Python::attach(|py| {
+            let s = PyString::new(py, "");
             let py_backed_str = s.extract::<PyBackedStr>().unwrap();
             assert_eq!(&*py_backed_str, "");
         });
@@ -132,8 +347,8 @@ mod test {
 
     #[test]
     fn py_backed_str() {
-        Python::with_gil(|py| {
-            let s = PyString::new_bound(py, "hello");
+        Python::attach(|py| {
+            let s = PyString::new(py, "hello");
             let py_backed_str = s.extract::<PyBackedStr>().unwrap();
             assert_eq!(&*py_backed_str, "hello");
         });
@@ -141,26 +356,38 @@ mod test {
 
     #[test]
     fn py_backed_str_try_from() {
-        Python::with_gil(|py| {
-            let s = PyString::new_bound(py, "hello");
+        Python::attach(|py| {
+            let s = PyString::new(py, "hello");
             let py_backed_str = PyBackedStr::try_from(s).unwrap();
             assert_eq!(&*py_backed_str, "hello");
         });
     }
 
+    #[test]
+    fn py_backed_str_into_pyobject() {
+        Python::attach(|py| {
+            let orig_str = PyString::new(py, "hello");
+            let py_backed_str = orig_str.extract::<PyBackedStr>().unwrap();
+            let new_str = py_backed_str.into_pyobject(py).unwrap();
+            assert_eq!(new_str.extract::<PyBackedStr>().unwrap(), "hello");
+            #[cfg(any(Py_3_10, not(Py_LIMITED_API)))]
+            assert!(new_str.is(&orig_str));
+        });
+    }
+
     #[test]
     fn py_backed_bytes_empty() {
-        Python::with_gil(|py| {
-            let b = PyBytes::new_bound(py, &[]);
+        Python::attach(|py| {
+            let b = PyBytes::new(py, b"");
             let py_backed_bytes = b.extract::<PyBackedBytes>().unwrap();
-            assert_eq!(&*py_backed_bytes, &[]);
+            assert_eq!(&*py_backed_bytes, b"");
         });
     }
 
     #[test]
     fn py_backed_bytes() {
-        Python::with_gil(|py| {
-            let b = PyBytes::new_bound(py, b"abcde");
+        Python::attach(|py| {
+            let b = PyBytes::new(py, b"abcde");
             let py_backed_bytes = b.extract::<PyBackedBytes>().unwrap();
             assert_eq!(&*py_backed_bytes, b"abcde");
         });
@@ -168,8 +395,8 @@ mod test {
 
     #[test]
     fn py_backed_bytes_from_bytes() {
-        Python::with_gil(|py| {
-            let b = PyBytes::new_bound(py, b"abcde");
+        Python::attach(|py| {
+            let b = PyBytes::new(py, b"abcde");
             let py_backed_bytes = PyBackedBytes::from(b);
             assert_eq!(&*py_backed_bytes, b"abcde");
         });
@@ -177,10 +404,194 @@ mod test {
 
     #[test]
     fn py_backed_bytes_from_bytearray() {
-        Python::with_gil(|py| {
-            let b = PyByteArray::new_bound(py, b"abcde");
+        Python::attach(|py| {
+            let b = PyByteArray::new(py, b"abcde");
             let py_backed_bytes = PyBackedBytes::from(b);
             assert_eq!(&*py_backed_bytes, b"abcde");
         });
     }
+
+    #[test]
+    fn py_backed_bytes_into_pyobject() {
+        Python::attach(|py| {
+            let orig_bytes = PyBytes::new(py, b"abcde");
+            let py_backed_bytes = PyBackedBytes::from(orig_bytes.clone());
+            assert!((&py_backed_bytes)
+                .into_pyobject(py)
+                .unwrap()
+                .is(&orig_bytes));
+        });
+    }
+
+    #[test]
+    fn rust_backed_bytes_into_pyobject() {
+        Python::attach(|py| {
+            let orig_bytes = PyByteArray::new(py, b"abcde");
+            let rust_backed_bytes = PyBackedBytes::from(orig_bytes);
+            assert!(matches!(
+                rust_backed_bytes.storage,
+                PyBackedBytesStorage::Rust(_)
+            ));
+            let to_object = (&rust_backed_bytes).into_pyobject(py).unwrap();
+            assert!(&to_object.is_exact_instance_of::<PyBytes>());
+            assert_eq!(&to_object.extract::<PyBackedBytes>().unwrap(), b"abcde");
+        });
+    }
+
+    #[test]
+    fn test_backed_types_send_sync() {
+        assert!(value_of!(IsSend, PyBackedStr));
+        assert!(value_of!(IsSync, PyBackedStr));
+
+        assert!(value_of!(IsSend, PyBackedBytes));
+        assert!(value_of!(IsSync, PyBackedBytes));
+    }
+
+    #[cfg(feature = "py-clone")]
+    #[test]
+    fn test_backed_str_clone() {
+        Python::attach(|py| {
+            let s1: PyBackedStr = PyString::new(py, "hello").try_into().unwrap();
+            let s2 = s1.clone();
+            assert_eq!(s1, s2);
+
+            drop(s1);
+            assert_eq!(s2, "hello");
+        });
+    }
+
+    #[test]
+    fn test_backed_str_eq() {
+        Python::attach(|py| {
+            let s1: PyBackedStr = PyString::new(py, "hello").try_into().unwrap();
+            let s2: PyBackedStr = PyString::new(py, "hello").try_into().unwrap();
+            assert_eq!(s1, "hello");
+            assert_eq!(s1, s2);
+
+            let s3: PyBackedStr = PyString::new(py, "abcde").try_into().unwrap();
+            assert_eq!("abcde", s3);
+            assert_ne!(s1, s3);
+        });
+    }
+
+    #[test]
+    fn test_backed_str_hash() {
+        Python::attach(|py| {
+            let h = {
+                let mut hasher = DefaultHasher::new();
+                "abcde".hash(&mut hasher);
+                hasher.finish()
+            };
+
+            let s1: PyBackedStr = PyString::new(py, "abcde").try_into().unwrap();
+            let h1 = {
+                let mut hasher = DefaultHasher::new();
+                s1.hash(&mut hasher);
+                hasher.finish()
+            };
+
+            assert_eq!(h, h1);
+        });
+    }
+
+    #[test]
+    fn test_backed_str_ord() {
+        Python::attach(|py| {
+            let mut a = vec!["a", "c", "d", "b", "f", "g", "e"];
+            let mut b = a
+                .iter()
+                .map(|s| PyString::new(py, s).try_into().unwrap())
+                .collect::<Vec<PyBackedStr>>();
+
+            a.sort();
+            b.sort();
+
+            assert_eq!(a, b);
+        })
+    }
+
+    #[cfg(feature = "py-clone")]
+    #[test]
+    fn test_backed_bytes_from_bytes_clone() {
+        Python::attach(|py| {
+            let b1: PyBackedBytes = PyBytes::new(py, b"abcde").into();
+            let b2 = b1.clone();
+            assert_eq!(b1, b2);
+
+            drop(b1);
+            assert_eq!(b2, b"abcde");
+        });
+    }
+
+    #[cfg(feature = "py-clone")]
+    #[test]
+    fn test_backed_bytes_from_bytearray_clone() {
+        Python::attach(|py| {
+            let b1: PyBackedBytes = PyByteArray::new(py, b"abcde").into();
+            let b2 = b1.clone();
+            assert_eq!(b1, b2);
+
+            drop(b1);
+            assert_eq!(b2, b"abcde");
+        });
+    }
+
+    #[test]
+    fn test_backed_bytes_eq() {
+        Python::attach(|py| {
+            let b1: PyBackedBytes = PyBytes::new(py, b"abcde").into();
+            let b2: PyBackedBytes = PyByteArray::new(py, b"abcde").into();
+
+            assert_eq!(b1, b"abcde");
+            assert_eq!(b1, b2);
+
+            let b3: PyBackedBytes = PyBytes::new(py, b"hello").into();
+            assert_eq!(b"hello", b3);
+            assert_ne!(b1, b3);
+        });
+    }
+
+    #[test]
+    fn test_backed_bytes_hash() {
+        Python::attach(|py| {
+            let h = {
+                let mut hasher = DefaultHasher::new();
+                b"abcde".hash(&mut hasher);
+                hasher.finish()
+            };
+
+            let b1: PyBackedBytes = PyBytes::new(py, b"abcde").into();
+            let h1 = {
+                let mut hasher = DefaultHasher::new();
+                b1.hash(&mut hasher);
+                hasher.finish()
+            };
+
+            let b2: PyBackedBytes = PyByteArray::new(py, b"abcde").into();
+            let h2 = {
+                let mut hasher = DefaultHasher::new();
+                b2.hash(&mut hasher);
+                hasher.finish()
+            };
+
+            assert_eq!(h, h1);
+            assert_eq!(h, h2);
+        });
+    }
+
+    #[test]
+    fn test_backed_bytes_ord() {
+        Python::attach(|py| {
+            let mut a = vec![b"a", b"c", b"d", b"b", b"f", b"g", b"e"];
+            let mut b = a
+                .iter()
+                .map(|&b| PyBytes::new(py, b).into())
+                .collect::<Vec<PyBackedBytes>>();
+
+            a.sort();
+            b.sort();
+
+            assert_eq!(a, b);
+        })
+    }
 }
diff --git a/src/pycell.rs b/src/pycell.rs
index 3744c55f67d..a9a282b24f0 100644
--- a/src/pycell.rs
+++ b/src/pycell.rs
@@ -7,22 +7,22 @@
 //! PyO3 deals with these differences by employing the [Interior Mutability]
 //! pattern. This requires that PyO3 enforces the borrowing rules and it has two mechanisms for
 //! doing so:
-//! - Statically it can enforce threadsafe access with the [`Python<'py>`](crate::Python) token.
-//! All Rust code holding that token, or anything derived from it, can assume that they have
-//! safe access to the Python interpreter's state. For this reason all the native Python objects
-//! can be mutated through shared references.
+//! - Statically it can enforce thread-safe access with the [`Python<'py>`](crate::Python) token.
+//!   All Rust code holding that token, or anything derived from it, can assume that they have
+//!   safe access to the Python interpreter's state. For this reason all the native Python objects
+//!   can be mutated through shared references.
 //! - However, methods and functions in Rust usually *do* need `&mut` references. While PyO3 can
-//! use the [`Python<'py>`](crate::Python) token to guarantee thread-safe access to them, it cannot
-//! statically guarantee uniqueness of `&mut` references. As such those references have to be tracked
-//! dynamically at runtime, using [`PyCell`] and the other types defined in this module. This works
-//! similar to std's [`RefCell`](std::cell::RefCell) type.
+//!   use the [`Python<'py>`](crate::Python) token to guarantee thread-safe access to them, it cannot
+//!   statically guarantee uniqueness of `&mut` references. As such those references have to be tracked
+//!   dynamically at runtime, using `PyCell` and the other types defined in this module. This works
+//!   similar to std's [`RefCell`](std::cell::RefCell) type.
 //!
 //! # When *not* to use PyCell
 //!
 //! Usually you can use `&mut` references as method and function receivers and arguments, and you
-//! won't need to use [`PyCell`] directly:
+//! won't need to use `PyCell` directly:
 //!
-//! ```rust
+//! ```rust,no_run
 //! use pyo3::prelude::*;
 //!
 //! #[pyclass]
@@ -39,9 +39,9 @@
 //! ```
 //!
 //! The [`#[pymethods]`](crate::pymethods) proc macro will generate this wrapper function (and more),
-//! using [`PyCell`] under the hood:
+//! using `PyCell` under the hood:
 //!
-//! ```rust
+//! ```rust,ignore
 //! # use pyo3::prelude::*;
 //! # #[pyclass]
 //! # struct Number {
@@ -62,12 +62,13 @@
 //! ) -> *mut pyo3::ffi::PyObject {
 //!     use :: pyo3 as _pyo3;
 //!     _pyo3::impl_::trampoline::noargs(_slf, _args, |py, _slf| {
+//! #       #[allow(deprecated)]
 //!         let _cell = py
 //!             .from_borrowed_ptr::<_pyo3::PyAny>(_slf)
-//!             .downcast::<_pyo3::PyCell<Number>>()?;
+//!             .cast::<_pyo3::PyCell<Number>>()?;
 //!         let mut _ref = _cell.try_borrow_mut()?;
 //!         let _slf: &mut Number = &mut *_ref;
-//!         _pyo3::callback::convert(py, Number::increment(_slf))
+//!         _pyo3::impl_::callback::convert(py, Number::increment(_slf))
 //!     })
 //! }
 //! ```
@@ -75,7 +76,7 @@
 //! # When to use PyCell
 //! ## Using pyclasses from Rust
 //!
-//! However, we *do* need [`PyCell`] if we want to call its methods from Rust:
+//! However, we *do* need `PyCell` if we want to call its methods from Rust:
 //! ```rust
 //! # use pyo3::prelude::*;
 //! #
@@ -91,12 +92,12 @@
 //! #     }
 //! # }
 //! # fn main() -> PyResult<()> {
-//! Python::with_gil(|py| {
+//! Python::attach(|py| {
 //!     let n = Py::new(py, Number { inner: 0 })?;
 //!
 //!     // We borrow the guard and then dereference
 //!     // it to get a mutable reference to Number
-//!     let mut guard: PyRefMut<'_, Number> = n.as_ref(py).borrow_mut();
+//!     let mut guard: PyRefMut<'_, Number> = n.bind(py).borrow_mut();
 //!     let n_mutable: &mut Number = &mut *guard;
 //!
 //!     n_mutable.increment();
@@ -105,7 +106,7 @@
 //!     // `PyRefMut` before borrowing again.
 //!     drop(guard);
 //!
-//!     let n_immutable: &Number = &n.as_ref(py).borrow();
+//!     let n_immutable: &Number = &n.bind(py).borrow();
 //!     assert_eq!(n_immutable.inner, 1);
 //!
 //!     Ok(())
@@ -114,7 +115,7 @@
 //! ```
 //! ## Dealing with possibly overlapping mutable references
 //!
-//! It is also necessary to use [`PyCell`] if you can receive mutable arguments that may overlap.
+//! It is also necessary to use `PyCell` if you can receive mutable arguments that may overlap.
 //! Suppose the following function that swaps the values of two `Number`s:
 //! ```
 //! # use pyo3::prelude::*;
@@ -127,7 +128,7 @@
 //!     std::mem::swap(&mut a.inner, &mut b.inner);
 //! }
 //! # fn main() {
-//! #     Python::with_gil(|py| {
+//! #     Python::attach(|py| {
 //! #         let n = Py::new(py, Number{inner: 35}).unwrap();
 //! #         let n2 = n.clone_ref(py);
 //! #         assert!(n.is(&n2));
@@ -147,7 +148,8 @@
 //! ```
 //!
 //! It is better to write that function like this:
-//! ```rust
+//! ```rust,ignore
+//! # #![allow(deprecated)]
 //! # use pyo3::prelude::*;
 //! # #[pyclass]
 //! # pub struct Number {
@@ -164,7 +166,7 @@
 //! }
 //! # fn main() {
 //! #     // With duplicate numbers
-//! #     Python::with_gil(|py| {
+//! #     Python::attach(|py| {
 //! #         let n = Py::new(py, Number{inner: 35}).unwrap();
 //! #         let n2 = n.clone_ref(py);
 //! #         assert!(n.is(&n2));
@@ -173,7 +175,7 @@
 //! #     });
 //! #
 //! #     // With two different numbers
-//! #     Python::with_gil(|py| {
+//! #     Python::attach(|py| {
 //! #         let n = Py::new(py, Number{inner: 35}).unwrap();
 //! #         let n2 = Py::new(py, Number{inner: 42}).unwrap();
 //! #         assert!(!n.is(&n2));
@@ -191,426 +193,30 @@
 //! [guide]: https://pyo3.rs/latest/class.html#pycell-and-interior-mutability "PyCell and interior mutability"
 //! [Interior Mutability]: https://doc.rust-lang.org/book/ch15-05-interior-mutability.html "RefCell<T> and the Interior Mutability Pattern - The Rust Programming Language"
 
+use crate::conversion::IntoPyObject;
 use crate::exceptions::PyRuntimeError;
-use crate::impl_::pyclass::{
-    PyClassBaseType, PyClassDict, PyClassImpl, PyClassThreadChecker, PyClassWeakRef,
-};
-use crate::pyclass::{
-    boolean_struct::{False, True},
-    PyClass,
-};
-use crate::pyclass_init::PyClassInitializer;
-use crate::type_object::{PyLayout, PySizedLayout};
-use crate::types::PyAny;
-use crate::{
-    conversion::{AsPyPointer, FromPyPointer, ToPyObject},
-    type_object::get_tp_free,
-    PyTypeInfo,
-};
-use crate::{ffi, Bound, IntoPy, PyErr, PyNativeType, PyObject, PyResult, PyTypeCheck, Python};
-use std::cell::UnsafeCell;
+use crate::ffi_ptr_ext::FfiPtrExt;
+use crate::pyclass::{boolean_struct::False, PyClass};
+use crate::{ffi, Borrowed, Bound, PyErr, Python};
+use std::convert::Infallible;
 use std::fmt;
 use std::mem::ManuallyDrop;
 use std::ops::{Deref, DerefMut};
+use std::ptr::NonNull;
 
 pub(crate) mod impl_;
-use impl_::{GetBorrowChecker, PyClassBorrowChecker, PyClassMutability};
-
-/// Base layout of PyCell.
-#[doc(hidden)]
-#[repr(C)]
-pub struct PyCellBase<T> {
-    ob_base: T,
-}
-
-unsafe impl<T, U> PyLayout<T> for PyCellBase<U> where U: PySizedLayout<T> {}
-
-/// A container type for (mutably) accessing [`PyClass`] values
-///
-/// `PyCell` autodereferences to [`PyAny`], so you can call `PyAny`'s methods on a `PyCell<T>`.
-///
-/// # Examples
-///
-/// This example demonstrates getting a mutable reference of the contained `PyClass`.
-/// ```rust
-/// use pyo3::prelude::*;
-///
-/// #[pyclass]
-/// struct Number {
-///     inner: u32,
-/// }
-///
-/// #[pymethods]
-/// impl Number {
-///     fn increment(&mut self) {
-///         self.inner += 1;
-///     }
-/// }
-///
-/// # fn main() -> PyResult<()> {
-/// Python::with_gil(|py| {
-///     let n = PyCell::new(py, Number { inner: 0 })?;
-///
-///     let n_mutable: &mut Number = &mut n.borrow_mut();
-///     n_mutable.increment();
-///
-///     Ok(())
-/// })
-/// # }
-/// ```
-/// For more information on how, when and why (not) to use `PyCell` please see the
-/// [module-level documentation](self).
-#[repr(C)]
-pub struct PyCell<T: PyClassImpl> {
-    ob_base: <T::BaseType as PyClassBaseType>::LayoutAsBase,
-    contents: PyCellContents<T>,
-}
-
-#[repr(C)]
-pub(crate) struct PyCellContents<T: PyClassImpl> {
-    pub(crate) value: ManuallyDrop<UnsafeCell<T>>,
-    pub(crate) borrow_checker: <T::PyClassMutability as PyClassMutability>::Storage,
-    pub(crate) thread_checker: T::ThreadChecker,
-    pub(crate) dict: T::Dict,
-    pub(crate) weakref: T::WeakRef,
-}
-
-unsafe impl<T: PyClass> PyNativeType for PyCell<T> {
-    type AsRefSource = T;
-}
-
-impl<T: PyClass> PyCell<T> {
-    /// Makes a new `PyCell` on the Python heap and return the reference to it.
-    ///
-    /// In cases where the value in the cell does not need to be accessed immediately after
-    /// creation, consider [`Py::new`](crate::Py::new) as a more efficient alternative.
-    pub fn new(py: Python<'_>, value: impl Into<PyClassInitializer<T>>) -> PyResult<&Self> {
-        unsafe {
-            let initializer = value.into();
-            let self_ = initializer.create_cell(py)?;
-            FromPyPointer::from_owned_ptr_or_err(py, self_ as _)
-        }
-    }
-
-    /// Immutably borrows the value `T`. This borrow lasts as long as the returned `PyRef` exists.
-    ///
-    /// For frozen classes, the simpler [`get`][Self::get] is available.
-    ///
-    /// # Panics
-    ///
-    /// Panics if the value is currently mutably borrowed. For a non-panicking variant, use
-    /// [`try_borrow`](#method.try_borrow).
-    pub fn borrow(&self) -> PyRef<'_, T> {
-        self.try_borrow().expect("Already mutably borrowed")
-    }
-
-    /// Mutably borrows the value `T`. This borrow lasts as long as the returned `PyRefMut` exists.
-    ///
-    /// # Panics
-    ///
-    /// Panics if the value is currently borrowed. For a non-panicking variant, use
-    /// [`try_borrow_mut`](#method.try_borrow_mut).
-    pub fn borrow_mut(&self) -> PyRefMut<'_, T>
-    where
-        T: PyClass<Frozen = False>,
-    {
-        self.try_borrow_mut().expect("Already borrowed")
-    }
-
-    /// Immutably borrows the value `T`, returning an error if the value is currently
-    /// mutably borrowed. This borrow lasts as long as the returned `PyRef` exists.
-    ///
-    /// This is the non-panicking variant of [`borrow`](#method.borrow).
-    ///
-    /// For frozen classes, the simpler [`get`][Self::get] is available.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use pyo3::prelude::*;
-    /// #[pyclass]
-    /// struct Class {}
-    ///
-    /// Python::with_gil(|py| {
-    ///     let c = PyCell::new(py, Class {}).unwrap();
-    ///     {
-    ///         let m = c.borrow_mut();
-    ///         assert!(c.try_borrow().is_err());
-    ///     }
-    ///
-    ///     {
-    ///         let m = c.borrow();
-    ///         assert!(c.try_borrow().is_ok());
-    ///     }
-    /// });
-    /// ```
-    pub fn try_borrow(&self) -> Result<PyRef<'_, T>, PyBorrowError> {
-        self.ensure_threadsafe();
-        self.borrow_checker()
-            .try_borrow()
-            .map(|_| PyRef { inner: self })
-    }
-
-    /// Variant of [`try_borrow`][Self::try_borrow] which fails instead of panicking if called from the wrong thread
-    pub(crate) fn try_borrow_threadsafe(&self) -> Result<PyRef<'_, T>, PyBorrowError> {
-        self.check_threadsafe()?;
-        self.borrow_checker()
-            .try_borrow()
-            .map(|_| PyRef { inner: self })
-    }
-
-    /// Mutably borrows the value `T`, returning an error if the value is currently borrowed.
-    /// This borrow lasts as long as the returned `PyRefMut` exists.
-    ///
-    /// This is the non-panicking variant of [`borrow_mut`](#method.borrow_mut).
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use pyo3::prelude::*;
-    /// #[pyclass]
-    /// struct Class {}
-    /// Python::with_gil(|py| {
-    ///     let c = PyCell::new(py, Class {}).unwrap();
-    ///     {
-    ///         let m = c.borrow();
-    ///         assert!(c.try_borrow_mut().is_err());
-    ///     }
-    ///
-    ///     assert!(c.try_borrow_mut().is_ok());
-    /// });
-    /// ```
-    pub fn try_borrow_mut(&self) -> Result<PyRefMut<'_, T>, PyBorrowMutError>
-    where
-        T: PyClass<Frozen = False>,
-    {
-        self.ensure_threadsafe();
-        self.borrow_checker()
-            .try_borrow_mut()
-            .map(|_| PyRefMut { inner: self })
-    }
-
-    /// Immutably borrows the value `T`, returning an error if the value is
-    /// currently mutably borrowed.
-    ///
-    /// # Safety
-    ///
-    /// This method is unsafe because it does not return a `PyRef`,
-    /// thus leaving the borrow flag untouched. Mutably borrowing the `PyCell`
-    /// while the reference returned by this method is alive is undefined behaviour.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use pyo3::prelude::*;
-    /// #[pyclass]
-    /// struct Class {}
-    /// Python::with_gil(|py| {
-    ///     let c = PyCell::new(py, Class {}).unwrap();
-    ///
-    ///     {
-    ///         let m = c.borrow_mut();
-    ///         assert!(unsafe { c.try_borrow_unguarded() }.is_err());
-    ///     }
-    ///
-    ///     {
-    ///         let m = c.borrow();
-    ///         assert!(unsafe { c.try_borrow_unguarded() }.is_ok());
-    ///     }
-    /// });
-    /// ```
-    pub unsafe fn try_borrow_unguarded(&self) -> Result<&T, PyBorrowError> {
-        self.ensure_threadsafe();
-        self.borrow_checker()
-            .try_borrow_unguarded()
-            .map(|_: ()| &*self.contents.value.get())
-    }
-
-    /// Provide an immutable borrow of the value `T` without acquiring the GIL.
-    ///
-    /// This is available if the class is [`frozen`][macro@crate::pyclass] and [`Sync`].
-    ///
-    /// While the GIL is usually required to get access to `&PyCell<T>`,
-    /// compared to [`borrow`][Self::borrow] or [`try_borrow`][Self::try_borrow]
-    /// this avoids any thread or borrow checking overhead at runtime.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::sync::atomic::{AtomicUsize, Ordering};
-    /// # use pyo3::prelude::*;
-    ///
-    /// #[pyclass(frozen)]
-    /// struct FrozenCounter {
-    ///     value: AtomicUsize,
-    /// }
-    ///
-    /// Python::with_gil(|py| {
-    ///     let counter = FrozenCounter { value: AtomicUsize::new(0) };
-    ///
-    ///     let cell = PyCell::new(py, counter).unwrap();
-    ///
-    ///     cell.get().value.fetch_add(1, Ordering::Relaxed);
-    /// });
-    /// ```
-    pub fn get(&self) -> &T
-    where
-        T: PyClass<Frozen = True> + Sync,
-    {
-        // SAFETY: The class itself is frozen and `Sync` and we do not access anything but `self.contents.value`.
-        unsafe { &*self.get_ptr() }
-    }
-
-    /// Replaces the wrapped value with a new one, returning the old value.
-    ///
-    /// # Panics
-    ///
-    /// Panics if the value is currently borrowed.
-    #[inline]
-    pub fn replace(&self, t: T) -> T
-    where
-        T: PyClass<Frozen = False>,
-    {
-        std::mem::replace(&mut *self.borrow_mut(), t)
-    }
-
-    /// Replaces the wrapped value with a new one computed from `f`, returning the old value.
-    ///
-    /// # Panics
-    ///
-    /// Panics if the value is currently borrowed.
-    pub fn replace_with<F: FnOnce(&mut T) -> T>(&self, f: F) -> T
-    where
-        T: PyClass<Frozen = False>,
-    {
-        let mut_borrow = &mut *self.borrow_mut();
-        let replacement = f(mut_borrow);
-        std::mem::replace(mut_borrow, replacement)
-    }
-
-    /// Swaps the wrapped value of `self` with the wrapped value of `other`.
-    ///
-    /// # Panics
-    ///
-    /// Panics if the value in either `PyCell` is currently borrowed.
-    #[inline]
-    pub fn swap(&self, other: &Self)
-    where
-        T: PyClass<Frozen = False>,
-    {
-        std::mem::swap(&mut *self.borrow_mut(), &mut *other.borrow_mut())
-    }
-
-    pub(crate) fn get_ptr(&self) -> *mut T {
-        self.contents.value.get()
-    }
-
-    /// Gets the offset of the dictionary from the start of the struct in bytes.
-    pub(crate) fn dict_offset() -> ffi::Py_ssize_t {
-        use memoffset::offset_of;
-
-        let offset = offset_of!(PyCell<T>, contents) + offset_of!(PyCellContents<T>, dict);
-
-        // Py_ssize_t may not be equal to isize on all platforms
-        #[allow(clippy::useless_conversion)]
-        offset.try_into().expect("offset should fit in Py_ssize_t")
-    }
-
-    /// Gets the offset of the weakref list from the start of the struct in bytes.
-    pub(crate) fn weaklist_offset() -> ffi::Py_ssize_t {
-        use memoffset::offset_of;
-
-        let offset = offset_of!(PyCell<T>, contents) + offset_of!(PyCellContents<T>, weakref);
-
-        // Py_ssize_t may not be equal to isize on all platforms
-        #[allow(clippy::useless_conversion)]
-        offset.try_into().expect("offset should fit in Py_ssize_t")
-    }
-
-    #[cfg(feature = "macros")]
-    pub(crate) fn release_ref(&self) {
-        self.borrow_checker().release_borrow();
-    }
-
-    #[cfg(feature = "macros")]
-    pub(crate) fn release_mut(&self) {
-        self.borrow_checker().release_borrow_mut();
-    }
-}
-
-impl<T: PyClassImpl> PyCell<T> {
-    fn borrow_checker(&self) -> &<T::PyClassMutability as PyClassMutability>::Checker {
-        T::PyClassMutability::borrow_checker(self)
-    }
-}
-
-unsafe impl<T: PyClassImpl> PyLayout<T> for PyCell<T> {}
-impl<T: PyClass> PySizedLayout<T> for PyCell<T> {}
-
-impl<T> PyTypeCheck for PyCell<T>
-where
-    T: PyClass,
-{
-    const NAME: &'static str = <T as PyTypeCheck>::NAME;
-
-    fn type_check(object: &Bound<'_, PyAny>) -> bool {
-        <T as PyTypeCheck>::type_check(object)
-    }
-}
-
-unsafe impl<T: PyClass> AsPyPointer for PyCell<T> {
-    fn as_ptr(&self) -> *mut ffi::PyObject {
-        (self as *const _) as *mut _
-    }
-}
-
-impl<T: PyClass> ToPyObject for &PyCell<T> {
-    fn to_object(&self, py: Python<'_>) -> PyObject {
-        unsafe { PyObject::from_borrowed_ptr(py, self.as_ptr()) }
-    }
-}
-
-impl<T: PyClass> AsRef<PyAny> for PyCell<T> {
-    fn as_ref(&self) -> &PyAny {
-        unsafe { self.py().from_borrowed_ptr(self.as_ptr()) }
-    }
-}
-
-impl<T: PyClass> Deref for PyCell<T> {
-    type Target = PyAny;
+#[cfg(feature = "experimental-inspect")]
+use crate::inspect::TypeHint;
+use impl_::{PyClassBorrowChecker, PyClassObjectLayout};
 
-    fn deref(&self) -> &PyAny {
-        unsafe { self.py().from_borrowed_ptr(self.as_ptr()) }
-    }
-}
-
-impl<T: PyClass + fmt::Debug> fmt::Debug for PyCell<T> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self.try_borrow() {
-            Ok(borrow) => f.debug_struct("RefCell").field("value", &borrow).finish(),
-            Err(_) => {
-                struct BorrowedPlaceholder;
-                impl fmt::Debug for BorrowedPlaceholder {
-                    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-                        f.write_str("<borrowed>")
-                    }
-                }
-                f.debug_struct("RefCell")
-                    .field("value", &BorrowedPlaceholder)
-                    .finish()
-            }
-        }
-    }
-}
-
-/// A wrapper type for an immutably borrowed value from a [`PyCell`]`<T>`.
+/// A wrapper type for an immutably borrowed value from a [`Bound<'py, T>`].
 ///
-/// See the [`PyCell`] documentation for more information.
+/// See the [`Bound`] documentation for more information.
 ///
 /// # Examples
 ///
-/// You can use `PyRef` as an alternative to a `&self` receiver when
-/// - you need to access the pointer of the `PyCell`, or
+/// You can use [`PyRef`] as an alternative to a `&self` receiver when
+/// - you need to access the pointer of the [`Bound`], or
 /// - you want to get a super class.
 /// ```
 /// # use pyo3::prelude::*;
@@ -639,15 +245,18 @@ impl<T: PyClass + fmt::Debug> fmt::Debug for PyCell<T> {
 ///         format!("{}(base: {}, cnt: {})", slf.name, basename, refcnt)
 ///     }
 /// }
-/// # Python::with_gil(|py| {
-/// #     let sub = PyCell::new(py, Child::new()).unwrap();
-/// #     pyo3::py_run!(py, sub, "assert sub.format() == 'Caterpillar(base: Butterfly, cnt: 3)'");
+/// # Python::attach(|py| {
+/// #     let sub = Py::new(py, Child::new()).unwrap();
+/// #     pyo3::py_run!(py, sub, "assert sub.format() == 'Caterpillar(base: Butterfly, cnt: 4)', sub.format()");
 /// # });
 /// ```
 ///
 /// See the [module-level documentation](self) for more information.
+#[repr(transparent)]
 pub struct PyRef<'p, T: PyClass> {
-    inner: &'p PyCell<T>,
+    // TODO: once the GIL Ref API is removed, consider adding a lifetime parameter to `PyRef` to
+    // store `Borrowed` here instead, avoiding reference counting overhead.
+    inner: Bound<'p, T>,
 }
 
 impl<'p, T: PyClass> PyRef<'p, T> {
@@ -657,17 +266,17 @@ impl<'p, T: PyClass> PyRef<'p, T> {
     }
 }
 
-impl<'p, T, U> AsRef<U> for PyRef<'p, T>
+impl<T, U> AsRef<U> for PyRef<'_, T>
 where
     T: PyClass<BaseType = U>,
     U: PyClass,
 {
     fn as_ref(&self) -> &T::BaseType {
-        unsafe { &*self.inner.ob_base.get_ptr() }
+        self.as_super()
     }
 }
 
-impl<'p, T: PyClass> PyRef<'p, T> {
+impl<'py, T: PyClass> PyRef<'py, T> {
     /// Returns the raw FFI pointer represented by self.
     ///
     /// # Safety
@@ -689,7 +298,20 @@ impl<'p, T: PyClass> PyRef<'p, T> {
     /// of the pointer or decrease the reference count (e.g. with [`pyo3::ffi::Py_DecRef`](crate::ffi::Py_DecRef)).
     #[inline]
     pub fn into_ptr(self) -> *mut ffi::PyObject {
-        self.inner.into_ptr()
+        self.inner.clone().into_ptr()
+    }
+
+    #[track_caller]
+    pub(crate) fn borrow(obj: &Bound<'py, T>) -> Self {
+        Self::try_borrow(obj).expect("Already mutably borrowed")
+    }
+
+    pub(crate) fn try_borrow(obj: &Bound<'py, T>) -> Result<Self, PyBorrowError> {
+        let cell = obj.get_class_object();
+        cell.ensure_threadsafe();
+        cell.borrow_checker()
+            .try_borrow()
+            .map(|_| Self { inner: obj.clone() })
     }
 }
 
@@ -738,57 +360,143 @@ where
     ///         format!("{} {} {}", super_.as_ref().name1, super_.name2, subname)
     ///     }
     /// }
-    /// # Python::with_gil(|py| {
-    /// #     let sub = PyCell::new(py, Sub::new()).unwrap();
+    /// # Python::attach(|py| {
+    /// #     let sub = Py::new(py, Sub::new()).unwrap();
     /// #     pyo3::py_run!(py, sub, "assert sub.name() == 'base1 base2 sub'")
     /// # });
     /// ```
     pub fn into_super(self) -> PyRef<'p, U> {
-        let PyRef { inner } = self;
-        std::mem::forget(self);
+        let py = self.py();
+        let t_not_frozen = !<T::Frozen as crate::pyclass::boolean_struct::private::Boolean>::VALUE;
+        let u_frozen = <U::Frozen as crate::pyclass::boolean_struct::private::Boolean>::VALUE;
+        if t_not_frozen && u_frozen {
+            // If `T` is mutable subclass of `U` differ, then it is possible that we need to
+            // release the borrow count now. (e.g. `U` may have a noop borrow checker so
+            // dropping the `PyRef<U>` later would noop and leak the borrow we currently hold.)
+            //
+            // However it's nontrivial, if `U` itself has a mutable base class `V`,
+            // then the borrow checker of both `T` and `U` is the shared borrow checker of `V`.
+            //
+            // But it's really hard to prove that in the type system, the soundest thing we
+            // can do is just add a borrow to `U` now and then release the borrow of `T`.
+
+            self.inner
+                .as_super()
+                .get_class_object()
+                .borrow_checker()
+                .try_borrow()
+                .expect("this object is already borrowed");
+
+            self.inner
+                .get_class_object()
+                .borrow_checker()
+                .release_borrow()
+        };
         PyRef {
-            inner: &inner.ob_base,
+            inner: unsafe {
+                ManuallyDrop::new(self)
+                    .as_ptr()
+                    .assume_owned_unchecked(py)
+                    .cast_into_unchecked()
+            },
         }
     }
+
+    /// Borrows a shared reference to `PyRef<T::BaseType>`.
+    ///
+    /// With the help of this method, you can access attributes and call methods
+    /// on the superclass without consuming the `PyRef<T>`. This method can also
+    /// be chained to access the super-superclass (and so on).
+    ///
+    /// # Examples
+    /// ```
+    /// # use pyo3::prelude::*;
+    /// #[pyclass(subclass)]
+    /// struct Base {
+    ///     base_name: &'static str,
+    /// }
+    /// #[pymethods]
+    /// impl Base {
+    ///     fn base_name_len(&self) -> usize {
+    ///         self.base_name.len()
+    ///     }
+    /// }
+    ///
+    /// #[pyclass(extends=Base)]
+    /// struct Sub {
+    ///     sub_name: &'static str,
+    /// }
+    ///
+    /// #[pymethods]
+    /// impl Sub {
+    ///     #[new]
+    ///     fn new() -> (Self, Base) {
+    ///         (Self { sub_name: "sub_name" }, Base { base_name: "base_name" })
+    ///     }
+    ///     fn sub_name_len(&self) -> usize {
+    ///         self.sub_name.len()
+    ///     }
+    ///     fn format_name_lengths(slf: PyRef<'_, Self>) -> String {
+    ///         format!("{} {}", slf.as_super().base_name_len(), slf.sub_name_len())
+    ///     }
+    /// }
+    /// # Python::attach(|py| {
+    /// #     let sub = Py::new(py, Sub::new()).unwrap();
+    /// #     pyo3::py_run!(py, sub, "assert sub.format_name_lengths() == '9 8'")
+    /// # });
+    /// ```
+    pub fn as_super(&self) -> &PyRef<'p, U> {
+        let ptr = NonNull::from(&self.inner)
+            // `Bound<T>` has the same layout as `Bound<T::BaseType>`
+            .cast::<Bound<'p, T::BaseType>>()
+            // `Bound<T::BaseType>` has the same layout as `PyRef<T::BaseType>`
+            .cast::<PyRef<'p, T::BaseType>>();
+        // SAFETY: lifetimes are correctly transferred, and `PyRef<T>` and `PyRef<U>` have the same layout
+        unsafe { ptr.as_ref() }
+    }
 }
 
-impl<'p, T: PyClass> Deref for PyRef<'p, T> {
+impl<T: PyClass> Deref for PyRef<'_, T> {
     type Target = T;
 
     #[inline]
     fn deref(&self) -> &T {
-        unsafe { &*self.inner.get_ptr() }
+        unsafe { &*self.inner.get_class_object().get_ptr() }
     }
 }
 
-impl<'p, T: PyClass> Drop for PyRef<'p, T> {
+impl<T: PyClass> Drop for PyRef<'_, T> {
     fn drop(&mut self) {
-        self.inner.borrow_checker().release_borrow()
+        self.inner
+            .get_class_object()
+            .borrow_checker()
+            .release_borrow()
     }
 }
 
-impl<T: PyClass> IntoPy<PyObject> for PyRef<'_, T> {
-    fn into_py(self, py: Python<'_>) -> PyObject {
-        unsafe { PyObject::from_borrowed_ptr(py, self.inner.as_ptr()) }
-    }
-}
+impl<'py, T: PyClass> IntoPyObject<'py> for PyRef<'py, T> {
+    type Target = T;
+    type Output = Bound<'py, T>;
+    type Error = Infallible;
 
-impl<T: PyClass> IntoPy<PyObject> for &'_ PyRef<'_, T> {
-    fn into_py(self, py: Python<'_>) -> PyObject {
-        self.inner.into_py(py)
-    }
-}
+    #[cfg(feature = "experimental-inspect")]
+    const OUTPUT_TYPE: TypeHint = T::TYPE_HINT;
 
-impl<'a, T: PyClass> std::convert::TryFrom<&'a PyCell<T>> for crate::PyRef<'a, T> {
-    type Error = PyBorrowError;
-    fn try_from(cell: &'a crate::PyCell<T>) -> Result<Self, Self::Error> {
-        cell.try_borrow()
+    fn into_pyobject(self, _py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        Ok(self.inner.clone())
     }
 }
 
-unsafe impl<'a, T: PyClass> AsPyPointer for PyRef<'a, T> {
-    fn as_ptr(&self) -> *mut ffi::PyObject {
-        self.inner.as_ptr()
+impl<'a, 'py, T: PyClass> IntoPyObject<'py> for &'a PyRef<'py, T> {
+    type Target = T;
+    type Output = Borrowed<'a, 'py, T>;
+    type Error = Infallible;
+
+    #[cfg(feature = "experimental-inspect")]
+    const OUTPUT_TYPE: TypeHint = T::TYPE_HINT;
+
+    fn into_pyobject(self, _py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        Ok(self.inner.as_borrowed())
     }
 }
 
@@ -798,11 +506,14 @@ impl<T: PyClass + fmt::Debug> fmt::Debug for PyRef<'_, T> {
     }
 }
 
-/// A wrapper type for a mutably borrowed value from a[`PyCell`]`<T>`.
+/// A wrapper type for a mutably borrowed value from a [`Bound<'py, T>`].
 ///
 /// See the [module-level documentation](self) for more information.
+#[repr(transparent)]
 pub struct PyRefMut<'p, T: PyClass<Frozen = False>> {
-    inner: &'p PyCell<T>,
+    // TODO: once the GIL Ref API is removed, consider adding a lifetime parameter to `PyRef` to
+    // store `Borrowed` here instead, avoiding reference counting overhead.
+    inner: Bound<'p, T>,
 }
 
 impl<'p, T: PyClass<Frozen = False>> PyRefMut<'p, T> {
@@ -812,27 +523,27 @@ impl<'p, T: PyClass<Frozen = False>> PyRefMut<'p, T> {
     }
 }
 
-impl<'p, T, U> AsRef<U> for PyRefMut<'p, T>
+impl<T, U> AsRef<U> for PyRefMut<'_, T>
 where
     T: PyClass<BaseType = U, Frozen = False>,
     U: PyClass<Frozen = False>,
 {
     fn as_ref(&self) -> &T::BaseType {
-        unsafe { &*self.inner.ob_base.get_ptr() }
+        PyRefMut::downgrade(self).as_super()
     }
 }
 
-impl<'p, T, U> AsMut<U> for PyRefMut<'p, T>
+impl<T, U> AsMut<U> for PyRefMut<'_, T>
 where
     T: PyClass<BaseType = U, Frozen = False>,
     U: PyClass<Frozen = False>,
 {
     fn as_mut(&mut self) -> &mut T::BaseType {
-        unsafe { &mut *self.inner.ob_base.get_ptr() }
+        self.as_super()
     }
 }
 
-impl<'p, T: PyClass<Frozen = False>> PyRefMut<'p, T> {
+impl<'py, T: PyClass<Frozen = False>> PyRefMut<'py, T> {
     /// Returns the raw FFI pointer represented by self.
     ///
     /// # Safety
@@ -854,7 +565,27 @@ impl<'p, T: PyClass<Frozen = False>> PyRefMut<'p, T> {
     /// of the pointer or decrease the reference count (e.g. with [`pyo3::ffi::Py_DecRef`](crate::ffi::Py_DecRef)).
     #[inline]
     pub fn into_ptr(self) -> *mut ffi::PyObject {
-        self.inner.into_ptr()
+        self.inner.clone().into_ptr()
+    }
+
+    #[inline]
+    #[track_caller]
+    pub(crate) fn borrow(obj: &Bound<'py, T>) -> Self {
+        Self::try_borrow(obj).expect("Already borrowed")
+    }
+
+    pub(crate) fn try_borrow(obj: &Bound<'py, T>) -> Result<Self, PyBorrowMutError> {
+        let cell = obj.get_class_object();
+        cell.ensure_threadsafe();
+        cell.borrow_checker()
+            .try_borrow_mut()
+            .map(|_| Self { inner: obj.clone() })
+    }
+
+    pub(crate) fn downgrade(slf: &Self) -> &PyRef<'py, T> {
+        let ptr = NonNull::from(slf).cast();
+        // SAFETY: `PyRefMut<T>` and `PyRef<T>` have the same layout
+        unsafe { ptr.as_ref() }
     }
 }
 
@@ -867,60 +598,84 @@ where
     ///
     /// See [`PyRef::into_super`] for more.
     pub fn into_super(self) -> PyRefMut<'p, U> {
-        let PyRefMut { inner } = self;
-        std::mem::forget(self);
+        let py = self.py();
         PyRefMut {
-            inner: &inner.ob_base,
+            inner: unsafe {
+                ManuallyDrop::new(self)
+                    .as_ptr()
+                    .assume_owned_unchecked(py)
+                    .cast_into_unchecked()
+            },
         }
     }
+
+    /// Borrows a mutable reference to `PyRefMut<T::BaseType>`.
+    ///
+    /// With the help of this method, you can mutate attributes and call mutating
+    /// methods on the superclass without consuming the `PyRefMut<T>`. This method
+    /// can also be chained to access the super-superclass (and so on).
+    ///
+    /// See [`PyRef::as_super`] for more.
+    pub fn as_super(&mut self) -> &mut PyRefMut<'p, U> {
+        let mut ptr = NonNull::from(&mut self.inner)
+            // `Bound<T>` has the same layout as `Bound<T::BaseType>`
+            .cast::<Bound<'p, T::BaseType>>()
+            // `Bound<T::BaseType>` has the same layout as `PyRefMut<T::BaseType>`,
+            // and the mutable borrow on `self` prevents aliasing
+            .cast::<PyRefMut<'p, T::BaseType>>();
+        // SAFETY: lifetimes are correctly transferred, and `PyRefMut<T>` and `PyRefMut<U>` have the same layout
+        unsafe { ptr.as_mut() }
+    }
 }
 
-impl<'p, T: PyClass<Frozen = False>> Deref for PyRefMut<'p, T> {
+impl<T: PyClass<Frozen = False>> Deref for PyRefMut<'_, T> {
     type Target = T;
 
     #[inline]
     fn deref(&self) -> &T {
-        unsafe { &*self.inner.get_ptr() }
+        unsafe { &*self.inner.get_class_object().get_ptr() }
     }
 }
 
-impl<'p, T: PyClass<Frozen = False>> DerefMut for PyRefMut<'p, T> {
+impl<T: PyClass<Frozen = False>> DerefMut for PyRefMut<'_, T> {
     #[inline]
     fn deref_mut(&mut self) -> &mut T {
-        unsafe { &mut *self.inner.get_ptr() }
+        unsafe { &mut *self.inner.get_class_object().get_ptr() }
     }
 }
 
-impl<'p, T: PyClass<Frozen = False>> Drop for PyRefMut<'p, T> {
+impl<T: PyClass<Frozen = False>> Drop for PyRefMut<'_, T> {
     fn drop(&mut self) {
-        self.inner.borrow_checker().release_borrow_mut()
+        self.inner
+            .get_class_object()
+            .borrow_checker()
+            .release_borrow_mut()
     }
 }
 
-impl<T: PyClass<Frozen = False>> IntoPy<PyObject> for PyRefMut<'_, T> {
-    fn into_py(self, py: Python<'_>) -> PyObject {
-        unsafe { PyObject::from_borrowed_ptr(py, self.inner.as_ptr()) }
-    }
-}
+impl<'py, T: PyClass<Frozen = False>> IntoPyObject<'py> for PyRefMut<'py, T> {
+    type Target = T;
+    type Output = Bound<'py, T>;
+    type Error = Infallible;
 
-impl<T: PyClass<Frozen = False>> IntoPy<PyObject> for &'_ PyRefMut<'_, T> {
-    fn into_py(self, py: Python<'_>) -> PyObject {
-        self.inner.into_py(py)
-    }
-}
+    #[cfg(feature = "experimental-inspect")]
+    const OUTPUT_TYPE: TypeHint = T::TYPE_HINT;
 
-unsafe impl<'a, T: PyClass<Frozen = False>> AsPyPointer for PyRefMut<'a, T> {
-    fn as_ptr(&self) -> *mut ffi::PyObject {
-        self.inner.as_ptr()
+    fn into_pyobject(self, _py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        Ok(self.inner.clone())
     }
 }
 
-impl<'a, T: PyClass<Frozen = False>> std::convert::TryFrom<&'a PyCell<T>>
-    for crate::PyRefMut<'a, T>
-{
-    type Error = PyBorrowMutError;
-    fn try_from(cell: &'a crate::PyCell<T>) -> Result<Self, Self::Error> {
-        cell.try_borrow_mut()
+impl<'a, 'py, T: PyClass<Frozen = False>> IntoPyObject<'py> for &'a PyRefMut<'py, T> {
+    type Target = T;
+    type Output = Borrowed<'a, 'py, T>;
+    type Error = Infallible;
+
+    #[cfg(feature = "experimental-inspect")]
+    const OUTPUT_TYPE: TypeHint = T::TYPE_HINT;
+
+    fn into_pyobject(self, _py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        Ok(self.inner.as_borrowed())
     }
 }
 
@@ -930,13 +685,19 @@ impl<T: PyClass<Frozen = False> + fmt::Debug> fmt::Debug for PyRefMut<'_, T> {
     }
 }
 
-/// An error type returned by [`PyCell::try_borrow`].
+/// An error type returned by [`Bound::try_borrow`].
 ///
 /// If this error is allowed to bubble up into Python code it will raise a `RuntimeError`.
 pub struct PyBorrowError {
     _private: (),
 }
 
+impl PyBorrowError {
+    pub(crate) fn new() -> Self {
+        Self { _private: () }
+    }
+}
+
 impl fmt::Debug for PyBorrowError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("PyBorrowError").finish()
@@ -955,13 +716,19 @@ impl From<PyBorrowError> for PyErr {
     }
 }
 
-/// An error type returned by [`PyCell::try_borrow_mut`].
+/// An error type returned by [`Bound::try_borrow_mut`].
 ///
 /// If this error is allowed to bubble up into Python code it will raise a `RuntimeError`.
 pub struct PyBorrowMutError {
     _private: (),
 }
 
+impl PyBorrowMutError {
+    pub(crate) fn new() -> Self {
+        Self { _private: () }
+    }
+}
+
 impl fmt::Debug for PyBorrowMutError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("PyBorrowMutError").finish()
@@ -980,81 +747,6 @@ impl From<PyBorrowMutError> for PyErr {
     }
 }
 
-#[doc(hidden)]
-pub trait PyCellLayout<T>: PyLayout<T> {
-    fn ensure_threadsafe(&self);
-    fn check_threadsafe(&self) -> Result<(), PyBorrowError>;
-    /// Implementation of tp_dealloc.
-    /// # Safety
-    /// - slf must be a valid pointer to an instance of a T or a subclass.
-    /// - slf must not be used after this call (as it will be freed).
-    unsafe fn tp_dealloc(py: Python<'_>, slf: *mut ffi::PyObject);
-}
-
-impl<T, U> PyCellLayout<T> for PyCellBase<U>
-where
-    U: PySizedLayout<T>,
-    T: PyTypeInfo,
-{
-    fn ensure_threadsafe(&self) {}
-    fn check_threadsafe(&self) -> Result<(), PyBorrowError> {
-        Ok(())
-    }
-    unsafe fn tp_dealloc(py: Python<'_>, slf: *mut ffi::PyObject) {
-        let type_obj = T::type_object_raw(py);
-        // For `#[pyclass]` types which inherit from PyAny, we can just call tp_free
-        if type_obj == std::ptr::addr_of_mut!(ffi::PyBaseObject_Type) {
-            return get_tp_free(ffi::Py_TYPE(slf))(slf as _);
-        }
-
-        // More complex native types (e.g. `extends=PyDict`) require calling the base's dealloc.
-        #[cfg(not(Py_LIMITED_API))]
-        {
-            if let Some(dealloc) = (*type_obj).tp_dealloc {
-                // Before CPython 3.11 BaseException_dealloc would use Py_GC_UNTRACK which
-                // assumes the exception is currently GC tracked, so we have to re-track
-                // before calling the dealloc so that it can safely call Py_GC_UNTRACK.
-                #[cfg(not(any(Py_3_11, PyPy)))]
-                if ffi::PyType_FastSubclass(type_obj, ffi::Py_TPFLAGS_BASE_EXC_SUBCLASS) == 1 {
-                    ffi::PyObject_GC_Track(slf.cast());
-                }
-                dealloc(slf as _);
-            } else {
-                get_tp_free(ffi::Py_TYPE(slf))(slf as _);
-            }
-        }
-
-        #[cfg(Py_LIMITED_API)]
-        unreachable!("subclassing native types is not possible with the `abi3` feature");
-    }
-}
-
-impl<T: PyClassImpl> PyCellLayout<T> for PyCell<T>
-where
-    <T::BaseType as PyClassBaseType>::LayoutAsBase: PyCellLayout<T::BaseType>,
-{
-    fn ensure_threadsafe(&self) {
-        self.contents.thread_checker.ensure();
-        self.ob_base.ensure_threadsafe();
-    }
-    fn check_threadsafe(&self) -> Result<(), PyBorrowError> {
-        if !self.contents.thread_checker.check() {
-            return Err(PyBorrowError { _private: () });
-        }
-        self.ob_base.check_threadsafe()
-    }
-    unsafe fn tp_dealloc(py: Python<'_>, slf: *mut ffi::PyObject) {
-        // Safety: Python only calls tp_dealloc when no references to the object remain.
-        let cell = &mut *(slf as *mut PyCell<T>);
-        if cell.contents.thread_checker.can_drop(py) {
-            ManuallyDrop::drop(&mut cell.contents.value);
-        }
-        cell.contents.dict.clear_dict(py);
-        cell.contents.weakref.clear_weakrefs(slf, py);
-        <T::BaseType as PyClassBaseType>::LayoutAsBase::tp_dealloc(py, slf)
-    }
-}
-
 #[cfg(test)]
 #[cfg(feature = "macros")]
 mod tests {
@@ -1067,114 +759,173 @@ mod tests {
     struct SomeClass(i32);
 
     #[test]
-    fn pycell_replace() {
-        Python::with_gil(|py| {
-            let cell = PyCell::new(py, SomeClass(0)).unwrap();
-            assert_eq!(*cell.borrow(), SomeClass(0));
-
-            let previous = cell.replace(SomeClass(123));
-            assert_eq!(previous, SomeClass(0));
-            assert_eq!(*cell.borrow(), SomeClass(123));
+    fn test_as_ptr() {
+        Python::attach(|py| {
+            let cell = Bound::new(py, SomeClass(0)).unwrap();
+            let ptr = cell.as_ptr();
+
+            assert_eq!(cell.borrow().as_ptr(), ptr);
+            assert_eq!(cell.borrow_mut().as_ptr(), ptr);
         })
     }
 
     #[test]
-    #[should_panic(expected = "Already borrowed: PyBorrowMutError")]
-    fn pycell_replace_panic() {
-        Python::with_gil(|py| {
-            let cell = PyCell::new(py, SomeClass(0)).unwrap();
-            let _guard = cell.borrow();
+    fn test_into_ptr() {
+        Python::attach(|py| {
+            let cell = Bound::new(py, SomeClass(0)).unwrap();
+            let ptr = cell.as_ptr();
+
+            assert_eq!(cell.borrow().into_ptr(), ptr);
+            unsafe { ffi::Py_DECREF(ptr) };
 
-            cell.replace(SomeClass(123));
+            assert_eq!(cell.borrow_mut().into_ptr(), ptr);
+            unsafe { ffi::Py_DECREF(ptr) };
         })
     }
 
-    #[test]
-    fn pycell_replace_with() {
-        Python::with_gil(|py| {
-            let cell = PyCell::new(py, SomeClass(0)).unwrap();
-            assert_eq!(*cell.borrow(), SomeClass(0));
-
-            let previous = cell.replace_with(|value| {
-                *value = SomeClass(2);
-                SomeClass(123)
-            });
-            assert_eq!(previous, SomeClass(2));
-            assert_eq!(*cell.borrow(), SomeClass(123));
-        })
+    #[crate::pyclass]
+    #[pyo3(crate = "crate", subclass)]
+    struct BaseClass {
+        val1: usize,
     }
 
-    #[test]
-    #[should_panic(expected = "Already borrowed: PyBorrowMutError")]
-    fn pycell_replace_with_panic() {
-        Python::with_gil(|py| {
-            let cell = PyCell::new(py, SomeClass(0)).unwrap();
-            let _guard = cell.borrow();
+    #[crate::pyclass]
+    #[pyo3(crate = "crate", extends=BaseClass, subclass)]
+    struct SubClass {
+        val2: usize,
+    }
 
-            cell.replace_with(|_| SomeClass(123));
-        })
+    #[crate::pyclass]
+    #[pyo3(crate = "crate", extends=SubClass)]
+    struct SubSubClass {
+        val3: usize,
+    }
+
+    #[crate::pymethods]
+    #[pyo3(crate = "crate")]
+    impl SubSubClass {
+        #[new]
+        fn new(py: Python<'_>) -> crate::Py<SubSubClass> {
+            let init = crate::PyClassInitializer::from(BaseClass { val1: 10 })
+                .add_subclass(SubClass { val2: 15 })
+                .add_subclass(SubSubClass { val3: 20 });
+            crate::Py::new(py, init).expect("allocation error")
+        }
+
+        fn get_values(self_: PyRef<'_, Self>) -> (usize, usize, usize) {
+            let val1 = self_.as_super().as_super().val1;
+            let val2 = self_.as_super().val2;
+            (val1, val2, self_.val3)
+        }
+
+        fn double_values(mut self_: PyRefMut<'_, Self>) {
+            self_.as_super().as_super().val1 *= 2;
+            self_.as_super().val2 *= 2;
+            self_.val3 *= 2;
+        }
     }
 
     #[test]
-    fn pycell_swap() {
-        Python::with_gil(|py| {
-            let cell = PyCell::new(py, SomeClass(0)).unwrap();
-            let cell2 = PyCell::new(py, SomeClass(123)).unwrap();
-            assert_eq!(*cell.borrow(), SomeClass(0));
-            assert_eq!(*cell2.borrow(), SomeClass(123));
-
-            cell.swap(cell2);
-            assert_eq!(*cell.borrow(), SomeClass(123));
-            assert_eq!(*cell2.borrow(), SomeClass(0));
-        })
+    fn test_pyref_as_super() {
+        Python::attach(|py| {
+            let obj = SubSubClass::new(py).into_bound(py);
+            let pyref = obj.borrow();
+            assert_eq!(pyref.as_super().as_super().val1, 10);
+            assert_eq!(pyref.as_super().val2, 15);
+            assert_eq!(pyref.as_ref().val2, 15); // `as_ref` also works
+            assert_eq!(pyref.val3, 20);
+            assert_eq!(SubSubClass::get_values(pyref), (10, 15, 20));
+        });
     }
 
     #[test]
-    #[should_panic(expected = "Already borrowed: PyBorrowMutError")]
-    fn pycell_swap_panic() {
-        Python::with_gil(|py| {
-            let cell = PyCell::new(py, SomeClass(0)).unwrap();
-            let cell2 = PyCell::new(py, SomeClass(123)).unwrap();
-
-            let _guard = cell.borrow();
-            cell.swap(cell2);
-        })
+    fn test_pyrefmut_as_super() {
+        Python::attach(|py| {
+            let obj = SubSubClass::new(py).into_bound(py);
+            assert_eq!(SubSubClass::get_values(obj.borrow()), (10, 15, 20));
+            {
+                let mut pyrefmut = obj.borrow_mut();
+                assert_eq!(pyrefmut.as_super().as_ref().val1, 10);
+                pyrefmut.as_super().as_super().val1 -= 5;
+                pyrefmut.as_super().val2 -= 3;
+                pyrefmut.as_mut().val2 -= 2; // `as_mut` also works
+                pyrefmut.val3 -= 5;
+            }
+            assert_eq!(SubSubClass::get_values(obj.borrow()), (5, 10, 15));
+            SubSubClass::double_values(obj.borrow_mut());
+            assert_eq!(SubSubClass::get_values(obj.borrow()), (10, 20, 30));
+        });
     }
 
     #[test]
-    #[should_panic(expected = "Already borrowed: PyBorrowMutError")]
-    fn pycell_swap_panic_other_borrowed() {
-        Python::with_gil(|py| {
-            let cell = PyCell::new(py, SomeClass(0)).unwrap();
-            let cell2 = PyCell::new(py, SomeClass(123)).unwrap();
-
-            let _guard = cell2.borrow();
-            cell.swap(cell2);
-        })
+    fn test_pyrefs_in_python() {
+        Python::attach(|py| {
+            let obj = SubSubClass::new(py);
+            crate::py_run!(py, obj, "assert obj.get_values() == (10, 15, 20)");
+            crate::py_run!(py, obj, "assert obj.double_values() is None");
+            crate::py_run!(py, obj, "assert obj.get_values() == (20, 30, 40)");
+        });
     }
 
     #[test]
-    fn test_as_ptr() {
-        Python::with_gil(|py| {
-            let cell = PyCell::new(py, SomeClass(0)).unwrap();
-            let ptr = cell.as_ptr();
+    fn test_into_frozen_super_released_borrow() {
+        #[crate::pyclass]
+        #[pyo3(crate = "crate", subclass, frozen)]
+        struct BaseClass {}
+
+        #[crate::pyclass]
+        #[pyo3(crate = "crate", extends=BaseClass, subclass)]
+        struct SubClass {}
+
+        #[crate::pymethods]
+        #[pyo3(crate = "crate")]
+        impl SubClass {
+            #[new]
+            fn new(py: Python<'_>) -> Bound<'_, SubClass> {
+                let init = crate::PyClassInitializer::from(BaseClass {}).add_subclass(SubClass {});
+                Bound::new(py, init).expect("allocation error")
+            }
+        }
 
-            assert_eq!(cell.borrow().as_ptr(), ptr);
-            assert_eq!(cell.borrow_mut().as_ptr(), ptr);
+        Python::attach(|py| {
+            let obj = SubClass::new(py);
+            drop(obj.borrow().into_super());
+            assert!(obj.try_borrow_mut().is_ok());
         })
     }
 
     #[test]
-    fn test_into_ptr() {
-        Python::with_gil(|py| {
-            let cell = PyCell::new(py, SomeClass(0)).unwrap();
-            let ptr = cell.as_ptr();
-
-            assert_eq!(cell.borrow().into_ptr(), ptr);
-            unsafe { ffi::Py_DECREF(ptr) };
+    fn test_into_frozen_super_mutable_base_holds_borrow() {
+        #[crate::pyclass]
+        #[pyo3(crate = "crate", subclass)]
+        struct BaseClass {}
+
+        #[crate::pyclass]
+        #[pyo3(crate = "crate", extends=BaseClass, subclass, frozen)]
+        struct SubClass {}
+
+        #[crate::pyclass]
+        #[pyo3(crate = "crate", extends=SubClass, subclass)]
+        struct SubSubClass {}
+
+        #[crate::pymethods]
+        #[pyo3(crate = "crate")]
+        impl SubSubClass {
+            #[new]
+            fn new(py: Python<'_>) -> Bound<'_, SubSubClass> {
+                let init = crate::PyClassInitializer::from(BaseClass {})
+                    .add_subclass(SubClass {})
+                    .add_subclass(SubSubClass {});
+                Bound::new(py, init).expect("allocation error")
+            }
+        }
 
-            assert_eq!(cell.borrow_mut().into_ptr(), ptr);
-            unsafe { ffi::Py_DECREF(ptr) };
+        Python::attach(|py| {
+            let obj = SubSubClass::new(py);
+            let _super_borrow = obj.borrow().into_super();
+            // the whole object still has an immutable borrow, so we cannot
+            // borrow any part mutably (the borrowflag is shared)
+            assert!(obj.try_borrow_mut().is_err());
         })
     }
 }
diff --git a/src/pycell/impl_.rs b/src/pycell/impl_.rs
index 62875e67ae4..32d345fcfb6 100644
--- a/src/pycell/impl_.rs
+++ b/src/pycell/impl_.rs
@@ -1,11 +1,18 @@
 #![allow(missing_docs)]
-//! Crate-private implementation of pycell
+//! Crate-private implementation of PyClassObject
 
-use std::cell::Cell;
+use std::cell::UnsafeCell;
 use std::marker::PhantomData;
+use std::mem::{offset_of, ManuallyDrop};
+use std::sync::atomic::{AtomicUsize, Ordering};
 
-use crate::impl_::pyclass::{PyClassBaseType, PyClassImpl};
-use crate::PyCell;
+use crate::impl_::pyclass::{
+    PyClassBaseType, PyClassDict, PyClassImpl, PyClassThreadChecker, PyClassWeakRef,
+};
+use crate::internal::get_slot::TP_FREE;
+use crate::type_object::{PyLayout, PySizedLayout};
+use crate::types::{PyType, PyTypeMethods};
+use crate::{ffi, PyClass, PyTypeInfo, Python};
 
 use super::{PyBorrowError, PyBorrowMutError};
 
@@ -46,32 +53,58 @@ impl<M: PyClassMutability> PyClassMutability for ExtendsMutableAncestor<M> {
     type MutableChild = ExtendsMutableAncestor<MutableClass>;
 }
 
-#[derive(Debug, Copy, Clone, Eq, PartialEq)]
-struct BorrowFlag(usize);
+#[derive(Debug)]
+struct BorrowFlag(AtomicUsize);
 
 impl BorrowFlag {
-    pub(crate) const UNUSED: BorrowFlag = BorrowFlag(0);
-    const HAS_MUTABLE_BORROW: BorrowFlag = BorrowFlag(usize::max_value());
-    const fn increment(self) -> Self {
-        Self(self.0 + 1)
+    pub(crate) const UNUSED: usize = 0;
+    const HAS_MUTABLE_BORROW: usize = usize::MAX;
+    fn increment(&self) -> Result<(), PyBorrowError> {
+        // relaxed is OK because we will read the value again in the compare_exchange
+        let mut value = self.0.load(Ordering::Relaxed);
+        loop {
+            if value == BorrowFlag::HAS_MUTABLE_BORROW {
+                return Err(PyBorrowError { _private: () });
+            }
+            match self.0.compare_exchange(
+                // only increment if the value hasn't changed since the
+                // last atomic load
+                value,
+                value + 1,
+                // reading the value is happens-after a previous write
+                // writing the new value is happens-after the previous read
+                Ordering::AcqRel,
+                // relaxed is OK here because we're going to try to read again
+                Ordering::Relaxed,
+            ) {
+                Ok(..) => {
+                    break Ok(());
+                }
+                Err(changed_value) => {
+                    // value changed under us, need to try again
+                    value = changed_value;
+                }
+            }
+        }
     }
-    const fn decrement(self) -> Self {
-        Self(self.0 - 1)
+    fn decrement(&self) {
+        // relaxed load is OK but decrements must happen-before the next read
+        self.0.fetch_sub(1, Ordering::Release);
     }
 }
 
 pub struct EmptySlot(());
-pub struct BorrowChecker(Cell<BorrowFlag>);
+pub struct BorrowChecker(BorrowFlag);
 
 pub trait PyClassBorrowChecker {
     /// Initial value for self
-    fn new() -> Self;
+    fn new() -> Self
+    where
+        Self: Sized;
 
     /// Increments immutable borrow count, if possible
     fn try_borrow(&self) -> Result<(), PyBorrowError>;
 
-    fn try_borrow_unguarded(&self) -> Result<(), PyBorrowError>;
-
     /// Decrements immutable borrow count
     fn release_borrow(&self);
     /// Increments mutable borrow count, if possible
@@ -91,11 +124,6 @@ impl PyClassBorrowChecker for EmptySlot {
         Ok(())
     }
 
-    #[inline]
-    fn try_borrow_unguarded(&self) -> Result<(), PyBorrowError> {
-        Ok(())
-    }
-
     #[inline]
     fn release_borrow(&self) {}
 
@@ -113,72 +141,217 @@ impl PyClassBorrowChecker for EmptySlot {
 impl PyClassBorrowChecker for BorrowChecker {
     #[inline]
     fn new() -> Self {
-        Self(Cell::new(BorrowFlag::UNUSED))
+        Self(BorrowFlag(AtomicUsize::new(BorrowFlag::UNUSED)))
     }
 
     fn try_borrow(&self) -> Result<(), PyBorrowError> {
-        let flag = self.0.get();
-        if flag != BorrowFlag::HAS_MUTABLE_BORROW {
-            self.0.set(flag.increment());
-            Ok(())
-        } else {
-            Err(PyBorrowError { _private: () })
-        }
-    }
-
-    fn try_borrow_unguarded(&self) -> Result<(), PyBorrowError> {
-        let flag = self.0.get();
-        if flag != BorrowFlag::HAS_MUTABLE_BORROW {
-            Ok(())
-        } else {
-            Err(PyBorrowError { _private: () })
-        }
+        self.0.increment()
     }
 
     fn release_borrow(&self) {
-        let flag = self.0.get();
-        self.0.set(flag.decrement())
+        self.0.decrement();
     }
 
     fn try_borrow_mut(&self) -> Result<(), PyBorrowMutError> {
-        let flag = self.0.get();
-        if flag == BorrowFlag::UNUSED {
-            self.0.set(BorrowFlag::HAS_MUTABLE_BORROW);
-            Ok(())
-        } else {
-            Err(PyBorrowMutError { _private: () })
+        let flag = &self.0;
+        match flag.0.compare_exchange(
+            // only allowed to transition to mutable borrow if the reference is
+            // currently unused
+            BorrowFlag::UNUSED,
+            BorrowFlag::HAS_MUTABLE_BORROW,
+            // On success, reading the flag and updating its state are an atomic
+            // operation
+            Ordering::AcqRel,
+            // It doesn't matter precisely when the failure gets turned
+            // into an error
+            Ordering::Relaxed,
+        ) {
+            Ok(..) => Ok(()),
+            Err(..) => Err(PyBorrowMutError { _private: () }),
         }
     }
 
     fn release_borrow_mut(&self) {
-        self.0.set(BorrowFlag::UNUSED)
+        self.0 .0.store(BorrowFlag::UNUSED, Ordering::Release)
     }
 }
 
 pub trait GetBorrowChecker<T: PyClassImpl> {
-    fn borrow_checker(cell: &PyCell<T>) -> &<T::PyClassMutability as PyClassMutability>::Checker;
+    fn borrow_checker(
+        class_object: &PyClassObject<T>,
+    ) -> &<T::PyClassMutability as PyClassMutability>::Checker;
 }
 
 impl<T: PyClassImpl<PyClassMutability = Self>> GetBorrowChecker<T> for MutableClass {
-    fn borrow_checker(cell: &PyCell<T>) -> &BorrowChecker {
-        &cell.contents.borrow_checker
+    fn borrow_checker(class_object: &PyClassObject<T>) -> &BorrowChecker {
+        &class_object.contents.borrow_checker
     }
 }
 
 impl<T: PyClassImpl<PyClassMutability = Self>> GetBorrowChecker<T> for ImmutableClass {
-    fn borrow_checker(cell: &PyCell<T>) -> &EmptySlot {
-        &cell.contents.borrow_checker
+    fn borrow_checker(class_object: &PyClassObject<T>) -> &EmptySlot {
+        &class_object.contents.borrow_checker
     }
 }
 
 impl<T: PyClassImpl<PyClassMutability = Self>, M: PyClassMutability> GetBorrowChecker<T>
     for ExtendsMutableAncestor<M>
 where
-    T::BaseType: PyClassImpl + PyClassBaseType<LayoutAsBase = PyCell<T::BaseType>>,
+    T::BaseType: PyClassImpl + PyClassBaseType<LayoutAsBase = PyClassObject<T::BaseType>>,
     <T::BaseType as PyClassImpl>::PyClassMutability: PyClassMutability<Checker = BorrowChecker>,
 {
-    fn borrow_checker(cell: &PyCell<T>) -> &BorrowChecker {
-        <<T::BaseType as PyClassImpl>::PyClassMutability as GetBorrowChecker<T::BaseType>>::borrow_checker(&cell.ob_base)
+    fn borrow_checker(class_object: &PyClassObject<T>) -> &BorrowChecker {
+        <<T::BaseType as PyClassImpl>::PyClassMutability as GetBorrowChecker<T::BaseType>>::borrow_checker(&class_object.ob_base)
+    }
+}
+
+/// Base layout of PyClassObject.
+#[doc(hidden)]
+#[repr(C)]
+pub struct PyClassObjectBase<T> {
+    ob_base: T,
+}
+
+unsafe impl<T, U> PyLayout<T> for PyClassObjectBase<U> where U: PySizedLayout<T> {}
+
+#[doc(hidden)]
+pub trait PyClassObjectLayout<T>: PyLayout<T> {
+    fn ensure_threadsafe(&self);
+    fn check_threadsafe(&self) -> Result<(), PyBorrowError>;
+    /// Implementation of tp_dealloc.
+    /// # Safety
+    /// - slf must be a valid pointer to an instance of a T or a subclass.
+    /// - slf must not be used after this call (as it will be freed).
+    unsafe fn tp_dealloc(py: Python<'_>, slf: *mut ffi::PyObject);
+}
+
+impl<T, U> PyClassObjectLayout<T> for PyClassObjectBase<U>
+where
+    U: PySizedLayout<T>,
+    T: PyTypeInfo,
+{
+    fn ensure_threadsafe(&self) {}
+    fn check_threadsafe(&self) -> Result<(), PyBorrowError> {
+        Ok(())
+    }
+    unsafe fn tp_dealloc(py: Python<'_>, slf: *mut ffi::PyObject) {
+        unsafe {
+            // FIXME: there is potentially subtle issues here if the base is overwritten
+            // at runtime? To be investigated.
+            let type_obj = T::type_object(py);
+            let type_ptr = type_obj.as_type_ptr();
+            let actual_type = PyType::from_borrowed_type_ptr(py, ffi::Py_TYPE(slf));
+
+            // For `#[pyclass]` types which inherit from PyAny, we can just call tp_free
+            if std::ptr::eq(type_ptr, std::ptr::addr_of!(ffi::PyBaseObject_Type)) {
+                let tp_free = actual_type
+                    .get_slot(TP_FREE)
+                    .expect("PyBaseObject_Type should have tp_free");
+                return tp_free(slf.cast());
+            }
+
+            // More complex native types (e.g. `extends=PyDict`) require calling the base's dealloc.
+            #[cfg(not(Py_LIMITED_API))]
+            {
+                // FIXME: should this be using actual_type.tp_dealloc?
+                if let Some(dealloc) = (*type_ptr).tp_dealloc {
+                    // Before CPython 3.11 BaseException_dealloc would use Py_GC_UNTRACK which
+                    // assumes the exception is currently GC tracked, so we have to re-track
+                    // before calling the dealloc so that it can safely call Py_GC_UNTRACK.
+                    #[cfg(not(any(Py_3_11, PyPy)))]
+                    if ffi::PyType_FastSubclass(type_ptr, ffi::Py_TPFLAGS_BASE_EXC_SUBCLASS) == 1 {
+                        ffi::PyObject_GC_Track(slf.cast());
+                    }
+                    dealloc(slf);
+                } else {
+                    (*actual_type.as_type_ptr())
+                        .tp_free
+                        .expect("type missing tp_free")(slf.cast());
+                }
+            }
+
+            #[cfg(Py_LIMITED_API)]
+            unreachable!("subclassing native types is not possible with the `abi3` feature");
+        }
+    }
+}
+
+/// The layout of a PyClass as a Python object
+#[repr(C)]
+pub struct PyClassObject<T: PyClassImpl> {
+    pub(crate) ob_base: <T::BaseType as PyClassBaseType>::LayoutAsBase,
+    pub(crate) contents: PyClassObjectContents<T>,
+}
+
+#[repr(C)]
+pub(crate) struct PyClassObjectContents<T: PyClassImpl> {
+    pub(crate) value: ManuallyDrop<UnsafeCell<T>>,
+    pub(crate) borrow_checker: <T::PyClassMutability as PyClassMutability>::Storage,
+    pub(crate) thread_checker: T::ThreadChecker,
+    pub(crate) dict: T::Dict,
+    pub(crate) weakref: T::WeakRef,
+}
+
+impl<T: PyClassImpl> PyClassObject<T> {
+    pub(crate) fn get_ptr(&self) -> *mut T {
+        self.contents.value.get()
+    }
+
+    /// Gets the offset of the dictionary from the start of the struct in bytes.
+    pub(crate) fn dict_offset() -> ffi::Py_ssize_t {
+        let offset =
+            offset_of!(PyClassObject<T>, contents) + offset_of!(PyClassObjectContents<T>, dict);
+
+        // Py_ssize_t may not be equal to isize on all platforms
+        #[allow(clippy::useless_conversion)]
+        offset.try_into().expect("offset should fit in Py_ssize_t")
+    }
+
+    /// Gets the offset of the weakref list from the start of the struct in bytes.
+    pub(crate) fn weaklist_offset() -> ffi::Py_ssize_t {
+        let offset =
+            offset_of!(PyClassObject<T>, contents) + offset_of!(PyClassObjectContents<T>, weakref);
+
+        // Py_ssize_t may not be equal to isize on all platforms
+        #[allow(clippy::useless_conversion)]
+        offset.try_into().expect("offset should fit in Py_ssize_t")
+    }
+}
+
+impl<T: PyClassImpl> PyClassObject<T> {
+    pub(crate) fn borrow_checker(&self) -> &<T::PyClassMutability as PyClassMutability>::Checker {
+        T::PyClassMutability::borrow_checker(self)
+    }
+}
+
+unsafe impl<T: PyClassImpl> PyLayout<T> for PyClassObject<T> {}
+impl<T: PyClass> PySizedLayout<T> for PyClassObject<T> {}
+
+impl<T: PyClassImpl> PyClassObjectLayout<T> for PyClassObject<T>
+where
+    <T::BaseType as PyClassBaseType>::LayoutAsBase: PyClassObjectLayout<T::BaseType>,
+{
+    fn ensure_threadsafe(&self) {
+        self.contents.thread_checker.ensure();
+        self.ob_base.ensure_threadsafe();
+    }
+    fn check_threadsafe(&self) -> Result<(), PyBorrowError> {
+        if !self.contents.thread_checker.check() {
+            return Err(PyBorrowError { _private: () });
+        }
+        self.ob_base.check_threadsafe()
+    }
+    unsafe fn tp_dealloc(py: Python<'_>, slf: *mut ffi::PyObject) {
+        // Safety: Python only calls tp_dealloc when no references to the object remain.
+        let class_object = unsafe { &mut *(slf.cast::<PyClassObject<T>>()) };
+        if class_object.contents.thread_checker.can_drop(py) {
+            unsafe { ManuallyDrop::drop(&mut class_object.contents.value) };
+        }
+        class_object.contents.dict.clear_dict(py);
+        unsafe {
+            class_object.contents.weakref.clear_weakrefs(slf, py);
+            <T::BaseType as PyClassBaseType>::LayoutAsBase::tp_dealloc(py, slf)
+        }
     }
 }
 
@@ -189,7 +362,6 @@ mod tests {
 
     use crate::prelude::*;
     use crate::pyclass::boolean_struct::{False, True};
-    use crate::PyClass;
 
     #[pyclass(crate = "crate", subclass)]
     struct MutableBase;
@@ -275,7 +447,7 @@ mod tests {
 
     #[test]
     fn test_mutable_borrow_prevents_further_borrows() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let mmm = Py::new(
                 py,
                 PyClassInitializer::from(MutableBase)
@@ -284,49 +456,49 @@ mod tests {
             )
             .unwrap();
 
-            let mmm_cell: &PyCell<MutableChildOfMutableChildOfMutableBase> = mmm.as_ref(py);
+            let mmm_bound: &Bound<'_, MutableChildOfMutableChildOfMutableBase> = mmm.bind(py);
 
-            let mmm_refmut = mmm_cell.borrow_mut();
+            let mmm_refmut = mmm_bound.borrow_mut();
 
             // Cannot take any other mutable or immutable borrows whilst the object is borrowed mutably
-            assert!(mmm_cell
+            assert!(mmm_bound
                 .extract::<PyRef<'_, MutableChildOfMutableChildOfMutableBase>>()
                 .is_err());
-            assert!(mmm_cell
+            assert!(mmm_bound
                 .extract::<PyRef<'_, MutableChildOfMutableBase>>()
                 .is_err());
-            assert!(mmm_cell.extract::<PyRef<'_, MutableBase>>().is_err());
-            assert!(mmm_cell
+            assert!(mmm_bound.extract::<PyRef<'_, MutableBase>>().is_err());
+            assert!(mmm_bound
                 .extract::<PyRefMut<'_, MutableChildOfMutableChildOfMutableBase>>()
                 .is_err());
-            assert!(mmm_cell
+            assert!(mmm_bound
                 .extract::<PyRefMut<'_, MutableChildOfMutableBase>>()
                 .is_err());
-            assert!(mmm_cell.extract::<PyRefMut<'_, MutableBase>>().is_err());
+            assert!(mmm_bound.extract::<PyRefMut<'_, MutableBase>>().is_err());
 
             // With the borrow dropped, all other borrow attempts will succeed
             drop(mmm_refmut);
 
-            assert!(mmm_cell
+            assert!(mmm_bound
                 .extract::<PyRef<'_, MutableChildOfMutableChildOfMutableBase>>()
                 .is_ok());
-            assert!(mmm_cell
+            assert!(mmm_bound
                 .extract::<PyRef<'_, MutableChildOfMutableBase>>()
                 .is_ok());
-            assert!(mmm_cell.extract::<PyRef<'_, MutableBase>>().is_ok());
-            assert!(mmm_cell
+            assert!(mmm_bound.extract::<PyRef<'_, MutableBase>>().is_ok());
+            assert!(mmm_bound
                 .extract::<PyRefMut<'_, MutableChildOfMutableChildOfMutableBase>>()
                 .is_ok());
-            assert!(mmm_cell
+            assert!(mmm_bound
                 .extract::<PyRefMut<'_, MutableChildOfMutableBase>>()
                 .is_ok());
-            assert!(mmm_cell.extract::<PyRefMut<'_, MutableBase>>().is_ok());
+            assert!(mmm_bound.extract::<PyRefMut<'_, MutableBase>>().is_ok());
         })
     }
 
     #[test]
     fn test_immutable_borrows_prevent_mutable_borrows() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let mmm = Py::new(
                 py,
                 PyClassInitializer::from(MutableBase)
@@ -335,38 +507,123 @@ mod tests {
             )
             .unwrap();
 
-            let mmm_cell: &PyCell<MutableChildOfMutableChildOfMutableBase> = mmm.as_ref(py);
+            let mmm_bound: &Bound<'_, MutableChildOfMutableChildOfMutableBase> = mmm.bind(py);
 
-            let mmm_refmut = mmm_cell.borrow();
+            let mmm_refmut = mmm_bound.borrow();
 
             // Further immutable borrows are ok
-            assert!(mmm_cell
+            assert!(mmm_bound
                 .extract::<PyRef<'_, MutableChildOfMutableChildOfMutableBase>>()
                 .is_ok());
-            assert!(mmm_cell
+            assert!(mmm_bound
                 .extract::<PyRef<'_, MutableChildOfMutableBase>>()
                 .is_ok());
-            assert!(mmm_cell.extract::<PyRef<'_, MutableBase>>().is_ok());
+            assert!(mmm_bound.extract::<PyRef<'_, MutableBase>>().is_ok());
 
             // Further mutable borrows are not ok
-            assert!(mmm_cell
+            assert!(mmm_bound
                 .extract::<PyRefMut<'_, MutableChildOfMutableChildOfMutableBase>>()
                 .is_err());
-            assert!(mmm_cell
+            assert!(mmm_bound
                 .extract::<PyRefMut<'_, MutableChildOfMutableBase>>()
                 .is_err());
-            assert!(mmm_cell.extract::<PyRefMut<'_, MutableBase>>().is_err());
+            assert!(mmm_bound.extract::<PyRefMut<'_, MutableBase>>().is_err());
 
             // With the borrow dropped, all mutable borrow attempts will succeed
             drop(mmm_refmut);
 
-            assert!(mmm_cell
+            assert!(mmm_bound
                 .extract::<PyRefMut<'_, MutableChildOfMutableChildOfMutableBase>>()
                 .is_ok());
-            assert!(mmm_cell
+            assert!(mmm_bound
                 .extract::<PyRefMut<'_, MutableChildOfMutableBase>>()
                 .is_ok());
-            assert!(mmm_cell.extract::<PyRefMut<'_, MutableBase>>().is_ok());
+            assert!(mmm_bound.extract::<PyRefMut<'_, MutableBase>>().is_ok());
         })
     }
+
+    #[test]
+    #[cfg(not(target_arch = "wasm32"))]
+    fn test_thread_safety() {
+        #[crate::pyclass(crate = "crate")]
+        struct MyClass {
+            x: u64,
+        }
+
+        Python::attach(|py| {
+            let inst = Py::new(py, MyClass { x: 0 }).unwrap();
+
+            let total_modifications = py.detach(|| {
+                std::thread::scope(|s| {
+                    // Spawn a bunch of threads all racing to write to
+                    // the same instance of `MyClass`.
+                    let threads = (0..10)
+                        .map(|_| {
+                            s.spawn(|| {
+                                Python::attach(|py| {
+                                    // Each thread records its own view of how many writes it made
+                                    let mut local_modifications = 0;
+                                    for _ in 0..100 {
+                                        if let Ok(mut i) = inst.try_borrow_mut(py) {
+                                            i.x += 1;
+                                            local_modifications += 1;
+                                        }
+                                    }
+                                    local_modifications
+                                })
+                            })
+                        })
+                        .collect::<Vec<_>>();
+
+                    // Sum up the total number of writes made by all threads
+                    threads.into_iter().map(|t| t.join().unwrap()).sum::<u64>()
+                })
+            });
+
+            // If the implementation is free of data races, the total number of writes
+            // should match the final value of `x`.
+            assert_eq!(total_modifications, inst.borrow(py).x);
+        });
+    }
+
+    #[test]
+    #[cfg(not(target_arch = "wasm32"))]
+    fn test_thread_safety_2() {
+        struct SyncUnsafeCell<T>(UnsafeCell<T>);
+        unsafe impl<T> Sync for SyncUnsafeCell<T> {}
+
+        impl<T> SyncUnsafeCell<T> {
+            fn get(&self) -> *mut T {
+                self.0.get()
+            }
+        }
+
+        let data = SyncUnsafeCell(UnsafeCell::new(0));
+        let data2 = SyncUnsafeCell(UnsafeCell::new(0));
+        let borrow_checker = BorrowChecker(BorrowFlag(AtomicUsize::new(BorrowFlag::UNUSED)));
+
+        std::thread::scope(|s| {
+            s.spawn(|| {
+                for _ in 0..1_000_000 {
+                    if borrow_checker.try_borrow_mut().is_ok() {
+                        // thread 1 writes to both values during the mutable borrow
+                        unsafe { *data.get() += 1 };
+                        unsafe { *data2.get() += 1 };
+                        borrow_checker.release_borrow_mut();
+                    }
+                }
+            });
+
+            s.spawn(|| {
+                for _ in 0..1_000_000 {
+                    if borrow_checker.try_borrow().is_ok() {
+                        // if the borrow checker is working correctly, it should be impossible
+                        // for thread 2 to observe a difference in the two values
+                        assert_eq!(unsafe { *data.get() }, unsafe { *data2.get() });
+                        borrow_checker.release_borrow();
+                    }
+                }
+            });
+        });
+    }
 }
diff --git a/src/pyclass.rs b/src/pyclass.rs
index eb4a5595ca9..f5a3fd5e4eb 100644
--- a/src/pyclass.rs
+++ b/src/pyclass.rs
@@ -1,21 +1,23 @@
 //! `PyClass` and related traits.
-use crate::{
-    callback::IntoPyCallbackOutput, ffi, impl_::pyclass::PyClassImpl, IntoPy, PyCell, PyObject,
-    PyResult, PyTypeInfo, Python,
-};
+use crate::{ffi, impl_::pyclass::PyClassImpl, PyTypeInfo};
 use std::{cmp::Ordering, os::raw::c_int};
 
 mod create_type_object;
 mod gc;
+mod guard;
 
 pub(crate) use self::create_type_object::{create_type_object, PyClassTypeObject};
+
 pub use self::gc::{PyTraverseError, PyVisit};
+pub use self::guard::{
+    PyClassGuard, PyClassGuardError, PyClassGuardMap, PyClassGuardMut, PyClassGuardMutError,
+};
 
 /// Types that can be used as Python classes.
 ///
 /// The `#[pyclass]` attribute implements this trait for your Rust struct -
 /// you shouldn't implement this trait directly.
-pub trait PyClass: PyTypeInfo<AsRefTarget = PyCell<Self>> + PyClassImpl {
+pub trait PyClass: PyTypeInfo + PyClassImpl {
     /// Whether the pyclass is frozen.
     ///
     /// This can be enabled via `#[pyclass(frozen)]`.
@@ -57,7 +59,7 @@ impl CompareOp {
     ///
     /// Usage example:
     ///
-    /// ```rust
+    /// ```rust,no_run
     /// # use pyo3::prelude::*;
     /// # use pyo3::class::basic::CompareOp;
     ///
@@ -85,111 +87,6 @@ impl CompareOp {
     }
 }
 
-/// Output of `__next__` which can either `yield` the next value in the iteration, or
-/// `return` a value to raise `StopIteration` in Python.
-///
-/// Usage example:
-///
-/// ```rust
-/// # #![allow(deprecated)]
-/// use pyo3::prelude::*;
-/// use pyo3::iter::IterNextOutput;
-///
-/// #[pyclass]
-/// struct PyClassIter {
-///     count: usize,
-/// }
-///
-/// #[pymethods]
-/// impl PyClassIter {
-///     #[new]
-///     pub fn new() -> Self {
-///         PyClassIter { count: 0 }
-///     }
-///
-///     fn __next__(&mut self) -> IterNextOutput<usize, &'static str> {
-///         if self.count < 5 {
-///             self.count += 1;
-///             // Given an instance `counter`, First five `next(counter)` calls yield 1, 2, 3, 4, 5.
-///             IterNextOutput::Yield(self.count)
-///         } else {
-///             // At the sixth time, we get a `StopIteration` with `'Ended'`.
-///             //     try:
-///             //         next(counter)
-///             //     except StopIteration as e:
-///             //         assert e.value == 'Ended'
-///             IterNextOutput::Return("Ended")
-///         }
-///     }
-/// }
-/// ```
-#[deprecated(since = "0.21.0", note = "Use `Option` or `PyStopIteration` instead.")]
-pub enum IterNextOutput<T, U> {
-    /// The value yielded by the iterator.
-    Yield(T),
-    /// The `StopIteration` object.
-    Return(U),
-}
-
-/// Alias of `IterNextOutput` with `PyObject` yield & return values.
-#[deprecated(since = "0.21.0", note = "Use `Option` or `PyStopIteration` instead.")]
-#[allow(deprecated)]
-pub type PyIterNextOutput = IterNextOutput<PyObject, PyObject>;
-
-#[allow(deprecated)]
-impl<T, U> IntoPyCallbackOutput<*mut ffi::PyObject> for IterNextOutput<T, U>
-where
-    T: IntoPy<PyObject>,
-    U: IntoPy<PyObject>,
-{
-    fn convert(self, py: Python<'_>) -> PyResult<*mut ffi::PyObject> {
-        match self {
-            IterNextOutput::Yield(o) => Ok(o.into_py(py).into_ptr()),
-            IterNextOutput::Return(o) => {
-                Err(crate::exceptions::PyStopIteration::new_err(o.into_py(py)))
-            }
-        }
-    }
-}
-
-/// Output of `__anext__`.
-///
-/// <https://docs.python.org/3/reference/expressions.html#agen.__anext__>
-#[deprecated(
-    since = "0.21.0",
-    note = "Use `Option` or `PyStopAsyncIteration` instead."
-)]
-pub enum IterANextOutput<T, U> {
-    /// An expression which the generator yielded.
-    Yield(T),
-    /// A `StopAsyncIteration` object.
-    Return(U),
-}
-
-/// An [IterANextOutput] of Python objects.
-#[deprecated(
-    since = "0.21.0",
-    note = "Use `Option` or `PyStopAsyncIteration` instead."
-)]
-#[allow(deprecated)]
-pub type PyIterANextOutput = IterANextOutput<PyObject, PyObject>;
-
-#[allow(deprecated)]
-impl<T, U> IntoPyCallbackOutput<*mut ffi::PyObject> for IterANextOutput<T, U>
-where
-    T: IntoPy<PyObject>,
-    U: IntoPy<PyObject>,
-{
-    fn convert(self, py: Python<'_>) -> PyResult<*mut ffi::PyObject> {
-        match self {
-            IterANextOutput::Yield(o) => Ok(o.into_py(py).into_ptr()),
-            IterANextOutput::Return(o) => Err(crate::exceptions::PyStopAsyncIteration::new_err(
-                o.into_py(py),
-            )),
-        }
-    }
-}
-
 /// A workaround for [associated const equality](https://github.com/rust-lang/rust/issues/92827).
 ///
 /// This serves to have True / False values in the [`PyClass`] trait's `Frozen` type.
@@ -199,10 +96,16 @@ pub mod boolean_struct {
         use super::*;
 
         /// A way to "seal" the boolean traits.
-        pub trait Boolean {}
+        pub trait Boolean {
+            const VALUE: bool;
+        }
 
-        impl Boolean for True {}
-        impl Boolean for False {}
+        impl Boolean for True {
+            const VALUE: bool = true;
+        }
+        impl Boolean for False {
+            const VALUE: bool = false;
+        }
     }
 
     pub struct True(());
diff --git a/src/pyclass/create_type_object.rs b/src/pyclass/create_type_object.rs
index a7196f30288..7fd3ed2b09e 100644
--- a/src/pyclass/create_type_object.rs
+++ b/src/pyclass/create_type_object.rs
@@ -1,30 +1,28 @@
-use pyo3_ffi::PyType_IS_GC;
-
 use crate::{
     exceptions::PyTypeError,
     ffi,
-    impl_::pyclass::{
-        assign_sequence_item_from_mapping, get_sequence_item_from_mapping, tp_dealloc,
-        tp_dealloc_with_gc, PyClassItemsIter,
-    },
     impl_::{
-        pymethods::{get_doc, get_name, Getter, Setter},
+        pycell::PyClassObject,
+        pyclass::{
+            assign_sequence_item_from_mapping, get_sequence_item_from_mapping, tp_dealloc,
+            tp_dealloc_with_gc, PyClassItemsIter,
+        },
+        pymethods::{Getter, PyGetterDef, PyMethodDefType, PySetterDef, Setter, _call_clear},
         trampoline::trampoline,
     },
-    types::PyType,
-    Py, PyCell, PyClass, PyGetterDef, PyMethodDefType, PyResult, PySetterDef, PyTypeInfo, Python,
+    types::{typeobject::PyTypeMethods, PyType},
+    Py, PyClass, PyResult, PyTypeInfo, Python,
 };
 use std::{
-    borrow::Cow,
     collections::HashMap,
-    convert::TryInto,
     ffi::{CStr, CString},
     os::raw::{c_char, c_int, c_ulong, c_void},
-    ptr,
+    ptr::{self, NonNull},
 };
 
 pub(crate) struct PyClassTypeObject {
     pub type_object: Py<PyType>,
+    pub is_immutable_type: bool,
     #[allow(dead_code)] // This is purely a cache that must live as long as the type object
     getset_destructors: Vec<GetSetDefDestructor>,
 }
@@ -42,6 +40,7 @@ where
         dealloc_with_gc: unsafe extern "C" fn(*mut ffi::PyObject),
         is_mapping: bool,
         is_sequence: bool,
+        is_immutable_type: bool,
         doc: &'static CStr,
         dict_offset: Option<ffi::Py_ssize_t>,
         weaklist_offset: Option<ffi::Py_ssize_t>,
@@ -51,32 +50,36 @@ where
         module: Option<&'static str>,
         size_of: usize,
     ) -> PyResult<PyClassTypeObject> {
-        PyTypeBuilder {
-            slots: Vec::new(),
-            method_defs: Vec::new(),
-            getset_builders: HashMap::new(),
-            cleanup: Vec::new(),
-            tp_base: base,
-            tp_dealloc: dealloc,
-            tp_dealloc_with_gc: dealloc_with_gc,
-            is_mapping,
-            is_sequence,
-            has_new: false,
-            has_dealloc: false,
-            has_getitem: false,
-            has_setitem: false,
-            has_traverse: false,
-            has_clear: false,
-            has_dict: false,
-            class_flags: 0,
-            #[cfg(all(not(Py_3_9), not(Py_LIMITED_API)))]
-            buffer_procs: Default::default(),
+        unsafe {
+            PyTypeBuilder {
+                slots: Vec::new(),
+                method_defs: Vec::new(),
+                member_defs: Vec::new(),
+                getset_builders: HashMap::new(),
+                cleanup: Vec::new(),
+                tp_base: base,
+                tp_dealloc: dealloc,
+                tp_dealloc_with_gc: dealloc_with_gc,
+                is_mapping,
+                is_sequence,
+                is_immutable_type,
+                has_new: false,
+                has_dealloc: false,
+                has_getitem: false,
+                has_setitem: false,
+                has_traverse: false,
+                has_clear: false,
+                dict_offset: None,
+                class_flags: 0,
+                #[cfg(all(not(Py_3_9), not(Py_LIMITED_API)))]
+                buffer_procs: Default::default(),
+            }
+            .type_doc(doc)
+            .offsets(dict_offset, weaklist_offset)
+            .set_is_basetype(is_basetype)
+            .class_items(items_iter)
+            .build(py, name, module, size_of)
         }
-        .type_doc(doc)
-        .offsets(dict_offset, weaklist_offset)
-        .set_is_basetype(is_basetype)
-        .class_items(items_iter)
-        .build(py, name, module, size_of)
     }
 
     unsafe {
@@ -87,14 +90,15 @@ where
             tp_dealloc_with_gc::<T>,
             T::IS_MAPPING,
             T::IS_SEQUENCE,
-            T::doc(py)?,
+            T::IS_IMMUTABLE_TYPE,
+            T::DOC,
             T::dict_offset(),
             T::weaklist_offset(),
             T::IS_BASETYPE,
             T::items_iter(),
             T::NAME,
             T::MODULE,
-            std::mem::size_of::<PyCell<T>>(),
+            std::mem::size_of::<PyClassObject<T>>(),
         )
     }
 }
@@ -104,7 +108,8 @@ type PyTypeBuilderCleanup = Box<dyn Fn(&PyTypeBuilder, *mut ffi::PyTypeObject)>;
 struct PyTypeBuilder {
     slots: Vec<ffi::PyType_Slot>,
     method_defs: Vec<ffi::PyMethodDef>,
-    getset_builders: HashMap<&'static str, GetSetDefBuilder>,
+    member_defs: Vec<ffi::PyMemberDef>,
+    getset_builders: HashMap<&'static CStr, GetSetDefBuilder>,
     /// Used to patch the type objects for the things there's no
     /// PyType_FromSpec API for... there's no reason this should work,
     /// except for that it does and we have tests.
@@ -114,13 +119,14 @@ struct PyTypeBuilder {
     tp_dealloc_with_gc: ffi::destructor,
     is_mapping: bool,
     is_sequence: bool,
+    is_immutable_type: bool,
     has_new: bool,
     has_dealloc: bool,
     has_getitem: bool,
     has_setitem: bool,
     has_traverse: bool,
     has_clear: bool,
-    has_dict: bool,
+    dict_offset: Option<ffi::Py_ssize_t>,
     class_flags: c_ulong,
     // Before Python 3.9, need to patch in buffer methods manually (they don't work in slots)
     #[cfg(all(not(Py_3_9), not(Py_LIMITED_API)))]
@@ -144,12 +150,14 @@ impl PyTypeBuilder {
             #[cfg(all(not(Py_3_9), not(Py_LIMITED_API)))]
             ffi::Py_bf_getbuffer => {
                 // Safety: slot.pfunc is a valid function pointer
-                self.buffer_procs.bf_getbuffer = Some(std::mem::transmute(pfunc));
+                self.buffer_procs.bf_getbuffer =
+                    Some(unsafe { std::mem::transmute::<*mut T, ffi::getbufferproc>(pfunc) });
             }
             #[cfg(all(not(Py_3_9), not(Py_LIMITED_API)))]
             ffi::Py_bf_releasebuffer => {
                 // Safety: slot.pfunc is a valid function pointer
-                self.buffer_procs.bf_releasebuffer = Some(std::mem::transmute(pfunc));
+                self.buffer_procs.bf_releasebuffer =
+                    Some(unsafe { std::mem::transmute::<*mut T, ffi::releasebufferproc>(pfunc) });
             }
             _ => {}
         }
@@ -165,43 +173,43 @@ impl PyTypeBuilder {
     unsafe fn push_raw_vec_slot<T>(&mut self, slot: c_int, mut data: Vec<T>) {
         if !data.is_empty() {
             // Python expects a zeroed entry to mark the end of the defs
-            data.push(std::mem::zeroed());
-            self.push_slot(slot, Box::into_raw(data.into_boxed_slice()) as *mut c_void);
+            unsafe {
+                data.push(std::mem::zeroed());
+                self.push_slot(slot, Box::into_raw(data.into_boxed_slice()) as *mut c_void);
+            }
         }
     }
 
     fn pymethod_def(&mut self, def: &PyMethodDefType) {
         match def {
-            PyMethodDefType::Getter(getter) => {
-                self.getset_builders
-                    .entry(getter.name)
-                    .or_default()
-                    .add_getter(getter);
-            }
-            PyMethodDefType::Setter(setter) => {
-                self.getset_builders
-                    .entry(setter.name)
-                    .or_default()
-                    .add_setter(setter);
-            }
+            PyMethodDefType::Getter(getter) => self
+                .getset_builders
+                .entry(getter.name)
+                .or_default()
+                .add_getter(getter),
+            PyMethodDefType::Setter(setter) => self
+                .getset_builders
+                .entry(setter.name)
+                .or_default()
+                .add_setter(setter),
             PyMethodDefType::Method(def)
             | PyMethodDefType::Class(def)
-            | PyMethodDefType::Static(def) => {
-                let (def, destructor) = def.as_method_def().unwrap();
-                // FIXME: stop leaking destructor
-                std::mem::forget(destructor);
-                self.method_defs.push(def);
-            }
+            | PyMethodDefType::Static(def) => self.method_defs.push(def.into_raw()),
             // These class attributes are added after the type gets created by LazyStaticType
             PyMethodDefType::ClassAttribute(_) => {}
+            PyMethodDefType::StructMember(def) => self.member_defs.push(*def),
         }
     }
 
-    fn finalize_methods_and_properties(&mut self) -> PyResult<Vec<GetSetDefDestructor>> {
+    fn finalize_methods_and_properties(&mut self) -> Vec<GetSetDefDestructor> {
         let method_defs: Vec<pyo3_ffi::PyMethodDef> = std::mem::take(&mut self.method_defs);
         // Safety: Py_tp_methods expects a raw vec of PyMethodDef
         unsafe { self.push_raw_vec_slot(ffi::Py_tp_methods, method_defs) };
 
+        let member_defs = std::mem::take(&mut self.member_defs);
+        // Safety: Py_tp_members expects a raw vec of PyMemberDef
+        unsafe { self.push_raw_vec_slot(ffi::Py_tp_members, member_defs) };
+
         let mut getset_destructors = Vec::with_capacity(self.getset_builders.len());
 
         #[allow(unused_mut)]
@@ -209,26 +217,63 @@ impl PyTypeBuilder {
             .getset_builders
             .iter()
             .map(|(name, builder)| {
-                let (def, destructor) = builder.as_get_set_def(name)?;
+                let (def, destructor) = builder.as_get_set_def(name);
                 getset_destructors.push(destructor);
-                Ok(def)
+                def
             })
-            .collect::<PyResult<_>>()?;
+            .collect();
+
+        // PyPy automatically adds __dict__ getter / setter.
+        #[cfg(not(PyPy))]
+        // Supported on unlimited API for all versions, and on 3.9+ for limited API
+        #[cfg(any(Py_3_9, not(Py_LIMITED_API)))]
+        if let Some(dict_offset) = self.dict_offset {
+            let get_dict;
+            let closure;
+            // PyObject_GenericGetDict not in the limited API until Python 3.10.
+            #[cfg(any(not(Py_LIMITED_API), Py_3_10))]
+            {
+                let _ = dict_offset;
+                get_dict = ffi::PyObject_GenericGetDict;
+                closure = ptr::null_mut();
+            }
+
+            // ... so we write a basic implementation ourselves
+            #[cfg(not(any(not(Py_LIMITED_API), Py_3_10)))]
+            {
+                extern "C" fn get_dict_impl(
+                    object: *mut ffi::PyObject,
+                    closure: *mut c_void,
+                ) -> *mut ffi::PyObject {
+                    unsafe {
+                        trampoline(|_| {
+                            let dict_offset = closure as ffi::Py_ssize_t;
+                            // we don't support negative dict_offset here; PyO3 doesn't set it negative
+                            assert!(dict_offset > 0);
+                            let dict_ptr =
+                                object.byte_offset(dict_offset).cast::<*mut ffi::PyObject>();
+                            if (*dict_ptr).is_null() {
+                                std::ptr::write(dict_ptr, ffi::PyDict_New());
+                            }
+                            Ok(ffi::compat::Py_XNewRef(*dict_ptr))
+                        })
+                    }
+                }
+
+                get_dict = get_dict_impl;
+                closure = dict_offset as _;
+            }
 
-        // PyPy doesn't automatically add __dict__ getter / setter.
-        // PyObject_GenericGetDict not in the limited API until Python 3.10.
-        if self.has_dict {
-            #[cfg(not(any(PyPy, all(Py_LIMITED_API, not(Py_3_10)))))]
             property_defs.push(ffi::PyGetSetDef {
-                name: "__dict__\0".as_ptr().cast(),
-                get: Some(ffi::PyObject_GenericGetDict),
+                name: c"__dict__".as_ptr(),
+                get: Some(get_dict),
                 set: Some(ffi::PyObject_GenericSetDict),
                 doc: ptr::null(),
-                closure: ptr::null_mut(),
+                closure,
             });
         }
 
-        // Safety: Py_tp_members expects a raw vec of PyGetSetDef
+        // Safety: Py_tp_getset expects a raw vec of PyGetSetDef
         unsafe { self.push_raw_vec_slot(ffi::Py_tp_getset, property_defs) };
 
         // If mapping methods implemented, define sequence methods get implemented too.
@@ -259,7 +304,7 @@ impl PyTypeBuilder {
             }
         }
 
-        Ok(getset_destructors)
+        getset_destructors
     }
 
     fn set_is_basetype(mut self, is_basetype: bool) -> Self {
@@ -274,7 +319,7 @@ impl PyTypeBuilder {
     unsafe fn class_items(mut self, iter: PyClassItemsIter) -> Self {
         for items in iter {
             for slot in items.slots {
-                self.push_slot(slot.slot, slot.pfunc);
+                unsafe { self.push_slot(slot.slot, slot.pfunc) };
             }
             for method in items.methods {
                 self.pymethod_def(method);
@@ -288,8 +333,7 @@ impl PyTypeBuilder {
         if !slice.is_empty() {
             unsafe { self.push_slot(ffi::Py_tp_doc, type_doc.as_ptr() as *mut c_char) }
 
-            // Running this causes PyPy to segfault.
-            #[cfg(all(not(PyPy), not(Py_LIMITED_API), not(Py_3_10)))]
+            #[cfg(all(not(Py_LIMITED_API), not(Py_3_10)))]
             {
                 // Until CPython 3.10, tp_doc was treated specially for
                 // heap-types, and it removed the text_signature value from it.
@@ -312,38 +356,32 @@ impl PyTypeBuilder {
         dict_offset: Option<ffi::Py_ssize_t>,
         #[allow(unused_variables)] weaklist_offset: Option<ffi::Py_ssize_t>,
     ) -> Self {
-        self.has_dict = dict_offset.is_some();
+        self.dict_offset = dict_offset;
 
         #[cfg(Py_3_9)]
         {
             #[inline(always)]
-            fn offset_def(
-                name: &'static str,
-                offset: ffi::Py_ssize_t,
-            ) -> ffi::structmember::PyMemberDef {
-                ffi::structmember::PyMemberDef {
-                    name: name.as_ptr() as _,
-                    type_code: ffi::structmember::T_PYSSIZET,
+            fn offset_def(name: &'static CStr, offset: ffi::Py_ssize_t) -> ffi::PyMemberDef {
+                ffi::PyMemberDef {
+                    name: name.as_ptr().cast(),
+                    type_code: ffi::Py_T_PYSSIZET,
                     offset,
-                    flags: ffi::structmember::READONLY,
+                    flags: ffi::Py_READONLY,
                     doc: std::ptr::null_mut(),
                 }
             }
 
-            let mut members = Vec::new();
-
             // __dict__ support
             if let Some(dict_offset) = dict_offset {
-                members.push(offset_def("__dictoffset__\0", dict_offset));
+                self.member_defs
+                    .push(offset_def(c"__dictoffset__", dict_offset));
             }
 
             // weakref support
             if let Some(weaklist_offset) = weaklist_offset {
-                members.push(offset_def("__weaklistoffset__\0", weaklist_offset));
+                self.member_defs
+                    .push(offset_def(c"__weaklistoffset__", weaklist_offset));
             }
-
-            // Safety: Py_tp_members expects a raw vec of PyMemberDef
-            unsafe { self.push_raw_vec_slot(ffi::Py_tp_members, members) };
         }
 
         // Setting buffer protocols, tp_dictoffset and tp_weaklistoffset via slots doesn't work until
@@ -379,16 +417,24 @@ impl PyTypeBuilder {
         // on some platforms (like windows)
         #![allow(clippy::useless_conversion)]
 
-        let getset_destructors = self.finalize_methods_and_properties()?;
+        let getset_destructors = self.finalize_methods_and_properties();
 
         unsafe { self.push_slot(ffi::Py_tp_base, self.tp_base) }
 
         if !self.has_new {
-            // Safety: This is the correct slot type for Py_tp_new
-            unsafe { self.push_slot(ffi::Py_tp_new, no_constructor_defined as *mut c_void) }
+            #[cfg(not(Py_3_10))]
+            {
+                // Safety: This is the correct slot type for Py_tp_new
+                unsafe { self.push_slot(ffi::Py_tp_new, no_constructor_defined as *mut c_void) }
+            }
+            #[cfg(Py_3_10)]
+            {
+                self.class_flags |= ffi::Py_TPFLAGS_DISALLOW_INSTANTIATION;
+            }
         }
 
-        let tp_dealloc = if self.has_traverse || unsafe { PyType_IS_GC(self.tp_base) == 1 } {
+        let base_is_gc = unsafe { ffi::PyType_IS_GC(self.tp_base) == 1 };
+        let tp_dealloc = if self.has_traverse || base_is_gc {
             self.tp_dealloc_with_gc
         } else {
             self.tp_dealloc
@@ -397,11 +443,26 @@ impl PyTypeBuilder {
 
         if self.has_clear && !self.has_traverse {
             return Err(PyTypeError::new_err(format!(
-                "`#[pyclass]` {} implements __clear__ without __traverse__",
-                name
+                "`#[pyclass]` {name} implements __clear__ without __traverse__"
             )));
         }
 
+        // If this type is a GC type, and the base also is, we may need to add
+        // `tp_traverse` / `tp_clear` implementations to call the base, if this type didn't
+        // define `__traverse__` or `__clear__`.
+        //
+        // This is because when Py_TPFLAGS_HAVE_GC is set, then `tp_traverse` and
+        // `tp_clear` are not inherited.
+        if ((self.class_flags & ffi::Py_TPFLAGS_HAVE_GC) != 0) && base_is_gc {
+            // If this assertion breaks, need to consider doing the same for __traverse__.
+            assert!(self.has_traverse); // Py_TPFLAGS_HAVE_GC is set when a `__traverse__` method is found
+
+            if !self.has_clear {
+                // Safety: This is the correct slot type for Py_tp_clear
+                unsafe { self.push_slot(ffi::Py_tp_clear, call_super_clear as *mut c_void) }
+            }
+        }
+
         // For sequences, implement sq_length instead of mp_length
         if self.is_sequence {
             for slot in &mut self.slots {
@@ -435,11 +496,12 @@ impl PyTypeBuilder {
         bpo_45315_workaround(py, class_name);
 
         for cleanup in std::mem::take(&mut self.cleanup) {
-            cleanup(&self, type_object.as_ref(py).as_type_ptr());
+            cleanup(&self, type_object.bind(py).as_type_ptr());
         }
 
         Ok(PyClassTypeObject {
             type_object,
+            is_immutable_type: self.is_immutable_type,
             getset_destructors,
         })
     }
@@ -461,8 +523,8 @@ fn bpo_45315_workaround(py: Python<'_>, class_name: CString) {
     {
         // Must check version at runtime for abi3 wheels - they could run against a higher version
         // than the build config suggests.
-        use crate::sync::GILOnceCell;
-        static IS_PYTHON_3_11: GILOnceCell<bool> = GILOnceCell::new();
+        use crate::sync::PyOnceLock;
+        static IS_PYTHON_3_11: PyOnceLock<bool> = PyOnceLock::new();
 
         if *IS_PYTHON_3_11.get_or_init(py, || py.version_info() >= (3, 11)) {
             // No fix needed - the wheel is running on a sufficiently new interpreter.
@@ -479,21 +541,35 @@ fn bpo_45315_workaround(py: Python<'_>, class_name: CString) {
 }
 
 /// Default new implementation
+#[cfg(not(Py_3_10))]
 unsafe extern "C" fn no_constructor_defined(
-    _subtype: *mut ffi::PyTypeObject,
+    subtype: *mut ffi::PyTypeObject,
     _args: *mut ffi::PyObject,
     _kwds: *mut ffi::PyObject,
 ) -> *mut ffi::PyObject {
-    trampoline(|_| {
-        Err(crate::exceptions::PyTypeError::new_err(
-            "No constructor defined",
-        ))
-    })
+    unsafe {
+        trampoline(|py| {
+            let tpobj = PyType::from_borrowed_type_ptr(py, subtype);
+            // unlike `fully_qualified_name`, this always include the module
+            let module = tpobj
+                .module()
+                .map_or_else(|_| "<unknown>".into(), |s| s.to_string());
+            let qualname = tpobj.qualname();
+            let qualname = qualname.map_or_else(|_| "<unknown>".into(), |s| s.to_string());
+            Err(crate::exceptions::PyTypeError::new_err(format!(
+                "cannot create '{module}.{qualname}' instances"
+            )))
+        })
+    }
+}
+
+unsafe extern "C" fn call_super_clear(slf: *mut ffi::PyObject) -> c_int {
+    unsafe { _call_clear(slf, |_, _| Ok(()), call_super_clear) }
 }
 
 #[derive(Default)]
 struct GetSetDefBuilder {
-    doc: Option<&'static str>,
+    doc: Option<&'static CStr>,
     getter: Option<Getter>,
     setter: Option<Setter>,
 }
@@ -505,7 +581,7 @@ impl GetSetDefBuilder {
             self.doc = Some(getter.doc);
         }
         // TODO: return an error if getter already defined?
-        self.getter = Some(getter.meth.0)
+        self.getter = Some(getter.meth)
     }
 
     fn add_setter(&mut self, setter: &PySetterDef) {
@@ -514,16 +590,10 @@ impl GetSetDefBuilder {
             self.doc = Some(setter.doc);
         }
         // TODO: return an error if setter already defined?
-        self.setter = Some(setter.meth.0)
+        self.setter = Some(setter.meth)
     }
 
-    fn as_get_set_def(
-        &self,
-        name: &'static str,
-    ) -> PyResult<(ffi::PyGetSetDef, GetSetDefDestructor)> {
-        let name = get_name(name)?;
-        let doc = self.doc.map(get_doc).transpose()?;
-
+    fn as_get_set_def(&self, name: &'static CStr) -> (ffi::PyGetSetDef, GetSetDefDestructor) {
         let getset_type = match (self.getter, self.setter) {
             (Some(getter), None) => GetSetDefType::Getter(getter),
             (None, Some(setter)) => GetSetDefType::Setter(setter),
@@ -535,20 +605,16 @@ impl GetSetDefBuilder {
             }
         };
 
-        let getset_def = getset_type.create_py_get_set_def(&name, doc.as_deref());
+        let getset_def = getset_type.create_py_get_set_def(name, self.doc);
         let destructor = GetSetDefDestructor {
-            name,
-            doc,
             closure: getset_type,
         };
-        Ok((getset_def, destructor))
+        (getset_def, destructor)
     }
 }
 
 #[allow(dead_code)] // a stack of fields which are purely to cache until dropped
 struct GetSetDefDestructor {
-    name: Cow<'static, CStr>,
-    doc: Option<Cow<'static, CStr>>,
     closure: GetSetDefType,
 }
 
@@ -583,8 +649,8 @@ impl GetSetDefType {
                         closure: *mut c_void,
                     ) -> *mut ffi::PyObject {
                         // Safety: PyO3 sets the closure when constructing the ffi getter so this cast should always be valid
-                        let getter: Getter = std::mem::transmute(closure);
-                        trampoline(|py| getter(py, slf))
+                        let getter: Getter = unsafe { std::mem::transmute(closure) };
+                        unsafe { trampoline(|py| getter(py, slf)) }
                     }
                     (Some(getter), None, closure as Getter as _)
                 }
@@ -595,8 +661,8 @@ impl GetSetDefType {
                         closure: *mut c_void,
                     ) -> c_int {
                         // Safety: PyO3 sets the closure when constructing the ffi setter so this cast should always be valid
-                        let setter: Setter = std::mem::transmute(closure);
-                        trampoline(|py| setter(py, slf, value))
+                        let setter: Setter = unsafe { std::mem::transmute(closure) };
+                        unsafe { trampoline(|py| setter(py, slf, value)) }
                     }
                     (None, Some(setter), closure as Setter as _)
                 }
@@ -605,8 +671,8 @@ impl GetSetDefType {
                         slf: *mut ffi::PyObject,
                         closure: *mut c_void,
                     ) -> *mut ffi::PyObject {
-                        let getset: &GetterAndSetter = &*(closure as *const GetterAndSetter);
-                        trampoline(|py| (getset.getter)(py, slf))
+                        let getset: &GetterAndSetter = unsafe { &*closure.cast() };
+                        unsafe { trampoline(|py| (getset.getter)(py, slf)) }
                     }
 
                     unsafe extern "C" fn getset_setter(
@@ -614,13 +680,15 @@ impl GetSetDefType {
                         value: *mut ffi::PyObject,
                         closure: *mut c_void,
                     ) -> c_int {
-                        let getset: &GetterAndSetter = &*(closure as *const GetterAndSetter);
-                        trampoline(|py| (getset.setter)(py, slf, value))
+                        let getset: &GetterAndSetter = unsafe { &*closure.cast() };
+                        unsafe { trampoline(|py| (getset.setter)(py, slf, value)) }
                     }
                     (
                         Some(getset_getter),
                         Some(getset_setter),
-                        closure.as_ref() as *const GetterAndSetter as _,
+                        NonNull::<GetterAndSetter>::from(closure.as_ref())
+                            .cast()
+                            .as_ptr(),
                     )
                 }
             };
diff --git a/src/pyclass/gc.rs b/src/pyclass/gc.rs
index 7878ccf5ca8..6b9da449c3e 100644
--- a/src/pyclass/gc.rs
+++ b/src/pyclass/gc.rs
@@ -1,48 +1,61 @@
-use std::os::raw::{c_int, c_void};
+use std::{
+    marker::PhantomData,
+    num::NonZero,
+    os::raw::{c_int, c_void},
+};
 
-use crate::{ffi, AsPyPointer, Python};
+use crate::{ffi, Py};
 
 /// Error returned by a `__traverse__` visitor implementation.
 #[repr(transparent)]
-pub struct PyTraverseError(pub(crate) c_int);
+pub struct PyTraverseError(NonZero<c_int>);
+
+impl PyTraverseError {
+    /// Returns the error code.
+    pub(crate) fn into_inner(self) -> c_int {
+        self.0.into()
+    }
+}
 
 /// Object visitor for GC.
 #[derive(Clone)]
-pub struct PyVisit<'p> {
+pub struct PyVisit<'a> {
     pub(crate) visit: ffi::visitproc,
     pub(crate) arg: *mut c_void,
-    /// VisitProc contains a Python instance to ensure that
-    /// 1) it is cannot be moved out of the traverse() call
-    /// 2) it cannot be sent to other threads
-    pub(crate) _py: Python<'p>,
+    /// Prevents the `PyVisit` from outliving the `__traverse__` call.
+    pub(crate) _guard: PhantomData<&'a ()>,
 }
 
-impl<'p> PyVisit<'p> {
+impl PyVisit<'_> {
     /// Visit `obj`.
-    pub fn call<T>(&self, obj: &T) -> Result<(), PyTraverseError>
+    ///
+    /// Note: `obj` accepts a variety of types, including
+    /// - `&Py<T>`
+    /// - `&Option<Py<T>>`
+    /// - `Option<&Py<T>>`
+    pub fn call<'a, T, U: 'a>(&self, obj: T) -> Result<(), PyTraverseError>
     where
-        T: AsPyPointer,
+        T: Into<Option<&'a Py<U>>>,
     {
-        let ptr = obj.as_ptr();
+        let ptr = obj.into().map_or_else(std::ptr::null_mut, Py::as_ptr);
         if !ptr.is_null() {
-            let r = unsafe { (self.visit)(ptr, self.arg) };
-            if r == 0 {
-                Ok(())
-            } else {
-                Err(PyTraverseError(r))
+            match NonZero::new(unsafe { (self.visit)(ptr, self.arg) }) {
+                None => Ok(()),
+                Some(r) => Err(PyTraverseError(r)),
             }
         } else {
             Ok(())
         }
     }
+}
 
-    /// Creates the PyVisit from the arguments to tp_traverse
-    #[doc(hidden)]
-    pub unsafe fn from_raw(visit: ffi::visitproc, arg: *mut c_void, py: Python<'p>) -> Self {
-        Self {
-            visit,
-            arg,
-            _py: py,
-        }
+#[cfg(test)]
+mod tests {
+    use super::PyVisit;
+    use static_assertions::assert_not_impl_any;
+
+    #[test]
+    fn py_visit_not_send_sync() {
+        assert_not_impl_any!(PyVisit<'_>: Send, Sync);
     }
 }
diff --git a/src/pyclass/guard.rs b/src/pyclass/guard.rs
new file mode 100644
index 00000000000..6a58b8a47a5
--- /dev/null
+++ b/src/pyclass/guard.rs
@@ -0,0 +1,1069 @@
+use crate::impl_::pycell::{PyClassObject, PyClassObjectLayout as _};
+#[cfg(feature = "experimental-inspect")]
+use crate::inspect::TypeHint;
+use crate::pycell::PyBorrowMutError;
+use crate::pycell::{impl_::PyClassBorrowChecker, PyBorrowError};
+use crate::pyclass::boolean_struct::False;
+use crate::{ffi, Borrowed, CastError, FromPyObject, IntoPyObject, Py, PyClass, PyErr};
+use std::convert::Infallible;
+use std::fmt;
+use std::marker::PhantomData;
+use std::ops::{Deref, DerefMut};
+use std::ptr::NonNull;
+
+/// A wrapper type for an immutably borrowed value from a `PyClass`.
+///
+/// Rust has strict aliasing rules - you can either have any number of immutable
+/// (shared) references or one mutable reference. Python's ownership model is
+/// the complete opposite of that - any Python object can be referenced any
+/// number of times, and mutation is allowed from any reference.
+///
+/// PyO3 deals with these differences by employing the [Interior Mutability]
+/// pattern. This requires that PyO3 enforces the borrowing rules and it has two
+/// mechanisms for doing so:
+/// - Statically it can enforce thread-safe access with the
+///   [`Python<'py>`](crate::Python) token. All Rust code holding that token, or
+///   anything derived from it, can assume that they have safe access to the
+///   Python interpreter's state. For this reason all the native Python objects
+///   can be mutated through shared references.
+/// - However, methods and functions in Rust usually *do* need `&mut`
+///   references. While PyO3 can use the [`Python<'py>`](crate::Python) token to
+///   guarantee thread-safe access to them, it cannot statically guarantee
+///   uniqueness of `&mut` references. As such those references have to be
+///   tracked dynamically at runtime, using [`PyClassGuard`] and
+///   [`PyClassGuardMut`] defined in this module. This works similar to std's
+///   [`RefCell`](std::cell::RefCell) type. Especially when building for
+///   free-threaded Python it gets harder to track which thread borrows which
+///   object at any time. This can lead to method calls failing with
+///   [`PyBorrowError`]. In these cases consider using `frozen` classes together
+///   with Rust interior mutability primitives like [`Mutex`](std::sync::Mutex)
+///   instead of using [`PyClassGuardMut`] to get mutable access.
+///
+/// # Examples
+///
+/// You can use [`PyClassGuard`] as an alternative to a `&self` receiver when
+/// - you need to access the pointer of the `PyClass`, or
+/// - you want to get a super class.
+/// ```
+/// # use pyo3::prelude::*;
+/// # use pyo3::PyClassGuard;
+/// #[pyclass(subclass)]
+/// struct Parent {
+///     basename: &'static str,
+/// }
+///
+/// #[pyclass(extends=Parent)]
+/// struct Child {
+///     name: &'static str,
+///  }
+///
+/// #[pymethods]
+/// impl Child {
+///     #[new]
+///     fn new() -> (Self, Parent) {
+///         (Child { name: "Caterpillar" }, Parent { basename: "Butterfly" })
+///     }
+///
+///     fn format(slf: PyClassGuard<'_, Self>) -> String {
+///         // We can get &Self::BaseType by as_super
+///         let basename = slf.as_super().basename;
+///         format!("{}(base: {})", slf.name, basename)
+///     }
+/// }
+/// # Python::attach(|py| {
+/// #     let sub = Py::new(py, Child::new()).unwrap();
+/// #     pyo3::py_run!(py, sub, "assert sub.format() == 'Caterpillar(base: Butterfly)', sub.format()");
+/// # });
+/// ```
+///
+/// See also [`PyClassGuardMut`] and the [guide] for more information.
+///
+/// [Interior Mutability]:
+///     https://doc.rust-lang.org/book/ch15-05-interior-mutability.html
+///     "RefCell<T> and the Interior Mutability Pattern - The Rust Programming
+///     Language"
+/// [guide]: https://pyo3.rs/latest/class.html#bound-and-interior-mutability
+///     "Bound and interior mutability"
+#[repr(transparent)]
+pub struct PyClassGuard<'a, T: PyClass> {
+    ptr: NonNull<ffi::PyObject>,
+    marker: PhantomData<&'a Py<T>>,
+}
+
+impl<'a, T: PyClass> PyClassGuard<'a, T> {
+    pub(crate) fn try_borrow(obj: &'a Py<T>) -> Result<Self, PyBorrowError> {
+        Self::try_from_class_object(obj.get_class_object())
+    }
+
+    fn try_from_class_object(obj: &'a PyClassObject<T>) -> Result<Self, PyBorrowError> {
+        obj.ensure_threadsafe();
+        obj.borrow_checker().try_borrow().map(|_| Self {
+            ptr: NonNull::from(obj).cast(),
+            marker: PhantomData,
+        })
+    }
+
+    pub(crate) fn as_class_object(&self) -> &'a PyClassObject<T> {
+        // SAFETY: `ptr` by construction points to a `PyClassObject<T>` and is
+        // valid for at least 'a
+        unsafe { self.ptr.cast().as_ref() }
+    }
+
+    /// Consumes the [`PyClassGuard`] and returns a [`PyClassGuardMap`] for a component of the
+    /// borrowed data
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use pyo3::prelude::*;
+    /// # use pyo3::PyClassGuard;
+    ///
+    /// #[pyclass]
+    /// pub struct MyClass {
+    ///     msg: String,
+    /// }
+    ///
+    /// # Python::attach(|py| {
+    /// let obj = Bound::new(py, MyClass { msg: String::from("hello") })?;
+    /// let msg = obj.extract::<PyClassGuard<'_, MyClass>>()?.map(|c| &c.msg);
+    /// assert_eq!(&*msg, "hello");
+    /// # Ok::<_, PyErr>(())
+    /// # }).unwrap();
+    /// ```
+    pub fn map<F, U: ?Sized>(self, f: F) -> PyClassGuardMap<'a, U, false>
+    where
+        F: FnOnce(&T) -> &U,
+    {
+        let slf = std::mem::ManuallyDrop::new(self); // the borrow is released when dropping the `PyClassGuardMap`
+        PyClassGuardMap {
+            ptr: NonNull::from(f(&slf)),
+            checker: slf.as_class_object().borrow_checker(),
+        }
+    }
+}
+
+impl<'a, T, U> PyClassGuard<'a, T>
+where
+    T: PyClass<BaseType = U>,
+    U: PyClass,
+{
+    /// Borrows a shared reference to `PyClassGuard<T::BaseType>`.
+    ///
+    /// With the help of this method, you can access attributes and call methods
+    /// on the superclass without consuming the `PyClassGuard<T>`. This method
+    /// can also be chained to access the super-superclass (and so on).
+    ///
+    /// # Examples
+    /// ```
+    /// # use pyo3::prelude::*;
+    /// # use pyo3::PyClassGuard;
+    /// #[pyclass(subclass)]
+    /// struct Base {
+    ///     base_name: &'static str,
+    /// }
+    /// #[pymethods]
+    /// impl Base {
+    ///     fn base_name_len(&self) -> usize {
+    ///         self.base_name.len()
+    ///     }
+    /// }
+    ///
+    /// #[pyclass(extends=Base)]
+    /// struct Sub {
+    ///     sub_name: &'static str,
+    /// }
+    ///
+    /// #[pymethods]
+    /// impl Sub {
+    ///     #[new]
+    ///     fn new() -> (Self, Base) {
+    ///         (Self { sub_name: "sub_name" }, Base { base_name: "base_name" })
+    ///     }
+    ///     fn sub_name_len(&self) -> usize {
+    ///         self.sub_name.len()
+    ///     }
+    ///     fn format_name_lengths(slf: PyClassGuard<'_, Self>) -> String {
+    ///         format!("{} {}", slf.as_super().base_name_len(), slf.sub_name_len())
+    ///     }
+    /// }
+    /// # Python::attach(|py| {
+    /// #     let sub = Py::new(py, Sub::new()).unwrap();
+    /// #     pyo3::py_run!(py, sub, "assert sub.format_name_lengths() == '9 8'")
+    /// # });
+    /// ```
+    pub fn as_super(&self) -> &PyClassGuard<'a, U> {
+        // SAFETY: `PyClassGuard<T>` and `PyClassGuard<U>` have the same layout
+        unsafe { NonNull::from(self).cast().as_ref() }
+    }
+
+    /// Gets a `PyClassGuard<T::BaseType>`.
+    ///
+    /// With the help of this method, you can get hold of instances of the
+    /// super-superclass when needed.
+    ///
+    /// # Examples
+    /// ```
+    /// # use pyo3::prelude::*;
+    /// # use pyo3::PyClassGuard;
+    /// #[pyclass(subclass)]
+    /// struct Base1 {
+    ///     name1: &'static str,
+    /// }
+    ///
+    /// #[pyclass(extends=Base1, subclass)]
+    /// struct Base2 {
+    ///     name2: &'static str,
+    /// }
+    ///
+    /// #[pyclass(extends=Base2)]
+    /// struct Sub {
+    ///     name3: &'static str,
+    /// }
+    ///
+    /// #[pymethods]
+    /// impl Sub {
+    ///     #[new]
+    ///     fn new() -> PyClassInitializer<Self> {
+    ///         PyClassInitializer::from(Base1 { name1: "base1" })
+    ///             .add_subclass(Base2 { name2: "base2" })
+    ///             .add_subclass(Self { name3: "sub" })
+    ///     }
+    ///     fn name(slf: PyClassGuard<'_, Self>) -> String {
+    ///         let subname = slf.name3;
+    ///         let super_ = slf.into_super();
+    ///         format!("{} {} {}", super_.as_super().name1, super_.name2, subname)
+    ///     }
+    /// }
+    /// # Python::attach(|py| {
+    /// #     let sub = Py::new(py, Sub::new()).unwrap();
+    /// #     pyo3::py_run!(py, sub, "assert sub.name() == 'base1 base2 sub'")
+    /// # });
+    /// ```
+    pub fn into_super(self) -> PyClassGuard<'a, U> {
+        let t_not_frozen = !<T::Frozen as crate::pyclass::boolean_struct::private::Boolean>::VALUE;
+        let u_frozen = <U::Frozen as crate::pyclass::boolean_struct::private::Boolean>::VALUE;
+        if t_not_frozen && u_frozen {
+            // If `T` is a mutable subclass of a frozen `U` base, then it is possible that we need
+            // to release the borrow count now. (e.g. `U` may have a noop borrow checker so dropping
+            // the `PyRef<U>` later would noop and leak the borrow we currently hold.)
+            //
+            // However it's nontrivial, if `U` is frozen but itself has a mutable base class `V`,
+            // then the borrow checker of both `T` and `U` is the shared borrow checker of `V`.
+            //
+            // But it's really hard to prove that in the type system, the soundest thing we can do
+            // is just add a borrow to `U` now and then release the borrow of `T`.
+
+            self.as_super()
+                .as_class_object()
+                .borrow_checker()
+                .try_borrow()
+                .expect("this object is already borrowed");
+
+            self.as_class_object().borrow_checker().release_borrow()
+        };
+        PyClassGuard {
+            ptr: std::mem::ManuallyDrop::new(self).ptr,
+            marker: PhantomData,
+        }
+    }
+}
+
+impl<T: PyClass> Deref for PyClassGuard<'_, T> {
+    type Target = T;
+
+    #[inline]
+    fn deref(&self) -> &T {
+        // SAFETY: `PyClassObject<T>` contains a valid `T`, by construction no
+        // mutable alias is enforced
+        unsafe { &*self.as_class_object().get_ptr().cast_const() }
+    }
+}
+
+impl<'a, 'py, T: PyClass> FromPyObject<'a, 'py> for PyClassGuard<'a, T> {
+    type Error = PyClassGuardError<'a, 'py>;
+
+    fn extract(obj: Borrowed<'a, 'py, crate::PyAny>) -> Result<Self, Self::Error> {
+        Self::try_from_class_object(
+            obj.cast()
+                .map_err(|e| PyClassGuardError(Some(e)))?
+                .get_class_object(),
+        )
+        .map_err(|_| PyClassGuardError(None))
+    }
+}
+
+impl<'a, 'py, T: PyClass> IntoPyObject<'py> for PyClassGuard<'a, T> {
+    type Target = T;
+    type Output = Borrowed<'a, 'py, T>;
+    type Error = Infallible;
+
+    #[inline]
+    fn into_pyobject(self, py: crate::Python<'py>) -> Result<Self::Output, Self::Error> {
+        (&self).into_pyobject(py)
+    }
+}
+
+impl<'a, 'py, T: PyClass> IntoPyObject<'py> for &PyClassGuard<'a, T> {
+    type Target = T;
+    type Output = Borrowed<'a, 'py, T>;
+    type Error = Infallible;
+
+    #[cfg(feature = "experimental-inspect")]
+    const OUTPUT_TYPE: TypeHint = T::TYPE_HINT;
+
+    #[inline]
+    fn into_pyobject(self, py: crate::Python<'py>) -> Result<Self::Output, Self::Error> {
+        // SAFETY: `ptr` is guaranteed to be valid for 'a and points to an
+        // object of type T
+        unsafe { Ok(Borrowed::from_non_null(py, self.ptr).cast_unchecked()) }
+    }
+}
+
+impl<T: PyClass> Drop for PyClassGuard<'_, T> {
+    /// Releases the shared borrow
+    fn drop(&mut self) {
+        self.as_class_object().borrow_checker().release_borrow()
+    }
+}
+
+// SAFETY: `PyClassGuard` only provides access to the inner `T` (and no other
+// Python APIs) which does not require a Python thread state
+#[cfg(feature = "nightly")]
+unsafe impl<T: PyClass> crate::marker::Ungil for PyClassGuard<'_, T> {}
+// SAFETY: we provide access to
+// - `&T`, which requires `T: Sync` to be Send and `T: Sync` to be Sync
+unsafe impl<T: PyClass + Sync> Send for PyClassGuard<'_, T> {}
+unsafe impl<T: PyClass + Sync> Sync for PyClassGuard<'_, T> {}
+
+/// Custom error type for extracting a [PyClassGuard]
+pub struct PyClassGuardError<'a, 'py>(pub(crate) Option<CastError<'a, 'py>>);
+
+impl fmt::Debug for PyClassGuardError<'_, '_> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        if let Some(e) = &self.0 {
+            write!(f, "{e:?}")
+        } else {
+            write!(f, "{:?}", PyBorrowError::new())
+        }
+    }
+}
+
+impl fmt::Display for PyClassGuardError<'_, '_> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        if let Some(e) = &self.0 {
+            write!(f, "{e}")
+        } else {
+            write!(f, "{}", PyBorrowError::new())
+        }
+    }
+}
+
+impl From<PyClassGuardError<'_, '_>> for PyErr {
+    fn from(value: PyClassGuardError<'_, '_>) -> Self {
+        if let Some(e) = value.0 {
+            e.into()
+        } else {
+            PyBorrowError::new().into()
+        }
+    }
+}
+
+/// A wrapper type for a mutably borrowed value from a `PyClass`
+///
+/// # When *not* to use [`PyClassGuardMut`]
+///
+/// Usually you can use `&mut` references as method and function receivers and
+/// arguments, and you won't need to use [`PyClassGuardMut`] directly:
+///
+/// ```rust,no_run
+/// use pyo3::prelude::*;
+///
+/// #[pyclass]
+/// struct Number {
+///     inner: u32,
+/// }
+///
+/// #[pymethods]
+/// impl Number {
+///     fn increment(&mut self) {
+///         self.inner += 1;
+///     }
+/// }
+/// ```
+///
+/// The [`#[pymethods]`](crate::pymethods) proc macro will generate this wrapper
+/// function (and more), using [`PyClassGuardMut`] under the hood:
+///
+/// ```rust,no_run
+/// # use pyo3::prelude::*;
+/// # #[pyclass]
+/// # struct Number {
+/// #    inner: u32,
+/// # }
+/// #
+/// # #[pymethods]
+/// # impl Number {
+/// #    fn increment(&mut self) {
+/// #        self.inner += 1;
+/// #    }
+/// # }
+/// #
+/// // The function which is exported to Python looks roughly like the following
+/// unsafe extern "C" fn __pymethod_increment__(
+///     _slf: *mut ::pyo3::ffi::PyObject,
+///     _args: *mut ::pyo3::ffi::PyObject,
+/// ) -> *mut ::pyo3::ffi::PyObject {
+///     unsafe fn inner<'py>(
+///         py: ::pyo3::Python<'py>,
+///         _slf: *mut ::pyo3::ffi::PyObject,
+///     ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
+///         let function = Number::increment;
+/// #       #[allow(clippy::let_unit_value)]
+///         let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
+///         let result = {
+///             let ret = function(::pyo3::impl_::extract_argument::extract_pyclass_ref_mut::<Number>(
+///                 unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }.0,
+///                 &mut holder_0,
+///             )?);
+///             {
+///                 let result = {
+///                     let obj = ret;
+/// #                   #[allow(clippy::useless_conversion)]
+///                     ::pyo3::impl_::wrap::converter(&obj)
+///                         .wrap(obj)
+///                         .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
+///                 };
+///                 ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
+///             }
+///         };
+///         result
+///     }
+///
+///     unsafe {
+///         ::pyo3::impl_::trampoline::noargs(
+///             _slf,
+///             _args,
+///             inner,
+///         )
+///     }
+/// }
+/// ```
+///
+/// # When to use [`PyClassGuardMut`]
+/// ## Using PyClasses from Rust
+///
+/// However, we *do* need [`PyClassGuardMut`] if we want to call its methods
+/// from Rust:
+/// ```rust
+/// # use pyo3::prelude::*;
+/// # use pyo3::{PyClassGuard, PyClassGuardMut};
+/// #
+/// # #[pyclass]
+/// # struct Number {
+/// #     inner: u32,
+/// # }
+/// #
+/// # #[pymethods]
+/// # impl Number {
+/// #     fn increment(&mut self) {
+/// #         self.inner += 1;
+/// #     }
+/// # }
+/// # fn main() -> PyResult<()> {
+/// Python::attach(|py| {
+///     let n = Py::new(py, Number { inner: 0 })?;
+///
+///     // We borrow the guard and then dereference
+///     // it to get a mutable reference to Number
+///     let mut guard: PyClassGuardMut<'_, Number> = n.extract(py)?;
+///     let n_mutable: &mut Number = &mut *guard;
+///
+///     n_mutable.increment();
+///
+///     // To avoid panics we must dispose of the
+///     // `PyClassGuardMut` before borrowing again.
+///     drop(guard);
+///
+///     let n_immutable: &Number = &*n.extract::<PyClassGuard<'_, Number>>(py)?;
+///     assert_eq!(n_immutable.inner, 1);
+///
+///     Ok(())
+/// })
+/// # }
+/// ```
+/// ## Dealing with possibly overlapping mutable references
+///
+/// It is also necessary to use [`PyClassGuardMut`] if you can receive mutable
+/// arguments that may overlap. Suppose the following function that swaps the
+/// values of two `Number`s:
+/// ```
+/// # use pyo3::prelude::*;
+/// # #[pyclass]
+/// # pub struct Number {
+/// #     inner: u32,
+/// # }
+/// #[pyfunction]
+/// fn swap_numbers(a: &mut Number, b: &mut Number) {
+///     std::mem::swap(&mut a.inner, &mut b.inner);
+/// }
+/// # fn main() {
+/// #     Python::attach(|py| {
+/// #         let n = Py::new(py, Number{inner: 35}).unwrap();
+/// #         let n2 = n.clone_ref(py);
+/// #         assert!(n.is(&n2));
+/// #         let fun = pyo3::wrap_pyfunction!(swap_numbers, py).unwrap();
+/// #         fun.call1((n, n2)).expect_err("Managed to create overlapping mutable references. Note: this is undefined behaviour.");
+/// #     });
+/// # }
+/// ```
+/// When users pass in the same `Number` as both arguments, one of the mutable
+/// borrows will fail and raise a `RuntimeError`:
+/// ```text
+/// >>> a = Number()
+/// >>> swap_numbers(a, a)
+/// Traceback (most recent call last):
+///   File "<stdin>", line 1, in <module>
+///   RuntimeError: Already borrowed
+/// ```
+///
+/// It is better to write that function like this:
+/// ```rust
+/// # use pyo3::prelude::*;
+/// # use pyo3::{PyClassGuard, PyClassGuardMut};
+/// # #[pyclass]
+/// # pub struct Number {
+/// #     inner: u32,
+/// # }
+/// #[pyfunction]
+/// fn swap_numbers(a: &Bound<'_, Number>, b: &Bound<'_, Number>) -> PyResult<()> {
+///     // Check that the pointers are unequal
+///     if !a.is(b) {
+///         let mut a: PyClassGuardMut<'_, Number> = a.extract()?;
+///         let mut b: PyClassGuardMut<'_, Number> = b.extract()?;
+///         std::mem::swap(&mut a.inner, &mut b.inner);
+///     } else {
+///         // Do nothing - they are the same object, so don't need swapping.
+///     }
+///     Ok(())
+/// }
+/// # fn main() {
+/// #     // With duplicate numbers
+/// #     Python::attach(|py| {
+/// #         let n = Py::new(py, Number{inner: 35}).unwrap();
+/// #         let n2 = n.clone_ref(py);
+/// #         assert!(n.is(&n2));
+/// #         let fun = pyo3::wrap_pyfunction!(swap_numbers, py).unwrap();
+/// #         fun.call1((n, n2)).unwrap();
+/// #     });
+/// #
+/// #     // With two different numbers
+/// #     Python::attach(|py| {
+/// #         let n = Py::new(py, Number{inner: 35}).unwrap();
+/// #         let n2 = Py::new(py, Number{inner: 42}).unwrap();
+/// #         assert!(!n.is(&n2));
+/// #         let fun = pyo3::wrap_pyfunction!(swap_numbers, py).unwrap();
+/// #         fun.call1((&n, &n2)).unwrap();
+/// #         let n: u32 = n.extract::<PyClassGuard<'_, Number>>(py).unwrap().inner;
+/// #         let n2: u32 = n2.extract::<PyClassGuard<'_, Number>>(py).unwrap().inner;
+/// #         assert_eq!(n, 42);
+/// #         assert_eq!(n2, 35);
+/// #     });
+/// # }
+/// ```
+/// See [`PyClassGuard`] and the [guide] for more information.
+///
+/// [guide]: https://pyo3.rs/latest/class.html#bound-and-interior-mutability
+///     "Bound and interior mutability"
+#[repr(transparent)]
+pub struct PyClassGuardMut<'a, T: PyClass<Frozen = False>> {
+    ptr: NonNull<ffi::PyObject>,
+    marker: PhantomData<&'a Py<T>>,
+}
+
+impl<'a, T: PyClass<Frozen = False>> PyClassGuardMut<'a, T> {
+    pub(crate) fn try_borrow_mut(obj: &'a Py<T>) -> Result<Self, PyBorrowMutError> {
+        Self::try_from_class_object(obj.get_class_object())
+    }
+
+    fn try_from_class_object(obj: &'a PyClassObject<T>) -> Result<Self, PyBorrowMutError> {
+        obj.ensure_threadsafe();
+        obj.borrow_checker().try_borrow_mut().map(|_| Self {
+            ptr: NonNull::from(obj).cast(),
+            marker: PhantomData,
+        })
+    }
+
+    pub(crate) fn as_class_object(&self) -> &'a PyClassObject<T> {
+        // SAFETY: `ptr` by construction points to a `PyClassObject<T>` and is
+        // valid for at least 'a
+        unsafe { self.ptr.cast().as_ref() }
+    }
+
+    /// Consumes the [`PyClassGuardMut`] and returns a [`PyClassGuardMap`] for a component of the
+    /// borrowed data
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use pyo3::prelude::*;
+    /// # use pyo3::PyClassGuardMut;
+    ///
+    /// #[pyclass]
+    /// pub struct MyClass {
+    ///     data: [i32; 100],
+    /// }
+    ///
+    /// # Python::attach(|py| {
+    /// let obj = Bound::new(py, MyClass { data: [0; 100] })?;
+    /// let mut data = obj.extract::<PyClassGuardMut<'_, MyClass>>()?.map(|c| c.data.as_mut_slice());
+    /// data[0] = 42;
+    /// # Ok::<_, PyErr>(())
+    /// # }).unwrap();
+    /// ```
+    pub fn map<F, U: ?Sized>(self, f: F) -> PyClassGuardMap<'a, U, true>
+    where
+        F: FnOnce(&mut T) -> &mut U,
+    {
+        let mut slf = std::mem::ManuallyDrop::new(self); // the borrow is released when dropping the `PyClassGuardMap`
+        PyClassGuardMap {
+            ptr: NonNull::from(f(&mut slf)),
+            checker: slf.as_class_object().borrow_checker(),
+        }
+    }
+}
+
+impl<'a, T, U> PyClassGuardMut<'a, T>
+where
+    T: PyClass<BaseType = U, Frozen = False>,
+    U: PyClass<Frozen = False>,
+{
+    /// Borrows a mutable reference to `PyClassGuardMut<T::BaseType>`.
+    ///
+    /// With the help of this method, you can mutate attributes and call
+    /// mutating methods on the superclass without consuming the
+    /// `PyClassGuardMut<T>`. This method can also be chained to access the
+    /// super-superclass (and so on).
+    ///
+    /// See [`PyClassGuard::as_super`] for more.
+    pub fn as_super(&mut self) -> &mut PyClassGuardMut<'a, U> {
+        // SAFETY: `PyClassGuardMut<T>` and `PyClassGuardMut<U>` have the same layout
+        unsafe { NonNull::from(self).cast().as_mut() }
+    }
+
+    /// Gets a `PyClassGuardMut<T::BaseType>`.
+    ///
+    /// See [`PyClassGuard::into_super`] for more.
+    pub fn into_super(self) -> PyClassGuardMut<'a, U> {
+        // `PyClassGuardMut` is only available for non-frozen classes, so there
+        // is no possibility of leaking borrows like `PyClassGuard`
+        PyClassGuardMut {
+            ptr: std::mem::ManuallyDrop::new(self).ptr,
+            marker: PhantomData,
+        }
+    }
+}
+
+impl<T: PyClass<Frozen = False>> Deref for PyClassGuardMut<'_, T> {
+    type Target = T;
+
+    #[inline]
+    fn deref(&self) -> &T {
+        // SAFETY: `PyClassObject<T>` contains a valid `T`, by construction no
+        // alias is enforced
+        unsafe { &*self.as_class_object().get_ptr().cast_const() }
+    }
+}
+impl<T: PyClass<Frozen = False>> DerefMut for PyClassGuardMut<'_, T> {
+    #[inline]
+    fn deref_mut(&mut self) -> &mut T {
+        // SAFETY: `PyClassObject<T>` contains a valid `T`, by construction no
+        // alias is enforced
+        unsafe { &mut *self.as_class_object().get_ptr() }
+    }
+}
+
+impl<'a, 'py, T: PyClass<Frozen = False>> FromPyObject<'a, 'py> for PyClassGuardMut<'a, T> {
+    type Error = PyClassGuardMutError<'a, 'py>;
+
+    fn extract(obj: Borrowed<'a, 'py, crate::PyAny>) -> Result<Self, Self::Error> {
+        Self::try_from_class_object(
+            obj.cast()
+                .map_err(|e| PyClassGuardMutError(Some(e)))?
+                .get_class_object(),
+        )
+        .map_err(|_| PyClassGuardMutError(None))
+    }
+}
+
+impl<'a, 'py, T: PyClass<Frozen = False>> IntoPyObject<'py> for PyClassGuardMut<'a, T> {
+    type Target = T;
+    type Output = Borrowed<'a, 'py, T>;
+    type Error = Infallible;
+
+    #[inline]
+    fn into_pyobject(self, py: crate::Python<'py>) -> Result<Self::Output, Self::Error> {
+        (&self).into_pyobject(py)
+    }
+}
+
+impl<'a, 'py, T: PyClass<Frozen = False>> IntoPyObject<'py> for &PyClassGuardMut<'a, T> {
+    type Target = T;
+    type Output = Borrowed<'a, 'py, T>;
+    type Error = Infallible;
+
+    #[inline]
+    fn into_pyobject(self, py: crate::Python<'py>) -> Result<Self::Output, Self::Error> {
+        // SAFETY: `ptr` is guaranteed to be valid for 'a and points to an
+        // object of type T
+        unsafe { Ok(Borrowed::from_non_null(py, self.ptr).cast_unchecked()) }
+    }
+}
+
+impl<T: PyClass<Frozen = False>> Drop for PyClassGuardMut<'_, T> {
+    /// Releases the mutable borrow
+    fn drop(&mut self) {
+        self.as_class_object().borrow_checker().release_borrow_mut()
+    }
+}
+
+// SAFETY: `PyClassGuardMut` only provides access to the inner `T` (and no other
+// Python APIs) which does not require a Python thread state
+#[cfg(feature = "nightly")]
+unsafe impl<T: PyClass<Frozen = False>> crate::marker::Ungil for PyClassGuardMut<'_, T> {}
+// SAFETY: we provide access to
+// - `&T`, which requires `T: Sync` to be Send and `T: Sync` to be Sync
+// - `&mut T`, which requires `T: Send` to be Send and `T: Sync` to be Sync
+unsafe impl<T: PyClass<Frozen = False> + Send + Sync> Send for PyClassGuardMut<'_, T> {}
+unsafe impl<T: PyClass<Frozen = False> + Sync> Sync for PyClassGuardMut<'_, T> {}
+
+/// Custom error type for extracting a [PyClassGuardMut]
+pub struct PyClassGuardMutError<'a, 'py>(pub(crate) Option<CastError<'a, 'py>>);
+
+impl fmt::Debug for PyClassGuardMutError<'_, '_> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        if let Some(e) = &self.0 {
+            write!(f, "{e:?}")
+        } else {
+            write!(f, "{:?}", PyBorrowMutError::new())
+        }
+    }
+}
+
+impl fmt::Display for PyClassGuardMutError<'_, '_> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        if let Some(e) = &self.0 {
+            write!(f, "{e}")
+        } else {
+            write!(f, "{}", PyBorrowMutError::new())
+        }
+    }
+}
+
+impl From<PyClassGuardMutError<'_, '_>> for PyErr {
+    fn from(value: PyClassGuardMutError<'_, '_>) -> Self {
+        if let Some(e) = value.0 {
+            e.into()
+        } else {
+            PyBorrowMutError::new().into()
+        }
+    }
+}
+
+/// Wraps a borrowed reference `U` to a value stored inside of a pyclass `T`
+///
+/// See [`PyClassGuard::map`] and [`PyClassGuardMut::map`]
+pub struct PyClassGuardMap<'a, U: ?Sized, const MUT: bool> {
+    ptr: NonNull<U>,
+    checker: &'a dyn PyClassBorrowChecker,
+}
+
+impl<U: ?Sized, const MUT: bool> Deref for PyClassGuardMap<'_, U, MUT> {
+    type Target = U;
+
+    fn deref(&self) -> &U {
+        // SAFETY: `checker` guards our access to the `T` that `U` points into
+        unsafe { self.ptr.as_ref() }
+    }
+}
+
+impl<U: ?Sized> DerefMut for PyClassGuardMap<'_, U, true> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        // SAFETY: `checker` guards our access to the `T` that `U` points into
+        unsafe { self.ptr.as_mut() }
+    }
+}
+
+impl<U: ?Sized, const MUT: bool> Drop for PyClassGuardMap<'_, U, MUT> {
+    fn drop(&mut self) {
+        if MUT {
+            self.checker.release_borrow_mut();
+        } else {
+            self.checker.release_borrow();
+        }
+    }
+}
+
+#[cfg(test)]
+#[cfg(feature = "macros")]
+mod tests {
+    use super::{PyClassGuard, PyClassGuardMut};
+    use crate::{types::PyAnyMethods as _, Bound, IntoPyObject as _, Py, PyErr, Python};
+
+    #[test]
+    fn test_into_frozen_super_released_borrow() {
+        #[crate::pyclass]
+        #[pyo3(crate = "crate", subclass, frozen)]
+        struct BaseClass {}
+
+        #[crate::pyclass]
+        #[pyo3(crate = "crate", extends=BaseClass, subclass)]
+        struct SubClass {}
+
+        #[crate::pymethods]
+        #[pyo3(crate = "crate")]
+        impl SubClass {
+            #[new]
+            fn new(py: Python<'_>) -> Py<SubClass> {
+                let init = crate::PyClassInitializer::from(BaseClass {}).add_subclass(SubClass {});
+                Py::new(py, init).expect("allocation error")
+            }
+        }
+
+        Python::attach(|py| {
+            let obj = SubClass::new(py);
+            drop(PyClassGuard::try_borrow(&obj).unwrap().into_super());
+            assert!(PyClassGuardMut::try_borrow_mut(&obj).is_ok());
+        })
+    }
+
+    #[test]
+    fn test_into_frozen_super_mutable_base_holds_borrow() {
+        #[crate::pyclass]
+        #[pyo3(crate = "crate", subclass)]
+        struct BaseClass {}
+
+        #[crate::pyclass]
+        #[pyo3(crate = "crate", extends=BaseClass, subclass, frozen)]
+        struct SubClass {}
+
+        #[crate::pyclass]
+        #[pyo3(crate = "crate", extends=SubClass, subclass)]
+        struct SubSubClass {}
+
+        #[crate::pymethods]
+        #[pyo3(crate = "crate")]
+        impl SubSubClass {
+            #[new]
+            fn new(py: Python<'_>) -> Py<SubSubClass> {
+                let init = crate::PyClassInitializer::from(BaseClass {})
+                    .add_subclass(SubClass {})
+                    .add_subclass(SubSubClass {});
+                Py::new(py, init).expect("allocation error")
+            }
+        }
+
+        Python::attach(|py| {
+            let obj = SubSubClass::new(py);
+            let _super_borrow = PyClassGuard::try_borrow(&obj).unwrap().into_super();
+            // the whole object still has an immutable borrow, so we cannot
+            // borrow any part mutably (the borrowflag is shared)
+            assert!(PyClassGuardMut::try_borrow_mut(&obj).is_err());
+        })
+    }
+
+    #[crate::pyclass]
+    #[pyo3(crate = "crate", subclass)]
+    struct BaseClass {
+        val1: usize,
+    }
+
+    #[crate::pyclass]
+    #[pyo3(crate = "crate", extends=BaseClass, subclass)]
+    struct SubClass {
+        val2: usize,
+    }
+
+    #[crate::pyclass]
+    #[pyo3(crate = "crate", extends=SubClass)]
+    struct SubSubClass {
+        #[pyo3(get)]
+        val3: usize,
+    }
+
+    #[crate::pymethods]
+    #[pyo3(crate = "crate")]
+    impl SubSubClass {
+        #[new]
+        fn new(py: Python<'_>) -> Py<SubSubClass> {
+            let init = crate::PyClassInitializer::from(BaseClass { val1: 10 })
+                .add_subclass(SubClass { val2: 15 })
+                .add_subclass(SubSubClass { val3: 20 });
+            Py::new(py, init).expect("allocation error")
+        }
+
+        fn get_values(self_: PyClassGuard<'_, Self>) -> (usize, usize, usize) {
+            let val1 = self_.as_super().as_super().val1;
+            let val2 = self_.as_super().val2;
+            (val1, val2, self_.val3)
+        }
+
+        fn double_values(mut self_: PyClassGuardMut<'_, Self>) {
+            self_.as_super().as_super().val1 *= 2;
+            self_.as_super().val2 *= 2;
+            self_.val3 *= 2;
+        }
+
+        fn __add__<'a>(
+            mut slf: PyClassGuardMut<'a, Self>,
+            other: PyClassGuard<'a, Self>,
+        ) -> PyClassGuardMut<'a, Self> {
+            slf.val3 += other.val3;
+            slf
+        }
+
+        fn __rsub__<'a>(
+            slf: PyClassGuard<'a, Self>,
+            mut other: PyClassGuardMut<'a, Self>,
+        ) -> PyClassGuardMut<'a, Self> {
+            other.val3 -= slf.val3;
+            other
+        }
+    }
+
+    #[test]
+    fn test_pyclassguard_into_pyobject() {
+        Python::attach(|py| {
+            let class = Py::new(py, BaseClass { val1: 42 })?;
+            let guard = PyClassGuard::try_borrow(&class).unwrap();
+            let new_ref = (&guard).into_pyobject(py)?;
+            assert!(new_ref.is(&class));
+            let new = guard.into_pyobject(py)?;
+            assert!(new.is(&class));
+            Ok::<_, PyErr>(())
+        })
+        .unwrap();
+    }
+
+    #[test]
+    fn test_pyclassguardmut_into_pyobject() {
+        Python::attach(|py| {
+            let class = Py::new(py, BaseClass { val1: 42 })?;
+            let guard = PyClassGuardMut::try_borrow_mut(&class).unwrap();
+            let new_ref = (&guard).into_pyobject(py)?;
+            assert!(new_ref.is(&class));
+            let new = guard.into_pyobject(py)?;
+            assert!(new.is(&class));
+            Ok::<_, PyErr>(())
+        })
+        .unwrap();
+    }
+    #[test]
+    fn test_pyclassguard_as_super() {
+        Python::attach(|py| {
+            let obj = SubSubClass::new(py).into_bound(py);
+            let pyref = PyClassGuard::try_borrow(obj.as_unbound()).unwrap();
+            assert_eq!(pyref.as_super().as_super().val1, 10);
+            assert_eq!(pyref.as_super().val2, 15);
+            assert_eq!(pyref.val3, 20);
+            assert_eq!(SubSubClass::get_values(pyref), (10, 15, 20));
+        });
+    }
+
+    #[test]
+    fn test_pyclassguardmut_as_super() {
+        Python::attach(|py| {
+            let obj = SubSubClass::new(py).into_bound(py);
+            assert_eq!(
+                SubSubClass::get_values(PyClassGuard::try_borrow(obj.as_unbound()).unwrap()),
+                (10, 15, 20)
+            );
+            {
+                let mut pyrefmut = PyClassGuardMut::try_borrow_mut(obj.as_unbound()).unwrap();
+                assert_eq!(pyrefmut.as_super().as_super().val1, 10);
+                pyrefmut.as_super().as_super().val1 -= 5;
+                pyrefmut.as_super().val2 -= 5;
+                pyrefmut.val3 -= 5;
+            }
+            assert_eq!(
+                SubSubClass::get_values(PyClassGuard::try_borrow(obj.as_unbound()).unwrap()),
+                (5, 10, 15)
+            );
+            SubSubClass::double_values(PyClassGuardMut::try_borrow_mut(obj.as_unbound()).unwrap());
+            assert_eq!(
+                SubSubClass::get_values(PyClassGuard::try_borrow(obj.as_unbound()).unwrap()),
+                (10, 20, 30)
+            );
+        });
+    }
+
+    #[test]
+    fn test_extract_guard() {
+        Python::attach(|py| {
+            let obj1 = SubSubClass::new(py);
+            let obj2 = SubSubClass::new(py);
+            crate::py_run!(py, obj1 obj2, "assert ((obj1 + obj2) - obj2).val3 == obj1.val3");
+        });
+    }
+
+    #[test]
+    fn test_pyclassguards_in_python() {
+        Python::attach(|py| {
+            let obj = SubSubClass::new(py);
+            crate::py_run!(py, obj, "assert obj.get_values() == (10, 15, 20)");
+            crate::py_run!(py, obj, "assert obj.double_values() is None");
+            crate::py_run!(py, obj, "assert obj.get_values() == (20, 30, 40)");
+        });
+    }
+
+    #[crate::pyclass]
+    #[pyo3(crate = "crate")]
+    pub struct MyClass {
+        data: [i32; 100],
+    }
+
+    #[test]
+    fn test_pyclassguard_map() {
+        Python::attach(|py| {
+            let obj = Bound::new(py, MyClass { data: [0; 100] })?;
+            let data = PyClassGuard::try_borrow(obj.as_unbound())?.map(|c| &c.data);
+            assert_eq!(data[0], 0);
+            assert!(obj.try_borrow_mut().is_err()); // obj is still protected
+            drop(data);
+            assert!(obj.try_borrow_mut().is_ok()); // drop released shared borrow
+            Ok::<_, PyErr>(())
+        })
+        .unwrap()
+    }
+
+    #[test]
+    fn test_pyclassguardmut_map() {
+        Python::attach(|py| {
+            let obj = Bound::new(py, MyClass { data: [0; 100] })?;
+            let mut data =
+                PyClassGuardMut::try_borrow_mut(obj.as_unbound())?.map(|c| c.data.as_mut_slice());
+            assert_eq!(data[0], 0);
+            data[0] = 5;
+            assert_eq!(data[0], 5);
+            assert!(obj.try_borrow_mut().is_err()); // obj is still protected
+            drop(data);
+            assert!(obj.try_borrow_mut().is_ok()); // drop released mutable borrow
+            Ok::<_, PyErr>(())
+        })
+        .unwrap()
+    }
+
+    #[test]
+    fn test_pyclassguard_map_unrelated() {
+        use crate::types::{PyString, PyStringMethods};
+        Python::attach(|py| {
+            let obj = Bound::new(py, MyClass { data: [0; 100] })?;
+            let string = PyString::new(py, "pyo3");
+            // It is possible to return something not borrowing from the guard, but that shouldn't
+            // matter. `RefCell` has the same behaviour
+            let refmap = PyClassGuard::try_borrow(obj.as_unbound())?.map(|_| &string);
+            assert_eq!(refmap.to_cow()?, "pyo3");
+            Ok::<_, PyErr>(())
+        })
+        .unwrap()
+    }
+}
diff --git a/src/pyclass_init.rs b/src/pyclass_init.rs
index 63761f435bb..507fa24c2be 100644
--- a/src/pyclass_init.rs
+++ b/src/pyclass_init.rs
@@ -1,14 +1,12 @@
 //! Contains initialization utilities for `#[pyclass]`.
-use crate::callback::IntoPyCallbackOutput;
+use crate::ffi_ptr_ext::FfiPtrExt;
+use crate::impl_::callback::IntoPyCallbackOutput;
 use crate::impl_::pyclass::{PyClassBaseType, PyClassDict, PyClassThreadChecker, PyClassWeakRef};
-use crate::{ffi, Py, PyCell, PyClass, PyErr, PyResult, Python};
+use crate::impl_::pyclass_init::{PyNativeTypeInitializer, PyObjectInit};
+use crate::{ffi, Bound, Py, PyClass, PyResult, Python};
 use crate::{
     ffi::PyTypeObject,
-    pycell::{
-        impl_::{PyClassBorrowChecker, PyClassMutability},
-        PyCellContents,
-    },
-    type_object::{get_tp_alloc, PyTypeInfo},
+    pycell::impl_::{PyClassBorrowChecker, PyClassMutability, PyClassObjectContents},
 };
 use std::{
     cell::UnsafeCell,
@@ -16,75 +14,6 @@ use std::{
     mem::{ManuallyDrop, MaybeUninit},
 };
 
-/// Initializer for Python types.
-///
-/// This trait is intended to use internally for distinguishing `#[pyclass]` and
-/// Python native types.
-pub trait PyObjectInit<T>: Sized {
-    /// # Safety
-    /// - `subtype` must be a valid pointer to a type object of T or a subclass.
-    unsafe fn into_new_object(
-        self,
-        py: Python<'_>,
-        subtype: *mut PyTypeObject,
-    ) -> PyResult<*mut ffi::PyObject>;
-    private_decl! {}
-}
-
-/// Initializer for Python native types, like `PyDict`.
-pub struct PyNativeTypeInitializer<T: PyTypeInfo>(PhantomData<T>);
-
-impl<T: PyTypeInfo> PyObjectInit<T> for PyNativeTypeInitializer<T> {
-    unsafe fn into_new_object(
-        self,
-        py: Python<'_>,
-        subtype: *mut PyTypeObject,
-    ) -> PyResult<*mut ffi::PyObject> {
-        unsafe fn inner(
-            py: Python<'_>,
-            type_object: *mut PyTypeObject,
-            subtype: *mut PyTypeObject,
-        ) -> PyResult<*mut ffi::PyObject> {
-            // HACK (due to FIXME below): PyBaseObject_Type's tp_new isn't happy with NULL arguments
-            let is_base_object = type_object == std::ptr::addr_of_mut!(ffi::PyBaseObject_Type);
-            if is_base_object {
-                let alloc = get_tp_alloc(subtype).unwrap_or(ffi::PyType_GenericAlloc);
-                let obj = alloc(subtype, 0);
-                return if obj.is_null() {
-                    Err(PyErr::fetch(py))
-                } else {
-                    Ok(obj)
-                };
-            }
-
-            #[cfg(Py_LIMITED_API)]
-            unreachable!("subclassing native types is not possible with the `abi3` feature");
-
-            #[cfg(not(Py_LIMITED_API))]
-            {
-                match (*type_object).tp_new {
-                    // FIXME: Call __new__ with actual arguments
-                    Some(newfunc) => {
-                        let obj = newfunc(subtype, std::ptr::null_mut(), std::ptr::null_mut());
-                        if obj.is_null() {
-                            Err(PyErr::fetch(py))
-                        } else {
-                            Ok(obj)
-                        }
-                    }
-                    None => Err(crate::exceptions::PyTypeError::new_err(
-                        "base type without tp_new",
-                    )),
-                }
-            }
-        }
-        let type_object = T::type_object_raw(py);
-        inner(py, type_object, subtype)
-    }
-
-    private_impl! {}
-}
-
 /// Initializer for our `#[pyclass]` system.
 ///
 /// You can use this type to initialize complicatedly nested `#[pyclass]`.
@@ -121,7 +50,7 @@ impl<T: PyTypeInfo> PyObjectInit<T> for PyNativeTypeInitializer<T> {
 ///             })
 ///     }
 /// }
-/// Python::with_gil(|py| {
+/// Python::attach(|py| {
 ///     let typeobj = py.get_type::<SubSubClass>();
 ///     let sub_sub_class = typeobj.call((), None).unwrap();
 ///     py_run!(
@@ -148,7 +77,14 @@ impl<T: PyClass> PyClassInitializer<T> {
     /// Constructs a new initializer from value `T` and base class' initializer.
     ///
     /// It is recommended to use `add_subclass` instead of this method for most usage.
+    #[track_caller]
+    #[inline]
     pub fn new(init: T, super_init: <T::BaseType as PyClassBaseType>::Initializer) -> Self {
+        // This is unsound; see https://github.com/PyO3/pyo3/issues/4452.
+        assert!(
+            super_init.can_be_subclassed(),
+            "you cannot add a subclass to an existing value",
+        );
         Self(PyClassInitializerImpl::New { init, super_init })
     }
 
@@ -183,7 +119,7 @@ impl<T: PyClass> PyClassInitializer<T> {
     /// }
     ///
     /// fn main() -> PyResult<()> {
-    ///     Python::with_gil(|py| {
+    ///     Python::attach(|py| {
     ///         let m = PyModule::new(py, "example")?;
     ///         m.add_class::<SubClass>()?;
     ///         m.add_class::<BaseClass>()?;
@@ -198,6 +134,8 @@ impl<T: PyClass> PyClassInitializer<T> {
     ///     })
     /// }
     /// ```
+    #[track_caller]
+    #[inline]
     pub fn add_subclass<S>(self, subclass_value: S) -> PyClassInitializer<S>
     where
         S: PyClass<BaseType = T>,
@@ -206,69 +144,77 @@ impl<T: PyClass> PyClassInitializer<T> {
         PyClassInitializer::new(subclass_value, self)
     }
 
-    /// Creates a new PyCell and initializes it.
-    #[doc(hidden)]
-    pub fn create_cell(self, py: Python<'_>) -> PyResult<*mut PyCell<T>>
+    /// Creates a new class object and initializes it.
+    pub(crate) fn create_class_object(self, py: Python<'_>) -> PyResult<Bound<'_, T>>
     where
         T: PyClass,
     {
-        unsafe { self.create_cell_from_subtype(py, T::type_object_raw(py)) }
+        unsafe { self.create_class_object_of_type(py, T::type_object_raw(py)) }
     }
 
-    /// Creates a new PyCell and initializes it given a typeobject `subtype`.
-    /// Called by the Python `tp_new` implementation generated by a `#[new]` function in a `#[pymethods]` block.
+    /// Creates a new class object and initializes it given a typeobject `subtype`.
     ///
     /// # Safety
     /// `subtype` must be a valid pointer to the type object of T or a subclass.
-    #[doc(hidden)]
-    pub unsafe fn create_cell_from_subtype(
+    pub(crate) unsafe fn create_class_object_of_type(
         self,
         py: Python<'_>,
-        subtype: *mut crate::ffi::PyTypeObject,
-    ) -> PyResult<*mut PyCell<T>>
+        target_type: *mut crate::ffi::PyTypeObject,
+    ) -> PyResult<Bound<'_, T>>
     where
         T: PyClass,
     {
-        self.into_new_object(py, subtype).map(|obj| obj as _)
-    }
-}
-
-impl<T: PyClass> PyObjectInit<T> for PyClassInitializer<T> {
-    unsafe fn into_new_object(
-        self,
-        py: Python<'_>,
-        subtype: *mut PyTypeObject,
-    ) -> PyResult<*mut ffi::PyObject> {
-        /// Layout of a PyCell after base new has been called, but the contents have not yet been
+        /// Layout of a PyClassObject after base new has been called, but the contents have not yet been
         /// written.
         #[repr(C)]
-        struct PartiallyInitializedPyCell<T: PyClass> {
+        struct PartiallyInitializedClassObject<T: PyClass> {
             _ob_base: <T::BaseType as PyClassBaseType>::LayoutAsBase,
-            contents: MaybeUninit<PyCellContents<T>>,
+            contents: MaybeUninit<PyClassObjectContents<T>>,
         }
 
         let (init, super_init) = match self.0 {
-            PyClassInitializerImpl::Existing(value) => return Ok(value.into_ptr()),
+            PyClassInitializerImpl::Existing(value) => return Ok(value.into_bound(py)),
             PyClassInitializerImpl::New { init, super_init } => (init, super_init),
         };
 
-        let obj = super_init.into_new_object(py, subtype)?;
+        let obj = unsafe { super_init.into_new_object(py, target_type)? };
 
-        let cell: *mut PartiallyInitializedPyCell<T> = obj as _;
-        std::ptr::write(
-            (*cell).contents.as_mut_ptr(),
-            PyCellContents {
-                value: ManuallyDrop::new(UnsafeCell::new(init)),
-                borrow_checker: <T::PyClassMutability as PyClassMutability>::Storage::new(),
-                thread_checker: T::ThreadChecker::new(),
-                dict: T::Dict::INIT,
-                weakref: T::WeakRef::INIT,
-            },
-        );
-        Ok(obj)
+        let part_init: *mut PartiallyInitializedClassObject<T> = obj.cast();
+        unsafe {
+            std::ptr::write(
+                (*part_init).contents.as_mut_ptr(),
+                PyClassObjectContents {
+                    value: ManuallyDrop::new(UnsafeCell::new(init)),
+                    borrow_checker: <T::PyClassMutability as PyClassMutability>::Storage::new(),
+                    thread_checker: T::ThreadChecker::new(),
+                    dict: T::Dict::INIT,
+                    weakref: T::WeakRef::INIT,
+                },
+            );
+        }
+
+        // Safety: obj is a valid pointer to an object of type `target_type`, which` is a known
+        // subclass of `T`
+        Ok(unsafe { obj.assume_owned(py).cast_into_unchecked() })
+    }
+}
+
+impl<T: PyClass> PyObjectInit<T> for PyClassInitializer<T> {
+    unsafe fn into_new_object(
+        self,
+        py: Python<'_>,
+        subtype: *mut PyTypeObject,
+    ) -> PyResult<*mut ffi::PyObject> {
+        unsafe {
+            self.create_class_object_of_type(py, subtype)
+                .map(Bound::into_ptr)
+        }
     }
 
-    private_impl! {}
+    #[inline]
+    fn can_be_subclassed(&self) -> bool {
+        !matches!(self.0, PyClassInitializerImpl::Existing(..))
+    }
 }
 
 impl<T> From<T> for PyClassInitializer<T>
@@ -285,9 +231,11 @@ where
 impl<S, B> From<(S, B)> for PyClassInitializer<S>
 where
     S: PyClass<BaseType = B>,
-    B: PyClass,
+    B: PyClass + PyClassBaseType<Initializer = PyClassInitializer<B>>,
     B::BaseType: PyClassBaseType<Initializer = PyNativeTypeInitializer<B::BaseType>>,
 {
+    #[track_caller]
+    #[inline]
     fn from(sub_and_base: (S, B)) -> PyClassInitializer<S> {
         let (sub, base) = sub_and_base;
         PyClassInitializer::from(base).add_subclass(sub)
@@ -301,9 +249,16 @@ impl<T: PyClass> From<Py<T>> for PyClassInitializer<T> {
     }
 }
 
+impl<'py, T: PyClass> From<Bound<'py, T>> for PyClassInitializer<T> {
+    #[inline]
+    fn from(value: Bound<'py, T>) -> PyClassInitializer<T> {
+        PyClassInitializer::from(value.unbind())
+    }
+}
+
 // Implementation used by proc macros to allow anything convertible to PyClassInitializer<T> to be
 // the return value of pyclass #[new] method (optionally wrapped in `Result<U, E>`).
-impl<T, U> IntoPyCallbackOutput<PyClassInitializer<T>> for U
+impl<T, U> IntoPyCallbackOutput<'_, PyClassInitializer<T>> for U
 where
     T: PyClass,
     U: Into<PyClassInitializer<T>>,
@@ -313,3 +268,27 @@ where
         Ok(self.into())
     }
 }
+
+#[cfg(all(test, feature = "macros"))]
+mod tests {
+    //! See https://github.com/PyO3/pyo3/issues/4452.
+
+    use crate::prelude::*;
+
+    #[pyclass(crate = "crate", subclass)]
+    struct BaseClass {}
+
+    #[pyclass(crate = "crate", extends=BaseClass)]
+    struct SubClass {
+        _data: i32,
+    }
+
+    #[test]
+    #[should_panic]
+    fn add_subclass_to_py_is_unsound() {
+        Python::attach(|py| {
+            let base = Py::new(py, BaseClass {}).unwrap();
+            let _subclass = PyClassInitializer::from(base).add_subclass(SubClass { _data: 42 });
+        });
+    }
+}
diff --git a/src/sealed.rs b/src/sealed.rs
new file mode 100644
index 00000000000..ce66511c15a
--- /dev/null
+++ b/src/sealed.rs
@@ -0,0 +1,71 @@
+use crate::impl_::pyfunction::PyFunctionDef;
+use crate::types::{
+    PyBool, PyByteArray, PyBytes, PyCapsule, PyComplex, PyDict, PyFloat, PyFrozenSet, PyList,
+    PyMapping, PyMappingProxy, PyModule, PyRange, PySequence, PySet, PySlice, PyString,
+    PyTraceback, PyTuple, PyType, PyWeakref, PyWeakrefProxy, PyWeakrefReference,
+};
+use crate::{ffi, Bound, PyAny, PyResult};
+
+use crate::pyclass_init::PyClassInitializer;
+
+use crate::impl_::{
+    pyclass_init::PyNativeTypeInitializer,
+    pymethods::PyMethodDef,
+    pymodule::{AddClassToModule, AddTypeToModule, ModuleDef},
+};
+
+pub trait Sealed {}
+
+// for FfiPtrExt
+impl Sealed for *mut ffi::PyObject {}
+
+// for PyResultExt
+impl Sealed for PyResult<Bound<'_, PyAny>> {}
+
+// for Py(...)Methods
+impl Sealed for Bound<'_, PyAny> {}
+impl Sealed for Bound<'_, PyBool> {}
+impl Sealed for Bound<'_, PyByteArray> {}
+impl Sealed for Bound<'_, PyBytes> {}
+impl Sealed for Bound<'_, PyCapsule> {}
+impl Sealed for Bound<'_, PyComplex> {}
+impl Sealed for Bound<'_, PyDict> {}
+impl Sealed for Bound<'_, PyFloat> {}
+impl Sealed for Bound<'_, PyFrozenSet> {}
+impl Sealed for Bound<'_, PyList> {}
+impl Sealed for Bound<'_, PyMapping> {}
+impl Sealed for Bound<'_, PyMappingProxy> {}
+impl Sealed for Bound<'_, PyModule> {}
+impl Sealed for Bound<'_, PyRange> {}
+impl Sealed for Bound<'_, PySequence> {}
+impl Sealed for Bound<'_, PySet> {}
+impl Sealed for Bound<'_, PySlice> {}
+impl Sealed for Bound<'_, PyString> {}
+impl Sealed for Bound<'_, PyTraceback> {}
+impl Sealed for Bound<'_, PyTuple> {}
+impl Sealed for Bound<'_, PyType> {}
+impl Sealed for Bound<'_, PyWeakref> {}
+impl Sealed for Bound<'_, PyWeakrefProxy> {}
+impl Sealed for Bound<'_, PyWeakrefReference> {}
+
+impl<T> Sealed for AddTypeToModule<T> {}
+impl<T> Sealed for AddClassToModule<T> {}
+impl Sealed for PyMethodDef {}
+impl Sealed for PyFunctionDef {}
+impl Sealed for ModuleDef {}
+
+impl<T: crate::type_object::PyTypeInfo> Sealed for PyNativeTypeInitializer<T> {}
+impl<T: crate::pyclass::PyClass> Sealed for PyClassInitializer<T> {}
+
+impl Sealed for std::sync::Once {}
+impl<T> Sealed for std::sync::Mutex<T> {}
+#[cfg(feature = "lock_api")]
+impl<R, T> Sealed for lock_api::Mutex<R, T> {}
+#[cfg(feature = "parking_lot")]
+impl Sealed for parking_lot::Once {}
+#[cfg(feature = "arc_lock")]
+impl<R, T> Sealed for std::sync::Arc<lock_api::Mutex<R, T>> {}
+#[cfg(feature = "lock_api")]
+impl<R, G, T> Sealed for lock_api::ReentrantMutex<R, G, T> {}
+#[cfg(feature = "arc_lock")]
+impl<R, G, T> Sealed for std::sync::Arc<lock_api::ReentrantMutex<R, G, T>> {}
diff --git a/src/sync.rs b/src/sync.rs
index 8fff0e82c0f..40d77d712a9 100644
--- a/src/sync.rs
+++ b/src/sync.rs
@@ -1,9 +1,33 @@
-//! Synchronization mechanisms based on the Python GIL.
+//! Synchronization mechanisms which are aware of the existence of the Python interpreter.
+//!
+//! The Python interpreter has multiple "stop the world" situations which may block threads, such as
+//! - The Python global interpreter lock (GIL), on GIL-enabled builds of Python, or
+//! - The Python garbage collector (GC), which pauses attached threads during collection.
+//!
+//! To avoid deadlocks in these cases, threads should take care to be detached from the Python interpreter
+//! before performing operations which might block waiting for other threads attached to the Python
+//! interpreter.
+//!
+//! This module provides synchronization primitives which are able to synchronize under these conditions.
 use crate::{
-    types::{any::PyAnyMethods, PyString, PyType},
-    Bound, Py, PyResult, PyVisit, Python,
+    internal::state::SuspendAttach,
+    sealed::Sealed,
+    types::{any::PyAnyMethods, PyAny, PyString},
+    Bound, Py, PyResult, PyTypeCheck, Python,
 };
-use std::cell::UnsafeCell;
+use std::{
+    cell::UnsafeCell,
+    marker::PhantomData,
+    mem::MaybeUninit,
+    sync::{Once, OnceState},
+};
+
+pub(crate) mod once_lock;
+
+#[cfg(not(Py_GIL_DISABLED))]
+use crate::PyVisit;
+
+pub use self::once_lock::PyOnceLock;
 
 /// Value with concurrent access protected by the GIL.
 ///
@@ -11,25 +35,35 @@ use std::cell::UnsafeCell;
 /// It ensures that only one thread at a time can access the inner value via shared references.
 /// It can be combined with interior mutability to obtain mutable references.
 ///
+/// This type is not defined for extensions built against the free-threaded CPython ABI.
+///
 /// # Example
 ///
 /// Combining `GILProtected` with `RefCell` enables mutable access to static data:
 ///
 /// ```
+/// # #![allow(deprecated)]
 /// # use pyo3::prelude::*;
 /// use pyo3::sync::GILProtected;
 /// use std::cell::RefCell;
 ///
 /// static NUMBERS: GILProtected<RefCell<Vec<i32>>> = GILProtected::new(RefCell::new(Vec::new()));
 ///
-/// Python::with_gil(|py| {
+/// Python::attach(|py| {
 ///     NUMBERS.get(py).borrow_mut().push(42);
 /// });
 /// ```
+#[deprecated(
+    since = "0.26.0",
+    note = "Prefer an interior mutability primitive compatible with free-threaded Python, such as `Mutex` in combination with the `MutexExt` trait"
+)]
+#[cfg(not(Py_GIL_DISABLED))]
 pub struct GILProtected<T> {
     value: T,
 }
 
+#[allow(deprecated)]
+#[cfg(not(Py_GIL_DISABLED))]
 impl<T> GILProtected<T> {
     /// Place the given value under the protection of the GIL.
     pub const fn new(value: T) -> Self {
@@ -47,24 +81,40 @@ impl<T> GILProtected<T> {
     }
 }
 
+#[allow(deprecated)]
+#[cfg(not(Py_GIL_DISABLED))]
 unsafe impl<T> Sync for GILProtected<T> where T: Send {}
 
-/// A write-once cell similar to [`once_cell::OnceCell`](https://docs.rs/once_cell/latest/once_cell/).
+/// A write-once primitive similar to [`std::sync::OnceLock<T>`].
+///
+/// Unlike `OnceLock<T>` which blocks threads to achieve thread safety, `GilOnceCell<T>`
+/// allows calls to [`get_or_init`][GILOnceCell::get_or_init] and
+/// [`get_or_try_init`][GILOnceCell::get_or_try_init] to race to create an initialized value.
+/// (It is still guaranteed that only one thread will ever write to the cell.)
 ///
-/// Unlike `once_cell::sync` which blocks threads to achieve thread safety, this implementation
-/// uses the Python GIL to mediate concurrent access. This helps in cases where `once_cell` or
-/// `lazy_static`'s synchronization strategy can lead to deadlocks when interacting with the Python
-/// GIL. For an example, see [the FAQ section](https://pyo3.rs/latest/faq.html) of the guide.
+/// On Python versions that run with the Global Interpreter Lock (GIL), this helps to avoid
+/// deadlocks between initialization and the GIL. For an example of such a deadlock, see
+#[doc = concat!(
+    "[the FAQ section](https://pyo3.rs/v",
+    env!("CARGO_PKG_VERSION"),
+    "/faq.html#im-experiencing-deadlocks-using-pyo3-with-stdsynconcelock-stdsynclazylock-lazy_static-and-once_cell)"
+)]
+/// of the guide.
 ///
-/// Note that:
-///  1) `get_or_init` and `get_or_try_init` do not protect against infinite recursion
-///     from reentrant initialization.
-///  2) If the initialization function `f` provided to `get_or_init` (or `get_or_try_init`)
-///     temporarily releases the GIL (e.g. by calling `Python::import`) then it is possible
-///     for a second thread to also begin initializing the `GITOnceCell`. Even when this
-///     happens `GILOnceCell` guarantees that only **one** write to the cell ever occurs
-///     - this is treated as a race, other threads will discard the value they compute and
-///     return the result of the first complete computation.
+/// Note that because the GIL blocks concurrent execution, in practice the means that
+/// [`get_or_init`][GILOnceCell::get_or_init] and
+/// [`get_or_try_init`][GILOnceCell::get_or_try_init] may race if the initialization
+/// function leads to the GIL being released and a thread context switch. This can
+/// happen when importing or calling any Python code, as long as it releases the
+/// GIL at some point. On free-threaded Python without any GIL, the race is
+/// more likely since there is no GIL to prevent races. In the future, PyO3 may change
+/// the semantics of GILOnceCell to behave more like the GIL build in the future.
+///
+/// # Re-entrant initialization
+///
+/// [`get_or_init`][GILOnceCell::get_or_init] and
+/// [`get_or_try_init`][GILOnceCell::get_or_try_init] do not protect against infinite recursion
+/// from reentrant initialization.
 ///
 /// # Examples
 ///
@@ -72,6 +122,7 @@ unsafe impl<T> Sync for GILProtected<T> where T: Send {}
 /// between threads:
 ///
 /// ```
+/// #![allow(deprecated)]
 /// use pyo3::sync::GILOnceCell;
 /// use pyo3::prelude::*;
 /// use pyo3::types::PyList;
@@ -80,29 +131,78 @@ unsafe impl<T> Sync for GILProtected<T> where T: Send {}
 ///
 /// pub fn get_shared_list(py: Python<'_>) -> &Bound<'_, PyList> {
 ///     LIST_CELL
-///         .get_or_init(py, || PyList::empty_bound(py).unbind())
+///         .get_or_init(py, || PyList::empty(py).unbind())
 ///         .bind(py)
 /// }
-/// # Python::with_gil(|py| assert_eq!(get_shared_list(py).len(), 0));
+/// # Python::attach(|py| assert_eq!(get_shared_list(py).len(), 0));
 /// ```
-pub struct GILOnceCell<T>(UnsafeCell<Option<T>>);
+#[deprecated(
+    since = "0.26.0",
+    note = "Prefer `pyo3::sync::PyOnceLock`, which avoids the possibility of racing during initialization."
+)]
+pub struct GILOnceCell<T> {
+    once: Once,
+    data: UnsafeCell<MaybeUninit<T>>,
+
+    /// (Copied from std::sync::OnceLock)
+    ///
+    /// `PhantomData` to make sure dropck understands we're dropping T in our Drop impl.
+    ///
+    /// ```compile_error,E0597
+    /// #![allow(deprecated)]
+    /// use pyo3::Python;
+    /// use pyo3::sync::GILOnceCell;
+    ///
+    /// struct A<'a>(#[allow(dead_code)] &'a str);
+    ///
+    /// impl<'a> Drop for A<'a> {
+    ///     fn drop(&mut self) {}
+    /// }
+    ///
+    /// let cell = GILOnceCell::new();
+    /// {
+    ///     let s = String::new();
+    ///     let _ = Python::attach(|py| cell.set(py,A(&s)));
+    /// }
+    /// ```
+    _marker: PhantomData<T>,
+}
+
+#[allow(deprecated)]
+impl<T> Default for GILOnceCell<T> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
 
 // T: Send is needed for Sync because the thread which drops the GILOnceCell can be different
-// to the thread which fills it.
+// to the thread which fills it. (e.g. think scoped thread which fills the cell and then exits,
+// leaving the cell to be dropped by the main thread).
+#[allow(deprecated)]
 unsafe impl<T: Send + Sync> Sync for GILOnceCell<T> {}
+#[allow(deprecated)]
 unsafe impl<T: Send> Send for GILOnceCell<T> {}
 
+#[allow(deprecated)]
 impl<T> GILOnceCell<T> {
     /// Create a `GILOnceCell` which does not yet contain a value.
     pub const fn new() -> Self {
-        Self(UnsafeCell::new(None))
+        Self {
+            once: Once::new(),
+            data: UnsafeCell::new(MaybeUninit::uninit()),
+            _marker: PhantomData,
+        }
     }
 
     /// Get a reference to the contained value, or `None` if the cell has not yet been written.
     #[inline]
     pub fn get(&self, _py: Python<'_>) -> Option<&T> {
-        // Safe because if the cell has not yet been written, None is returned.
-        unsafe { &*self.0.get() }.as_ref()
+        if self.once.is_completed() {
+            // SAFETY: the cell has been written.
+            Some(unsafe { (*self.data.get()).assume_init_ref() })
+        } else {
+            None
+        }
     }
 
     /// Get a reference to the contained value, initializing it if needed using the provided
@@ -118,10 +218,9 @@ impl<T> GILOnceCell<T> {
             return value;
         }
 
-        match self.init(py, || Ok::<T, std::convert::Infallible>(f())) {
-            Ok(value) => value,
-            Err(void) => match void {},
-        }
+        // .unwrap() will never panic because the result is always Ok
+        self.init(py, || Ok::<T, std::convert::Infallible>(f()))
+            .unwrap()
     }
 
     /// Like `get_or_init`, but accepts a fallible initialization function. If it fails, the cell
@@ -148,6 +247,10 @@ impl<T> GILOnceCell<T> {
         // Note that f() could temporarily release the GIL, so it's possible that another thread
         // writes to this GILOnceCell before f() finishes. That's fine; we'll just have to discard
         // the value computed here and accept a bit of wasted computation.
+
+        // TODO: on the freethreaded build, consider wrapping this pair of operations in a
+        // critical section (requires a critical section API which can use a PyMutex without
+        // an object.)
         let value = f()?;
         let _ = self.set(py, value);
 
@@ -157,7 +260,12 @@ impl<T> GILOnceCell<T> {
     /// Get the contents of the cell mutably. This is only possible if the reference to the cell is
     /// unique.
     pub fn get_mut(&mut self) -> Option<&mut T> {
-        self.0.get_mut().as_mut()
+        if self.once.is_completed() {
+            // SAFETY: the cell has been written.
+            Some(unsafe { (*self.data.get()).assume_init_mut() })
+        } else {
+            None
+        }
     }
 
     /// Set the value in the cell.
@@ -165,48 +273,129 @@ impl<T> GILOnceCell<T> {
     /// If the cell has already been written, `Err(value)` will be returned containing the new
     /// value which was not written.
     pub fn set(&self, _py: Python<'_>, value: T) -> Result<(), T> {
-        // Safe because GIL is held, so no other thread can be writing to this cell concurrently.
-        let inner = unsafe { &mut *self.0.get() };
-        if inner.is_some() {
-            return Err(value);
-        }
+        let mut value = Some(value);
+        // NB this can block, but since this is only writing a single value and
+        // does not call arbitrary python code, we don't need to worry about
+        // deadlocks with the GIL.
+        self.once.call_once_force(|_| {
+            // SAFETY: no other threads can be writing this value, because we are
+            // inside the `call_once_force` closure.
+            unsafe {
+                // `.take().unwrap()` will never panic
+                (*self.data.get()).write(value.take().unwrap());
+            }
+        });
 
-        *inner = Some(value);
-        Ok(())
+        match value {
+            // Some other thread wrote to the cell first
+            Some(value) => Err(value),
+            None => Ok(()),
+        }
     }
 
     /// Takes the value out of the cell, moving it back to an uninitialized state.
     ///
     /// Has no effect and returns None if the cell has not yet been written.
     pub fn take(&mut self) -> Option<T> {
-        self.0.get_mut().take()
+        if self.once.is_completed() {
+            // Reset the cell to its default state so that it won't try to
+            // drop the value again.
+            self.once = Once::new();
+            // SAFETY: the cell has been written. `self.once` has been reset,
+            // so when `self` is dropped the value won't be read again.
+            Some(unsafe { self.data.get_mut().assume_init_read() })
+        } else {
+            None
+        }
     }
 
     /// Consumes the cell, returning the wrapped value.
     ///
     /// Returns None if the cell has not yet been written.
-    pub fn into_inner(self) -> Option<T> {
-        self.0.into_inner()
+    pub fn into_inner(mut self) -> Option<T> {
+        self.take()
+    }
+}
+
+#[allow(deprecated)]
+impl<T> GILOnceCell<Py<T>> {
+    /// Creates a new cell that contains a new Python reference to the same contained object.
+    ///
+    /// Returns an uninitialized cell if `self` has not yet been initialized.
+    pub fn clone_ref(&self, py: Python<'_>) -> Self {
+        let cloned = Self {
+            once: Once::new(),
+            data: UnsafeCell::new(MaybeUninit::uninit()),
+            _marker: PhantomData,
+        };
+        if let Some(value) = self.get(py) {
+            let _ = cloned.set(py, value.clone_ref(py));
+        }
+        cloned
     }
 }
 
-impl GILOnceCell<Py<PyType>> {
-    /// Get a reference to the contained Python type, initializing it if needed.
+#[allow(deprecated)]
+impl<T> GILOnceCell<Py<T>>
+where
+    T: PyTypeCheck,
+{
+    /// Get a reference to the contained Python type, initializing the cell if needed.
     ///
     /// This is a shorthand method for `get_or_init` which imports the type from Python on init.
-    pub(crate) fn get_or_try_init_type_ref<'py>(
-        &'py self,
+    ///
+    /// # Example: Using `GILOnceCell` to store a class in a static variable.
+    ///
+    /// `GILOnceCell` can be used to avoid importing a class multiple times:
+    /// ```
+    /// #![allow(deprecated)]
+    /// # use pyo3::prelude::*;
+    /// # use pyo3::sync::GILOnceCell;
+    /// # use pyo3::types::{PyDict, PyType};
+    /// # use pyo3::intern;
+    /// #
+    /// #[pyfunction]
+    /// fn create_ordered_dict<'py>(py: Python<'py>, dict: Bound<'py, PyDict>) -> PyResult<Bound<'py, PyAny>> {
+    ///     // Even if this function is called multiple times,
+    ///     // the `OrderedDict` class will be imported only once.
+    ///     static ORDERED_DICT: GILOnceCell<Py<PyType>> = GILOnceCell::new();
+    ///     ORDERED_DICT
+    ///         .import(py, "collections", "OrderedDict")?
+    ///         .call1((dict,))
+    /// }
+    ///
+    /// # Python::attach(|py| {
+    /// #     let dict = PyDict::new(py);
+    /// #     dict.set_item(intern!(py, "foo"), 42).unwrap();
+    /// #     let fun = wrap_pyfunction!(create_ordered_dict, py).unwrap();
+    /// #     let ordered_dict = fun.call1((&dict,)).unwrap();
+    /// #     assert!(dict.eq(ordered_dict).unwrap());
+    /// # });
+    /// ```
+    pub fn import<'py>(
+        &self,
         py: Python<'py>,
         module_name: &str,
         attr_name: &str,
-    ) -> PyResult<&Bound<'py, PyType>> {
+    ) -> PyResult<&Bound<'py, T>> {
         self.get_or_try_init(py, || {
-            py.import_bound(module_name)?.getattr(attr_name)?.extract()
+            let type_object = py.import(module_name)?.getattr(attr_name)?.cast_into()?;
+            Ok(type_object.unbind())
         })
         .map(|ty| ty.bind(py))
     }
 }
 
+#[allow(deprecated)]
+impl<T> Drop for GILOnceCell<T> {
+    fn drop(&mut self) {
+        if self.once.is_completed() {
+            // SAFETY: the cell has been written.
+            unsafe { MaybeUninit::assume_init_drop(self.data.get_mut()) }
+        }
+    }
+}
+
 /// Interns `text` as a Python string and stores a reference to it in static storage.
 ///
 /// A reference to the same Python string is returned on each invocation.
@@ -215,11 +404,11 @@ impl GILOnceCell<Py<PyType>> {
 ///
 /// ```
 /// use pyo3::intern;
-/// # use pyo3::{pyfunction, types::PyDict, wrap_pyfunction, PyResult, Python, prelude::PyDictMethods, Bound};
+/// # use pyo3::{prelude::*, types::PyDict};
 ///
 /// #[pyfunction]
 /// fn create_dict(py: Python<'_>) -> PyResult<Bound<'_, PyDict>> {
-///     let dict = PyDict::new_bound(py);
+///     let dict = PyDict::new(py);
 ///     //             👇 A new `PyString` is created
 ///     //                for every call of this function.
 ///     dict.set_item("foo", 42)?;
@@ -228,14 +417,14 @@ impl GILOnceCell<Py<PyType>> {
 ///
 /// #[pyfunction]
 /// fn create_dict_faster(py: Python<'_>) -> PyResult<Bound<'_, PyDict>> {
-///     let dict = PyDict::new_bound(py);
+///     let dict = PyDict::new(py);
 ///     //               👇 A `PyString` is created once and reused
 ///     //                  for the lifetime of the program.
 ///     dict.set_item(intern!(py, "foo"), 42)?;
 ///     Ok(dict)
 /// }
 /// #
-/// # Python::with_gil(|py| {
+/// # Python::attach(|py| {
 /// #     let fun_slow = wrap_pyfunction!(create_dict, py).unwrap();
 /// #     let dict = fun_slow.call0().unwrap();
 /// #     assert!(dict.contains("foo").unwrap());
@@ -254,37 +443,618 @@ macro_rules! intern {
 
 /// Implementation detail for `intern!` macro.
 #[doc(hidden)]
-pub struct Interned(&'static str, GILOnceCell<Py<PyString>>);
+pub struct Interned(&'static str, PyOnceLock<Py<PyString>>);
 
 impl Interned {
     /// Creates an empty holder for an interned `str`.
     pub const fn new(value: &'static str) -> Self {
-        Interned(value, GILOnceCell::new())
+        Interned(value, PyOnceLock::new())
     }
 
     /// Gets or creates the interned `str` value.
     #[inline]
     pub fn get<'py>(&self, py: Python<'py>) -> &Bound<'py, PyString> {
         self.1
-            .get_or_init(py, || PyString::intern_bound(py, self.0).into())
+            .get_or_init(py, || PyString::intern(py, self.0).into())
             .bind(py)
     }
 }
 
+/// Executes a closure with a Python critical section held on an object.
+///
+/// Acquires the per-object lock for the object `op` that is held
+/// until the closure `f` is finished.
+///
+/// This is structurally equivalent to the use of the paired
+/// Py_BEGIN_CRITICAL_SECTION and Py_END_CRITICAL_SECTION C-API macros.
+///
+/// A no-op on GIL-enabled builds, where the critical section API is exposed as
+/// a no-op by the Python C API.
+///
+/// Provides weaker locking guarantees than traditional locks, but can in some
+/// cases be used to provide guarantees similar to the GIL without the risk of
+/// deadlocks associated with traditional locks.
+///
+/// Many CPython C API functions do not acquire the per-object lock on objects
+/// passed to Python. You should not expect critical sections applied to
+/// built-in types to prevent concurrent modification. This API is most useful
+/// for user-defined types with full control over how the internal state for the
+/// type is managed.
+#[cfg_attr(not(Py_GIL_DISABLED), allow(unused_variables))]
+pub fn with_critical_section<F, R>(object: &Bound<'_, PyAny>, f: F) -> R
+where
+    F: FnOnce() -> R,
+{
+    #[cfg(Py_GIL_DISABLED)]
+    {
+        struct Guard(crate::ffi::PyCriticalSection);
+
+        impl Drop for Guard {
+            fn drop(&mut self) {
+                unsafe {
+                    crate::ffi::PyCriticalSection_End(&mut self.0);
+                }
+            }
+        }
+
+        let mut guard = Guard(unsafe { std::mem::zeroed() });
+        unsafe { crate::ffi::PyCriticalSection_Begin(&mut guard.0, object.as_ptr()) };
+        f()
+    }
+    #[cfg(not(Py_GIL_DISABLED))]
+    {
+        f()
+    }
+}
+
+/// Executes a closure with a Python critical section held on two objects.
+///
+/// Acquires the per-object lock for the objects `a` and `b` that are held
+/// until the closure `f` is finished.
+///
+/// This is structurally equivalent to the use of the paired
+/// Py_BEGIN_CRITICAL_SECTION2 and Py_END_CRITICAL_SECTION2 C-API macros.
+///
+/// A no-op on GIL-enabled builds, where the critical section API is exposed as
+/// a no-op by the Python C API.
+///
+/// Provides weaker locking guarantees than traditional locks, but can in some
+/// cases be used to provide guarantees similar to the GIL without the risk of
+/// deadlocks associated with traditional locks.
+///
+/// Many CPython C API functions do not acquire the per-object lock on objects
+/// passed to Python. You should not expect critical sections applied to
+/// built-in types to prevent concurrent modification. This API is most useful
+/// for user-defined types with full control over how the internal state for the
+/// type is managed.
+#[cfg_attr(not(Py_GIL_DISABLED), allow(unused_variables))]
+pub fn with_critical_section2<F, R>(a: &Bound<'_, PyAny>, b: &Bound<'_, PyAny>, f: F) -> R
+where
+    F: FnOnce() -> R,
+{
+    #[cfg(Py_GIL_DISABLED)]
+    {
+        struct Guard(crate::ffi::PyCriticalSection2);
+
+        impl Drop for Guard {
+            fn drop(&mut self) {
+                unsafe {
+                    crate::ffi::PyCriticalSection2_End(&mut self.0);
+                }
+            }
+        }
+
+        let mut guard = Guard(unsafe { std::mem::zeroed() });
+        unsafe { crate::ffi::PyCriticalSection2_Begin(&mut guard.0, a.as_ptr(), b.as_ptr()) };
+        f()
+    }
+    #[cfg(not(Py_GIL_DISABLED))]
+    {
+        f()
+    }
+}
+
+mod once_lock_ext_sealed {
+    pub trait Sealed {}
+    impl<T> Sealed for std::sync::OnceLock<T> {}
+}
+
+mod rwlock_ext_sealed {
+    pub trait Sealed {}
+    impl<T> Sealed for std::sync::RwLock<T> {}
+    #[cfg(feature = "lock_api")]
+    impl<R, T> Sealed for lock_api::RwLock<R, T> {}
+    #[cfg(feature = "arc_lock")]
+    impl<R, T> Sealed for std::sync::Arc<lock_api::RwLock<R, T>> {}
+}
+
+/// Extension trait for [`Once`] to help avoid deadlocking when using a [`Once`] when attached to a
+/// Python thread.
+pub trait OnceExt: Sealed {
+    ///The state of `Once`
+    type OnceState;
+
+    /// Similar to [`call_once`][Once::call_once], but releases the Python GIL temporarily
+    /// if blocking on another thread currently calling this `Once`.
+    fn call_once_py_attached(&self, py: Python<'_>, f: impl FnOnce());
+
+    /// Similar to [`call_once_force`][Once::call_once_force], but releases the Python GIL
+    /// temporarily if blocking on another thread currently calling this `Once`.
+    fn call_once_force_py_attached(&self, py: Python<'_>, f: impl FnOnce(&Self::OnceState));
+}
+
+/// Extension trait for [`std::sync::OnceLock`] which helps avoid deadlocks between the Python
+/// interpreter and initialization with the `OnceLock`.
+pub trait OnceLockExt<T>: once_lock_ext_sealed::Sealed {
+    /// Initializes this `OnceLock` with the given closure if it has not been initialized yet.
+    ///
+    /// If this function would block, this function detaches from the Python interpreter and
+    /// reattaches before calling `f`. This avoids deadlocks between the Python interpreter and
+    /// the `OnceLock` in cases where `f` can call arbitrary Python code, as calling arbitrary
+    /// Python code can lead to `f` itself blocking on the Python interpreter.
+    ///
+    /// By detaching from the Python interpreter before blocking, this ensures that if `f` blocks
+    /// then the Python interpreter cannot be blocked by `f` itself.
+    fn get_or_init_py_attached<F>(&self, py: Python<'_>, f: F) -> &T
+    where
+        F: FnOnce() -> T;
+}
+
+/// Extension trait for [`std::sync::Mutex`] which helps avoid deadlocks between
+/// the Python interpreter and acquiring the `Mutex`.
+pub trait MutexExt<T>: Sealed {
+    /// The result type returned by the `lock_py_attached` method.
+    type LockResult<'a>
+    where
+        Self: 'a;
+
+    /// Lock this `Mutex` in a manner that cannot deadlock with the Python interpreter.
+    ///
+    /// Before attempting to lock the mutex, this function detaches from the
+    /// Python runtime. When the lock is acquired, it re-attaches to the Python
+    /// runtime before returning the `LockResult`. This avoids deadlocks between
+    /// the GIL and other global synchronization events triggered by the Python
+    /// interpreter.
+    fn lock_py_attached(&self, py: Python<'_>) -> Self::LockResult<'_>;
+}
+
+/// Extension trait for [`std::sync::RwLock`] which helps avoid deadlocks between
+/// the Python interpreter and acquiring the `RwLock`.
+pub trait RwLockExt<T>: rwlock_ext_sealed::Sealed {
+    /// The result type returned by the `read_py_attached` method.
+    type ReadLockResult<'a>
+    where
+        Self: 'a;
+
+    /// The result type returned by the `write_py_attached` method.
+    type WriteLockResult<'a>
+    where
+        Self: 'a;
+
+    /// Lock this `RwLock` for reading in a manner that cannot deadlock with
+    /// the Python interpreter.
+    ///
+    /// Before attempting to lock the rwlock, this function detaches from the
+    /// Python runtime. When the lock is acquired, it re-attaches to the Python
+    /// runtime before returning the `ReadLockResult`. This avoids deadlocks between
+    /// the GIL and other global synchronization events triggered by the Python
+    /// interpreter.
+    fn read_py_attached(&self, py: Python<'_>) -> Self::ReadLockResult<'_>;
+
+    /// Lock this `RwLock` for writing in a manner that cannot deadlock with
+    /// the Python interpreter.
+    ///
+    /// Before attempting to lock the rwlock, this function detaches from the
+    /// Python runtime. When the lock is acquired, it re-attaches to the Python
+    /// runtime before returning the `WriteLockResult`. This avoids deadlocks between
+    /// the GIL and other global synchronization events triggered by the Python
+    /// interpreter.
+    fn write_py_attached(&self, py: Python<'_>) -> Self::WriteLockResult<'_>;
+}
+
+impl OnceExt for Once {
+    type OnceState = OnceState;
+
+    fn call_once_py_attached(&self, py: Python<'_>, f: impl FnOnce()) {
+        if self.is_completed() {
+            return;
+        }
+
+        init_once_py_attached(self, py, f)
+    }
+
+    fn call_once_force_py_attached(&self, py: Python<'_>, f: impl FnOnce(&OnceState)) {
+        if self.is_completed() {
+            return;
+        }
+
+        init_once_force_py_attached(self, py, f);
+    }
+}
+
+#[cfg(feature = "parking_lot")]
+impl OnceExt for parking_lot::Once {
+    type OnceState = parking_lot::OnceState;
+
+    fn call_once_py_attached(&self, _py: Python<'_>, f: impl FnOnce()) {
+        if self.state().done() {
+            return;
+        }
+
+        let ts_guard = unsafe { SuspendAttach::new() };
+
+        self.call_once(move || {
+            drop(ts_guard);
+            f();
+        });
+    }
+
+    fn call_once_force_py_attached(
+        &self,
+        _py: Python<'_>,
+        f: impl FnOnce(&parking_lot::OnceState),
+    ) {
+        if self.state().done() {
+            return;
+        }
+
+        let ts_guard = unsafe { SuspendAttach::new() };
+
+        self.call_once_force(move |state| {
+            drop(ts_guard);
+            f(&state);
+        });
+    }
+}
+
+impl<T> OnceLockExt<T> for std::sync::OnceLock<T> {
+    fn get_or_init_py_attached<F>(&self, py: Python<'_>, f: F) -> &T
+    where
+        F: FnOnce() -> T,
+    {
+        // Use self.get() first to create a fast path when initialized
+        self.get()
+            .unwrap_or_else(|| init_once_lock_py_attached(self, py, f))
+    }
+}
+
+impl<T> MutexExt<T> for std::sync::Mutex<T> {
+    type LockResult<'a>
+        = std::sync::LockResult<std::sync::MutexGuard<'a, T>>
+    where
+        Self: 'a;
+
+    fn lock_py_attached(
+        &self,
+        _py: Python<'_>,
+    ) -> std::sync::LockResult<std::sync::MutexGuard<'_, T>> {
+        // If try_lock is successful or returns a poisoned mutex, return them so
+        // the caller can deal with them. Otherwise we need to use blocking
+        // lock, which requires detaching from the Python runtime to avoid
+        // possible deadlocks.
+        match self.try_lock() {
+            Ok(inner) => return Ok(inner),
+            Err(std::sync::TryLockError::Poisoned(inner)) => {
+                return std::sync::LockResult::Err(inner)
+            }
+            Err(std::sync::TryLockError::WouldBlock) => {}
+        }
+        // SAFETY: detach from the runtime right before a possibly blocking call
+        // then reattach when the blocking call completes and before calling
+        // into the C API.
+        let ts_guard = unsafe { SuspendAttach::new() };
+        let res = self.lock();
+        drop(ts_guard);
+        res
+    }
+}
+
+#[cfg(feature = "lock_api")]
+impl<R: lock_api::RawMutex, T> MutexExt<T> for lock_api::Mutex<R, T> {
+    type LockResult<'a>
+        = lock_api::MutexGuard<'a, R, T>
+    where
+        Self: 'a;
+
+    fn lock_py_attached(&self, _py: Python<'_>) -> lock_api::MutexGuard<'_, R, T> {
+        if let Some(guard) = self.try_lock() {
+            return guard;
+        }
+
+        let ts_guard = unsafe { SuspendAttach::new() };
+        let res = self.lock();
+        drop(ts_guard);
+        res
+    }
+}
+
+#[cfg(feature = "arc_lock")]
+impl<R, T> MutexExt<T> for std::sync::Arc<lock_api::Mutex<R, T>>
+where
+    R: lock_api::RawMutex,
+{
+    type LockResult<'a>
+        = lock_api::ArcMutexGuard<R, T>
+    where
+        Self: 'a;
+
+    fn lock_py_attached(&self, _py: Python<'_>) -> lock_api::ArcMutexGuard<R, T> {
+        if let Some(guard) = self.try_lock_arc() {
+            return guard;
+        }
+
+        let ts_guard = unsafe { SuspendAttach::new() };
+        let res = self.lock_arc();
+        drop(ts_guard);
+        res
+    }
+}
+
+#[cfg(feature = "lock_api")]
+impl<R, G, T> MutexExt<T> for lock_api::ReentrantMutex<R, G, T>
+where
+    R: lock_api::RawMutex,
+    G: lock_api::GetThreadId,
+{
+    type LockResult<'a>
+        = lock_api::ReentrantMutexGuard<'a, R, G, T>
+    where
+        Self: 'a;
+
+    fn lock_py_attached(&self, _py: Python<'_>) -> lock_api::ReentrantMutexGuard<'_, R, G, T> {
+        if let Some(guard) = self.try_lock() {
+            return guard;
+        }
+
+        let ts_guard = unsafe { SuspendAttach::new() };
+        let res = self.lock();
+        drop(ts_guard);
+        res
+    }
+}
+
+#[cfg(feature = "arc_lock")]
+impl<R, G, T> MutexExt<T> for std::sync::Arc<lock_api::ReentrantMutex<R, G, T>>
+where
+    R: lock_api::RawMutex,
+    G: lock_api::GetThreadId,
+{
+    type LockResult<'a>
+        = lock_api::ArcReentrantMutexGuard<R, G, T>
+    where
+        Self: 'a;
+
+    fn lock_py_attached(&self, _py: Python<'_>) -> lock_api::ArcReentrantMutexGuard<R, G, T> {
+        if let Some(guard) = self.try_lock_arc() {
+            return guard;
+        }
+
+        let ts_guard = unsafe { SuspendAttach::new() };
+        let res = self.lock_arc();
+        drop(ts_guard);
+        res
+    }
+}
+
+impl<T> RwLockExt<T> for std::sync::RwLock<T> {
+    type ReadLockResult<'a>
+        = std::sync::LockResult<std::sync::RwLockReadGuard<'a, T>>
+    where
+        Self: 'a;
+
+    type WriteLockResult<'a>
+        = std::sync::LockResult<std::sync::RwLockWriteGuard<'a, T>>
+    where
+        Self: 'a;
+
+    fn read_py_attached(&self, _py: Python<'_>) -> Self::ReadLockResult<'_> {
+        // If try_read is successful or returns a poisoned rwlock, return them so
+        // the caller can deal with them. Otherwise we need to use blocking
+        // read lock, which requires detaching from the Python runtime to avoid
+        // possible deadlocks.
+        match self.try_read() {
+            Ok(inner) => return Ok(inner),
+            Err(std::sync::TryLockError::Poisoned(inner)) => {
+                return std::sync::LockResult::Err(inner)
+            }
+            Err(std::sync::TryLockError::WouldBlock) => {}
+        }
+
+        // SAFETY: detach from the runtime right before a possibly blocking call
+        // then reattach when the blocking call completes and before calling
+        // into the C API.
+        let ts_guard = unsafe { SuspendAttach::new() };
+
+        let res = self.read();
+        drop(ts_guard);
+        res
+    }
+
+    fn write_py_attached(&self, _py: Python<'_>) -> Self::WriteLockResult<'_> {
+        // If try_write is successful or returns a poisoned rwlock, return them so
+        // the caller can deal with them. Otherwise we need to use blocking
+        // write lock, which requires detaching from the Python runtime to avoid
+        // possible deadlocks.
+        match self.try_write() {
+            Ok(inner) => return Ok(inner),
+            Err(std::sync::TryLockError::Poisoned(inner)) => {
+                return std::sync::LockResult::Err(inner)
+            }
+            Err(std::sync::TryLockError::WouldBlock) => {}
+        }
+
+        // SAFETY: detach from the runtime right before a possibly blocking call
+        // then reattach when the blocking call completes and before calling
+        // into the C API.
+        let ts_guard = unsafe { SuspendAttach::new() };
+
+        let res = self.write();
+        drop(ts_guard);
+        res
+    }
+}
+
+#[cfg(feature = "lock_api")]
+impl<R: lock_api::RawRwLock, T> RwLockExt<T> for lock_api::RwLock<R, T> {
+    type ReadLockResult<'a>
+        = lock_api::RwLockReadGuard<'a, R, T>
+    where
+        Self: 'a;
+
+    type WriteLockResult<'a>
+        = lock_api::RwLockWriteGuard<'a, R, T>
+    where
+        Self: 'a;
+
+    fn read_py_attached(&self, _py: Python<'_>) -> Self::ReadLockResult<'_> {
+        if let Some(guard) = self.try_read() {
+            return guard;
+        }
+
+        let ts_guard = unsafe { SuspendAttach::new() };
+        let res = self.read();
+        drop(ts_guard);
+        res
+    }
+
+    fn write_py_attached(&self, _py: Python<'_>) -> Self::WriteLockResult<'_> {
+        if let Some(guard) = self.try_write() {
+            return guard;
+        }
+
+        let ts_guard = unsafe { SuspendAttach::new() };
+        let res = self.write();
+        drop(ts_guard);
+        res
+    }
+}
+
+#[cfg(feature = "arc_lock")]
+impl<R, T> RwLockExt<T> for std::sync::Arc<lock_api::RwLock<R, T>>
+where
+    R: lock_api::RawRwLock,
+{
+    type ReadLockResult<'a>
+        = lock_api::ArcRwLockReadGuard<R, T>
+    where
+        Self: 'a;
+
+    type WriteLockResult<'a>
+        = lock_api::ArcRwLockWriteGuard<R, T>
+    where
+        Self: 'a;
+
+    fn read_py_attached(&self, _py: Python<'_>) -> Self::ReadLockResult<'_> {
+        if let Some(guard) = self.try_read_arc() {
+            return guard;
+        }
+
+        let ts_guard = unsafe { SuspendAttach::new() };
+        let res = self.read_arc();
+        drop(ts_guard);
+        res
+    }
+
+    fn write_py_attached(&self, _py: Python<'_>) -> Self::WriteLockResult<'_> {
+        if let Some(guard) = self.try_write_arc() {
+            return guard;
+        }
+
+        let ts_guard = unsafe { SuspendAttach::new() };
+        let res = self.write_arc();
+        drop(ts_guard);
+        res
+    }
+}
+
+#[cold]
+fn init_once_py_attached<F, T>(once: &Once, _py: Python<'_>, f: F)
+where
+    F: FnOnce() -> T,
+{
+    // SAFETY: detach from the runtime right before a possibly blocking call
+    // then reattach when the blocking call completes and before calling
+    // into the C API.
+    let ts_guard = unsafe { SuspendAttach::new() };
+
+    once.call_once(move || {
+        drop(ts_guard);
+        f();
+    });
+}
+
+#[cold]
+fn init_once_force_py_attached<F, T>(once: &Once, _py: Python<'_>, f: F)
+where
+    F: FnOnce(&OnceState) -> T,
+{
+    // SAFETY: detach from the runtime right before a possibly blocking call
+    // then reattach when the blocking call completes and before calling
+    // into the C API.
+    let ts_guard = unsafe { SuspendAttach::new() };
+
+    once.call_once_force(move |state| {
+        drop(ts_guard);
+        f(state);
+    });
+}
+
+#[cold]
+fn init_once_lock_py_attached<'a, F, T>(
+    lock: &'a std::sync::OnceLock<T>,
+    _py: Python<'_>,
+    f: F,
+) -> &'a T
+where
+    F: FnOnce() -> T,
+{
+    // SAFETY: detach from the runtime right before a possibly blocking call
+    // then reattach when the blocking call completes and before calling
+    // into the C API.
+    let ts_guard = unsafe { SuspendAttach::new() };
+
+    // By having detached here, we guarantee that `.get_or_init` cannot deadlock with
+    // the Python interpreter
+    let value = lock.get_or_init(move || {
+        drop(ts_guard);
+        f()
+    });
+
+    value
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
 
-    use crate::types::{any::PyAnyMethods, dict::PyDictMethods, PyDict};
+    use crate::types::{PyDict, PyDictMethods};
+    #[cfg(not(target_arch = "wasm32"))]
+    use std::sync::Mutex;
+    #[cfg(not(target_arch = "wasm32"))]
+    #[cfg(feature = "macros")]
+    use std::sync::{
+        atomic::{AtomicBool, Ordering},
+        Barrier,
+    };
+
+    #[cfg(not(target_arch = "wasm32"))]
+    #[cfg(feature = "macros")]
+    #[crate::pyclass(crate = "crate")]
+    struct BoolWrapper(AtomicBool);
+
+    #[cfg(not(target_arch = "wasm32"))]
+    #[cfg(feature = "macros")]
+    #[crate::pyclass(crate = "crate")]
+    struct VecWrapper(Vec<isize>);
 
     #[test]
     fn test_intern() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let foo1 = "foo";
             let foo2 = intern!(py, "foo");
             let foo3 = intern!(py, stringify!(foo));
 
-            let dict = PyDict::new_bound(py);
+            let dict = PyDict::new(py);
             dict.set_item(foo1, 42_usize).unwrap();
             assert!(dict.contains(foo2).unwrap());
             assert_eq!(
@@ -299,8 +1069,9 @@ mod tests {
     }
 
     #[test]
+    #[allow(deprecated)]
     fn test_once_cell() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let mut cell = GILOnceCell::new();
 
             assert!(cell.get(py).is_none());
@@ -314,7 +1085,621 @@ mod tests {
             assert_eq!(cell.get_or_try_init(py, || Err(5)), Ok(&2));
 
             assert_eq!(cell.take(), Some(2));
-            assert_eq!(cell.into_inner(), None)
+            assert_eq!(cell.into_inner(), None);
+
+            let cell_py = GILOnceCell::new();
+            assert!(cell_py.clone_ref(py).get(py).is_none());
+            cell_py.get_or_init(py, || py.None());
+            assert!(cell_py.clone_ref(py).get(py).unwrap().is_none(py));
         })
     }
+
+    #[test]
+    #[allow(deprecated)]
+    fn test_once_cell_drop() {
+        #[derive(Debug)]
+        struct RecordDrop<'a>(&'a mut bool);
+
+        impl Drop for RecordDrop<'_> {
+            fn drop(&mut self) {
+                *self.0 = true;
+            }
+        }
+
+        Python::attach(|py| {
+            let mut dropped = false;
+            let cell = GILOnceCell::new();
+            cell.set(py, RecordDrop(&mut dropped)).unwrap();
+            let drop_container = cell.get(py).unwrap();
+
+            assert!(!*drop_container.0);
+            drop(cell);
+            assert!(dropped);
+        });
+    }
+
+    #[cfg(feature = "macros")]
+    #[cfg(not(target_arch = "wasm32"))] // We are building wasm Python with pthreads disabled
+    #[test]
+    fn test_critical_section() {
+        let barrier = Barrier::new(2);
+
+        let bool_wrapper = Python::attach(|py| -> Py<BoolWrapper> {
+            Py::new(py, BoolWrapper(AtomicBool::new(false))).unwrap()
+        });
+
+        std::thread::scope(|s| {
+            s.spawn(|| {
+                Python::attach(|py| {
+                    let b = bool_wrapper.bind(py);
+                    with_critical_section(b, || {
+                        barrier.wait();
+                        std::thread::sleep(std::time::Duration::from_millis(10));
+                        b.borrow().0.store(true, Ordering::Release);
+                    })
+                });
+            });
+            s.spawn(|| {
+                barrier.wait();
+                Python::attach(|py| {
+                    let b = bool_wrapper.bind(py);
+                    // this blocks until the other thread's critical section finishes
+                    with_critical_section(b, || {
+                        assert!(b.borrow().0.load(Ordering::Acquire));
+                    });
+                });
+            });
+        });
+    }
+
+    #[cfg(feature = "macros")]
+    #[cfg(not(target_arch = "wasm32"))] // We are building wasm Python with pthreads disabled
+    #[test]
+    fn test_critical_section2() {
+        let barrier = Barrier::new(3);
+
+        let (bool_wrapper1, bool_wrapper2) = Python::attach(|py| {
+            (
+                Py::new(py, BoolWrapper(AtomicBool::new(false))).unwrap(),
+                Py::new(py, BoolWrapper(AtomicBool::new(false))).unwrap(),
+            )
+        });
+
+        std::thread::scope(|s| {
+            s.spawn(|| {
+                Python::attach(|py| {
+                    let b1 = bool_wrapper1.bind(py);
+                    let b2 = bool_wrapper2.bind(py);
+                    with_critical_section2(b1, b2, || {
+                        barrier.wait();
+                        std::thread::sleep(std::time::Duration::from_millis(10));
+                        b1.borrow().0.store(true, Ordering::Release);
+                        b2.borrow().0.store(true, Ordering::Release);
+                    })
+                });
+            });
+            s.spawn(|| {
+                barrier.wait();
+                Python::attach(|py| {
+                    let b1 = bool_wrapper1.bind(py);
+                    // this blocks until the other thread's critical section finishes
+                    with_critical_section(b1, || {
+                        assert!(b1.borrow().0.load(Ordering::Acquire));
+                    });
+                });
+            });
+            s.spawn(|| {
+                barrier.wait();
+                Python::attach(|py| {
+                    let b2 = bool_wrapper2.bind(py);
+                    // this blocks until the other thread's critical section finishes
+                    with_critical_section(b2, || {
+                        assert!(b2.borrow().0.load(Ordering::Acquire));
+                    });
+                });
+            });
+        });
+    }
+
+    #[cfg(feature = "macros")]
+    #[cfg(not(target_arch = "wasm32"))] // We are building wasm Python with pthreads disabled
+    #[test]
+    fn test_critical_section2_same_object_no_deadlock() {
+        let barrier = Barrier::new(2);
+
+        let bool_wrapper = Python::attach(|py| -> Py<BoolWrapper> {
+            Py::new(py, BoolWrapper(AtomicBool::new(false))).unwrap()
+        });
+
+        std::thread::scope(|s| {
+            s.spawn(|| {
+                Python::attach(|py| {
+                    let b = bool_wrapper.bind(py);
+                    with_critical_section2(b, b, || {
+                        barrier.wait();
+                        std::thread::sleep(std::time::Duration::from_millis(10));
+                        b.borrow().0.store(true, Ordering::Release);
+                    })
+                });
+            });
+            s.spawn(|| {
+                barrier.wait();
+                Python::attach(|py| {
+                    let b = bool_wrapper.bind(py);
+                    // this blocks until the other thread's critical section finishes
+                    with_critical_section(b, || {
+                        assert!(b.borrow().0.load(Ordering::Acquire));
+                    });
+                });
+            });
+        });
+    }
+
+    #[cfg(feature = "macros")]
+    #[cfg(not(target_arch = "wasm32"))] // We are building wasm Python with pthreads disabled
+    #[test]
+    fn test_critical_section2_two_containers() {
+        let (vec1, vec2) = Python::attach(|py| {
+            (
+                Py::new(py, VecWrapper(vec![1, 2, 3])).unwrap(),
+                Py::new(py, VecWrapper(vec![4, 5])).unwrap(),
+            )
+        });
+
+        std::thread::scope(|s| {
+            s.spawn(|| {
+                Python::attach(|py| {
+                    let v1 = vec1.bind(py);
+                    let v2 = vec2.bind(py);
+                    with_critical_section2(v1, v2, || {
+                        // v2.extend(v1)
+                        v2.borrow_mut().0.extend(v1.borrow().0.iter());
+                    })
+                });
+            });
+            s.spawn(|| {
+                Python::attach(|py| {
+                    let v1 = vec1.bind(py);
+                    let v2 = vec2.bind(py);
+                    with_critical_section2(v1, v2, || {
+                        // v1.extend(v2)
+                        v1.borrow_mut().0.extend(v2.borrow().0.iter());
+                    })
+                });
+            });
+        });
+
+        Python::attach(|py| {
+            let v1 = vec1.bind(py);
+            let v2 = vec2.bind(py);
+            // execution order is not guaranteed, so we need to check both
+            // NB: extend should be atomic, items must not be interleaved
+            // v1.extend(v2)
+            // v2.extend(v1)
+            let expected1_vec1 = vec![1, 2, 3, 4, 5];
+            let expected1_vec2 = vec![4, 5, 1, 2, 3, 4, 5];
+            // v2.extend(v1)
+            // v1.extend(v2)
+            let expected2_vec1 = vec![1, 2, 3, 4, 5, 1, 2, 3];
+            let expected2_vec2 = vec![4, 5, 1, 2, 3];
+
+            assert!(
+                (v1.borrow().0.eq(&expected1_vec1) && v2.borrow().0.eq(&expected1_vec2))
+                    || (v1.borrow().0.eq(&expected2_vec1) && v2.borrow().0.eq(&expected2_vec2))
+            );
+        });
+    }
+
+    #[test]
+    #[cfg(not(target_arch = "wasm32"))] // We are building wasm Python with pthreads disabled
+    fn test_once_ext() {
+        macro_rules! test_once {
+            ($once:expr, $is_poisoned:expr) => {{
+                // adapted from the example in the docs for Once::try_once_force
+                let init = $once;
+                std::thread::scope(|s| {
+                    // poison the once
+                    let handle = s.spawn(|| {
+                        Python::attach(|py| {
+                            init.call_once_py_attached(py, || panic!());
+                        })
+                    });
+                    assert!(handle.join().is_err());
+
+                    // poisoning propagates
+                    let handle = s.spawn(|| {
+                        Python::attach(|py| {
+                            init.call_once_py_attached(py, || {});
+                        });
+                    });
+
+                    assert!(handle.join().is_err());
+
+                    // call_once_force will still run and reset the poisoned state
+                    Python::attach(|py| {
+                        init.call_once_force_py_attached(py, |state| {
+                            assert!($is_poisoned(state.clone()));
+                        });
+
+                        // once any success happens, we stop propagating the poison
+                        init.call_once_py_attached(py, || {});
+                    });
+
+                    // calling call_once_force should return immediately without calling the closure
+                    Python::attach(|py| init.call_once_force_py_attached(py, |_| panic!()));
+                });
+            }};
+        }
+
+        test_once!(Once::new(), OnceState::is_poisoned);
+        #[cfg(feature = "parking_lot")]
+        test_once!(parking_lot::Once::new(), parking_lot::OnceState::poisoned);
+    }
+
+    #[cfg(not(target_arch = "wasm32"))] // We are building wasm Python with pthreads disabled
+    #[test]
+    fn test_once_lock_ext() {
+        let cell = std::sync::OnceLock::new();
+        std::thread::scope(|s| {
+            assert!(cell.get().is_none());
+
+            s.spawn(|| {
+                Python::attach(|py| {
+                    assert_eq!(*cell.get_or_init_py_attached(py, || 12345), 12345);
+                });
+            });
+        });
+        assert_eq!(cell.get(), Some(&12345));
+    }
+
+    #[cfg(feature = "macros")]
+    #[cfg(not(target_arch = "wasm32"))] // We are building wasm Python with pthreads disabled
+    #[test]
+    fn test_mutex_ext() {
+        let barrier = Barrier::new(2);
+
+        let mutex = Python::attach(|py| -> Mutex<Py<BoolWrapper>> {
+            Mutex::new(Py::new(py, BoolWrapper(AtomicBool::new(false))).unwrap())
+        });
+
+        std::thread::scope(|s| {
+            s.spawn(|| {
+                Python::attach(|py| {
+                    let b = mutex.lock_py_attached(py).unwrap();
+                    barrier.wait();
+                    // sleep to ensure the other thread actually blocks
+                    std::thread::sleep(std::time::Duration::from_millis(10));
+                    (*b).bind(py).borrow().0.store(true, Ordering::Release);
+                    drop(b);
+                });
+            });
+            s.spawn(|| {
+                barrier.wait();
+                Python::attach(|py| {
+                    // blocks until the other thread releases the lock
+                    let b = mutex.lock_py_attached(py).unwrap();
+                    assert!((*b).bind(py).borrow().0.load(Ordering::Acquire));
+                });
+            });
+        });
+    }
+
+    #[cfg(feature = "macros")]
+    #[cfg(all(
+        any(feature = "parking_lot", feature = "lock_api"),
+        not(target_arch = "wasm32") // We are building wasm Python with pthreads disabled
+    ))]
+    #[test]
+    fn test_parking_lot_mutex_ext() {
+        macro_rules! test_mutex {
+            ($guard:ty ,$mutex:stmt) => {{
+                let barrier = Barrier::new(2);
+
+                let mutex = Python::attach({ $mutex });
+
+                std::thread::scope(|s| {
+                    s.spawn(|| {
+                        Python::attach(|py| {
+                            let b: $guard = mutex.lock_py_attached(py);
+                            barrier.wait();
+                            // sleep to ensure the other thread actually blocks
+                            std::thread::sleep(std::time::Duration::from_millis(10));
+                            (*b).bind(py).borrow().0.store(true, Ordering::Release);
+                            drop(b);
+                        });
+                    });
+                    s.spawn(|| {
+                        barrier.wait();
+                        Python::attach(|py| {
+                            // blocks until the other thread releases the lock
+                            let b: $guard = mutex.lock_py_attached(py);
+                            assert!((*b).bind(py).borrow().0.load(Ordering::Acquire));
+                        });
+                    });
+                });
+            }};
+        }
+
+        test_mutex!(parking_lot::MutexGuard<'_, _>, |py| {
+            parking_lot::Mutex::new(Py::new(py, BoolWrapper(AtomicBool::new(false))).unwrap())
+        });
+
+        test_mutex!(parking_lot::ReentrantMutexGuard<'_, _>, |py| {
+            parking_lot::ReentrantMutex::new(
+                Py::new(py, BoolWrapper(AtomicBool::new(false))).unwrap(),
+            )
+        });
+
+        #[cfg(feature = "arc_lock")]
+        test_mutex!(parking_lot::ArcMutexGuard<_, _>, |py| {
+            let mutex =
+                parking_lot::Mutex::new(Py::new(py, BoolWrapper(AtomicBool::new(false))).unwrap());
+            std::sync::Arc::new(mutex)
+        });
+
+        #[cfg(feature = "arc_lock")]
+        test_mutex!(parking_lot::ArcReentrantMutexGuard<_, _, _>, |py| {
+            let mutex =
+                parking_lot::ReentrantMutex::new(Py::new(py, BoolWrapper(AtomicBool::new(false))).unwrap());
+            std::sync::Arc::new(mutex)
+        });
+    }
+
+    #[cfg(not(target_arch = "wasm32"))] // We are building wasm Python with pthreads disabled
+    #[test]
+    fn test_mutex_ext_poison() {
+        let mutex = Mutex::new(42);
+
+        std::thread::scope(|s| {
+            let lock_result = s.spawn(|| {
+                Python::attach(|py| {
+                    let _unused = mutex.lock_py_attached(py);
+                    panic!();
+                });
+            });
+            assert!(lock_result.join().is_err());
+            assert!(mutex.is_poisoned());
+        });
+        let guard = Python::attach(|py| {
+            // recover from the poisoning
+            match mutex.lock_py_attached(py) {
+                Ok(guard) => guard,
+                Err(poisoned) => poisoned.into_inner(),
+            }
+        });
+        assert_eq!(*guard, 42);
+    }
+
+    #[cfg(feature = "macros")]
+    #[cfg(not(target_arch = "wasm32"))] // We are building wasm Python with pthreads disabled
+    #[test]
+    fn test_rwlock_ext_writer_blocks_reader() {
+        use std::sync::RwLock;
+
+        let barrier = Barrier::new(2);
+
+        let rwlock = Python::attach(|py| -> RwLock<Py<BoolWrapper>> {
+            RwLock::new(Py::new(py, BoolWrapper(AtomicBool::new(false))).unwrap())
+        });
+
+        std::thread::scope(|s| {
+            s.spawn(|| {
+                Python::attach(|py| {
+                    let b = rwlock.write_py_attached(py).unwrap();
+                    barrier.wait();
+                    // sleep to ensure the other thread actually blocks
+                    std::thread::sleep(std::time::Duration::from_millis(10));
+                    (*b).bind(py).borrow().0.store(true, Ordering::Release);
+                    drop(b);
+                });
+            });
+            s.spawn(|| {
+                barrier.wait();
+                Python::attach(|py| {
+                    // blocks until the other thread releases the lock
+                    let b = rwlock.read_py_attached(py).unwrap();
+                    assert!((*b).bind(py).borrow().0.load(Ordering::Acquire));
+                });
+            });
+        });
+    }
+
+    #[cfg(feature = "macros")]
+    #[cfg(not(target_arch = "wasm32"))] // We are building wasm Python with pthreads disabled
+    #[test]
+    fn test_rwlock_ext_reader_blocks_writer() {
+        use std::sync::RwLock;
+
+        let barrier = Barrier::new(2);
+
+        let rwlock = Python::attach(|py| -> RwLock<Py<BoolWrapper>> {
+            RwLock::new(Py::new(py, BoolWrapper(AtomicBool::new(false))).unwrap())
+        });
+
+        std::thread::scope(|s| {
+            s.spawn(|| {
+                Python::attach(|py| {
+                    let b = rwlock.read_py_attached(py).unwrap();
+                    barrier.wait();
+
+                    // sleep to ensure the other thread actually blocks
+                    std::thread::sleep(std::time::Duration::from_millis(10));
+
+                    // The bool must still be false (i.e., the writer did not actually write the
+                    // value yet).
+                    assert!(!(*b).bind(py).borrow().0.load(Ordering::Acquire));
+                });
+            });
+            s.spawn(|| {
+                barrier.wait();
+                Python::attach(|py| {
+                    // blocks until the other thread releases the lock
+                    let b = rwlock.write_py_attached(py).unwrap();
+                    (*b).bind(py).borrow().0.store(true, Ordering::Release);
+                    drop(b);
+                });
+            });
+        });
+
+        // Confirm that the writer did in fact run and write the expected `true` value.
+        Python::attach(|py| {
+            let b = rwlock.read_py_attached(py).unwrap();
+            assert!((*b).bind(py).borrow().0.load(Ordering::Acquire));
+            drop(b);
+        });
+    }
+
+    #[cfg(feature = "macros")]
+    #[cfg(all(
+        any(feature = "parking_lot", feature = "lock_api"),
+        not(target_arch = "wasm32") // We are building wasm Python with pthreads disabled
+    ))]
+    #[test]
+    fn test_parking_lot_rwlock_ext_writer_blocks_reader() {
+        macro_rules! test_rwlock {
+            ($write_guard:ty, $read_guard:ty, $rwlock:stmt) => {{
+                let barrier = Barrier::new(2);
+
+                let rwlock = Python::attach({ $rwlock });
+
+                std::thread::scope(|s| {
+                    s.spawn(|| {
+                        Python::attach(|py| {
+                            let b: $write_guard = rwlock.write_py_attached(py);
+                            barrier.wait();
+                            // sleep to ensure the other thread actually blocks
+                            std::thread::sleep(std::time::Duration::from_millis(10));
+                            (*b).bind(py).borrow().0.store(true, Ordering::Release);
+                            drop(b);
+                        });
+                    });
+                    s.spawn(|| {
+                        barrier.wait();
+                        Python::attach(|py| {
+                            // blocks until the other thread releases the lock
+                            let b: $read_guard = rwlock.read_py_attached(py);
+                            assert!((*b).bind(py).borrow().0.load(Ordering::Acquire));
+                        });
+                    });
+                });
+            }};
+        }
+
+        test_rwlock!(
+            parking_lot::RwLockWriteGuard<'_, _>,
+            parking_lot::RwLockReadGuard<'_, _>,
+            |py| {
+                parking_lot::RwLock::new(Py::new(py, BoolWrapper(AtomicBool::new(false))).unwrap())
+            }
+        );
+
+        #[cfg(feature = "arc_lock")]
+        test_rwlock!(
+            parking_lot::ArcRwLockWriteGuard<_, _>,
+            parking_lot::ArcRwLockReadGuard<_, _>,
+            |py| {
+                let rwlock = parking_lot::RwLock::new(
+                    Py::new(py, BoolWrapper(AtomicBool::new(false))).unwrap(),
+                );
+                std::sync::Arc::new(rwlock)
+            }
+        );
+    }
+
+    #[cfg(feature = "macros")]
+    #[cfg(all(
+        any(feature = "parking_lot", feature = "lock_api"),
+        not(target_arch = "wasm32") // We are building wasm Python with pthreads disabled
+    ))]
+    #[test]
+    fn test_parking_lot_rwlock_ext_reader_blocks_writer() {
+        macro_rules! test_rwlock {
+            ($write_guard:ty, $read_guard:ty, $rwlock:stmt) => {{
+                let barrier = Barrier::new(2);
+
+                let rwlock = Python::attach({ $rwlock });
+
+                std::thread::scope(|s| {
+                    s.spawn(|| {
+                        Python::attach(|py| {
+                            let b: $read_guard = rwlock.read_py_attached(py);
+                            barrier.wait();
+
+                            // sleep to ensure the other thread actually blocks
+                            std::thread::sleep(std::time::Duration::from_millis(10));
+
+                            // The bool must still be false (i.e., the writer did not actually write the
+                            // value yet).
+                            assert!(!(*b).bind(py).borrow().0.load(Ordering::Acquire));                            (*b).bind(py).borrow().0.store(true, Ordering::Release);
+
+                            drop(b);
+                        });
+                    });
+                    s.spawn(|| {
+                        barrier.wait();
+                        Python::attach(|py| {
+                            // blocks until the other thread releases the lock
+                            let b: $write_guard = rwlock.write_py_attached(py);
+                            (*b).bind(py).borrow().0.store(true, Ordering::Release);
+                        });
+                    });
+                });
+
+                // Confirm that the writer did in fact run and write the expected `true` value.
+                Python::attach(|py| {
+                    let b: $read_guard = rwlock.read_py_attached(py);
+                    assert!((*b).bind(py).borrow().0.load(Ordering::Acquire));
+                    drop(b);
+                });
+            }};
+        }
+
+        test_rwlock!(
+            parking_lot::RwLockWriteGuard<'_, _>,
+            parking_lot::RwLockReadGuard<'_, _>,
+            |py| {
+                parking_lot::RwLock::new(Py::new(py, BoolWrapper(AtomicBool::new(false))).unwrap())
+            }
+        );
+
+        #[cfg(feature = "arc_lock")]
+        test_rwlock!(
+            parking_lot::ArcRwLockWriteGuard<_, _>,
+            parking_lot::ArcRwLockReadGuard<_, _>,
+            |py| {
+                let rwlock = parking_lot::RwLock::new(
+                    Py::new(py, BoolWrapper(AtomicBool::new(false))).unwrap(),
+                );
+                std::sync::Arc::new(rwlock)
+            }
+        );
+    }
+
+    #[cfg(not(target_arch = "wasm32"))] // We are building wasm Python with pthreads disabled
+    #[test]
+    fn test_rwlock_ext_poison() {
+        use std::sync::RwLock;
+
+        let rwlock = RwLock::new(42);
+
+        std::thread::scope(|s| {
+            let lock_result = s.spawn(|| {
+                Python::attach(|py| {
+                    let _unused = rwlock.write_py_attached(py);
+                    panic!();
+                });
+            });
+            assert!(lock_result.join().is_err());
+            assert!(rwlock.is_poisoned());
+            Python::attach(|py| {
+                assert!(rwlock.read_py_attached(py).is_err());
+                assert!(rwlock.write_py_attached(py).is_err());
+            });
+        });
+        Python::attach(|py| {
+            // recover from the poisoning
+            let guard = rwlock.write_py_attached(py).unwrap_err().into_inner();
+            assert_eq!(*guard, 42);
+        });
+    }
 }
diff --git a/src/sync/once_lock.rs b/src/sync/once_lock.rs
new file mode 100644
index 00000000000..5612b556e38
--- /dev/null
+++ b/src/sync/once_lock.rs
@@ -0,0 +1,267 @@
+use crate::{
+    internal::state::SuspendAttach, types::any::PyAnyMethods, Bound, Py, PyResult, PyTypeCheck,
+    Python,
+};
+
+/// An equivalent to [`std::sync::OnceLock`] for initializing objects while attached to
+/// the Python interpreter.
+///
+/// Unlike `OnceLock<T>`, this type will not deadlock with the interpreter.
+/// Before blocking calls the cell will detach from the runtime and then
+/// re-attach once the cell is unblocked.
+///
+/// # Re-entrant initialization
+///
+/// Like `OnceLock<T>`, it is an error to re-entrantly initialize a `PyOnceLock<T>`. The exact
+/// behavior in this case is not guaranteed, it may either deadlock or panic.
+///
+/// # Examples
+///
+/// The following example shows how to use `PyOnceLock` to share a reference to a Python list
+/// between threads:
+///
+/// ```
+/// use pyo3::sync::PyOnceLock;
+/// use pyo3::prelude::*;
+/// use pyo3::types::PyList;
+///
+/// static LIST_CELL: PyOnceLock<Py<PyList>> = PyOnceLock::new();
+///
+/// pub fn get_shared_list(py: Python<'_>) -> &Bound<'_, PyList> {
+///     LIST_CELL
+///         .get_or_init(py, || PyList::empty(py).unbind())
+///         .bind(py)
+/// }
+/// # Python::attach(|py| assert_eq!(get_shared_list(py).len(), 0));
+/// ```
+#[derive(Default)]
+pub struct PyOnceLock<T> {
+    inner: once_cell::sync::OnceCell<T>,
+}
+
+impl<T> PyOnceLock<T> {
+    /// Create a `PyOnceLock` which does not yet contain a value.
+    pub const fn new() -> Self {
+        Self {
+            inner: once_cell::sync::OnceCell::new(),
+        }
+    }
+
+    /// Get a reference to the contained value, or `None` if the cell has not yet been written.
+    #[inline]
+    pub fn get(&self, _py: Python<'_>) -> Option<&T> {
+        self.inner.get()
+    }
+
+    /// Get a reference to the contained value, initializing it if needed using the provided
+    /// closure.
+    ///
+    /// See the type-level documentation for detail on re-entrancy and concurrent initialization.
+    #[inline]
+    pub fn get_or_init<F>(&self, py: Python<'_>, f: F) -> &T
+    where
+        F: FnOnce() -> T,
+    {
+        self.inner
+            .get()
+            .unwrap_or_else(|| init_once_cell_py_attached(&self.inner, py, f))
+    }
+
+    /// Like `get_or_init`, but accepts a fallible initialization function. If it fails, the cell
+    /// is left uninitialized.
+    ///
+    /// See the type-level documentation for detail on re-entrancy and concurrent initialization.
+    pub fn get_or_try_init<F, E>(&self, py: Python<'_>, f: F) -> Result<&T, E>
+    where
+        F: FnOnce() -> Result<T, E>,
+    {
+        self.inner
+            .get()
+            .map_or_else(|| try_init_once_cell_py_attached(&self.inner, py, f), Ok)
+    }
+
+    /// Get the contents of the cell mutably. This is only possible if the reference to the cell is
+    /// unique.
+    pub fn get_mut(&mut self) -> Option<&mut T> {
+        self.inner.get_mut()
+    }
+
+    /// Set the value in the cell.
+    ///
+    /// If the cell has already been written, `Err(value)` will be returned containing the new
+    /// value which was not written.
+    pub fn set(&self, _py: Python<'_>, value: T) -> Result<(), T> {
+        self.inner.set(value)
+    }
+
+    /// Takes the value out of the cell, moving it back to an uninitialized state.
+    ///
+    /// Has no effect and returns None if the cell has not yet been written.
+    pub fn take(&mut self) -> Option<T> {
+        self.inner.take()
+    }
+
+    /// Consumes the cell, returning the wrapped value.
+    ///
+    /// Returns None if the cell has not yet been written.
+    pub fn into_inner(self) -> Option<T> {
+        self.inner.into_inner()
+    }
+}
+
+impl<T> PyOnceLock<Py<T>> {
+    /// Creates a new cell that contains a new Python reference to the same contained object.
+    ///
+    /// Returns an uninitialized cell if `self` has not yet been initialized.
+    pub fn clone_ref(&self, py: Python<'_>) -> Self {
+        let cloned = PyOnceLock::new();
+        if let Some(value) = self.get(py) {
+            let _ = cloned.set(py, value.clone_ref(py));
+        }
+        cloned
+    }
+}
+
+impl<T> PyOnceLock<Py<T>>
+where
+    T: PyTypeCheck,
+{
+    /// This is a shorthand method for `get_or_init` which imports the type from Python on init.
+    ///
+    /// # Example: Using `PyOnceLock` to store a class in a static variable.
+    ///
+    /// `PyOnceLock` can be used to avoid importing a class multiple times:
+    /// ```
+    /// # use pyo3::prelude::*;
+    /// # use pyo3::sync::PyOnceLock;
+    /// # use pyo3::types::{PyDict, PyType};
+    /// # use pyo3::intern;
+    /// #
+    /// #[pyfunction]
+    /// fn create_ordered_dict<'py>(py: Python<'py>, dict: Bound<'py, PyDict>) -> PyResult<Bound<'py, PyAny>> {
+    ///     // Even if this function is called multiple times,
+    ///     // the `OrderedDict` class will be imported only once.
+    ///     static ORDERED_DICT: PyOnceLock<Py<PyType>> = PyOnceLock::new();
+    ///     ORDERED_DICT
+    ///         .import(py, "collections", "OrderedDict")?
+    ///         .call1((dict,))
+    /// }
+    ///
+    /// # Python::attach(|py| {
+    /// #     let dict = PyDict::new(py);
+    /// #     dict.set_item(intern!(py, "foo"), 42).unwrap();
+    /// #     let fun = wrap_pyfunction!(create_ordered_dict, py).unwrap();
+    /// #     let ordered_dict = fun.call1((&dict,)).unwrap();
+    /// #     assert!(dict.eq(ordered_dict).unwrap());
+    /// # });
+    /// ```
+    pub fn import<'py>(
+        &self,
+        py: Python<'py>,
+        module_name: &str,
+        attr_name: &str,
+    ) -> PyResult<&Bound<'py, T>> {
+        self.get_or_try_init(py, || {
+            let type_object = py.import(module_name)?.getattr(attr_name)?.cast_into()?;
+            Ok(type_object.unbind())
+        })
+        .map(|ty| ty.bind(py))
+    }
+}
+
+#[cold]
+fn init_once_cell_py_attached<'a, F, T>(
+    cell: &'a once_cell::sync::OnceCell<T>,
+    _py: Python<'_>,
+    f: F,
+) -> &'a T
+where
+    F: FnOnce() -> T,
+{
+    // SAFETY: detach from the runtime right before a possibly blocking call
+    // then reattach when the blocking call completes and before calling
+    // into the C API.
+    let ts_guard = unsafe { SuspendAttach::new() };
+
+    // By having detached here, we guarantee that `.get_or_init` cannot deadlock with
+    // the Python interpreter
+    cell.get_or_init(move || {
+        drop(ts_guard);
+        f()
+    })
+}
+
+#[cold]
+fn try_init_once_cell_py_attached<'a, F, T, E>(
+    cell: &'a once_cell::sync::OnceCell<T>,
+    _py: Python<'_>,
+    f: F,
+) -> Result<&'a T, E>
+where
+    F: FnOnce() -> Result<T, E>,
+{
+    // SAFETY: detach from the runtime right before a possibly blocking call
+    // then reattach when the blocking call completes and before calling
+    // into the C API.
+    let ts_guard = unsafe { SuspendAttach::new() };
+
+    // By having detached here, we guarantee that `.get_or_init` cannot deadlock with
+    // the Python interpreter
+    cell.get_or_try_init(move || {
+        drop(ts_guard);
+        f()
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_once_cell() {
+        Python::attach(|py| {
+            let mut cell = PyOnceLock::new();
+
+            assert!(cell.get(py).is_none());
+
+            assert_eq!(cell.get_or_try_init(py, || Err(5)), Err(5));
+            assert!(cell.get(py).is_none());
+
+            assert_eq!(cell.get_or_try_init(py, || Ok::<_, ()>(2)), Ok(&2));
+            assert_eq!(cell.get(py), Some(&2));
+
+            assert_eq!(cell.get_or_try_init(py, || Err(5)), Ok(&2));
+
+            assert_eq!(cell.take(), Some(2));
+            assert_eq!(cell.into_inner(), None);
+
+            let cell_py = PyOnceLock::new();
+            assert!(cell_py.clone_ref(py).get(py).is_none());
+            cell_py.get_or_init(py, || py.None());
+            assert!(cell_py.clone_ref(py).get(py).unwrap().is_none(py));
+        })
+    }
+
+    #[test]
+    fn test_once_cell_drop() {
+        #[derive(Debug)]
+        struct RecordDrop<'a>(&'a mut bool);
+
+        impl Drop for RecordDrop<'_> {
+            fn drop(&mut self) {
+                *self.0 = true;
+            }
+        }
+
+        Python::attach(|py| {
+            let mut dropped = false;
+            let cell = PyOnceLock::new();
+            cell.set(py, RecordDrop(&mut dropped)).unwrap();
+            let drop_container = cell.get(py).unwrap();
+
+            assert!(!*drop_container.0);
+            drop(cell);
+            assert!(dropped);
+        });
+    }
+}
diff --git a/src/test_utils.rs b/src/test_utils.rs
index a007483fad4..32b74997bcb 100644
--- a/src/test_utils.rs
+++ b/src/test_utils.rs
@@ -1,2 +1,6 @@
+// Brings in `test_utils` from the `tests` directory
+//
+// to make that file function (lots of references to `pyo3` within it) need
+// re-bind `crate` as pyo3
 use crate as pyo3;
-include!("../tests/common.rs");
+include!("../tests/test_utils/mod.rs");
diff --git a/src/tests/common.rs b/src/tests/common.rs
deleted file mode 100644
index ed3972f16a6..00000000000
--- a/src/tests/common.rs
+++ /dev/null
@@ -1,162 +0,0 @@
-// the inner mod enables the #![allow(dead_code)] to
-// be applied - `test_utils.rs` uses `include!` to pull in this file
-
-/// Common macros and helpers for tests
-#[allow(dead_code)] // many tests do not use the complete set of functionality offered here
-#[macro_use]
-mod inner {
-
-    #[allow(unused_imports)] // pulls in `use crate as pyo3` in `test_utils.rs`
-    use super::*;
-
-    use pyo3::prelude::*;
-
-    use pyo3::types::{IntoPyDict, PyList};
-
-    #[macro_export]
-    macro_rules! py_assert {
-        ($py:expr, $($val:ident)+, $assertion:literal) => {
-            pyo3::py_run!($py, $($val)+, concat!("assert ", $assertion))
-        };
-        ($py:expr, *$dict:expr, $assertion:literal) => {
-            pyo3::py_run!($py, *$dict, concat!("assert ", $assertion))
-        };
-    }
-
-    #[macro_export]
-    macro_rules! assert_py_eq {
-        ($val:expr, $expected:expr) => {
-            assert!($val.eq($expected).unwrap());
-        };
-    }
-
-    #[macro_export]
-    macro_rules! py_expect_exception {
-        // Case1: idents & no err_msg
-        ($py:expr, $($val:ident)+, $code:expr, $err:ident) => {{
-            use pyo3::types::IntoPyDict;
-            let d = [$((stringify!($val), $val.to_object($py)),)+].into_py_dict_bound($py);
-            py_expect_exception!($py, *d, $code, $err)
-        }};
-        // Case2: dict & no err_msg
-        ($py:expr, *$dict:expr, $code:expr, $err:ident) => {{
-            let res = $py.run_bound($code, None, Some(&$dict.as_borrowed()));
-            let err = res.expect_err(&format!("Did not raise {}", stringify!($err)));
-            if !err.matches($py, $py.get_type::<pyo3::exceptions::$err>()) {
-                panic!("Expected {} but got {:?}", stringify!($err), err)
-            }
-            err
-        }};
-        // Case3: idents & err_msg
-        ($py:expr, $($val:ident)+, $code:expr, $err:ident, $err_msg:literal) => {{
-            let err = py_expect_exception!($py, $($val)+, $code, $err);
-            // Suppose that the error message looks like 'TypeError: ~'
-            assert_eq!(format!("Py{}", err), concat!(stringify!($err), ": ", $err_msg));
-            err
-        }};
-        // Case4: dict & err_msg
-        ($py:expr, *$dict:expr, $code:expr, $err:ident, $err_msg:literal) => {{
-            let err = py_expect_exception!($py, *$dict, $code, $err);
-            assert_eq!(format!("Py{}", err), concat!(stringify!($err), ": ", $err_msg));
-            err
-        }};
-    }
-
-    // sys.unraisablehook not available until Python 3.8
-    #[cfg(all(feature = "macros", Py_3_8))]
-    #[pyclass(crate = "pyo3")]
-    pub struct UnraisableCapture {
-        pub capture: Option<(PyErr, PyObject)>,
-        old_hook: Option<PyObject>,
-    }
-
-    #[cfg(all(feature = "macros", Py_3_8))]
-    #[pymethods(crate = "pyo3")]
-    impl UnraisableCapture {
-        pub fn hook(&mut self, unraisable: &PyAny) {
-            let err = PyErr::from_value(unraisable.getattr("exc_value").unwrap());
-            let instance = unraisable.getattr("object").unwrap();
-            self.capture = Some((err, instance.into()));
-        }
-    }
-
-    #[cfg(all(feature = "macros", Py_3_8))]
-    impl UnraisableCapture {
-        pub fn install(py: Python<'_>) -> Py<Self> {
-            let sys = py.import_bound("sys").unwrap();
-            let old_hook = sys.getattr("unraisablehook").unwrap().into();
-
-            let capture = Py::new(
-                py,
-                UnraisableCapture {
-                    capture: None,
-                    old_hook: Some(old_hook),
-                },
-            )
-            .unwrap();
-
-            sys.setattr("unraisablehook", capture.getattr(py, "hook").unwrap())
-                .unwrap();
-
-            capture
-        }
-
-        pub fn uninstall(&mut self, py: Python<'_>) {
-            let old_hook = self.old_hook.take().unwrap();
-
-            let sys = py.import_bound("sys").unwrap();
-            sys.setattr("unraisablehook", old_hook).unwrap();
-        }
-    }
-
-    pub struct CatchWarnings<'py> {
-        catch_warnings: Bound<'py, PyAny>,
-    }
-
-    impl<'py> CatchWarnings<'py> {
-        pub fn enter<R>(py: Python<'py>, f: impl FnOnce(&PyList) -> PyResult<R>) -> PyResult<R> {
-            let warnings = py.import_bound("warnings")?;
-            let kwargs = [("record", true)].into_py_dict_bound(py);
-            let catch_warnings = warnings
-                .getattr("catch_warnings")?
-                .call((), Some(&kwargs))?;
-            let list = catch_warnings.call_method0("__enter__")?.extract()?;
-            let _guard = Self { catch_warnings };
-            f(list)
-        }
-    }
-
-    impl Drop for CatchWarnings<'_> {
-        fn drop(&mut self) {
-            let py = self.catch_warnings.py();
-            self.catch_warnings
-                .call_method1("__exit__", (py.None(), py.None(), py.None()))
-                .unwrap();
-        }
-    }
-
-    #[macro_export]
-    macro_rules! assert_warnings {
-        ($py:expr, $body:expr, [$(($category:ty, $message:literal)),+] $(,)? ) => {{
-            $crate::tests::common::CatchWarnings::enter($py, |w| {
-                $body;
-                let expected_warnings = [$((<$category as $crate::type_object::PyTypeInfo>::type_object_bound($py), $message)),+];
-                assert_eq!(w.len(), expected_warnings.len());
-                for (warning, (category, message)) in w.iter().zip(expected_warnings) {
-
-                    assert!(warning.getattr("category").unwrap().is(&category));
-                    assert_eq!(
-                        warning.getattr("message").unwrap().str().unwrap().to_string_lossy(),
-                        message
-                    );
-                }
-
-                Ok(())
-            })
-            .unwrap();
-        }};
-    }
-}
-
-#[allow(unused_imports)] // some tests use just the macros and none of the other functionality
-pub use inner::*;
diff --git a/src/tests/hygiene/misc.rs b/src/tests/hygiene/misc.rs
index 66db7f3a28a..e2e584c18a4 100644
--- a/src/tests/hygiene/misc.rs
+++ b/src/tests/hygiene/misc.rs
@@ -1,25 +1,23 @@
-#![no_implicit_prelude]
-
 #[derive(crate::FromPyObject)]
 #[pyo3(crate = "crate")]
-struct Derive1(#[allow(dead_code)] i32); // newtype case
+struct Derive1(i32); // newtype case
 
 #[derive(crate::FromPyObject)]
 #[pyo3(crate = "crate")]
-#[allow(dead_code)]
 struct Derive2(i32, i32); // tuple case
 
 #[derive(crate::FromPyObject)]
 #[pyo3(crate = "crate")]
-#[allow(dead_code)]
 struct Derive3 {
     f: i32,
+    #[pyo3(item(42))]
     g: i32,
+    #[pyo3(default)]
+    h: i32,
 } // struct case
 
 #[derive(crate::FromPyObject)]
 #[pyo3(crate = "crate")]
-#[allow(dead_code)]
 enum Derive4 {
     A(i32),
     B { f: i32 },
@@ -28,20 +26,71 @@ enum Derive4 {
 crate::create_exception!(mymodule, CustomError, crate::exceptions::PyException);
 crate::import_exception!(socket, gaierror);
 
-#[allow(dead_code)]
 fn intern(py: crate::Python<'_>) {
     let _foo = crate::intern!(py, "foo");
     let _bar = crate::intern!(py, stringify!(bar));
 }
 
-#[allow(dead_code)]
-#[cfg(not(PyPy))]
+#[cfg(not(any(PyPy, GraalPy)))]
 fn append_to_inittab() {
     #[crate::pymodule]
     #[pyo3(crate = "crate")]
-    #[allow(clippy::unnecessary_wraps)]
-    fn module_for_inittab(_: crate::Python<'_>, _: &crate::types::PyModule) -> crate::PyResult<()> {
-        ::std::result::Result::Ok(())
-    }
+    mod module_for_inittab {}
+
     crate::append_to_inittab!(module_for_inittab);
 }
+
+macro_rules! macro_rules_hygiene {
+    ($name_a:ident, $name_b:ident) => {
+        #[crate::pyclass(crate = "crate")]
+        struct $name_a {}
+
+        #[crate::pymethods(crate = "crate")]
+        impl $name_a {
+            fn finalize(&mut self) -> $name_b {
+                $name_b {}
+            }
+        }
+
+        #[crate::pyclass(crate = "crate")]
+        struct $name_b {}
+    };
+}
+
+macro_rules_hygiene!(MyClass1, MyClass2);
+
+#[derive(crate::IntoPyObject, crate::IntoPyObjectRef)]
+#[pyo3(crate = "crate")]
+struct IntoPyObject1(i32); // transparent newtype case
+
+#[derive(crate::IntoPyObject, crate::IntoPyObjectRef)]
+#[pyo3(crate = "crate", transparent)]
+struct IntoPyObject2<'a> {
+    inner: &'a str, // transparent newtype case
+}
+
+#[derive(crate::IntoPyObject, crate::IntoPyObjectRef)]
+#[pyo3(crate = "crate")]
+struct IntoPyObject3<'py>(i32, crate::Bound<'py, crate::PyAny>); // tuple case
+
+#[derive(crate::IntoPyObject, crate::IntoPyObjectRef)]
+#[pyo3(crate = "crate")]
+struct IntoPyObject4<'a, 'py> {
+    callable: &'a crate::Bound<'py, crate::PyAny>, // struct case
+    num: usize,
+}
+
+#[derive(crate::IntoPyObject, crate::IntoPyObjectRef)]
+#[pyo3(crate = "crate")]
+enum IntoPyObject5<'a, 'py> {
+    TransparentTuple(i32),
+    #[pyo3(transparent)]
+    TransparentStruct {
+        f: crate::Py<crate::PyAny>,
+    },
+    Tuple(crate::Bound<'py, crate::types::PyString>, usize),
+    Struct {
+        f: i32,
+        g: &'a str,
+    },
+} // enum case
diff --git a/src/tests/hygiene/mod.rs b/src/tests/hygiene/mod.rs
index f612c2d7162..c950e18da94 100644
--- a/src/tests/hygiene/mod.rs
+++ b/src/tests/hygiene/mod.rs
@@ -1,3 +1,6 @@
+#![no_implicit_prelude]
+#![allow(dead_code, unused_variables, clippy::unnecessary_wraps)]
+
 // The modules in this test are used to check PyO3 macro expansion is hygienic. By locating the test
 // inside the crate the global `::pyo3` namespace is not available, so in combination with
 // #[pyo3(crate = "crate")] this validates that all macro expansion respects the setting.
diff --git a/src/tests/hygiene/pyclass.rs b/src/tests/hygiene/pyclass.rs
index 4d07009cad6..306712e4d78 100644
--- a/src/tests/hygiene/pyclass.rs
+++ b/src/tests/hygiene/pyclass.rs
@@ -1,6 +1,3 @@
-#![no_implicit_prelude]
-#![allow(unused_variables)]
-
 #[crate::pyclass]
 #[pyo3(crate = "crate")]
 #[derive(::std::clone::Clone)]
@@ -10,27 +7,37 @@ pub struct Foo;
 #[pyo3(crate = "crate")]
 pub struct Foo2;
 
-#[crate::pyclass(
+#[cfg_attr(any(Py_3_9, not(Py_LIMITED_API)), crate::pyclass(
     name = "ActuallyBar",
     freelist = 8,
+    unsendable,
+    subclass,
+    extends = crate::types::PyAny,
+    module = "Spam",
     weakref,
+    dict
+))]
+#[cfg_attr(not(any(Py_3_9, not(Py_LIMITED_API))), crate::pyclass(
+    name = "ActuallyBar",
+    freelist = 8,
     unsendable,
     subclass,
     extends = crate::types::PyAny,
     module = "Spam"
-)]
+))]
 #[pyo3(crate = "crate")]
 pub struct Bar {
     #[pyo3(get, set)]
     a: u8,
     #[pyo3(get, set)]
     b: Foo,
-    #[pyo3(get, set)]
+    #[pyo3(set)]
     c: ::std::option::Option<crate::Py<Foo2>>,
 }
 
-#[crate::pyclass]
+#[crate::pyclass(eq, eq_int)]
 #[pyo3(crate = "crate")]
+#[derive(PartialEq)]
 pub enum Enum {
     Var0,
 }
@@ -39,11 +46,11 @@ pub enum Enum {
 #[pyo3(crate = "crate")]
 pub struct Foo3 {
     #[pyo3(get, set)]
-    #[cfg(FALSE)]
+    #[cfg(any())]
     field: i32,
 
     #[pyo3(get, set)]
-    #[cfg(not(FALSE))]
+    #[cfg(not(any()))]
     field: u32,
 }
 
@@ -51,11 +58,102 @@ pub struct Foo3 {
 #[pyo3(crate = "crate")]
 pub struct Foo4 {
     #[pyo3(get, set)]
-    #[cfg(FALSE)]
-    #[cfg(not(FALSE))]
+    #[cfg(any())]
+    #[cfg(not(any()))]
     field: i32,
 
     #[pyo3(get, set)]
-    #[cfg(not(FALSE))]
+    #[cfg(not(any()))]
     field: u32,
 }
+
+#[crate::pyclass(eq, ord)]
+#[pyo3(crate = "crate")]
+#[derive(PartialEq, PartialOrd)]
+pub struct PointEqOrd {
+    x: u32,
+    y: u32,
+    z: u32,
+}
+
+#[crate::pyclass(eq, ord)]
+#[pyo3(crate = "crate")]
+#[derive(PartialEq, PartialOrd)]
+pub enum ComplexEnumEqOrd {
+    Variant1 { a: u32, b: u32 },
+    Variant2 { c: u32 },
+}
+
+#[crate::pyclass(eq, ord)]
+#[pyo3(crate = "crate")]
+#[derive(PartialEq, PartialOrd)]
+pub enum TupleEnumEqOrd {
+    Variant1(u32, u32),
+    Variant2(u32),
+}
+
+#[crate::pyclass(crate = "crate")]
+pub enum ComplexEnumManyVariantFields {
+    ManyStructFields {
+        field_1: u16,
+        field_2: u32,
+        field_3: u32,
+        field_4: i32,
+        field_5: u32,
+        field_6: u32,
+        field_7: u8,
+        field_8: u32,
+        field_9: i32,
+        field_10: u32,
+        field_11: u32,
+        field_12: u32,
+        field_13: u32,
+        field_14: i16,
+        field_15: u32,
+    },
+    ManyTupleFields(
+        u16,
+        u32,
+        u32,
+        i32,
+        u32,
+        u32,
+        u8,
+        u32,
+        i32,
+        u32,
+        u32,
+        u32,
+        u32,
+        i16,
+        u32,
+    ),
+}
+
+#[crate::pyclass(str = "{x}, {y}, {z}")]
+#[pyo3(crate = "crate")]
+pub struct PointFmt {
+    x: u32,
+    y: u32,
+    z: u32,
+}
+
+#[crate::pyclass(str)]
+#[pyo3(crate = "crate")]
+pub struct Point {
+    x: i32,
+    y: i32,
+    z: i32,
+}
+
+impl ::std::fmt::Display for Point {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+        ::std::write!(f, "({}, {}, {})", self.x, self.y, self.z)
+    }
+}
+
+#[crate::pyclass(crate = "crate", from_py_object)]
+#[derive(Clone)]
+pub struct Foo5 {
+    a: i32,
+}
diff --git a/src/tests/hygiene/pyfunction.rs b/src/tests/hygiene/pyfunction.rs
index 19fe2739407..a692b0acd3f 100644
--- a/src/tests/hygiene/pyfunction.rs
+++ b/src/tests/hygiene/pyfunction.rs
@@ -1,16 +1,33 @@
-#![no_implicit_prelude]
-#![allow(unused_variables, clippy::unnecessary_wraps)]
-
 #[crate::pyfunction]
 #[pyo3(crate = "crate")]
 fn do_something(x: i32) -> crate::PyResult<i32> {
     ::std::result::Result::Ok(x)
 }
 
+#[crate::pyfunction]
+#[pyo3(crate = "crate", name = "check5012")]
+fn check_5012(x: i32) -> crate::PyResult<i32> {
+    ::std::result::Result::Ok(x)
+}
+
+#[crate::pyfunction]
+#[pyo3(crate = "crate")]
+#[pyo3(warn(message = "This is a warning message"))]
+fn function_with_warning() {}
+
+#[crate::pyfunction(crate = "crate")]
+#[pyo3(warn(message = "This is a warning message with custom category", category = crate::exceptions::PyFutureWarning))]
+fn function_with_warning_and_category() {}
+
+#[crate::pyfunction(crate = "crate")]
+#[pyo3(warn(message = "This is a warning message"))]
+#[pyo3(warn(message = "This is another warning message", category = crate::exceptions::PyFutureWarning))]
+fn multiple_warning_function() {}
+
 #[test]
 fn invoke_wrap_pyfunction() {
-    crate::Python::with_gil(|py| {
-        let func = crate::wrap_pyfunction!(do_something)(py).unwrap();
+    crate::Python::attach(|py| {
+        let func = crate::wrap_pyfunction!(do_something, py).unwrap();
         crate::py_run!(py, func, r#"func(5)"#);
     });
 }
diff --git a/src/tests/hygiene/pymethods.rs b/src/tests/hygiene/pymethods.rs
index a00e67d9a85..3f7361a395a 100644
--- a/src/tests/hygiene/pymethods.rs
+++ b/src/tests/hygiene/pymethods.rs
@@ -1,6 +1,3 @@
-#![no_implicit_prelude]
-#![allow(unused_variables, clippy::unnecessary_wraps)]
-
 #[crate::pyclass]
 #[pyo3(crate = "crate")]
 pub struct Dummy;
@@ -9,7 +6,6 @@ pub struct Dummy;
 #[pyo3(crate = "crate")]
 pub struct DummyIter;
 
-#[cfg(Py_3_8)]
 #[crate::pymethods]
 #[pyo3(crate = "crate")]
 impl Dummy {
@@ -25,11 +21,11 @@ impl Dummy {
     }
 
     fn __bytes__<'py>(&self, py: crate::Python<'py>) -> crate::Bound<'py, crate::types::PyBytes> {
-        crate::types::PyBytes::new_bound(py, &[0])
+        crate::types::PyBytes::new(py, &[0])
     }
 
     fn __format__(&self, format_spec: ::std::string::String) -> ::std::string::String {
-        ::std::panic!("unimplemented isn't hygienic before 1.50")
+        ::std::unimplemented!()
     }
 
     fn __lt__(&self, other: &Self) -> bool {
@@ -64,20 +60,23 @@ impl Dummy {
     // Customizing attribute access
     //////////////////////
 
-    fn __getattr__(&self, name: ::std::string::String) -> &crate::PyAny {
-        ::std::panic!("unimplemented isn't hygienic before 1.50")
+    fn __getattr__(&self, name: ::std::string::String) -> &crate::Bound<'_, crate::PyAny> {
+        ::std::unimplemented!()
     }
 
-    fn __getattribute__(&self, name: ::std::string::String) -> &crate::PyAny {
-        ::std::panic!("unimplemented isn't hygienic before 1.50")
+    fn __getattribute__(&self, name: ::std::string::String) -> &crate::Bound<'_, crate::PyAny> {
+        ::std::unimplemented!()
     }
 
     fn __setattr__(&mut self, name: ::std::string::String, value: ::std::string::String) {}
 
     fn __delattr__(&mut self, name: ::std::string::String) {}
 
-    fn __dir__<'py>(&self, py: crate::Python<'py>) -> crate::Bound<'py, crate::types::PyList> {
-        crate::types::PyList::new_bound(py, ::std::vec![0_u8])
+    fn __dir__<'py>(
+        &self,
+        py: crate::Python<'py>,
+    ) -> crate::PyResult<crate::Bound<'py, crate::types::PyList>> {
+        crate::types::PyList::new(py, ::std::vec![0_u8])
     }
 
     //////////////////////
@@ -86,17 +85,27 @@ impl Dummy {
 
     fn __get__(
         &self,
-        instance: &crate::PyAny,
-        owner: &crate::PyAny,
-    ) -> crate::PyResult<&crate::PyAny> {
-        ::std::panic!("unimplemented isn't hygienic before 1.50")
+        instance: &crate::Bound<'_, crate::PyAny>,
+        owner: &crate::Bound<'_, crate::PyAny>,
+    ) -> crate::PyResult<&crate::Bound<'_, crate::PyAny>> {
+        ::std::unimplemented!()
     }
 
-    fn __set__(&self, instance: &crate::PyAny, owner: &crate::PyAny) {}
+    fn __set__(
+        &self,
+        instance: &crate::Bound<'_, crate::PyAny>,
+        owner: &crate::Bound<'_, crate::PyAny>,
+    ) {
+    }
 
-    fn __delete__(&self, instance: &crate::PyAny) {}
+    fn __delete__(&self, instance: &crate::Bound<'_, crate::PyAny>) {}
 
-    fn __set_name__(&self, owner: &crate::PyAny, name: &crate::PyAny) {}
+    fn __set_name__(
+        &self,
+        owner: &crate::Bound<'_, crate::PyAny>,
+        name: &crate::Bound<'_, crate::PyAny>,
+    ) {
+    }
 
     //////////////////////
     // Implementing Descriptors
@@ -285,7 +294,7 @@ impl Dummy {
         &self,
         py: crate::Python<'py>,
     ) -> crate::Bound<'py, crate::types::PyComplex> {
-        crate::types::PyComplex::from_doubles_bound(py, 0.0, 0.0)
+        crate::types::PyComplex::from_doubles(py, 0.0, 0.0)
     }
 
     fn __int__(&self) -> u32 {
@@ -300,6 +309,7 @@ impl Dummy {
         0
     }
 
+    #[pyo3(signature=(ndigits=::std::option::Option::None))]
     fn __round__(&self, ndigits: ::std::option::Option<u32>) -> u32 {
         0
     }
@@ -324,9 +334,9 @@ impl Dummy {
 
     fn __exit__(
         &mut self,
-        exc_type: &crate::PyAny,
-        exc_value: &crate::PyAny,
-        traceback: &crate::PyAny,
+        exc_type: &crate::Bound<'_, crate::PyAny>,
+        exc_value: &crate::Bound<'_, crate::PyAny>,
+        traceback: &crate::Bound<'_, crate::PyAny>,
     ) {
     }
 
@@ -362,9 +372,9 @@ impl Dummy {
 
     fn __aexit__(
         &mut self,
-        exc_type: &crate::PyAny,
-        exc_value: &crate::PyAny,
-        traceback: &crate::PyAny,
+        exc_type: &crate::Bound<'_, crate::PyAny>,
+        exc_value: &crate::Bound<'_, crate::PyAny>,
+        traceback: &crate::Bound<'_, crate::PyAny>,
     ) {
     }
 
@@ -379,10 +389,10 @@ impl Dummy {
     #[pyo3(signature = (*_args, **_kwds))]
     fn __call__(
         &self,
-        _args: &crate::types::PyTuple,
-        _kwds: ::std::option::Option<&crate::types::PyDict>,
+        _args: &crate::Bound<'_, crate::types::PyTuple>,
+        _kwds: ::std::option::Option<&crate::Bound<'_, crate::types::PyDict>>,
     ) -> crate::PyResult<i32> {
-        ::std::panic!("unimplemented isn't hygienic before 1.50")
+        ::std::unimplemented!()
     }
     #[new]
     fn new(a: u8) -> Self {
@@ -405,405 +415,146 @@ impl Dummy {
     // Buffer protocol?
 }
 
-#[cfg(not(Py_3_8))]
-#[crate::pymethods]
-#[pyo3(crate = "crate")]
-impl Dummy {
-    //////////////////////
-    // Basic customization
-    //////////////////////
-    fn __repr__(&self) -> &'static str {
-        "Dummy"
-    }
-
-    fn __str__(&self) -> &'static str {
-        "Dummy"
-    }
-
-    fn __bytes__<'py>(&self, py: crate::Python<'py>) -> crate::Bound<'py, crate::types::PyBytes> {
-        crate::types::PyBytes::new_bound(py, &[0])
-    }
-
-    fn __format__(&self, format_spec: ::std::string::String) -> ::std::string::String {
-        ::std::panic!("unimplemented isn't hygienic before 1.50")
-    }
-
-    fn __lt__(&self, other: &Self) -> bool {
-        false
-    }
-
-    fn __le__(&self, other: &Self) -> bool {
-        false
-    }
-    fn __eq__(&self, other: &Self) -> bool {
-        false
-    }
-    fn __ne__(&self, other: &Self) -> bool {
-        false
-    }
-    fn __gt__(&self, other: &Self) -> bool {
-        false
-    }
-    fn __ge__(&self, other: &Self) -> bool {
-        false
-    }
-
-    fn __hash__(&self) -> u64 {
-        42
-    }
-
-    fn __bool__(&self) -> bool {
-        true
-    }
-
-    //////////////////////
-    // Customizing attribute access
-    //////////////////////
-
-    fn __getattr__(&self, name: ::std::string::String) -> &crate::PyAny {
-        ::std::panic!("unimplemented isn't hygienic before 1.50")
-    }
-
-    fn __getattribute__(&self, name: ::std::string::String) -> &crate::PyAny {
-        ::std::panic!("unimplemented isn't hygienic before 1.50")
-    }
-
-    fn __setattr__(&mut self, name: ::std::string::String, value: ::std::string::String) {}
-
-    fn __delattr__(&mut self, name: ::std::string::String) {}
-
-    fn __dir__<'py>(&self, py: crate::Python<'py>) -> crate::Bound<'py, crate::types::PyList> {
-        crate::types::PyList::new_bound(py, ::std::vec![0_u8])
-    }
-
-    //////////////////////
-    // Implementing Descriptors
-    //////////////////////
+#[crate::pyclass(crate = "crate")]
+struct Clear;
 
-    fn __get__(
+#[crate::pymethods(crate = "crate")]
+impl Clear {
+    pub fn __traverse__(
         &self,
-        instance: &crate::PyAny,
-        owner: &crate::PyAny,
-    ) -> crate::PyResult<&crate::PyAny> {
-        ::std::panic!("unimplemented isn't hygienic before 1.50")
+        visit: crate::PyVisit<'_>,
+    ) -> ::std::result::Result<(), crate::PyTraverseError> {
+        ::std::result::Result::Ok(())
     }
 
-    fn __set__(&self, instance: &crate::PyAny, owner: &crate::PyAny) {}
-
-    fn __delete__(&self, instance: &crate::PyAny) {}
-
-    fn __set_name__(&self, owner: &crate::PyAny, name: &crate::PyAny) {}
-
-    //////////////////////
-    // Implementing Descriptors
-    //////////////////////
-
-    fn __len__(&self) -> usize {
-        0
-    }
-
-    fn __getitem__(&self, key: u32) -> crate::PyResult<u32> {
-        ::std::result::Result::Err(crate::exceptions::PyKeyError::new_err("boo"))
-    }
-
-    fn __setitem__(&self, key: u32, value: u32) {}
+    pub fn __clear__(&self) {}
 
-    fn __delitem__(&self, key: u32) {}
-
-    fn __iter__(_: crate::pycell::PyRef<'_, Self>, py: crate::Python<'_>) -> crate::Py<DummyIter> {
-        crate::Py::new(py, DummyIter {}).unwrap()
-    }
-
-    fn __next__(&mut self) -> ::std::option::Option<()> {
-        ::std::option::Option::None
-    }
-
-    fn __reversed__(
-        slf: crate::pycell::PyRef<'_, Self>,
-        py: crate::Python<'_>,
-    ) -> crate::Py<DummyIter> {
-        crate::Py::new(py, DummyIter {}).unwrap()
-    }
-
-    fn __contains__(&self, item: u32) -> bool {
-        false
-    }
-
-    //////////////////////
-    // Emulating numeric types
-    //////////////////////
-
-    fn __add__(&self, other: &Self) -> Dummy {
-        Dummy {}
-    }
-
-    fn __sub__(&self, other: &Self) -> Dummy {
-        Dummy {}
-    }
-
-    fn __mul__(&self, other: &Self) -> Dummy {
-        Dummy {}
-    }
-
-    fn __truediv__(&self, _other: &Self) -> crate::PyResult<()> {
-        ::std::result::Result::Err(crate::exceptions::PyZeroDivisionError::new_err("boo"))
-    }
-
-    fn __floordiv__(&self, _other: &Self) -> crate::PyResult<()> {
-        ::std::result::Result::Err(crate::exceptions::PyZeroDivisionError::new_err("boo"))
-    }
-
-    fn __mod__(&self, _other: &Self) -> u32 {
-        0
-    }
-
-    fn __divmod__(&self, _other: &Self) -> (u32, u32) {
-        (0, 0)
-    }
-
-    fn __pow__(&self, _other: &Self, modulo: ::std::option::Option<i32>) -> Dummy {
-        Dummy {}
-    }
-
-    fn __lshift__(&self, other: &Self) -> Dummy {
-        Dummy {}
-    }
-
-    fn __rshift__(&self, other: &Self) -> Dummy {
-        Dummy {}
-    }
-
-    fn __and__(&self, other: &Self) -> Dummy {
-        Dummy {}
-    }
-
-    fn __xor__(&self, other: &Self) -> Dummy {
-        Dummy {}
-    }
-
-    fn __or__(&self, other: &Self) -> Dummy {
-        Dummy {}
-    }
-
-    fn __radd__(&self, other: &Self) -> Dummy {
-        Dummy {}
-    }
-
-    fn __rrsub__(&self, other: &Self) -> Dummy {
-        Dummy {}
-    }
-
-    fn __rmul__(&self, other: &Self) -> Dummy {
-        Dummy {}
-    }
-
-    fn __rtruediv__(&self, _other: &Self) -> crate::PyResult<()> {
-        ::std::result::Result::Err(crate::exceptions::PyZeroDivisionError::new_err("boo"))
-    }
-
-    fn __rfloordiv__(&self, _other: &Self) -> crate::PyResult<()> {
-        ::std::result::Result::Err(crate::exceptions::PyZeroDivisionError::new_err("boo"))
-    }
-
-    fn __rmod__(&self, _other: &Self) -> u32 {
-        0
-    }
-
-    fn __rdivmod__(&self, _other: &Self) -> (u32, u32) {
-        (0, 0)
-    }
-
-    fn __rpow__(&self, _other: &Self, modulo: ::std::option::Option<i32>) -> Dummy {
-        Dummy {}
-    }
-
-    fn __rlshift__(&self, other: &Self) -> Dummy {
-        Dummy {}
-    }
+    #[pyo3(signature=(*, reuse=false))]
+    pub fn clear(&self, reuse: bool) {}
+}
 
-    fn __rrshift__(&self, other: &Self) -> Dummy {
-        Dummy {}
-    }
+// Ensure that crate argument is also accepted inline
 
-    fn __rand__(&self, other: &Self) -> Dummy {
-        Dummy {}
-    }
+#[crate::pyclass(crate = "crate")]
+struct Dummy2;
 
-    fn __rxor__(&self, other: &Self) -> Dummy {
-        Dummy {}
+#[crate::pymethods(crate = "crate")]
+impl Dummy2 {
+    #[classmethod]
+    fn __len__(cls: &crate::Bound<'_, crate::types::PyType>) -> crate::PyResult<usize> {
+        ::std::result::Result::Ok(0)
     }
 
-    fn __ror__(&self, other: &Self) -> Dummy {
-        Dummy {}
+    #[staticmethod]
+    fn __repr__() -> &'static str {
+        "Dummy"
     }
+}
 
-    fn __iadd__(&mut self, other: &Self) {}
-
-    fn __irsub__(&mut self, other: &Self) {}
-
-    fn __imul__(&mut self, other: &Self) {}
-
-    fn __itruediv__(&mut self, _other: &Self) {}
-
-    fn __ifloordiv__(&mut self, _other: &Self) {}
-
-    fn __imod__(&mut self, _other: &Self) {}
-
-    fn __ipow__(&mut self, _other: &Self, _modulo: ::std::option::Option<u32>) {}
-    fn __ilshift__(&mut self, other: &Self) {}
-
-    fn __irshift__(&mut self, other: &Self) {}
-
-    fn __iand__(&mut self, other: &Self) {}
-
-    fn __ixor__(&mut self, other: &Self) {}
-
-    fn __ior__(&mut self, other: &Self) {}
-
-    fn __neg__(slf: crate::pycell::PyRef<'_, Self>) -> crate::pycell::PyRef<'_, Self> {
-        slf
-    }
+#[crate::pyclass(crate = "crate")]
+struct WarningDummy {
+    value: i32,
+}
 
-    fn __pos__(slf: crate::pycell::PyRef<'_, Self>) -> crate::pycell::PyRef<'_, Self> {
-        slf
-    }
+#[cfg(not(Py_LIMITED_API))]
+#[crate::pyclass(crate = "crate", extends=crate::exceptions::PyWarning)]
+pub struct UserDefinedWarning {}
 
-    fn __abs__(slf: crate::pycell::PyRef<'_, Self>) -> crate::pycell::PyRef<'_, Self> {
-        slf
+#[cfg(not(Py_LIMITED_API))]
+#[crate::pymethods(crate = "crate")]
+impl UserDefinedWarning {
+    #[new]
+    #[pyo3(signature = (*_args, **_kwargs))]
+    fn new(
+        _args: crate::Bound<'_, crate::PyAny>,
+        _kwargs: ::std::option::Option<crate::Bound<'_, crate::PyAny>>,
+    ) -> Self {
+        Self {}
     }
+}
 
-    fn __invert__(slf: crate::pycell::PyRef<'_, Self>) -> crate::pycell::PyRef<'_, Self> {
-        slf
+#[crate::pymethods(crate = "crate")]
+impl WarningDummy {
+    #[new]
+    #[pyo3(warn(message = "this __new__ method raises warning"))]
+    fn new() -> Self {
+        Self { value: 0 }
     }
 
-    fn __complex__<'py>(
-        &self,
-        py: crate::Python<'py>,
-    ) -> crate::Bound<'py, crate::types::PyComplex> {
-        crate::types::PyComplex::from_doubles_bound(py, 0.0, 0.0)
-    }
+    #[pyo3(warn(message = "this method raises warning"))]
+    fn method_with_warning(_slf: crate::PyRef<'_, Self>) {}
 
-    fn __int__(&self) -> u32 {
-        0
-    }
+    #[pyo3(warn(message = "this method raises warning", category = crate::exceptions::PyFutureWarning))]
+    fn method_with_warning_and_custom_category(_slf: crate::PyRef<'_, Self>) {}
 
-    fn __float__(&self) -> f64 {
-        0.0
-    }
+    #[cfg(not(Py_LIMITED_API))]
+    #[pyo3(warn(message = "this method raises user-defined warning", category = UserDefinedWarning))]
+    fn method_with_warning_and_user_defined_category(&self) {}
 
-    fn __index__(&self) -> u32 {
-        0
-    }
+    #[staticmethod]
+    #[pyo3(warn(message = "this static method raises warning"))]
+    fn static_method() {}
 
-    fn __round__(&self, ndigits: ::std::option::Option<u32>) -> u32 {
-        0
-    }
+    #[staticmethod]
+    #[pyo3(warn(message = "this class method raises warning"))]
+    fn class_method() {}
 
-    fn __trunc__(&self) -> u32 {
-        0
+    #[getter]
+    #[pyo3(warn(message = "this getter raises warning"))]
+    fn get_value(&self) -> i32 {
+        self.value
     }
 
-    fn __floor__(&self) -> u32 {
-        0
+    #[setter]
+    #[pyo3(warn(message = "this setter raises warning"))]
+    fn set_value(&mut self, value: i32) {
+        self.value = value;
     }
 
-    fn __ceil__(&self) -> u32 {
+    #[pyo3(warn(message = "this subscript op method raises warning"))]
+    fn __getitem__(&self, _key: i32) -> i32 {
         0
     }
 
-    //////////////////////
-    // With Statement Context Managers
-    //////////////////////
-
-    fn __enter__(&mut self) {}
-
-    fn __exit__(
-        &mut self,
-        exc_type: &crate::PyAny,
-        exc_value: &crate::PyAny,
-        traceback: &crate::PyAny,
-    ) {
-    }
-
-    //////////////////////
-    // Awaitable Objects
-    //////////////////////
-
-    fn __await__(slf: crate::pycell::PyRef<'_, Self>) -> crate::pycell::PyRef<'_, Self> {
-        slf
+    #[pyo3(warn(message = "the + op method raises warning"))]
+    fn __add__(&self, other: crate::PyRef<'_, Self>) -> Self {
+        Self {
+            value: self.value + other.value,
+        }
     }
 
-    //////////////////////
-
-    // Asynchronous Iterators
-    //////////////////////
-
-    fn __aiter__(
-        slf: crate::pycell::PyRef<'_, Self>,
-        py: crate::Python<'_>,
-    ) -> crate::Py<DummyIter> {
-        crate::Py::new(py, DummyIter {}).unwrap()
+    #[pyo3(warn(message = "this __call__ method raises warning"))]
+    fn __call__(&self) -> i32 {
+        self.value
     }
 
-    fn __anext__(&mut self) -> ::std::option::Option<()> {
-        ::std::option::Option::None
-    }
-
-    //////////////////////
-    // Asynchronous Context Managers
-    //////////////////////
-
-    fn __aenter__(&mut self) {}
-
-    fn __aexit__(
-        &mut self,
-        exc_type: &crate::PyAny,
-        exc_value: &crate::PyAny,
-        traceback: &crate::PyAny,
-    ) {
-    }
+    #[pyo3(warn(message = "this method raises warning 1"))]
+    #[pyo3(warn(message = "this method raises warning 2", category = crate::exceptions::PyFutureWarning))]
+    fn multiple_warn_method(&self) {}
+}
 
-    // Things with attributes
+#[crate::pyclass(crate = "crate")]
+struct WarningDummy2;
 
-    #[pyo3(signature = (_y, *, _z=2))]
-    fn test(&self, _y: &Dummy, _z: i32) {}
-    #[staticmethod]
-    fn staticmethod() {}
-    #[classmethod]
-    fn clsmethod(_: &crate::Bound<'_, crate::types::PyType>) {}
-    #[pyo3(signature = (*_args, **_kwds))]
-    fn __call__(
-        &self,
-        _args: &crate::types::PyTuple,
-        _kwds: ::std::option::Option<&crate::types::PyDict>,
-    ) -> crate::PyResult<i32> {
-        ::std::panic!("unimplemented isn't hygienic before 1.50")
-    }
+#[crate::pymethods(crate = "crate")]
+impl WarningDummy2 {
     #[new]
-    fn new(a: u8) -> Self {
-        Dummy {}
-    }
-    #[getter]
-    fn get(&self) -> i32 {
-        0
-    }
-    #[setter]
-    fn set(&mut self, _v: i32) {}
-    #[classattr]
-    fn class_attr() -> i32 {
-        0
+    #[classmethod]
+    #[pyo3(warn(message = "this class-method __new__ method raises warning"))]
+    fn new(_cls: crate::Bound<'_, crate::types::PyType>) -> Self {
+        Self {}
     }
 
-    // Dunder methods invented for protocols
-
-    // PyGcProtocol
-    // Buffer protocol?
-}
+    #[pyo3(warn(message = "this class-method raises warning 1"))]
+    #[pyo3(warn(message = "this class-method raises warning 2"))]
+    fn multiple_default_warnings_fn(&self) {}
 
-// Ensure that crate argument is also accepted inline
+    #[pyo3(warn(message = "this class-method raises warning"))]
+    #[pyo3(warn(message = "this class-method raises future warning", category = crate::exceptions::PyFutureWarning))]
+    fn multiple_warnings_fn(&self) {}
 
-#[crate::pyclass(crate = "crate")]
-struct Dummy2;
-
-#[crate::pymethods(crate = "crate")]
-impl Dummy2 {}
+    #[cfg(not(Py_LIMITED_API))]
+    #[pyo3(warn(message = "this class-method raises future warning", category = crate::exceptions::PyFutureWarning))]
+    #[pyo3(warn(message = "this class-method raises user-defined warning", category = UserDefinedWarning))]
+    fn multiple_warnings_fn_with_custom_category(&self) {}
+}
diff --git a/src/tests/hygiene/pymodule.rs b/src/tests/hygiene/pymodule.rs
index 0b37c440325..56c6f10fa20 100644
--- a/src/tests/hygiene/pymodule.rs
+++ b/src/tests/hygiene/pymodule.rs
@@ -1,6 +1,3 @@
-#![no_implicit_prelude]
-#![allow(unused_variables, clippy::unnecessary_wraps)]
-
 #[crate::pyfunction]
 #[pyo3(crate = "crate")]
 fn do_something(x: i32) -> crate::PyResult<i32> {
@@ -9,15 +6,34 @@ fn do_something(x: i32) -> crate::PyResult<i32> {
 
 #[crate::pymodule]
 #[pyo3(crate = "crate")]
-fn foo(_py: crate::Python<'_>, _m: &crate::types::PyModule) -> crate::PyResult<()> {
+fn foo(
+    _py: crate::Python<'_>,
+    _m: &crate::Bound<'_, crate::types::PyModule>,
+) -> crate::PyResult<()> {
     ::std::result::Result::Ok(())
 }
 
 #[crate::pymodule]
 #[pyo3(crate = "crate")]
-fn my_module(_py: crate::Python<'_>, m: &crate::types::PyModule) -> crate::PyResult<()> {
-    m.add_function(crate::wrap_pyfunction!(do_something, m)?)?;
-    m.add_wrapped(crate::wrap_pymodule!(foo))?;
+fn my_module(m: &crate::Bound<'_, crate::types::PyModule>) -> crate::PyResult<()> {
+    <crate::Bound<'_, crate::types::PyModule> as crate::types::PyModuleMethods>::add_function(
+        m,
+        crate::wrap_pyfunction!(do_something, m)?,
+    )?;
+    <crate::Bound<'_, crate::types::PyModule> as crate::types::PyModuleMethods>::add_wrapped(
+        m,
+        crate::wrap_pymodule!(foo),
+    )?;
 
     ::std::result::Result::Ok(())
 }
+
+#[crate::pymodule(submodule)]
+#[pyo3(crate = "crate")]
+mod my_module_declarative {
+    #[pymodule_export]
+    use super::{do_something, foo};
+
+    #[pymodule_export]
+    const BAR: u32 = 42;
+}
diff --git a/src/tests/mod.rs b/src/tests/mod.rs
index 7e78b6f19bd..3b72764301c 100644
--- a/src/tests/mod.rs
+++ b/src/tests/mod.rs
@@ -1,9 +1,3 @@
-#[macro_use]
-pub(crate) mod common {
-    use crate as pyo3;
-    include!("./common.rs");
-}
-
 /// Test macro hygiene - this is in the crate since we won't have
 /// `pyo3` available in the crate root.
 #[cfg(all(test, feature = "macros"))]
diff --git a/src/type_object.rs b/src/type_object.rs
index 994781b3fc0..e15a9c6b8c0 100644
--- a/src/type_object.rs
+++ b/src/type_object.rs
@@ -1,12 +1,14 @@
 //! Python type object information
 
 use crate::ffi_ptr_ext::FfiPtrExt;
-use crate::types::any::PyAnyMethods;
+#[cfg(feature = "experimental-inspect")]
+use crate::inspect::TypeHint;
 use crate::types::{PyAny, PyType};
-use crate::{ffi, Bound, PyNativeType, Python};
+use crate::{ffi, Bound, Python};
+use std::ptr;
 
 /// `T: PyLayout<U>` represents that `T` is a concrete representation of `U` in the Python heap.
-/// E.g., `PyCell` is a concrete representation of all `pyclass`es, and `ffi::PyObject`
+/// E.g., `PyClassObject` is a concrete representation of all `pyclass`es, and `ffi::PyObject`
 /// is of `PyAny`.
 ///
 /// This trait is intended to be used internally.
@@ -17,30 +19,11 @@ use crate::{ffi, Bound, PyNativeType, Python};
 pub unsafe trait PyLayout<T> {}
 
 /// `T: PySizedLayout<U>` represents that `T` is not a instance of
-/// [`PyVarObject`](https://docs.python.org/3.8/c-api/structures.html?highlight=pyvarobject#c.PyVarObject).
+/// [`PyVarObject`](https://docs.python.org/3/c-api/structures.html#c.PyVarObject).
+///
 /// In addition, that `T` is a concrete representation of `U`.
 pub trait PySizedLayout<T>: PyLayout<T> + Sized {}
 
-/// Specifies that this type has a "GIL-bound Reference" form.
-///
-/// This is expected to be deprecated in the near future, see <https://github.com/PyO3/pyo3/issues/3382>
-///
-/// # Safety
-///
-/// - `Py<Self>::as_ref` will hand out references to `Self::AsRefTarget`.
-/// - `Self::AsRefTarget` must have the same layout as `UnsafeCell<ffi::PyAny>`.
-pub unsafe trait HasPyGilRef {
-    /// Utility type to make Py::as_ref work.
-    type AsRefTarget: PyNativeType;
-}
-
-unsafe impl<T> HasPyGilRef for T
-where
-    T: PyNativeType,
-{
-    type AsRefTarget = Self;
-}
-
 /// Python type information.
 /// All Python native types (e.g., `PyDict`) and `#[pyclass]` structs implement this trait.
 ///
@@ -54,34 +37,27 @@ where
 ///
 /// Implementations must provide an implementation for `type_object_raw` which infallibly produces a
 /// non-null pointer to the corresponding Python type object.
-pub unsafe trait PyTypeInfo: Sized + HasPyGilRef {
+///
+/// `is_type_of` must only return true for objects which can safely be treated as instances of `Self`.
+///
+/// `is_exact_type_of` must only return true for objects whose type is exactly `Self`.
+pub unsafe trait PyTypeInfo: Sized {
     /// Class name.
     const NAME: &'static str;
 
     /// Module name, if any.
     const MODULE: Option<&'static str>;
 
+    /// Provides the full python type as a type hint.
+    #[cfg(feature = "experimental-inspect")]
+    const TYPE_HINT: TypeHint = TypeHint::module_attr("typing", "Any");
+
     /// Returns the PyTypeObject instance for this type.
     fn type_object_raw(py: Python<'_>) -> *mut ffi::PyTypeObject;
 
     /// Returns the safe abstraction over the type object.
     #[inline]
-    #[cfg_attr(
-        not(feature = "gil-refs"),
-        deprecated(
-            since = "0.21.0",
-            note = "`PyTypeInfo::type_object` will be replaced by `PyTypeInfo::type_object_bound` in a future PyO3 version"
-        )
-    )]
-    fn type_object(py: Python<'_>) -> &PyType {
-        // This isn't implemented in terms of `type_object_bound` because this just borrowed the
-        // object, for legacy reasons.
-        unsafe { py.from_borrowed_ptr(Self::type_object_raw(py) as _) }
-    }
-
-    /// Returns the safe abstraction over the type object.
-    #[inline]
-    fn type_object_bound(py: Python<'_>) -> Bound<'_, PyType> {
+    fn type_object(py: Python<'_>) -> Bound<'_, PyType> {
         // Making the borrowed object `Bound` is necessary for soundness reasons. It's an extreme
         // edge case, but arbitrary Python code _could_ change the __class__ of an object and cause
         // the type object to be freed.
@@ -92,97 +68,74 @@ pub unsafe trait PyTypeInfo: Sized + HasPyGilRef {
                 .cast::<ffi::PyObject>()
                 .assume_borrowed_unchecked(py)
                 .to_owned()
-                .downcast_into_unchecked()
+                .cast_into_unchecked()
         }
     }
 
     /// Checks if `object` is an instance of this type or a subclass of this type.
     #[inline]
-    #[cfg_attr(
-        not(feature = "gil-refs"),
-        deprecated(
-            since = "0.21.0",
-            note = "`PyTypeInfo::is_type_of` will be replaced by `PyTypeInfo::is_type_of_bound` in a future PyO3 version"
-        )
-    )]
-    fn is_type_of(object: &PyAny) -> bool {
-        Self::is_type_of_bound(&object.as_borrowed())
-    }
-
-    /// Checks if `object` is an instance of this type or a subclass of this type.
-    #[inline]
-    fn is_type_of_bound(object: &Bound<'_, PyAny>) -> bool {
+    fn is_type_of(object: &Bound<'_, PyAny>) -> bool {
         unsafe { ffi::PyObject_TypeCheck(object.as_ptr(), Self::type_object_raw(object.py())) != 0 }
     }
 
     /// Checks if `object` is an instance of this type.
     #[inline]
-    #[cfg_attr(
-        not(feature = "gil-refs"),
-        deprecated(
-            since = "0.21.0",
-            note = "`PyTypeInfo::is_exact_type_of` will be replaced by `PyTypeInfo::is_exact_type_of_bound` in a future PyO3 version"
-        )
-    )]
-    fn is_exact_type_of(object: &PyAny) -> bool {
-        Self::is_exact_type_of_bound(&object.as_borrowed())
-    }
-
-    /// Checks if `object` is an instance of this type.
-    #[inline]
-    fn is_exact_type_of_bound(object: &Bound<'_, PyAny>) -> bool {
-        unsafe { ffi::Py_TYPE(object.as_ptr()) == Self::type_object_raw(object.py()) }
+    fn is_exact_type_of(object: &Bound<'_, PyAny>) -> bool {
+        unsafe {
+            ptr::eq(
+                ffi::Py_TYPE(object.as_ptr()),
+                Self::type_object_raw(object.py()),
+            )
+        }
     }
 }
 
 /// Implemented by types which can be used as a concrete Python type inside `Py<T>` smart pointers.
-pub trait PyTypeCheck: HasPyGilRef {
+///
+/// # Safety
+///
+/// This trait is used to determine whether [`Bound::cast`] and similar functions can safely cast
+/// to a concrete type. The implementor is responsible for ensuring that `type_check` only returns
+/// true for objects which can safely be treated as Python instances of `Self`.
+pub unsafe trait PyTypeCheck {
     /// Name of self. This is used in error messages, for example.
+    #[deprecated(
+        since = "0.27.0",
+        note = "Use ::classinfo_object() instead and format the type name at runtime. Note that using built-in cast features is often better than manual PyTypeCheck usage."
+    )]
     const NAME: &'static str;
 
+    /// Provides the full python type of the allowed values as a Python type hint.
+    #[cfg(feature = "experimental-inspect")]
+    const TYPE_HINT: TypeHint;
+
     /// Checks if `object` is an instance of `Self`, which may include a subtype.
     ///
     /// This should be equivalent to the Python expression `isinstance(object, Self)`.
     fn type_check(object: &Bound<'_, PyAny>) -> bool;
+
+    /// Returns the expected type as a possible argument for the `isinstance` and `issubclass` function.
+    ///
+    /// It may be a single type or a tuple of types.
+    fn classinfo_object(py: Python<'_>) -> Bound<'_, PyAny>;
 }
 
-impl<T> PyTypeCheck for T
+unsafe impl<T> PyTypeCheck for T
 where
     T: PyTypeInfo,
 {
-    const NAME: &'static str = <T as PyTypeInfo>::NAME;
+    const NAME: &'static str = T::NAME;
+
+    #[cfg(feature = "experimental-inspect")]
+    const TYPE_HINT: TypeHint = <T as PyTypeInfo>::TYPE_HINT;
 
     #[inline]
     fn type_check(object: &Bound<'_, PyAny>) -> bool {
-        T::is_type_of_bound(object)
-    }
-}
-
-#[inline]
-pub(crate) unsafe fn get_tp_alloc(tp: *mut ffi::PyTypeObject) -> Option<ffi::allocfunc> {
-    #[cfg(not(Py_LIMITED_API))]
-    {
-        (*tp).tp_alloc
+        T::is_type_of(object)
     }
 
-    #[cfg(Py_LIMITED_API)]
-    {
-        let ptr = ffi::PyType_GetSlot(tp, ffi::Py_tp_alloc);
-        std::mem::transmute(ptr)
-    }
-}
-
-#[inline]
-pub(crate) unsafe fn get_tp_free(tp: *mut ffi::PyTypeObject) -> ffi::freefunc {
-    #[cfg(not(Py_LIMITED_API))]
-    {
-        (*tp).tp_free.unwrap()
-    }
-
-    #[cfg(Py_LIMITED_API)]
-    {
-        let ptr = ffi::PyType_GetSlot(tp, ffi::Py_tp_free);
-        debug_assert_ne!(ptr, std::ptr::null_mut());
-        std::mem::transmute(ptr)
+    #[inline]
+    fn classinfo_object(py: Python<'_>) -> Bound<'_, PyAny> {
+        T::type_object(py).into_any()
     }
 }
diff --git a/src/types/any.rs b/src/types/any.rs
index 33b3d96405a..90034686a85 100644
--- a/src/types/any.rs
+++ b/src/types/any.rs
@@ -1,937 +1,59 @@
+use crate::call::PyCallArgs;
 use crate::class::basic::CompareOp;
-use crate::conversion::{AsPyPointer, FromPyObject, IntoPy, ToPyObject};
-use crate::err::{DowncastError, DowncastIntoError, PyDowncastError, PyErr, PyResult};
+use crate::conversion::{FromPyObject, IntoPyObject};
+use crate::err::{PyErr, PyResult};
 use crate::exceptions::{PyAttributeError, PyTypeError};
 use crate::ffi_ptr_ext::FfiPtrExt;
 use crate::instance::Bound;
+use crate::internal::get_slot::TP_DESCR_GET;
 use crate::py_result_ext::PyResultExt;
-use crate::type_object::{HasPyGilRef, PyTypeCheck, PyTypeInfo};
-#[cfg(not(PyPy))]
+use crate::type_object::{PyTypeCheck, PyTypeInfo};
+#[cfg(not(any(PyPy, GraalPy)))]
 use crate::types::PySuper;
-use crate::types::{PyDict, PyIterator, PyList, PyString, PyTuple, PyType};
-use crate::{err, ffi, Py, PyNativeType, Python};
+use crate::types::{PyDict, PyIterator, PyList, PyString, PyType};
+use crate::{err, ffi, Borrowed, BoundObject, IntoPyObjectExt, Py, Python};
+#[allow(deprecated)]
+use crate::{DowncastError, DowncastIntoError};
 use std::cell::UnsafeCell;
 use std::cmp::Ordering;
-use std::os::raw::c_int;
+use std::ffi::c_int;
+use std::ptr;
 
 /// Represents any Python object.
 ///
-/// It currently only appears as a *reference*, `&PyAny`,
-/// with a lifetime that represents the scope during which the GIL is held.
+/// Values of this type are accessed via PyO3's smart pointers, e.g. as
+/// [`Py<PyAny>`][crate::Py] or [`Bound<'py, PyAny>`][Bound].
 ///
-/// `PyAny` has some interesting properties, which it shares
-/// with the other [native Python types](crate::types):
+/// For APIs available on all Python objects, see the [`PyAnyMethods`] trait which is implemented for
+/// [`Bound<'py, PyAny>`][Bound].
 ///
-/// - It can only be obtained and used while the GIL is held,
-/// therefore its API does not require a [`Python<'py>`](crate::Python) token.
-/// - It can't be used in situations where the GIL is temporarily released,
-/// such as [`Python::allow_threads`](crate::Python::allow_threads)'s closure.
-/// - The underlying Python object, if mutable, can be mutated through any reference.
-/// - It can be converted to the GIL-independent [`Py`]`<`[`PyAny`]`>`,
-/// allowing it to outlive the GIL scope. However, using [`Py`]`<`[`PyAny`]`>`'s API
-/// *does* require a [`Python<'py>`](crate::Python) token.
-///
-/// It can be cast to a concrete type with PyAny::downcast (for native Python types only)
-/// and FromPyObject::extract. See their documentation for more information.
-///
-/// See [the guide](https://pyo3.rs/latest/types.html) for an explanation
-/// of the different Python object types.
-#[repr(transparent)]
-pub struct PyAny(UnsafeCell<ffi::PyObject>);
-
-unsafe impl AsPyPointer for PyAny {
-    #[inline]
-    fn as_ptr(&self) -> *mut ffi::PyObject {
-        self.0.get()
-    }
-}
-
-#[allow(non_snake_case)]
-// Copied here as the macro does not accept deprecated functions.
-// Originally ffi::object::PyObject_Check, but this is not in the Python C API.
-fn PyObject_Check(_: *mut ffi::PyObject) -> c_int {
-    1
-}
-
-pyobject_native_type_base!(PyAny);
-
-pyobject_native_type_info!(
-    PyAny,
-    pyobject_native_static_type_object!(ffi::PyBaseObject_Type),
-    Some("builtins"),
-    #checkfunction=PyObject_Check
-);
-
-pyobject_native_type_extract!(PyAny);
-
-pyobject_native_type_sized!(PyAny, ffi::PyObject);
-
-impl PyAny {
-    /// Returns whether `self` and `other` point to the same object. To compare
-    /// the equality of two objects (the `==` operator), use [`eq`](PyAny::eq).
-    ///
-    /// This is equivalent to the Python expression `self is other`.
-    #[inline]
-    pub fn is<T: AsPyPointer>(&self, other: &T) -> bool {
-        self.as_borrowed().is(other)
-    }
-
-    /// Determines whether this object has the given attribute.
-    ///
-    /// This is equivalent to the Python expression `hasattr(self, attr_name)`.
-    ///
-    /// To avoid repeated temporary allocations of Python strings, the [`intern!`] macro can be used
-    /// to intern `attr_name`.
-    ///
-    /// # Example: `intern!`ing the attribute name
-    ///
-    /// ```
-    /// # use pyo3::{prelude::*, intern};
-    /// #
-    /// #[pyfunction]
-    /// fn has_version(sys: &Bound<'_, PyModule>) -> PyResult<bool> {
-    ///     sys.hasattr(intern!(sys.py(), "version"))
-    /// }
-    /// #
-    /// # Python::with_gil(|py| {
-    /// #    let sys = py.import_bound("sys").unwrap();
-    /// #    has_version(&sys).unwrap();
-    /// # });
-    /// ```
-    pub fn hasattr<N>(&self, attr_name: N) -> PyResult<bool>
-    where
-        N: IntoPy<Py<PyString>>,
-    {
-        self.as_borrowed().hasattr(attr_name)
-    }
-
-    /// Retrieves an attribute value.
-    ///
-    /// This is equivalent to the Python expression `self.attr_name`.
-    ///
-    /// To avoid repeated temporary allocations of Python strings, the [`intern!`] macro can be used
-    /// to intern `attr_name`.
-    ///
-    /// # Example: `intern!`ing the attribute name
-    ///
-    /// ```
-    /// # use pyo3::{prelude::*, intern};
-    /// #
-    /// #[pyfunction]
-    /// fn version<'py>(sys: &Bound<'py, PyModule>) -> PyResult<Bound<'py, PyAny>> {
-    ///     sys.getattr(intern!(sys.py(), "version"))
-    /// }
-    /// #
-    /// # Python::with_gil(|py| {
-    /// #    let sys = py.import_bound("sys").unwrap();
-    /// #    version(&sys).unwrap();
-    /// # });
-    /// ```
-    pub fn getattr<N>(&self, attr_name: N) -> PyResult<&PyAny>
-    where
-        N: IntoPy<Py<PyString>>,
-    {
-        self.as_borrowed()
-            .getattr(attr_name)
-            .map(Bound::into_gil_ref)
-    }
-
-    /// Sets an attribute value.
-    ///
-    /// This is equivalent to the Python expression `self.attr_name = value`.
-    ///
-    /// To avoid repeated temporary allocations of Python strings, the [`intern!`] macro can be used
-    /// to intern `name`.
-    ///
-    /// # Example: `intern!`ing the attribute name
-    ///
-    /// ```
-    /// # use pyo3::{intern, pyfunction, types::PyModule, PyAny, Python, PyResult};
-    /// #
-    /// #[pyfunction]
-    /// fn set_answer(ob: &PyAny) -> PyResult<()> {
-    ///     ob.setattr(intern!(ob.py(), "answer"), 42)
-    /// }
-    /// #
-    /// # Python::with_gil(|py| {
-    /// #    let ob = PyModule::new(py, "empty").unwrap();
-    /// #    set_answer(ob).unwrap();
-    /// # });
-    /// ```
-    pub fn setattr<N, V>(&self, attr_name: N, value: V) -> PyResult<()>
-    where
-        N: IntoPy<Py<PyString>>,
-        V: ToPyObject,
-    {
-        self.as_borrowed().setattr(attr_name, value)
-    }
-
-    /// Deletes an attribute.
-    ///
-    /// This is equivalent to the Python statement `del self.attr_name`.
-    ///
-    /// To avoid repeated temporary allocations of Python strings, the [`intern!`] macro can be used
-    /// to intern `attr_name`.
-    pub fn delattr<N>(&self, attr_name: N) -> PyResult<()>
-    where
-        N: IntoPy<Py<PyString>>,
-    {
-        self.as_borrowed().delattr(attr_name)
-    }
-
-    /// Returns an [`Ordering`] between `self` and `other`.
-    ///
-    /// This is equivalent to the following Python code:
-    /// ```python
-    /// if self == other:
-    ///     return Equal
-    /// elif a < b:
-    ///     return Less
-    /// elif a > b:
-    ///     return Greater
-    /// else:
-    ///     raise TypeError("PyAny::compare(): All comparisons returned false")
-    /// ```
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// use pyo3::prelude::*;
-    /// use pyo3::types::PyFloat;
-    /// use std::cmp::Ordering;
-    ///
-    /// # fn main() -> PyResult<()> {
-    /// Python::with_gil(|py| -> PyResult<()> {
-    ///     let a = PyFloat::new_bound(py, 0_f64);
-    ///     let b = PyFloat::new_bound(py, 42_f64);
-    ///     assert_eq!(a.compare(b)?, Ordering::Less);
-    ///     Ok(())
-    /// })?;
-    /// # Ok(())}
-    /// ```
-    ///
-    /// It will return `PyErr` for values that cannot be compared:
-    ///
-    /// ```rust
-    /// use pyo3::prelude::*;
-    /// use pyo3::types::{PyFloat, PyString};
-    ///
-    /// # fn main() -> PyResult<()> {
-    /// Python::with_gil(|py| -> PyResult<()> {
-    ///     let a = PyFloat::new_bound(py, 0_f64);
-    ///     let b = PyString::new_bound(py, "zero");
-    ///     assert!(a.compare(b).is_err());
-    ///     Ok(())
-    /// })?;
-    /// # Ok(())}
-    /// ```
-    pub fn compare<O>(&self, other: O) -> PyResult<Ordering>
-    where
-        O: ToPyObject,
-    {
-        self.as_borrowed().compare(other)
-    }
-
-    /// Tests whether two Python objects obey a given [`CompareOp`].
-    ///
-    /// [`lt`](Self::lt), [`le`](Self::le), [`eq`](Self::eq), [`ne`](Self::ne),
-    /// [`gt`](Self::gt) and [`ge`](Self::ge) are the specialized versions
-    /// of this function.
-    ///
-    /// Depending on the value of `compare_op`, this is equivalent to one of the
-    /// following Python expressions:
-    ///
-    /// | `compare_op` | Python expression |
-    /// | :---: | :----: |
-    /// | [`CompareOp::Eq`] | `self == other` |
-    /// | [`CompareOp::Ne`] | `self != other` |
-    /// | [`CompareOp::Lt`] | `self < other` |
-    /// | [`CompareOp::Le`] | `self <= other` |
-    /// | [`CompareOp::Gt`] | `self > other` |
-    /// | [`CompareOp::Ge`] | `self >= other` |
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// use pyo3::class::basic::CompareOp;
-    /// use pyo3::prelude::*;
-    /// use pyo3::types::PyInt;
-    ///
-    /// # fn main() -> PyResult<()> {
-    /// Python::with_gil(|py| -> PyResult<()> {
-    ///     let a: &PyInt = 0_u8.into_py(py).into_ref(py).downcast()?;
-    ///     let b: &PyInt = 42_u8.into_py(py).into_ref(py).downcast()?;
-    ///     assert!(a.rich_compare(b, CompareOp::Le)?.is_truthy()?);
-    ///     Ok(())
-    /// })?;
-    /// # Ok(())}
-    /// ```
-    pub fn rich_compare<O>(&self, other: O, compare_op: CompareOp) -> PyResult<&PyAny>
-    where
-        O: ToPyObject,
-    {
-        self.as_borrowed()
-            .rich_compare(other, compare_op)
-            .map(Bound::into_gil_ref)
-    }
-
-    /// Tests whether this object is less than another.
-    ///
-    /// This is equivalent to the Python expression `self < other`.
-    pub fn lt<O>(&self, other: O) -> PyResult<bool>
-    where
-        O: ToPyObject,
-    {
-        self.as_borrowed().lt(other)
-    }
-
-    /// Tests whether this object is less than or equal to another.
-    ///
-    /// This is equivalent to the Python expression `self <= other`.
-    pub fn le<O>(&self, other: O) -> PyResult<bool>
-    where
-        O: ToPyObject,
-    {
-        self.as_borrowed().le(other)
-    }
-
-    /// Tests whether this object is equal to another.
-    ///
-    /// This is equivalent to the Python expression `self == other`.
-    pub fn eq<O>(&self, other: O) -> PyResult<bool>
-    where
-        O: ToPyObject,
-    {
-        self.as_borrowed().eq(other)
-    }
-
-    /// Tests whether this object is not equal to another.
-    ///
-    /// This is equivalent to the Python expression `self != other`.
-    pub fn ne<O>(&self, other: O) -> PyResult<bool>
-    where
-        O: ToPyObject,
-    {
-        self.as_borrowed().ne(other)
-    }
-
-    /// Tests whether this object is greater than another.
-    ///
-    /// This is equivalent to the Python expression `self > other`.
-    pub fn gt<O>(&self, other: O) -> PyResult<bool>
-    where
-        O: ToPyObject,
-    {
-        self.as_borrowed().gt(other)
-    }
-
-    /// Tests whether this object is greater than or equal to another.
-    ///
-    /// This is equivalent to the Python expression `self >= other`.
-    pub fn ge<O>(&self, other: O) -> PyResult<bool>
-    where
-        O: ToPyObject,
-    {
-        self.as_borrowed().ge(other)
-    }
-
-    /// Determines whether this object appears callable.
-    ///
-    /// This is equivalent to Python's [`callable()`][1] function.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// use pyo3::prelude::*;
-    ///
-    /// # fn main() -> PyResult<()> {
-    /// Python::with_gil(|py| -> PyResult<()> {
-    ///     let builtins = PyModule::import(py, "builtins")?;
-    ///     let print = builtins.getattr("print")?;
-    ///     assert!(print.is_callable());
-    ///     Ok(())
-    /// })?;
-    /// # Ok(())}
-    /// ```
-    ///
-    /// This is equivalent to the Python statement `assert callable(print)`.
-    ///
-    /// Note that unless an API needs to distinguish between callable and
-    /// non-callable objects, there is no point in checking for callability.
-    /// Instead, it is better to just do the call and handle potential
-    /// exceptions.
-    ///
-    /// [1]: https://docs.python.org/3/library/functions.html#callable
-    pub fn is_callable(&self) -> bool {
-        self.as_borrowed().is_callable()
-    }
-
-    /// Calls the object.
-    ///
-    /// This is equivalent to the Python expression `self(*args, **kwargs)`.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// use pyo3::prelude::*;
-    /// use pyo3::types::PyDict;
-    ///
-    /// const CODE: &str = r#"
-    /// def function(*args, **kwargs):
-    ///     assert args == ("hello",)
-    ///     assert kwargs == {"cruel": "world"}
-    ///     return "called with args and kwargs"
-    /// "#;
-    ///
-    /// # fn main() -> PyResult<()> {
-    /// Python::with_gil(|py| {
-    ///     let module = PyModule::from_code(py, CODE, "", "")?;
-    ///     let fun = module.getattr("function")?;
-    ///     let args = ("hello",);
-    ///     let kwargs = PyDict::new_bound(py);
-    ///     kwargs.set_item("cruel", "world")?;
-    ///     let result = fun.call(args, Some(kwargs.as_gil_ref()))?;
-    ///     assert_eq!(result.extract::<&str>()?, "called with args and kwargs");
-    ///     Ok(())
-    /// })
-    /// # }
-    /// ```
-    pub fn call(
-        &self,
-        args: impl IntoPy<Py<PyTuple>>,
-        kwargs: Option<&PyDict>,
-    ) -> PyResult<&PyAny> {
-        self.as_borrowed()
-            .call(args, kwargs.map(PyDict::as_borrowed).as_deref())
-            .map(Bound::into_gil_ref)
-    }
-
-    /// Calls the object without arguments.
-    ///
-    /// This is equivalent to the Python expression `self()`.
-    ///
-    /// # Examples
-    ///
-    /// ```no_run
-    /// use pyo3::prelude::*;
-    ///
-    /// # fn main() -> PyResult<()> {
-    /// Python::with_gil(|py| -> PyResult<()> {
-    ///     let module = PyModule::import(py, "builtins")?;
-    ///     let help = module.getattr("help")?;
-    ///     help.call0()?;
-    ///     Ok(())
-    /// })?;
-    /// # Ok(())}
-    /// ```
-    ///
-    /// This is equivalent to the Python expression `help()`.
-    pub fn call0(&self) -> PyResult<&PyAny> {
-        self.as_borrowed().call0().map(Bound::into_gil_ref)
-    }
-
-    /// Calls the object with only positional arguments.
-    ///
-    /// This is equivalent to the Python expression `self(*args)`.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// use pyo3::prelude::*;
-    ///
-    /// const CODE: &str = r#"
-    /// def function(*args, **kwargs):
-    ///     assert args == ("hello",)
-    ///     assert kwargs == {}
-    ///     return "called with args"
-    /// "#;
-    ///
-    /// # fn main() -> PyResult<()> {
-    /// Python::with_gil(|py| {
-    ///     let module = PyModule::from_code(py, CODE, "", "")?;
-    ///     let fun = module.getattr("function")?;
-    ///     let args = ("hello",);
-    ///     let result = fun.call1(args)?;
-    ///     assert_eq!(result.extract::<&str>()?, "called with args");
-    ///     Ok(())
-    /// })
-    /// # }
-    /// ```
-    pub fn call1(&self, args: impl IntoPy<Py<PyTuple>>) -> PyResult<&PyAny> {
-        self.as_borrowed().call1(args).map(Bound::into_gil_ref)
-    }
-
-    /// Calls a method on the object.
-    ///
-    /// This is equivalent to the Python expression `self.name(*args, **kwargs)`.
-    ///
-    /// To avoid repeated temporary allocations of Python strings, the [`intern!`] macro can be used
-    /// to intern `name`.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// use pyo3::prelude::*;
-    /// use pyo3::types::PyDict;
-    ///
-    /// const CODE: &str = r#"
-    /// class A:
-    ///     def method(self, *args, **kwargs):
-    ///         assert args == ("hello",)
-    ///         assert kwargs == {"cruel": "world"}
-    ///         return "called with args and kwargs"
-    /// a = A()
-    /// "#;
-    ///
-    /// # fn main() -> PyResult<()> {
-    /// Python::with_gil(|py| {
-    ///     let module = PyModule::from_code(py, CODE, "", "")?;
-    ///     let instance = module.getattr("a")?;
-    ///     let args = ("hello",);
-    ///     let kwargs = PyDict::new_bound(py);
-    ///     kwargs.set_item("cruel", "world")?;
-    ///     let result = instance.call_method("method", args, Some(kwargs.as_gil_ref()))?;
-    ///     assert_eq!(result.extract::<&str>()?, "called with args and kwargs");
-    ///     Ok(())
-    /// })
-    /// # }
-    /// ```
-    pub fn call_method<N, A>(&self, name: N, args: A, kwargs: Option<&PyDict>) -> PyResult<&PyAny>
-    where
-        N: IntoPy<Py<PyString>>,
-        A: IntoPy<Py<PyTuple>>,
-    {
-        self.as_borrowed()
-            .call_method(name, args, kwargs.map(PyDict::as_borrowed).as_deref())
-            .map(Bound::into_gil_ref)
-    }
-
-    /// Calls a method on the object without arguments.
-    ///
-    /// This is equivalent to the Python expression `self.name()`.
-    ///
-    /// To avoid repeated temporary allocations of Python strings, the [`intern!`] macro can be used
-    /// to intern `name`.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// use pyo3::prelude::*;
-    ///
-    /// const CODE: &str = r#"
-    /// class A:
-    ///     def method(self, *args, **kwargs):
-    ///         assert args == ()
-    ///         assert kwargs == {}
-    ///         return "called with no arguments"
-    /// a = A()
-    /// "#;
-    ///
-    /// # fn main() -> PyResult<()> {
-    /// Python::with_gil(|py| {
-    ///     let module = PyModule::from_code(py, CODE, "", "")?;
-    ///     let instance = module.getattr("a")?;
-    ///     let result = instance.call_method0("method")?;
-    ///     assert_eq!(result.extract::<&str>()?, "called with no arguments");
-    ///     Ok(())
-    /// })
-    /// # }
-    /// ```
-    pub fn call_method0<N>(&self, name: N) -> PyResult<&PyAny>
-    where
-        N: IntoPy<Py<PyString>>,
-    {
-        self.as_borrowed()
-            .call_method0(name)
-            .map(Bound::into_gil_ref)
-    }
-
-    /// Calls a method on the object with only positional arguments.
-    ///
-    /// This is equivalent to the Python expression `self.name(*args)`.
-    ///
-    /// To avoid repeated temporary allocations of Python strings, the [`intern!`] macro can be used
-    /// to intern `name`.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// use pyo3::prelude::*;
-    ///
-    /// const CODE: &str = r#"
-    /// class A:
-    ///     def method(self, *args, **kwargs):
-    ///         assert args == ("hello",)
-    ///         assert kwargs == {}
-    ///         return "called with args"
-    /// a = A()
-    /// "#;
-    ///
-    /// # fn main() -> PyResult<()> {
-    /// Python::with_gil(|py| {
-    ///     let module = PyModule::from_code(py, CODE, "", "")?;
-    ///     let instance = module.getattr("a")?;
-    ///     let args = ("hello",);
-    ///     let result = instance.call_method1("method", args)?;
-    ///     assert_eq!(result.extract::<&str>()?, "called with args");
-    ///     Ok(())
-    /// })
-    /// # }
-    /// ```
-    pub fn call_method1<N, A>(&self, name: N, args: A) -> PyResult<&PyAny>
-    where
-        N: IntoPy<Py<PyString>>,
-        A: IntoPy<Py<PyTuple>>,
-    {
-        self.as_borrowed()
-            .call_method1(name, args)
-            .map(Bound::into_gil_ref)
-    }
-
-    /// Returns whether the object is considered to be true.
-    ///
-    /// This is equivalent to the Python expression `bool(self)`.
-    #[deprecated(since = "0.21.0", note = "use `.is_truthy()` instead")]
-    pub fn is_true(&self) -> PyResult<bool> {
-        self.is_truthy()
-    }
-
-    /// Returns whether the object is considered to be true.
-    ///
-    /// This applies truth value testing equivalent to the Python expression `bool(self)`.
-    pub fn is_truthy(&self) -> PyResult<bool> {
-        self.as_borrowed().is_truthy()
-    }
-
-    /// Returns whether the object is considered to be None.
-    ///
-    /// This is equivalent to the Python expression `self is None`.
-    #[inline]
-    pub fn is_none(&self) -> bool {
-        self.as_borrowed().is_none()
-    }
-
-    /// Returns whether the object is Ellipsis, e.g. `...`.
-    ///
-    /// This is equivalent to the Python expression `self is ...`.
-    #[deprecated(since = "0.20.0", note = "use `.is(py.Ellipsis())` instead")]
-    pub fn is_ellipsis(&self) -> bool {
-        self.as_borrowed().is_ellipsis()
-    }
-
-    /// Returns true if the sequence or mapping has a length of 0.
-    ///
-    /// This is equivalent to the Python expression `len(self) == 0`.
-    pub fn is_empty(&self) -> PyResult<bool> {
-        self.as_borrowed().is_empty()
-    }
-
-    /// Gets an item from the collection.
-    ///
-    /// This is equivalent to the Python expression `self[key]`.
-    pub fn get_item<K>(&self, key: K) -> PyResult<&PyAny>
-    where
-        K: ToPyObject,
-    {
-        self.as_borrowed().get_item(key).map(Bound::into_gil_ref)
-    }
-
-    /// Sets a collection item value.
-    ///
-    /// This is equivalent to the Python expression `self[key] = value`.
-    pub fn set_item<K, V>(&self, key: K, value: V) -> PyResult<()>
-    where
-        K: ToPyObject,
-        V: ToPyObject,
-    {
-        self.as_borrowed().set_item(key, value)
-    }
-
-    /// Deletes an item from the collection.
-    ///
-    /// This is equivalent to the Python expression `del self[key]`.
-    pub fn del_item<K>(&self, key: K) -> PyResult<()>
-    where
-        K: ToPyObject,
-    {
-        self.as_borrowed().del_item(key)
-    }
-
-    /// Takes an object and returns an iterator for it.
-    ///
-    /// This is typically a new iterator but if the argument is an iterator,
-    /// this returns itself.
-    pub fn iter(&self) -> PyResult<&PyIterator> {
-        self.as_borrowed().iter().map(Bound::into_gil_ref)
-    }
-
-    /// Returns the Python type object for this object's type.
-    pub fn get_type(&self) -> &PyType {
-        self.as_borrowed().get_type()
-    }
-
-    /// Returns the Python type pointer for this object.
-    #[inline]
-    pub fn get_type_ptr(&self) -> *mut ffi::PyTypeObject {
-        self.as_borrowed().get_type_ptr()
-    }
-
-    /// Downcast this `PyAny` to a concrete Python type or pyclass.
-    ///
-    /// Note that you can often avoid downcasting yourself by just specifying
-    /// the desired type in function or method signatures.
-    /// However, manual downcasting is sometimes necessary.
-    ///
-    /// For extracting a Rust-only type, see [`PyAny::extract`](struct.PyAny.html#method.extract).
-    ///
-    /// # Example: Downcasting to a specific Python object
-    ///
-    /// ```rust
-    /// use pyo3::prelude::*;
-    /// use pyo3::types::{PyDict, PyList};
-    ///
-    /// Python::with_gil(|py| {
-    ///     let dict = PyDict::new_bound(py);
-    ///     assert!(dict.is_instance_of::<PyAny>());
-    ///     let any = dict.as_any();
-    ///
-    ///     assert!(any.downcast::<PyDict>().is_ok());
-    ///     assert!(any.downcast::<PyList>().is_err());
-    /// });
-    /// ```
-    ///
-    /// # Example: Getting a reference to a pyclass
-    ///
-    /// This is useful if you want to mutate a `PyObject` that
-    /// might actually be a pyclass.
-    ///
-    /// ```rust
-    /// # fn main() -> Result<(), pyo3::PyErr> {
-    /// use pyo3::prelude::*;
-    ///
-    /// #[pyclass]
-    /// struct Class {
-    ///     i: i32,
-    /// }
-    ///
-    /// Python::with_gil(|py| {
-    ///     let class: &PyAny = Py::new(py, Class { i: 0 }).unwrap().into_ref(py);
-    ///
-    ///     let class_cell: &PyCell<Class> = class.downcast()?;
-    ///
-    ///     class_cell.borrow_mut().i += 1;
-    ///
-    ///     // Alternatively you can get a `PyRefMut` directly
-    ///     let class_ref: PyRefMut<'_, Class> = class.extract()?;
-    ///     assert_eq!(class_ref.i, 1);
-    ///     Ok(())
-    /// })
-    /// # }
-    /// ```
-    #[inline]
-    pub fn downcast<T>(&self) -> Result<&T, PyDowncastError<'_>>
-    where
-        T: PyTypeCheck<AsRefTarget = T>,
-    {
-        if T::type_check(&self.as_borrowed()) {
-            // Safety: type_check is responsible for ensuring that the type is correct
-            Ok(unsafe { self.downcast_unchecked() })
-        } else {
-            Err(PyDowncastError::new(self, T::NAME))
-        }
-    }
-
-    /// Downcast this `PyAny` to a concrete Python type or pyclass (but not a subclass of it).
-    ///
-    /// It is almost always better to use [`PyAny::downcast`] because it accounts for Python
-    /// subtyping. Use this method only when you do not want to allow subtypes.
-    ///
-    /// The advantage of this method over [`PyAny::downcast`] is that it is faster. The implementation
-    /// of `downcast_exact` uses the equivalent of the Python expression `type(self) is T`, whereas
-    /// `downcast` uses `isinstance(self, T)`.
-    ///
-    /// For extracting a Rust-only type, see [`PyAny::extract`](struct.PyAny.html#method.extract).
-    ///
-    /// # Example: Downcasting to a specific Python object but not a subtype
-    ///
-    /// ```rust
-    /// use pyo3::prelude::*;
-    /// use pyo3::types::{PyBool, PyLong};
-    ///
-    /// Python::with_gil(|py| {
-    ///     let b = PyBool::new_bound(py, true);
-    ///     assert!(b.is_instance_of::<PyBool>());
-    ///     let any: &Bound<'_, PyAny> = b.as_any();
-    ///
-    ///     // `bool` is a subtype of `int`, so `downcast` will accept a `bool` as an `int`
-    ///     // but `downcast_exact` will not.
-    ///     assert!(any.downcast::<PyLong>().is_ok());
-    ///     assert!(any.downcast_exact::<PyLong>().is_err());
-    ///
-    ///     assert!(any.downcast_exact::<PyBool>().is_ok());
-    /// });
-    /// ```
-    #[inline]
-    pub fn downcast_exact<T>(&self) -> Result<&T, PyDowncastError<'_>>
-    where
-        T: PyTypeInfo<AsRefTarget = T>,
-    {
-        if T::is_exact_type_of_bound(&self.as_borrowed()) {
-            // Safety: type_check is responsible for ensuring that the type is correct
-            Ok(unsafe { self.downcast_unchecked() })
-        } else {
-            Err(PyDowncastError::new(self, T::NAME))
-        }
-    }
-
-    /// Converts this `PyAny` to a concrete Python type without checking validity.
-    ///
-    /// # Safety
-    ///
-    /// Callers must ensure that the type is valid or risk type confusion.
-    #[inline]
-    pub unsafe fn downcast_unchecked<T>(&self) -> &T
-    where
-        T: HasPyGilRef<AsRefTarget = T>,
-    {
-        &*(self.as_ptr() as *const T)
-    }
-
-    /// Extracts some type from the Python object.
-    ///
-    /// This is a wrapper function around [`FromPyObject::extract()`].
-    #[inline]
-    pub fn extract<'py, D>(&'py self) -> PyResult<D>
-    where
-        D: FromPyObject<'py>,
-    {
-        FromPyObject::extract(self)
-    }
-
-    /// Returns the reference count for the Python object.
-    pub fn get_refcnt(&self) -> isize {
-        self.as_borrowed().get_refcnt()
-    }
-
-    /// Computes the "repr" representation of self.
-    ///
-    /// This is equivalent to the Python expression `repr(self)`.
-    pub fn repr(&self) -> PyResult<&PyString> {
-        self.as_borrowed().repr().map(Bound::into_gil_ref)
-    }
-
-    /// Computes the "str" representation of self.
-    ///
-    /// This is equivalent to the Python expression `str(self)`.
-    pub fn str(&self) -> PyResult<&PyString> {
-        self.as_borrowed().str().map(Bound::into_gil_ref)
-    }
-
-    /// Retrieves the hash code of self.
-    ///
-    /// This is equivalent to the Python expression `hash(self)`.
-    pub fn hash(&self) -> PyResult<isize> {
-        self.as_borrowed().hash()
-    }
-
-    /// Returns the length of the sequence or mapping.
-    ///
-    /// This is equivalent to the Python expression `len(self)`.
-    pub fn len(&self) -> PyResult<usize> {
-        self.as_borrowed().len()
-    }
-
-    /// Returns the list of attributes of this object.
-    ///
-    /// This is equivalent to the Python expression `dir(self)`.
-    pub fn dir(&self) -> &PyList {
-        self.as_borrowed().dir().into_gil_ref()
-    }
-
-    /// Checks whether this object is an instance of type `ty`.
-    ///
-    /// This is equivalent to the Python expression `isinstance(self, ty)`.
-    #[inline]
-    pub fn is_instance(&self, ty: &PyAny) -> PyResult<bool> {
-        self.as_borrowed().is_instance(&ty.as_borrowed())
-    }
-
-    /// Checks whether this object is an instance of exactly type `ty` (not a subclass).
-    ///
-    /// This is equivalent to the Python expression `type(self) is ty`.
-    #[inline]
-    pub fn is_exact_instance(&self, ty: &PyAny) -> bool {
-        self.as_borrowed().is_exact_instance(&ty.as_borrowed())
-    }
-
-    /// Checks whether this object is an instance of type `T`.
-    ///
-    /// This is equivalent to the Python expression `isinstance(self, T)`,
-    /// if the type `T` is known at compile time.
-    #[inline]
-    pub fn is_instance_of<T: PyTypeInfo>(&self) -> bool {
-        self.as_borrowed().is_instance_of::<T>()
-    }
-
-    /// Checks whether this object is an instance of exactly type `T`.
-    ///
-    /// This is equivalent to the Python expression `type(self) is T`,
-    /// if the type `T` is known at compile time.
-    #[inline]
-    pub fn is_exact_instance_of<T: PyTypeInfo>(&self) -> bool {
-        self.as_borrowed().is_exact_instance_of::<T>()
-    }
-
-    /// Determines if self contains `value`.
-    ///
-    /// This is equivalent to the Python expression `value in self`.
-    pub fn contains<V>(&self, value: V) -> PyResult<bool>
-    where
-        V: ToPyObject,
-    {
-        self.as_borrowed().contains(value)
-    }
-
-    /// Returns a GIL marker constrained to the lifetime of this type.
-    #[inline]
-    pub fn py(&self) -> Python<'_> {
-        PyNativeType::py(self)
-    }
+/// See
+#[doc = concat!("[the guide](https://pyo3.rs/v", env!("CARGO_PKG_VERSION"), "/types.html#concrete-python-types)")]
+/// for an explanation of the different Python object types.
+#[repr(transparent)]
+pub struct PyAny(UnsafeCell<ffi::PyObject>);
 
-    /// Returns the raw FFI pointer represented by self.
-    ///
-    /// # Safety
-    ///
-    /// Callers are responsible for ensuring that the pointer does not outlive self.
-    ///
-    /// The reference is borrowed; callers should not decrease the reference count
-    /// when they are finished with the pointer.
-    #[inline]
-    pub fn as_ptr(&self) -> *mut ffi::PyObject {
-        self as *const PyAny as *mut ffi::PyObject
-    }
+#[allow(non_snake_case)]
+// Copied here as the macro does not accept deprecated functions.
+// Originally ffi::object::PyObject_Check, but this is not in the Python C API.
+fn PyObject_Check(_: *mut ffi::PyObject) -> c_int {
+    1
+}
 
-    /// Returns an owned raw FFI pointer represented by self.
-    ///
-    /// # Safety
-    ///
-    /// The reference is owned; when finished the caller should either transfer ownership
-    /// of the pointer or decrease the reference count (e.g. with [`pyo3::ffi::Py_DecRef`](crate::ffi::Py_DecRef)).
-    #[inline]
-    pub fn into_ptr(&self) -> *mut ffi::PyObject {
-        // Safety: self.as_ptr() returns a valid non-null pointer
-        let ptr = self.as_ptr();
-        unsafe { ffi::Py_INCREF(ptr) };
-        ptr
-    }
+pyobject_native_type_info!(
+    PyAny,
+    pyobject_native_static_type_object!(ffi::PyBaseObject_Type),
+    Some("builtins"),
+    #checkfunction=PyObject_Check
+);
 
-    /// Return a proxy object that delegates method calls to a parent or sibling class of type.
-    ///
-    /// This is equivalent to the Python expression `super()`
-    #[cfg(not(PyPy))]
-    pub fn py_super(&self) -> PyResult<&PySuper> {
-        self.as_borrowed().py_super().map(Bound::into_gil_ref)
-    }
+pyobject_native_type_sized!(PyAny, ffi::PyObject);
+// We cannot use `pyobject_subclassable_native_type!()` because it cfgs out on `Py_LIMITED_API`.
+impl crate::impl_::pyclass::PyClassBaseType for PyAny {
+    type LayoutAsBase = crate::impl_::pycell::PyClassObjectBase<ffi::PyObject>;
+    type BaseNativeType = PyAny;
+    type Initializer = crate::impl_::pyclass_init::PyNativeTypeInitializer<Self>;
+    type PyClassMutability = crate::pycell::impl_::ImmutableClass;
 }
 
 /// This trait represents the Python APIs which are usable on all Python objects.
@@ -939,12 +61,12 @@ impl PyAny {
 /// It is recommended you import this trait via `use pyo3::prelude::*` rather than
 /// by importing this trait directly.
 #[doc(alias = "PyAny")]
-pub trait PyAnyMethods<'py> {
+pub trait PyAnyMethods<'py>: crate::sealed::Sealed {
     /// Returns whether `self` and `other` point to the same object. To compare
-    /// the equality of two objects (the `==` operator), use [`eq`](PyAny::eq).
+    /// the equality of two objects (the `==` operator), use [`eq`](PyAnyMethods::eq).
     ///
     /// This is equivalent to the Python expression `self is other`.
-    fn is<T: AsPyPointer>(&self, other: &T) -> bool;
+    fn is<T: AsRef<Py<PyAny>>>(&self, other: T) -> bool;
 
     /// Determines whether this object has the given attribute.
     ///
@@ -963,14 +85,14 @@ pub trait PyAnyMethods<'py> {
     ///     sys.hasattr(intern!(sys.py(), "version"))
     /// }
     /// #
-    /// # Python::with_gil(|py| {
-    /// #    let sys = py.import_bound("sys").unwrap();
+    /// # Python::attach(|py| {
+    /// #    let sys = py.import("sys").unwrap();
     /// #    has_version(&sys).unwrap();
     /// # });
     /// ```
     fn hasattr<N>(&self, attr_name: N) -> PyResult<bool>
     where
-        N: IntoPy<Py<PyString>>;
+        N: IntoPyObject<'py, Target = PyString>;
 
     /// Retrieves an attribute value.
     ///
@@ -989,14 +111,46 @@ pub trait PyAnyMethods<'py> {
     ///     sys.getattr(intern!(sys.py(), "version"))
     /// }
     /// #
-    /// # Python::with_gil(|py| {
-    /// #    let sys = py.import_bound("sys").unwrap();
+    /// # Python::attach(|py| {
+    /// #    let sys = py.import("sys").unwrap();
     /// #    version(&sys).unwrap();
     /// # });
     /// ```
     fn getattr<N>(&self, attr_name: N) -> PyResult<Bound<'py, PyAny>>
     where
-        N: IntoPy<Py<PyString>>;
+        N: IntoPyObject<'py, Target = PyString>;
+
+    /// Retrieves an attribute value optionally.
+    ///
+    /// This is equivalent to the Python expression `getattr(self, attr_name, None)`, which may
+    /// be more efficient in some cases by simply returning `None` if the attribute is not found
+    /// instead of raising `AttributeError`.
+    ///
+    /// To avoid repeated temporary allocations of Python strings, the [`intern!`] macro can be used
+    /// to intern `attr_name`.
+    ///
+    /// # Errors
+    /// Returns `Err` if an exception other than `AttributeError` is raised during attribute lookup,
+    /// such as a `ValueError` from a property or descriptor.
+    ///
+    /// # Example: Retrieving an optional attribute
+    /// ```
+    /// # use pyo3::{prelude::*, intern};
+    /// #
+    /// #[pyfunction]
+    /// fn get_version_if_exists<'py>(sys: &Bound<'py, PyModule>) -> PyResult<Option<Bound<'py, PyAny>>> {
+    ///     sys.getattr_opt(intern!(sys.py(), "version"))
+    /// }
+    /// #
+    /// # Python::attach(|py| {
+    /// #    let sys = py.import("sys").unwrap();
+    /// #    let version = get_version_if_exists(&sys).unwrap();
+    /// #    assert!(version.is_some());
+    /// # });
+    /// ```
+    fn getattr_opt<N>(&self, attr_name: N) -> PyResult<Option<Bound<'py, PyAny>>>
+    where
+        N: IntoPyObject<'py, Target = PyString>;
 
     /// Sets an attribute value.
     ///
@@ -1008,22 +162,22 @@ pub trait PyAnyMethods<'py> {
     /// # Example: `intern!`ing the attribute name
     ///
     /// ```
-    /// # use pyo3::{intern, pyfunction, types::PyModule, PyAny, Python, PyResult};
+    /// # use pyo3::{prelude::*, intern};
     /// #
     /// #[pyfunction]
-    /// fn set_answer(ob: &PyAny) -> PyResult<()> {
+    /// fn set_answer(ob: &Bound<'_, PyAny>) -> PyResult<()> {
     ///     ob.setattr(intern!(ob.py(), "answer"), 42)
     /// }
     /// #
-    /// # Python::with_gil(|py| {
+    /// # Python::attach(|py| {
     /// #    let ob = PyModule::new(py, "empty").unwrap();
-    /// #    set_answer(ob).unwrap();
+    /// #    set_answer(&ob).unwrap();
     /// # });
     /// ```
     fn setattr<N, V>(&self, attr_name: N, value: V) -> PyResult<()>
     where
-        N: IntoPy<Py<PyString>>,
-        V: ToPyObject;
+        N: IntoPyObject<'py, Target = PyString>,
+        V: IntoPyObject<'py>;
 
     /// Deletes an attribute.
     ///
@@ -1033,7 +187,7 @@ pub trait PyAnyMethods<'py> {
     /// to intern `attr_name`.
     fn delattr<N>(&self, attr_name: N) -> PyResult<()>
     where
-        N: IntoPy<Py<PyString>>;
+        N: IntoPyObject<'py, Target = PyString>;
 
     /// Returns an [`Ordering`] between `self` and `other`.
     ///
@@ -1057,9 +211,9 @@ pub trait PyAnyMethods<'py> {
     /// use std::cmp::Ordering;
     ///
     /// # fn main() -> PyResult<()> {
-    /// Python::with_gil(|py| -> PyResult<()> {
-    ///     let a = PyFloat::new_bound(py, 0_f64);
-    ///     let b = PyFloat::new_bound(py, 42_f64);
+    /// Python::attach(|py| -> PyResult<()> {
+    ///     let a = PyFloat::new(py, 0_f64);
+    ///     let b = PyFloat::new(py, 42_f64);
     ///     assert_eq!(a.compare(b)?, Ordering::Less);
     ///     Ok(())
     /// })?;
@@ -1073,9 +227,9 @@ pub trait PyAnyMethods<'py> {
     /// use pyo3::types::{PyFloat, PyString};
     ///
     /// # fn main() -> PyResult<()> {
-    /// Python::with_gil(|py| -> PyResult<()> {
-    ///     let a = PyFloat::new_bound(py, 0_f64);
-    ///     let b = PyString::new_bound(py, "zero");
+    /// Python::attach(|py| -> PyResult<()> {
+    ///     let a = PyFloat::new(py, 0_f64);
+    ///     let b = PyString::new(py, "zero");
     ///     assert!(a.compare(b).is_err());
     ///     Ok(())
     /// })?;
@@ -1083,7 +237,7 @@ pub trait PyAnyMethods<'py> {
     /// ```
     fn compare<O>(&self, other: O) -> PyResult<Ordering>
     where
-        O: ToPyObject;
+        O: IntoPyObject<'py>;
 
     /// Tests whether two Python objects obey a given [`CompareOp`].
     ///
@@ -1108,12 +262,11 @@ pub trait PyAnyMethods<'py> {
     /// ```rust
     /// use pyo3::class::basic::CompareOp;
     /// use pyo3::prelude::*;
-    /// use pyo3::types::PyInt;
     ///
     /// # fn main() -> PyResult<()> {
-    /// Python::with_gil(|py| -> PyResult<()> {
-    ///     let a: &PyInt = 0_u8.into_py(py).into_ref(py).downcast()?;
-    ///     let b: &PyInt = 42_u8.into_py(py).into_ref(py).downcast()?;
+    /// Python::attach(|py| -> PyResult<()> {
+    ///     let a = 0_u8.into_pyobject(py)?;
+    ///     let b = 42_u8.into_pyobject(py)?;
     ///     assert!(a.rich_compare(b, CompareOp::Le)?.is_truthy()?);
     ///     Ok(())
     /// })?;
@@ -1121,101 +274,139 @@ pub trait PyAnyMethods<'py> {
     /// ```
     fn rich_compare<O>(&self, other: O, compare_op: CompareOp) -> PyResult<Bound<'py, PyAny>>
     where
-        O: ToPyObject;
+        O: IntoPyObject<'py>;
+
+    /// Computes the negative of self.
+    ///
+    /// Equivalent to the Python expression `-self`.
+    fn neg(&self) -> PyResult<Bound<'py, PyAny>>;
+
+    /// Computes the positive of self.
+    ///
+    /// Equivalent to the Python expression `+self`.
+    fn pos(&self) -> PyResult<Bound<'py, PyAny>>;
+
+    /// Computes the absolute of self.
+    ///
+    /// Equivalent to the Python expression `abs(self)`.
+    fn abs(&self) -> PyResult<Bound<'py, PyAny>>;
+
+    /// Computes `~self`.
+    fn bitnot(&self) -> PyResult<Bound<'py, PyAny>>;
 
     /// Tests whether this object is less than another.
     ///
     /// This is equivalent to the Python expression `self < other`.
     fn lt<O>(&self, other: O) -> PyResult<bool>
     where
-        O: ToPyObject;
+        O: IntoPyObject<'py>;
 
     /// Tests whether this object is less than or equal to another.
     ///
     /// This is equivalent to the Python expression `self <= other`.
     fn le<O>(&self, other: O) -> PyResult<bool>
     where
-        O: ToPyObject;
+        O: IntoPyObject<'py>;
 
     /// Tests whether this object is equal to another.
     ///
     /// This is equivalent to the Python expression `self == other`.
     fn eq<O>(&self, other: O) -> PyResult<bool>
     where
-        O: ToPyObject;
+        O: IntoPyObject<'py>;
 
     /// Tests whether this object is not equal to another.
     ///
     /// This is equivalent to the Python expression `self != other`.
     fn ne<O>(&self, other: O) -> PyResult<bool>
     where
-        O: ToPyObject;
+        O: IntoPyObject<'py>;
 
     /// Tests whether this object is greater than another.
     ///
     /// This is equivalent to the Python expression `self > other`.
     fn gt<O>(&self, other: O) -> PyResult<bool>
     where
-        O: ToPyObject;
+        O: IntoPyObject<'py>;
 
     /// Tests whether this object is greater than or equal to another.
     ///
     /// This is equivalent to the Python expression `self >= other`.
     fn ge<O>(&self, other: O) -> PyResult<bool>
     where
-        O: ToPyObject;
+        O: IntoPyObject<'py>;
 
     /// Computes `self + other`.
     fn add<O>(&self, other: O) -> PyResult<Bound<'py, PyAny>>
     where
-        O: ToPyObject;
+        O: IntoPyObject<'py>;
 
     /// Computes `self - other`.
     fn sub<O>(&self, other: O) -> PyResult<Bound<'py, PyAny>>
     where
-        O: ToPyObject;
+        O: IntoPyObject<'py>;
 
     /// Computes `self * other`.
     fn mul<O>(&self, other: O) -> PyResult<Bound<'py, PyAny>>
     where
-        O: ToPyObject;
+        O: IntoPyObject<'py>;
+
+    /// Computes `self @ other`.
+    fn matmul<O>(&self, other: O) -> PyResult<Bound<'py, PyAny>>
+    where
+        O: IntoPyObject<'py>;
 
     /// Computes `self / other`.
     fn div<O>(&self, other: O) -> PyResult<Bound<'py, PyAny>>
     where
-        O: ToPyObject;
+        O: IntoPyObject<'py>;
+
+    /// Computes `self // other`.
+    fn floor_div<O>(&self, other: O) -> PyResult<Bound<'py, PyAny>>
+    where
+        O: IntoPyObject<'py>;
+
+    /// Computes `self % other`.
+    fn rem<O>(&self, other: O) -> PyResult<Bound<'py, PyAny>>
+    where
+        O: IntoPyObject<'py>;
+
+    /// Computes `divmod(self, other)`.
+    fn divmod<O>(&self, other: O) -> PyResult<Bound<'py, PyAny>>
+    where
+        O: IntoPyObject<'py>;
 
     /// Computes `self << other`.
     fn lshift<O>(&self, other: O) -> PyResult<Bound<'py, PyAny>>
     where
-        O: ToPyObject;
+        O: IntoPyObject<'py>;
 
     /// Computes `self >> other`.
     fn rshift<O>(&self, other: O) -> PyResult<Bound<'py, PyAny>>
     where
-        O: ToPyObject;
+        O: IntoPyObject<'py>;
 
     /// Computes `self ** other % modulus` (`pow(self, other, modulus)`).
     /// `py.None()` may be passed for the `modulus`.
     fn pow<O1, O2>(&self, other: O1, modulus: O2) -> PyResult<Bound<'py, PyAny>>
     where
-        O1: ToPyObject,
-        O2: ToPyObject;
+        O1: IntoPyObject<'py>,
+        O2: IntoPyObject<'py>;
 
     /// Computes `self & other`.
     fn bitand<O>(&self, other: O) -> PyResult<Bound<'py, PyAny>>
     where
-        O: ToPyObject;
+        O: IntoPyObject<'py>;
 
     /// Computes `self | other`.
     fn bitor<O>(&self, other: O) -> PyResult<Bound<'py, PyAny>>
     where
-        O: ToPyObject;
+        O: IntoPyObject<'py>;
 
     /// Computes `self ^ other`.
     fn bitxor<O>(&self, other: O) -> PyResult<Bound<'py, PyAny>>
     where
-        O: ToPyObject;
+        O: IntoPyObject<'py>;
 
     /// Determines whether this object appears callable.
     ///
@@ -1227,7 +418,7 @@ pub trait PyAnyMethods<'py> {
     /// use pyo3::prelude::*;
     ///
     /// # fn main() -> PyResult<()> {
-    /// Python::with_gil(|py| -> PyResult<()> {
+    /// Python::attach(|py| -> PyResult<()> {
     ///     let builtins = PyModule::import(py, "builtins")?;
     ///     let print = builtins.getattr("print")?;
     ///     assert!(print.is_callable());
@@ -1255,8 +446,10 @@ pub trait PyAnyMethods<'py> {
     /// ```rust
     /// use pyo3::prelude::*;
     /// use pyo3::types::PyDict;
+    /// use pyo3_ffi::c_str;
+    /// use std::ffi::CStr;
     ///
-    /// const CODE: &str = r#"
+    /// const CODE: &CStr = cr#"
     /// def function(*args, **kwargs):
     ///     assert args == ("hello",)
     ///     assert kwargs == {"cruel": "world"}
@@ -1264,23 +457,21 @@ pub trait PyAnyMethods<'py> {
     /// "#;
     ///
     /// # fn main() -> PyResult<()> {
-    /// Python::with_gil(|py| {
-    ///     let module = PyModule::from_code(py, CODE, "", "")?;
+    /// Python::attach(|py| {
+    ///     let module = PyModule::from_code(py, CODE, c"func.py", c"")?;
     ///     let fun = module.getattr("function")?;
     ///     let args = ("hello",);
-    ///     let kwargs = PyDict::new_bound(py);
+    ///     let kwargs = PyDict::new(py);
     ///     kwargs.set_item("cruel", "world")?;
-    ///     let result = fun.call(args, Some(kwargs.as_gil_ref()))?;
-    ///     assert_eq!(result.extract::<&str>()?, "called with args and kwargs");
+    ///     let result = fun.call(args, Some(&kwargs))?;
+    ///     assert_eq!(result.extract::<String>()?, "called with args and kwargs");
     ///     Ok(())
     /// })
     /// # }
     /// ```
-    fn call(
-        &self,
-        args: impl IntoPy<Py<PyTuple>>,
-        kwargs: Option<&Bound<'_, PyDict>>,
-    ) -> PyResult<Bound<'py, PyAny>>;
+    fn call<A>(&self, args: A, kwargs: Option<&Bound<'py, PyDict>>) -> PyResult<Bound<'py, PyAny>>
+    where
+        A: PyCallArgs<'py>;
 
     /// Calls the object without arguments.
     ///
@@ -1292,7 +483,7 @@ pub trait PyAnyMethods<'py> {
     /// use pyo3::prelude::*;
     ///
     /// # fn main() -> PyResult<()> {
-    /// Python::with_gil(|py| -> PyResult<()> {
+    /// Python::attach(|py| -> PyResult<()> {
     ///     let module = PyModule::import(py, "builtins")?;
     ///     let help = module.getattr("help")?;
     ///     help.call0()?;
@@ -1312,8 +503,10 @@ pub trait PyAnyMethods<'py> {
     ///
     /// ```rust
     /// use pyo3::prelude::*;
+    /// use pyo3_ffi::c_str;
+    /// use std::ffi::CStr;
     ///
-    /// const CODE: &str = r#"
+    /// const CODE: &CStr = cr#"
     /// def function(*args, **kwargs):
     ///     assert args == ("hello",)
     ///     assert kwargs == {}
@@ -1321,17 +514,19 @@ pub trait PyAnyMethods<'py> {
     /// "#;
     ///
     /// # fn main() -> PyResult<()> {
-    /// Python::with_gil(|py| {
-    ///     let module = PyModule::from_code(py, CODE, "", "")?;
+    /// Python::attach(|py| {
+    ///     let module = PyModule::from_code(py, CODE, c"func.py", c"")?;
     ///     let fun = module.getattr("function")?;
     ///     let args = ("hello",);
     ///     let result = fun.call1(args)?;
-    ///     assert_eq!(result.extract::<&str>()?, "called with args");
+    ///     assert_eq!(result.extract::<String>()?, "called with args");
     ///     Ok(())
     /// })
     /// # }
     /// ```
-    fn call1(&self, args: impl IntoPy<Py<PyTuple>>) -> PyResult<Bound<'py, PyAny>>;
+    fn call1<A>(&self, args: A) -> PyResult<Bound<'py, PyAny>>
+    where
+        A: PyCallArgs<'py>;
 
     /// Calls a method on the object.
     ///
@@ -1345,8 +540,10 @@ pub trait PyAnyMethods<'py> {
     /// ```rust
     /// use pyo3::prelude::*;
     /// use pyo3::types::PyDict;
+    /// use pyo3_ffi::c_str;
+    /// use std::ffi::CStr;
     ///
-    /// const CODE: &str = r#"
+    /// const CODE: &CStr = cr#"
     /// class A:
     ///     def method(self, *args, **kwargs):
     ///         assert args == ("hello",)
@@ -1356,14 +553,14 @@ pub trait PyAnyMethods<'py> {
     /// "#;
     ///
     /// # fn main() -> PyResult<()> {
-    /// Python::with_gil(|py| {
-    ///     let module = PyModule::from_code(py, CODE, "", "")?;
+    /// Python::attach(|py| {
+    ///     let module = PyModule::from_code(py, CODE, c"a.py", c"")?;
     ///     let instance = module.getattr("a")?;
     ///     let args = ("hello",);
-    ///     let kwargs = PyDict::new_bound(py);
+    ///     let kwargs = PyDict::new(py);
     ///     kwargs.set_item("cruel", "world")?;
-    ///     let result = instance.call_method("method", args, Some(kwargs.as_gil_ref()))?;
-    ///     assert_eq!(result.extract::<&str>()?, "called with args and kwargs");
+    ///     let result = instance.call_method("method", args, Some(&kwargs))?;
+    ///     assert_eq!(result.extract::<String>()?, "called with args and kwargs");
     ///     Ok(())
     /// })
     /// # }
@@ -1372,11 +569,11 @@ pub trait PyAnyMethods<'py> {
         &self,
         name: N,
         args: A,
-        kwargs: Option<&Bound<'_, PyDict>>,
+        kwargs: Option<&Bound<'py, PyDict>>,
     ) -> PyResult<Bound<'py, PyAny>>
     where
-        N: IntoPy<Py<PyString>>,
-        A: IntoPy<Py<PyTuple>>;
+        N: IntoPyObject<'py, Target = PyString>,
+        A: PyCallArgs<'py>;
 
     /// Calls a method on the object without arguments.
     ///
@@ -1389,8 +586,10 @@ pub trait PyAnyMethods<'py> {
     ///
     /// ```rust
     /// use pyo3::prelude::*;
+    /// use pyo3_ffi::c_str;
+    /// use std::ffi::CStr;
     ///
-    /// const CODE: &str = r#"
+    /// const CODE: &CStr = cr#"
     /// class A:
     ///     def method(self, *args, **kwargs):
     ///         assert args == ()
@@ -1400,18 +599,18 @@ pub trait PyAnyMethods<'py> {
     /// "#;
     ///
     /// # fn main() -> PyResult<()> {
-    /// Python::with_gil(|py| {
-    ///     let module = PyModule::from_code(py, CODE, "", "")?;
+    /// Python::attach(|py| {
+    ///     let module = PyModule::from_code(py, CODE, c"a.py", c"")?;
     ///     let instance = module.getattr("a")?;
     ///     let result = instance.call_method0("method")?;
-    ///     assert_eq!(result.extract::<&str>()?, "called with no arguments");
+    ///     assert_eq!(result.extract::<String>()?, "called with no arguments");
     ///     Ok(())
     /// })
     /// # }
     /// ```
     fn call_method0<N>(&self, name: N) -> PyResult<Bound<'py, PyAny>>
     where
-        N: IntoPy<Py<PyString>>;
+        N: IntoPyObject<'py, Target = PyString>;
 
     /// Calls a method on the object with only positional arguments.
     ///
@@ -1424,8 +623,10 @@ pub trait PyAnyMethods<'py> {
     ///
     /// ```rust
     /// use pyo3::prelude::*;
+    /// use pyo3_ffi::c_str;
+    /// use std::ffi::CStr;
     ///
-    /// const CODE: &str = r#"
+    /// const CODE: &CStr = cr#"
     /// class A:
     ///     def method(self, *args, **kwargs):
     ///         assert args == ("hello",)
@@ -1435,20 +636,20 @@ pub trait PyAnyMethods<'py> {
     /// "#;
     ///
     /// # fn main() -> PyResult<()> {
-    /// Python::with_gil(|py| {
-    ///     let module = PyModule::from_code(py, CODE, "", "")?;
+    /// Python::attach(|py| {
+    ///     let module = PyModule::from_code(py, CODE, c"a.py", c"")?;
     ///     let instance = module.getattr("a")?;
     ///     let args = ("hello",);
     ///     let result = instance.call_method1("method", args)?;
-    ///     assert_eq!(result.extract::<&str>()?, "called with args");
+    ///     assert_eq!(result.extract::<String>()?, "called with args");
     ///     Ok(())
     /// })
     /// # }
     /// ```
     fn call_method1<N, A>(&self, name: N, args: A) -> PyResult<Bound<'py, PyAny>>
     where
-        N: IntoPy<Py<PyString>>,
-        A: IntoPy<Py<PyTuple>>;
+        N: IntoPyObject<'py, Target = PyString>,
+        A: PyCallArgs<'py>;
 
     /// Returns whether the object is considered to be true.
     ///
@@ -1460,11 +661,6 @@ pub trait PyAnyMethods<'py> {
     /// This is equivalent to the Python expression `self is None`.
     fn is_none(&self) -> bool;
 
-    /// Returns whether the object is Ellipsis, e.g. `...`.
-    ///
-    /// This is equivalent to the Python expression `self is ...`.
-    fn is_ellipsis(&self) -> bool;
-
     /// Returns true if the sequence or mapping has a length of 0.
     ///
     /// This is equivalent to the Python expression `len(self) == 0`.
@@ -1475,31 +671,51 @@ pub trait PyAnyMethods<'py> {
     /// This is equivalent to the Python expression `self[key]`.
     fn get_item<K>(&self, key: K) -> PyResult<Bound<'py, PyAny>>
     where
-        K: ToPyObject;
+        K: IntoPyObject<'py>;
 
     /// Sets a collection item value.
     ///
     /// This is equivalent to the Python expression `self[key] = value`.
     fn set_item<K, V>(&self, key: K, value: V) -> PyResult<()>
     where
-        K: ToPyObject,
-        V: ToPyObject;
+        K: IntoPyObject<'py>,
+        V: IntoPyObject<'py>;
 
     /// Deletes an item from the collection.
     ///
     /// This is equivalent to the Python expression `del self[key]`.
     fn del_item<K>(&self, key: K) -> PyResult<()>
     where
-        K: ToPyObject;
+        K: IntoPyObject<'py>;
 
-    /// Takes an object and returns an iterator for it.
+    /// Takes an object and returns an iterator for it. Returns an error if the object is not
+    /// iterable.
     ///
     /// This is typically a new iterator but if the argument is an iterator,
     /// this returns itself.
-    fn iter(&self) -> PyResult<Bound<'py, PyIterator>>;
+    ///
+    /// # Example: Checking a Python object for iterability
+    ///
+    /// ```rust
+    /// use pyo3::prelude::*;
+    /// use pyo3::types::{PyAny, PyNone};
+    ///
+    /// fn is_iterable(obj: &Bound<'_, PyAny>) -> bool {
+    ///     match obj.try_iter() {
+    ///         Ok(_) => true,
+    ///         Err(_) => false,
+    ///     }
+    /// }
+    ///
+    /// Python::attach(|py| {
+    ///     assert!(is_iterable(&vec![1, 2, 3].into_pyobject(py).unwrap()));
+    ///     assert!(!is_iterable(&PyNone::get(py)));
+    /// });
+    /// ```
+    fn try_iter(&self) -> PyResult<Bound<'py, PyIterator>>;
 
     /// Returns the Python type object for this object's type.
-    fn get_type(&self) -> &'py PyType;
+    fn get_type(&self) -> Bound<'py, PyType>;
 
     /// Returns the Python type pointer for this object.
     fn get_type_ptr(&self) -> *mut ffi::PyTypeObject;
@@ -1515,11 +731,12 @@ pub trait PyAnyMethods<'py> {
     /// # Example: Downcasting to a specific Python object
     ///
     /// ```rust
+    /// # #![allow(deprecated)]
     /// use pyo3::prelude::*;
     /// use pyo3::types::{PyDict, PyList};
     ///
-    /// Python::with_gil(|py| {
-    ///     let dict = PyDict::new_bound(py);
+    /// Python::attach(|py| {
+    ///     let dict = PyDict::new(py);
     ///     assert!(dict.is_instance_of::<PyAny>());
     ///     let any = dict.as_any();
     ///
@@ -1534,6 +751,7 @@ pub trait PyAnyMethods<'py> {
     /// might actually be a pyclass.
     ///
     /// ```rust
+    /// # #![allow(deprecated)]
     /// # fn main() -> Result<(), pyo3::PyErr> {
     /// use pyo3::prelude::*;
     ///
@@ -1542,12 +760,12 @@ pub trait PyAnyMethods<'py> {
     ///     i: i32,
     /// }
     ///
-    /// Python::with_gil(|py| {
-    ///     let class: &PyAny = Py::new(py, Class { i: 0 }).unwrap().into_ref(py);
+    /// Python::attach(|py| {
+    ///     let class = Py::new(py, Class { i: 0 }).unwrap().into_bound(py).into_any();
     ///
-    ///     let class_cell: &PyCell<Class> = class.downcast()?;
+    ///     let class_bound: &Bound<'_, Class> = class.downcast()?;
     ///
-    ///     class_cell.borrow_mut().i += 1;
+    ///     class_bound.borrow_mut().i += 1;
     ///
     ///     // Alternatively you can get a `PyRefMut` directly
     ///     let class_ref: PyRefMut<'_, Class> = class.extract()?;
@@ -1556,6 +774,8 @@ pub trait PyAnyMethods<'py> {
     /// })
     /// # }
     /// ```
+    #[deprecated(since = "0.27.0", note = "use `Bound::cast` instead")]
+    #[allow(deprecated)]
     fn downcast<T>(&self) -> Result<&Bound<'py, T>, DowncastError<'_, 'py>>
     where
         T: PyTypeCheck;
@@ -1567,11 +787,12 @@ pub trait PyAnyMethods<'py> {
     /// # Example
     ///
     /// ```rust
+    /// # #![allow(deprecated)]
     /// use pyo3::prelude::*;
     /// use pyo3::types::{PyDict, PyList};
     ///
-    /// Python::with_gil(|py| {
-    ///     let obj: Bound<'_, PyAny> = PyDict::new_bound(py).into_any();
+    /// Python::attach(|py| {
+    ///     let obj: Bound<'_, PyAny> = PyDict::new(py).into_any();
     ///
     ///     let obj: Bound<'_, PyAny> = match obj.downcast_into::<PyList>() {
     ///         Ok(_) => panic!("obj should not be a list"),
@@ -1582,16 +803,18 @@ pub trait PyAnyMethods<'py> {
     ///     assert!(obj.downcast_into::<PyDict>().is_ok());
     /// })
     /// ```
+    #[deprecated(since = "0.27.0", note = "use `Bound::cast_into` instead")]
+    #[allow(deprecated)]
     fn downcast_into<T>(self) -> Result<Bound<'py, T>, DowncastIntoError<'py>>
     where
         T: PyTypeCheck;
 
     /// Downcast this `PyAny` to a concrete Python type or pyclass (but not a subclass of it).
     ///
-    /// It is almost always better to use [`PyAny::downcast`] because it accounts for Python
+    /// It is almost always better to use [`PyAnyMethods::downcast`] because it accounts for Python
     /// subtyping. Use this method only when you do not want to allow subtypes.
     ///
-    /// The advantage of this method over [`PyAny::downcast`] is that it is faster. The implementation
+    /// The advantage of this method over [`PyAnyMethods::downcast`] is that it is faster. The implementation
     /// of `downcast_exact` uses the equivalent of the Python expression `type(self) is T`, whereas
     /// `downcast` uses `isinstance(self, T)`.
     ///
@@ -1600,27 +823,32 @@ pub trait PyAnyMethods<'py> {
     /// # Example: Downcasting to a specific Python object but not a subtype
     ///
     /// ```rust
+    /// # #![allow(deprecated)]
     /// use pyo3::prelude::*;
-    /// use pyo3::types::{PyBool, PyLong};
+    /// use pyo3::types::{PyBool, PyInt};
     ///
-    /// Python::with_gil(|py| {
-    ///     let b = PyBool::new_bound(py, true);
+    /// Python::attach(|py| {
+    ///     let b = PyBool::new(py, true);
     ///     assert!(b.is_instance_of::<PyBool>());
     ///     let any: &Bound<'_, PyAny> = b.as_any();
     ///
     ///     // `bool` is a subtype of `int`, so `downcast` will accept a `bool` as an `int`
     ///     // but `downcast_exact` will not.
-    ///     assert!(any.downcast::<PyLong>().is_ok());
-    ///     assert!(any.downcast_exact::<PyLong>().is_err());
+    ///     assert!(any.downcast::<PyInt>().is_ok());
+    ///     assert!(any.downcast_exact::<PyInt>().is_err());
     ///
     ///     assert!(any.downcast_exact::<PyBool>().is_ok());
     /// });
     /// ```
+    #[deprecated(since = "0.27.0", note = "use `Bound::cast_exact` instead")]
+    #[allow(deprecated)]
     fn downcast_exact<T>(&self) -> Result<&Bound<'py, T>, DowncastError<'_, 'py>>
     where
         T: PyTypeInfo;
 
     /// Like `downcast_exact` but takes ownership of `self`.
+    #[deprecated(since = "0.27.0", note = "use `Bound::cast_into_exact` instead")]
+    #[allow(deprecated)]
     fn downcast_into_exact<T>(self) -> Result<Bound<'py, T>, DowncastIntoError<'py>>
     where
         T: PyTypeInfo;
@@ -1630,6 +858,7 @@ pub trait PyAnyMethods<'py> {
     /// # Safety
     ///
     /// Callers must ensure that the type is valid or risk type confusion.
+    #[deprecated(since = "0.27.0", note = "use `Bound::cast_unchecked` instead")]
     unsafe fn downcast_unchecked<T>(&self) -> &Bound<'py, T>;
 
     /// Like `downcast_unchecked` but takes ownership of `self`.
@@ -1637,14 +866,15 @@ pub trait PyAnyMethods<'py> {
     /// # Safety
     ///
     /// Callers must ensure that the type is valid or risk type confusion.
+    #[deprecated(since = "0.27.0", note = "use `Bound::cast_into_unchecked` instead")]
     unsafe fn downcast_into_unchecked<T>(self) -> Bound<'py, T>;
 
     /// Extracts some type from the Python object.
     ///
-    /// This is a wrapper function around [`FromPyObject::extract()`].
-    fn extract<D>(&self) -> PyResult<D>
+    /// This is a wrapper function around [`FromPyObject::extract()`](crate::FromPyObject::extract).
+    fn extract<'a, T>(&'a self) -> Result<T, T::Error>
     where
-        D: FromPyObject<'py>;
+        T: FromPyObject<'a, 'py>;
 
     /// Returns the reference count for the Python object.
     fn get_refcnt(&self) -> isize;
@@ -1672,7 +902,7 @@ pub trait PyAnyMethods<'py> {
     /// Returns the list of attributes of this object.
     ///
     /// This is equivalent to the Python expression `dir(self)`.
-    fn dir(&self) -> Bound<'py, PyList>;
+    fn dir(&self) -> PyResult<Bound<'py, PyList>>;
 
     /// Checks whether this object is an instance of type `ty`.
     ///
@@ -1688,7 +918,7 @@ pub trait PyAnyMethods<'py> {
     ///
     /// This is equivalent to the Python expression `isinstance(self, T)`,
     /// if the type `T` is known at compile time.
-    fn is_instance_of<T: PyTypeInfo>(&self) -> bool;
+    fn is_instance_of<T: PyTypeCheck>(&self) -> bool;
 
     /// Checks whether this object is an instance of exactly type `T`.
     ///
@@ -1701,12 +931,12 @@ pub trait PyAnyMethods<'py> {
     /// This is equivalent to the Python expression `value in self`.
     fn contains<V>(&self, value: V) -> PyResult<bool>
     where
-        V: ToPyObject;
+        V: IntoPyObject<'py>;
 
     /// Return a proxy object that delegates method calls to a parent or sibling class of type.
     ///
     /// This is equivalent to the Python expression `super()`
-    #[cfg(not(PyPy))]
+    #[cfg(not(any(PyPy, GraalPy)))]
     fn py_super(&self) -> PyResult<Bound<'py, PySuper>>;
 }
 
@@ -1715,30 +945,33 @@ macro_rules! implement_binop {
         #[doc = concat!("Computes `self ", $op, " other`.")]
         fn $name<O>(&self, other: O) -> PyResult<Bound<'py, PyAny>>
         where
-            O: ToPyObject,
+            O: IntoPyObject<'py>,
         {
             fn inner<'py>(
                 any: &Bound<'py, PyAny>,
-                other: Bound<'_, PyAny>,
+                other: Borrowed<'_, 'py, PyAny>,
             ) -> PyResult<Bound<'py, PyAny>> {
                 unsafe { ffi::$c_api(any.as_ptr(), other.as_ptr()).assume_owned_or_err(any.py()) }
             }
 
             let py = self.py();
-            inner(self, other.to_object(py).into_bound(py))
+            inner(
+                self,
+                other.into_pyobject_or_pyerr(py)?.into_any().as_borrowed(),
+            )
         }
     };
 }
 
 impl<'py> PyAnyMethods<'py> for Bound<'py, PyAny> {
     #[inline]
-    fn is<T: AsPyPointer>(&self, other: &T) -> bool {
-        self.as_ptr() == other.as_ptr()
+    fn is<T: AsRef<Py<PyAny>>>(&self, other: T) -> bool {
+        ptr::eq(self.as_ptr(), other.as_ref().as_ptr())
     }
 
     fn hasattr<N>(&self, attr_name: N) -> PyResult<bool>
     where
-        N: IntoPy<Py<PyString>>,
+        N: IntoPyObject<'py, Target = PyString>,
     {
         // PyObject_HasAttr suppresses all exceptions, which was the behaviour of `hasattr` in Python 2.
         // Use an implementation which suppresses only AttributeError, which is consistent with `hasattr` in Python 3.
@@ -1755,11 +988,11 @@ impl<'py> PyAnyMethods<'py> for Bound<'py, PyAny> {
 
     fn getattr<N>(&self, attr_name: N) -> PyResult<Bound<'py, PyAny>>
     where
-        N: IntoPy<Py<PyString>>,
+        N: IntoPyObject<'py, Target = PyString>,
     {
         fn inner<'py>(
             any: &Bound<'py, PyAny>,
-            attr_name: Bound<'_, PyString>,
+            attr_name: Borrowed<'_, '_, PyString>,
         ) -> PyResult<Bound<'py, PyAny>> {
             unsafe {
                 ffi::PyObject_GetAttr(any.as_ptr(), attr_name.as_ptr())
@@ -1767,19 +1000,72 @@ impl<'py> PyAnyMethods<'py> for Bound<'py, PyAny> {
             }
         }
 
+        inner(
+            self,
+            attr_name
+                .into_pyobject(self.py())
+                .map_err(Into::into)?
+                .as_borrowed(),
+        )
+    }
+
+    fn getattr_opt<N>(&self, attr_name: N) -> PyResult<Option<Bound<'py, PyAny>>>
+    where
+        N: IntoPyObject<'py, Target = PyString>,
+    {
+        fn inner<'py>(
+            any: &Bound<'py, PyAny>,
+            attr_name: Borrowed<'_, 'py, PyString>,
+        ) -> PyResult<Option<Bound<'py, PyAny>>> {
+            #[cfg(Py_3_13)]
+            {
+                let mut resp_ptr: *mut ffi::PyObject = std::ptr::null_mut();
+                match unsafe {
+                    ffi::PyObject_GetOptionalAttr(any.as_ptr(), attr_name.as_ptr(), &mut resp_ptr)
+                } {
+                    // Attribute found, result is a new strong reference
+                    1 => {
+                        let bound = unsafe { Bound::from_owned_ptr(any.py(), resp_ptr) };
+                        Ok(Some(bound))
+                    }
+                    // Attribute not found, result is NULL
+                    0 => Ok(None),
+
+                    // An error occurred (other than AttributeError)
+                    _ => Err(PyErr::fetch(any.py())),
+                }
+            }
+
+            #[cfg(not(Py_3_13))]
+            {
+                match any.getattr(attr_name) {
+                    Ok(bound) => Ok(Some(bound)),
+                    Err(err) => {
+                        let err_type = err
+                            .get_type(any.py())
+                            .is(PyType::new::<PyAttributeError>(any.py()));
+                        match err_type {
+                            true => Ok(None),
+                            false => Err(err),
+                        }
+                    }
+                }
+            }
+        }
+
         let py = self.py();
-        inner(self, attr_name.into_py(self.py()).into_bound(py))
+        inner(self, attr_name.into_pyobject_or_pyerr(py)?.as_borrowed())
     }
 
     fn setattr<N, V>(&self, attr_name: N, value: V) -> PyResult<()>
     where
-        N: IntoPy<Py<PyString>>,
-        V: ToPyObject,
+        N: IntoPyObject<'py, Target = PyString>,
+        V: IntoPyObject<'py>,
     {
         fn inner(
             any: &Bound<'_, PyAny>,
-            attr_name: Bound<'_, PyString>,
-            value: Bound<'_, PyAny>,
+            attr_name: Borrowed<'_, '_, PyString>,
+            value: Borrowed<'_, '_, PyAny>,
         ) -> PyResult<()> {
             err::error_on_minusone(any.py(), unsafe {
                 ffi::PyObject_SetAttr(any.as_ptr(), attr_name.as_ptr(), value.as_ptr())
@@ -1789,30 +1075,30 @@ impl<'py> PyAnyMethods<'py> for Bound<'py, PyAny> {
         let py = self.py();
         inner(
             self,
-            attr_name.into_py(py).into_bound(py),
-            value.to_object(py).into_bound(py),
+            attr_name.into_pyobject_or_pyerr(py)?.as_borrowed(),
+            value.into_pyobject_or_pyerr(py)?.into_any().as_borrowed(),
         )
     }
 
     fn delattr<N>(&self, attr_name: N) -> PyResult<()>
     where
-        N: IntoPy<Py<PyString>>,
+        N: IntoPyObject<'py, Target = PyString>,
     {
-        fn inner(any: &Bound<'_, PyAny>, attr_name: Bound<'_, PyString>) -> PyResult<()> {
+        fn inner(any: &Bound<'_, PyAny>, attr_name: Borrowed<'_, '_, PyString>) -> PyResult<()> {
             err::error_on_minusone(any.py(), unsafe {
                 ffi::PyObject_DelAttr(any.as_ptr(), attr_name.as_ptr())
             })
         }
 
         let py = self.py();
-        inner(self, attr_name.into_py(py).into_bound(py))
+        inner(self, attr_name.into_pyobject_or_pyerr(py)?.as_borrowed())
     }
 
     fn compare<O>(&self, other: O) -> PyResult<Ordering>
     where
-        O: ToPyObject,
+        O: IntoPyObject<'py>,
     {
-        fn inner(any: &Bound<'_, PyAny>, other: Bound<'_, PyAny>) -> PyResult<Ordering> {
+        fn inner(any: &Bound<'_, PyAny>, other: Borrowed<'_, '_, PyAny>) -> PyResult<Ordering> {
             let other = other.as_ptr();
             // Almost the same as ffi::PyObject_RichCompareBool, but this one doesn't try self == other.
             // See https://github.com/PyO3/pyo3/issues/985 for more.
@@ -1835,16 +1121,19 @@ impl<'py> PyAnyMethods<'py> for Bound<'py, PyAny> {
         }
 
         let py = self.py();
-        inner(self, other.to_object(py).into_bound(py))
+        inner(
+            self,
+            other.into_pyobject_or_pyerr(py)?.into_any().as_borrowed(),
+        )
     }
 
     fn rich_compare<O>(&self, other: O, compare_op: CompareOp) -> PyResult<Bound<'py, PyAny>>
     where
-        O: ToPyObject,
+        O: IntoPyObject<'py>,
     {
         fn inner<'py>(
             any: &Bound<'py, PyAny>,
-            other: Bound<'_, PyAny>,
+            other: Borrowed<'_, 'py, PyAny>,
             compare_op: CompareOp,
         ) -> PyResult<Bound<'py, PyAny>> {
             unsafe {
@@ -1854,12 +1143,44 @@ impl<'py> PyAnyMethods<'py> for Bound<'py, PyAny> {
         }
 
         let py = self.py();
-        inner(self, other.to_object(py).into_bound(py), compare_op)
+        inner(
+            self,
+            other.into_pyobject_or_pyerr(py)?.into_any().as_borrowed(),
+            compare_op,
+        )
+    }
+
+    fn neg(&self) -> PyResult<Bound<'py, PyAny>> {
+        unsafe { ffi::PyNumber_Negative(self.as_ptr()).assume_owned_or_err(self.py()) }
+    }
+
+    fn pos(&self) -> PyResult<Bound<'py, PyAny>> {
+        fn inner<'py>(any: &Bound<'py, PyAny>) -> PyResult<Bound<'py, PyAny>> {
+            unsafe { ffi::PyNumber_Positive(any.as_ptr()).assume_owned_or_err(any.py()) }
+        }
+
+        inner(self)
+    }
+
+    fn abs(&self) -> PyResult<Bound<'py, PyAny>> {
+        fn inner<'py>(any: &Bound<'py, PyAny>) -> PyResult<Bound<'py, PyAny>> {
+            unsafe { ffi::PyNumber_Absolute(any.as_ptr()).assume_owned_or_err(any.py()) }
+        }
+
+        inner(self)
+    }
+
+    fn bitnot(&self) -> PyResult<Bound<'py, PyAny>> {
+        fn inner<'py>(any: &Bound<'py, PyAny>) -> PyResult<Bound<'py, PyAny>> {
+            unsafe { ffi::PyNumber_Invert(any.as_ptr()).assume_owned_or_err(any.py()) }
+        }
+
+        inner(self)
     }
 
     fn lt<O>(&self, other: O) -> PyResult<bool>
     where
-        O: ToPyObject,
+        O: IntoPyObject<'py>,
     {
         self.rich_compare(other, CompareOp::Lt)
             .and_then(|any| any.is_truthy())
@@ -1867,7 +1188,7 @@ impl<'py> PyAnyMethods<'py> for Bound<'py, PyAny> {
 
     fn le<O>(&self, other: O) -> PyResult<bool>
     where
-        O: ToPyObject,
+        O: IntoPyObject<'py>,
     {
         self.rich_compare(other, CompareOp::Le)
             .and_then(|any| any.is_truthy())
@@ -1875,7 +1196,7 @@ impl<'py> PyAnyMethods<'py> for Bound<'py, PyAny> {
 
     fn eq<O>(&self, other: O) -> PyResult<bool>
     where
-        O: ToPyObject,
+        O: IntoPyObject<'py>,
     {
         self.rich_compare(other, CompareOp::Eq)
             .and_then(|any| any.is_truthy())
@@ -1883,7 +1204,7 @@ impl<'py> PyAnyMethods<'py> for Bound<'py, PyAny> {
 
     fn ne<O>(&self, other: O) -> PyResult<bool>
     where
-        O: ToPyObject,
+        O: IntoPyObject<'py>,
     {
         self.rich_compare(other, CompareOp::Ne)
             .and_then(|any| any.is_truthy())
@@ -1891,7 +1212,7 @@ impl<'py> PyAnyMethods<'py> for Bound<'py, PyAny> {
 
     fn gt<O>(&self, other: O) -> PyResult<bool>
     where
-        O: ToPyObject,
+        O: IntoPyObject<'py>,
     {
         self.rich_compare(other, CompareOp::Gt)
             .and_then(|any| any.is_truthy())
@@ -1899,7 +1220,7 @@ impl<'py> PyAnyMethods<'py> for Bound<'py, PyAny> {
 
     fn ge<O>(&self, other: O) -> PyResult<bool>
     where
-        O: ToPyObject,
+        O: IntoPyObject<'py>,
     {
         self.rich_compare(other, CompareOp::Ge)
             .and_then(|any| any.is_truthy())
@@ -1908,24 +1229,48 @@ impl<'py> PyAnyMethods<'py> for Bound<'py, PyAny> {
     implement_binop!(add, PyNumber_Add, "+");
     implement_binop!(sub, PyNumber_Subtract, "-");
     implement_binop!(mul, PyNumber_Multiply, "*");
+    implement_binop!(matmul, PyNumber_MatrixMultiply, "@");
     implement_binop!(div, PyNumber_TrueDivide, "/");
+    implement_binop!(floor_div, PyNumber_FloorDivide, "//");
+    implement_binop!(rem, PyNumber_Remainder, "%");
     implement_binop!(lshift, PyNumber_Lshift, "<<");
     implement_binop!(rshift, PyNumber_Rshift, ">>");
     implement_binop!(bitand, PyNumber_And, "&");
     implement_binop!(bitor, PyNumber_Or, "|");
     implement_binop!(bitxor, PyNumber_Xor, "^");
 
+    /// Computes `divmod(self, other)`.
+    fn divmod<O>(&self, other: O) -> PyResult<Bound<'py, PyAny>>
+    where
+        O: IntoPyObject<'py>,
+    {
+        fn inner<'py>(
+            any: &Bound<'py, PyAny>,
+            other: Borrowed<'_, 'py, PyAny>,
+        ) -> PyResult<Bound<'py, PyAny>> {
+            unsafe {
+                ffi::PyNumber_Divmod(any.as_ptr(), other.as_ptr()).assume_owned_or_err(any.py())
+            }
+        }
+
+        let py = self.py();
+        inner(
+            self,
+            other.into_pyobject_or_pyerr(py)?.into_any().as_borrowed(),
+        )
+    }
+
     /// Computes `self ** other % modulus` (`pow(self, other, modulus)`).
     /// `py.None()` may be passed for the `modulus`.
     fn pow<O1, O2>(&self, other: O1, modulus: O2) -> PyResult<Bound<'py, PyAny>>
     where
-        O1: ToPyObject,
-        O2: ToPyObject,
+        O1: IntoPyObject<'py>,
+        O2: IntoPyObject<'py>,
     {
         fn inner<'py>(
             any: &Bound<'py, PyAny>,
-            other: Bound<'_, PyAny>,
-            modulus: Bound<'_, PyAny>,
+            other: Borrowed<'_, 'py, PyAny>,
+            modulus: Borrowed<'_, 'py, PyAny>,
         ) -> PyResult<Bound<'py, PyAny>> {
             unsafe {
                 ffi::PyNumber_Power(any.as_ptr(), other.as_ptr(), modulus.as_ptr())
@@ -1936,8 +1281,8 @@ impl<'py> PyAnyMethods<'py> for Bound<'py, PyAny> {
         let py = self.py();
         inner(
             self,
-            other.to_object(py).into_bound(py),
-            modulus.to_object(py).into_bound(py),
+            other.into_pyobject_or_pyerr(py)?.into_any().as_borrowed(),
+            modulus.into_pyobject_or_pyerr(py)?.into_any().as_borrowed(),
         )
     }
 
@@ -1945,89 +1290,76 @@ impl<'py> PyAnyMethods<'py> for Bound<'py, PyAny> {
         unsafe { ffi::PyCallable_Check(self.as_ptr()) != 0 }
     }
 
-    fn call(
-        &self,
-        args: impl IntoPy<Py<PyTuple>>,
-        kwargs: Option<&Bound<'_, PyDict>>,
-    ) -> PyResult<Bound<'py, PyAny>> {
-        fn inner<'py>(
-            any: &Bound<'py, PyAny>,
-            args: Bound<'_, PyTuple>,
-            kwargs: Option<&Bound<'_, PyDict>>,
-        ) -> PyResult<Bound<'py, PyAny>> {
-            unsafe {
-                ffi::PyObject_Call(
-                    any.as_ptr(),
-                    args.as_ptr(),
-                    kwargs.map_or(std::ptr::null_mut(), |dict| dict.as_ptr()),
-                )
-                .assume_owned_or_err(any.py())
-            }
+    fn call<A>(&self, args: A, kwargs: Option<&Bound<'py, PyDict>>) -> PyResult<Bound<'py, PyAny>>
+    where
+        A: PyCallArgs<'py>,
+    {
+        if let Some(kwargs) = kwargs {
+            args.call(
+                self.as_borrowed(),
+                kwargs.as_borrowed(),
+                crate::call::private::Token,
+            )
+        } else {
+            args.call_positional(self.as_borrowed(), crate::call::private::Token)
         }
-
-        let py = self.py();
-        inner(self, args.into_py(py).into_bound(py), kwargs)
     }
 
+    #[inline]
     fn call0(&self) -> PyResult<Bound<'py, PyAny>> {
-        cfg_if::cfg_if! {
-            if #[cfg(all(
-                not(PyPy),
-                any(Py_3_10, all(not(Py_LIMITED_API), Py_3_9)) // PyObject_CallNoArgs was added to python in 3.9 but to limited API in 3.10
-            ))] {
-                // Optimized path on python 3.9+
-                unsafe {
-                    ffi::PyObject_CallNoArgs(self.as_ptr()).assume_owned_or_err(self.py())
-                }
-            } else {
-                self.call((), None)
-            }
-        }
+        unsafe { ffi::compat::PyObject_CallNoArgs(self.as_ptr()).assume_owned_or_err(self.py()) }
     }
 
-    fn call1(&self, args: impl IntoPy<Py<PyTuple>>) -> PyResult<Bound<'py, PyAny>> {
-        self.call(args, None)
+    fn call1<A>(&self, args: A) -> PyResult<Bound<'py, PyAny>>
+    where
+        A: PyCallArgs<'py>,
+    {
+        args.call_positional(self.as_borrowed(), crate::call::private::Token)
     }
 
+    #[inline]
     fn call_method<N, A>(
         &self,
         name: N,
         args: A,
-        kwargs: Option<&Bound<'_, PyDict>>,
+        kwargs: Option<&Bound<'py, PyDict>>,
     ) -> PyResult<Bound<'py, PyAny>>
     where
-        N: IntoPy<Py<PyString>>,
-        A: IntoPy<Py<PyTuple>>,
+        N: IntoPyObject<'py, Target = PyString>,
+        A: PyCallArgs<'py>,
     {
-        self.getattr(name)
-            .and_then(|method| method.call(args, kwargs))
+        if kwargs.is_none() {
+            self.call_method1(name, args)
+        } else {
+            self.getattr(name)
+                .and_then(|method| method.call(args, kwargs))
+        }
     }
 
+    #[inline]
     fn call_method0<N>(&self, name: N) -> PyResult<Bound<'py, PyAny>>
     where
-        N: IntoPy<Py<PyString>>,
+        N: IntoPyObject<'py, Target = PyString>,
     {
-        cfg_if::cfg_if! {
-            if #[cfg(all(Py_3_9, not(any(Py_LIMITED_API, PyPy))))] {
-                let py = self.py();
-
-                // Optimized path on python 3.9+
-                unsafe {
-                    let name = name.into_py(py).into_bound(py);
-                    ffi::PyObject_CallMethodNoArgs(self.as_ptr(), name.as_ptr()).assume_owned_or_err(py)
-                }
-            } else {
-                self.call_method(name, (), None)
-            }
+        let py = self.py();
+        let name = name.into_pyobject_or_pyerr(py)?.into_bound();
+        unsafe {
+            ffi::compat::PyObject_CallMethodNoArgs(self.as_ptr(), name.as_ptr())
+                .assume_owned_or_err(py)
         }
     }
 
     fn call_method1<N, A>(&self, name: N, args: A) -> PyResult<Bound<'py, PyAny>>
     where
-        N: IntoPy<Py<PyString>>,
-        A: IntoPy<Py<PyTuple>>,
+        N: IntoPyObject<'py, Target = PyString>,
+        A: PyCallArgs<'py>,
     {
-        self.call_method(name, args, None)
+        let name = name.into_pyobject_or_pyerr(self.py())?;
+        args.call_method_positional(
+            self.as_borrowed(),
+            name.as_borrowed(),
+            crate::call::private::Token,
+        )
     }
 
     fn is_truthy(&self) -> PyResult<bool> {
@@ -2038,11 +1370,7 @@ impl<'py> PyAnyMethods<'py> for Bound<'py, PyAny> {
 
     #[inline]
     fn is_none(&self) -> bool {
-        unsafe { ffi::Py_None() == self.as_ptr() }
-    }
-
-    fn is_ellipsis(&self) -> bool {
-        unsafe { ffi::Py_Ellipsis() == self.as_ptr() }
+        unsafe { ptr::eq(ffi::Py_None(), self.as_ptr()) }
     }
 
     fn is_empty(&self) -> PyResult<bool> {
@@ -2051,11 +1379,11 @@ impl<'py> PyAnyMethods<'py> for Bound<'py, PyAny> {
 
     fn get_item<K>(&self, key: K) -> PyResult<Bound<'py, PyAny>>
     where
-        K: ToPyObject,
+        K: IntoPyObject<'py>,
     {
         fn inner<'py>(
             any: &Bound<'py, PyAny>,
-            key: Bound<'_, PyAny>,
+            key: Borrowed<'_, 'py, PyAny>,
         ) -> PyResult<Bound<'py, PyAny>> {
             unsafe {
                 ffi::PyObject_GetItem(any.as_ptr(), key.as_ptr()).assume_owned_or_err(any.py())
@@ -2063,18 +1391,21 @@ impl<'py> PyAnyMethods<'py> for Bound<'py, PyAny> {
         }
 
         let py = self.py();
-        inner(self, key.to_object(py).into_bound(py))
+        inner(
+            self,
+            key.into_pyobject_or_pyerr(py)?.into_any().as_borrowed(),
+        )
     }
 
     fn set_item<K, V>(&self, key: K, value: V) -> PyResult<()>
     where
-        K: ToPyObject,
-        V: ToPyObject,
+        K: IntoPyObject<'py>,
+        V: IntoPyObject<'py>,
     {
         fn inner(
             any: &Bound<'_, PyAny>,
-            key: Bound<'_, PyAny>,
-            value: Bound<'_, PyAny>,
+            key: Borrowed<'_, '_, PyAny>,
+            value: Borrowed<'_, '_, PyAny>,
         ) -> PyResult<()> {
             err::error_on_minusone(any.py(), unsafe {
                 ffi::PyObject_SetItem(any.as_ptr(), key.as_ptr(), value.as_ptr())
@@ -2084,31 +1415,34 @@ impl<'py> PyAnyMethods<'py> for Bound<'py, PyAny> {
         let py = self.py();
         inner(
             self,
-            key.to_object(py).into_bound(py),
-            value.to_object(py).into_bound(py),
+            key.into_pyobject_or_pyerr(py)?.into_any().as_borrowed(),
+            value.into_pyobject_or_pyerr(py)?.into_any().as_borrowed(),
         )
     }
 
     fn del_item<K>(&self, key: K) -> PyResult<()>
     where
-        K: ToPyObject,
+        K: IntoPyObject<'py>,
     {
-        fn inner(any: &Bound<'_, PyAny>, key: Bound<'_, PyAny>) -> PyResult<()> {
+        fn inner(any: &Bound<'_, PyAny>, key: Borrowed<'_, '_, PyAny>) -> PyResult<()> {
             err::error_on_minusone(any.py(), unsafe {
                 ffi::PyObject_DelItem(any.as_ptr(), key.as_ptr())
             })
         }
 
         let py = self.py();
-        inner(self, key.to_object(py).into_bound(py))
+        inner(
+            self,
+            key.into_pyobject_or_pyerr(py)?.into_any().as_borrowed(),
+        )
     }
 
-    fn iter(&self) -> PyResult<Bound<'py, PyIterator>> {
-        PyIterator::from_bound_object(self)
+    fn try_iter(&self) -> PyResult<Bound<'py, PyIterator>> {
+        PyIterator::from_object(self)
     }
 
-    fn get_type(&self) -> &'py PyType {
-        unsafe { PyType::from_type_ptr(self.py(), ffi::Py_TYPE(self.as_ptr())) }
+    fn get_type(&self) -> Bound<'py, PyType> {
+        unsafe { PyType::from_borrowed_type_ptr(self.py(), ffi::Py_TYPE(self.as_ptr())) }
     }
 
     #[inline]
@@ -2117,72 +1451,80 @@ impl<'py> PyAnyMethods<'py> for Bound<'py, PyAny> {
     }
 
     #[inline]
+    #[allow(deprecated)]
     fn downcast<T>(&self) -> Result<&Bound<'py, T>, DowncastError<'_, 'py>>
     where
         T: PyTypeCheck,
     {
         if T::type_check(self) {
             // Safety: type_check is responsible for ensuring that the type is correct
-            Ok(unsafe { self.downcast_unchecked() })
+            Ok(unsafe { self.cast_unchecked() })
         } else {
+            #[allow(deprecated)]
             Err(DowncastError::new(self, T::NAME))
         }
     }
 
     #[inline]
+    #[allow(deprecated)]
     fn downcast_into<T>(self) -> Result<Bound<'py, T>, DowncastIntoError<'py>>
     where
         T: PyTypeCheck,
     {
         if T::type_check(&self) {
             // Safety: type_check is responsible for ensuring that the type is correct
-            Ok(unsafe { self.downcast_into_unchecked() })
+            Ok(unsafe { self.cast_into_unchecked() })
         } else {
+            #[allow(deprecated)]
             Err(DowncastIntoError::new(self, T::NAME))
         }
     }
 
     #[inline]
+    #[allow(deprecated)]
     fn downcast_exact<T>(&self) -> Result<&Bound<'py, T>, DowncastError<'_, 'py>>
     where
         T: PyTypeInfo,
     {
-        if self.is_exact_instance_of::<T>() {
-            // Safety: is_exact_instance_of is responsible for ensuring that the type is correct
-            Ok(unsafe { self.downcast_unchecked() })
+        if T::is_exact_type_of(self) {
+            // Safety: is_exact_type_of is responsible for ensuring that the type is correct
+            Ok(unsafe { self.cast_unchecked() })
         } else {
+            #[allow(deprecated)]
             Err(DowncastError::new(self, T::NAME))
         }
     }
 
     #[inline]
+    #[allow(deprecated)]
     fn downcast_into_exact<T>(self) -> Result<Bound<'py, T>, DowncastIntoError<'py>>
     where
         T: PyTypeInfo,
     {
-        if self.is_exact_instance_of::<T>() {
-            // Safety: is_exact_instance_of is responsible for ensuring that the type is correct
-            Ok(unsafe { self.downcast_into_unchecked() })
+        if T::is_exact_type_of(&self) {
+            // Safety: is_exact_type_of is responsible for ensuring that the type is correct
+            Ok(unsafe { self.cast_into_unchecked() })
         } else {
+            #[allow(deprecated)]
             Err(DowncastIntoError::new(self, T::NAME))
         }
     }
 
     #[inline]
     unsafe fn downcast_unchecked<T>(&self) -> &Bound<'py, T> {
-        &*(self as *const Bound<'py, PyAny>).cast()
+        unsafe { self.cast_unchecked() }
     }
 
     #[inline]
     unsafe fn downcast_into_unchecked<T>(self) -> Bound<'py, T> {
-        std::mem::transmute(self)
+        unsafe { self.cast_into_unchecked() }
     }
 
-    fn extract<D>(&self) -> PyResult<D>
+    fn extract<'a, T>(&'a self) -> Result<T, T::Error>
     where
-        D: FromPyObject<'py>,
+        T: FromPyObject<'a, 'py>,
     {
-        FromPyObject::extract_bound(self)
+        FromPyObject::extract(self.as_borrowed())
     }
 
     fn get_refcnt(&self) -> isize {
@@ -2193,7 +1535,7 @@ impl<'py> PyAnyMethods<'py> for Bound<'py, PyAny> {
         unsafe {
             ffi::PyObject_Repr(self.as_ptr())
                 .assume_owned_or_err(self.py())
-                .downcast_into_unchecked()
+                .cast_into_unchecked()
         }
     }
 
@@ -2201,7 +1543,7 @@ impl<'py> PyAnyMethods<'py> for Bound<'py, PyAny> {
         unsafe {
             ffi::PyObject_Str(self.as_ptr())
                 .assume_owned_or_err(self.py())
-                .downcast_into_unchecked()
+                .cast_into_unchecked()
         }
     }
 
@@ -2217,11 +1559,11 @@ impl<'py> PyAnyMethods<'py> for Bound<'py, PyAny> {
         Ok(v as usize)
     }
 
-    fn dir(&self) -> Bound<'py, PyList> {
+    fn dir(&self) -> PyResult<Bound<'py, PyList>> {
         unsafe {
             ffi::PyObject_Dir(self.as_ptr())
-                .assume_owned(self.py())
-                .downcast_into_unchecked()
+                .assume_owned_or_err(self.py())
+                .cast_into_unchecked()
         }
     }
 
@@ -2238,20 +1580,20 @@ impl<'py> PyAnyMethods<'py> for Bound<'py, PyAny> {
     }
 
     #[inline]
-    fn is_instance_of<T: PyTypeInfo>(&self) -> bool {
-        T::is_type_of_bound(self)
+    fn is_instance_of<T: PyTypeCheck>(&self) -> bool {
+        T::type_check(self)
     }
 
     #[inline]
     fn is_exact_instance_of<T: PyTypeInfo>(&self) -> bool {
-        T::is_exact_type_of_bound(self)
+        T::is_exact_type_of(self)
     }
 
     fn contains<V>(&self, value: V) -> PyResult<bool>
     where
-        V: ToPyObject,
+        V: IntoPyObject<'py>,
     {
-        fn inner(any: &Bound<'_, PyAny>, value: Bound<'_, PyAny>) -> PyResult<bool> {
+        fn inner(any: &Bound<'_, PyAny>, value: Borrowed<'_, '_, PyAny>) -> PyResult<bool> {
             match unsafe { ffi::PySequence_Contains(any.as_ptr(), value.as_ptr()) } {
                 0 => Ok(false),
                 1 => Ok(true),
@@ -2260,12 +1602,15 @@ impl<'py> PyAnyMethods<'py> for Bound<'py, PyAny> {
         }
 
         let py = self.py();
-        inner(self, value.to_object(py).into_bound(py))
+        inner(
+            self,
+            value.into_pyobject_or_pyerr(py)?.into_any().as_borrowed(),
+        )
     }
 
-    #[cfg(not(PyPy))]
+    #[cfg(not(any(PyPy, GraalPy)))]
     fn py_super(&self) -> PyResult<Bound<'py, PySuper>> {
-        PySuper::new_bound(&self.get_type().as_borrowed(), self)
+        PySuper::new(&self.get_type(), self)
     }
 }
 
@@ -2283,37 +1628,24 @@ impl<'py> Bound<'py, PyAny> {
     #[allow(dead_code)] // Currently only used with num-complex+abi3, so dead without that.
     pub(crate) fn lookup_special<N>(&self, attr_name: N) -> PyResult<Option<Bound<'py, PyAny>>>
     where
-        N: IntoPy<Py<PyString>>,
+        N: IntoPyObject<'py, Target = PyString>,
     {
         let py = self.py();
-        let self_type = self.get_type().as_borrowed();
+        let self_type = self.get_type();
         let attr = if let Ok(attr) = self_type.getattr(attr_name) {
             attr
         } else {
             return Ok(None);
         };
 
-        // Manually resolve descriptor protocol.
-        if cfg!(Py_3_10)
-            || unsafe { ffi::PyType_HasFeature(attr.get_type_ptr(), ffi::Py_TPFLAGS_HEAPTYPE) } != 0
-        {
-            // This is the preferred faster path, but does not work on static types (generally,
-            // types defined in extension modules) before Python 3.10.
+        // Manually resolve descriptor protocol. (Faster than going through Python.)
+        if let Some(descr_get) = attr.get_type().get_slot(TP_DESCR_GET) {
+            // attribute is a descriptor, resolve it
             unsafe {
-                let descr_get_ptr = ffi::PyType_GetSlot(attr.get_type_ptr(), ffi::Py_tp_descr_get);
-                if descr_get_ptr.is_null() {
-                    return Ok(Some(attr));
-                }
-                let descr_get: ffi::descrgetfunc = std::mem::transmute(descr_get_ptr);
-                let ret = descr_get(attr.as_ptr(), self.as_ptr(), self_type.as_ptr());
-                ret.assume_owned_or_err(py).map(Some)
+                descr_get(attr.as_ptr(), self.as_ptr(), self_type.as_ptr())
+                    .assume_owned_or_err(py)
+                    .map(Some)
             }
-        } else if let Ok(descr_get) = attr
-            .get_type()
-            .as_borrowed()
-            .getattr(crate::intern!(py, "__get__"))
-        {
-            descr_get.call1((attr, self, self_type)).map(Some)
         } else {
             Ok(Some(attr))
         }
@@ -2321,20 +1653,22 @@ impl<'py> Bound<'py, PyAny> {
 }
 
 #[cfg(test)]
-#[cfg_attr(not(feature = "gil-refs"), allow(deprecated))]
 mod tests {
     use crate::{
         basic::CompareOp,
-        types::{any::PyAnyMethods, IntoPyDict, PyAny, PyBool, PyList, PyLong, PyModule},
-        PyNativeType, PyTypeInfo, Python, ToPyObject,
+        test_utils::generate_unique_module_name,
+        types::{IntoPyDict, PyAny, PyAnyMethods, PyBool, PyInt, PyList, PyModule, PyTypeMethods},
+        Bound, BoundObject, IntoPyObject, PyTypeInfo, Python,
     };
+    use pyo3_ffi::c_str;
+    use std::fmt::Debug;
 
     #[test]
     fn test_lookup_special() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let module = PyModule::from_code(
                 py,
-                r#"
+                cr#"
 class CustomCallable:
     def __call__(self):
         return 1
@@ -2365,19 +1699,14 @@ class NonHeapNonDescriptorInt:
     # A static-typed callable that doesn't implement `__get__`.  These are pretty hard to come by.
     __int__ = int
                 "#,
-                "test.py",
-                "test",
+                c"test.py",
+                &generate_unique_module_name("test"),
             )
             .unwrap();
 
             let int = crate::intern!(py, "__int__");
-            let eval_int = |obj: &PyAny| {
-                obj.as_borrowed()
-                    .lookup_special(int)?
-                    .unwrap()
-                    .call0()?
-                    .extract::<u32>()
-            };
+            let eval_int =
+                |obj: Bound<'_, PyAny>| obj.lookup_special(int)?.unwrap().call0()?.extract::<u32>();
 
             let simple = module.getattr("SimpleInt").unwrap().call0().unwrap();
             assert_eq!(eval_int(simple).unwrap(), 1);
@@ -2386,7 +1715,7 @@ class NonHeapNonDescriptorInt:
             let no_descriptor = module.getattr("NoDescriptorInt").unwrap().call0().unwrap();
             assert_eq!(eval_int(no_descriptor).unwrap(), 1);
             let missing = module.getattr("NoInt").unwrap().call0().unwrap();
-            assert!(missing.as_borrowed().lookup_special(int).unwrap().is_none());
+            assert!(missing.lookup_special(int).unwrap().is_none());
             // Note the instance override should _not_ call the instance method that returns 2,
             // because that's not how special lookups are meant to work.
             let instance_override = module.getattr("instance_override").unwrap();
@@ -2396,7 +1725,7 @@ class NonHeapNonDescriptorInt:
                 .unwrap()
                 .call0()
                 .unwrap();
-            assert!(descriptor_error.as_borrowed().lookup_special(int).is_err());
+            assert!(descriptor_error.lookup_special(int).is_err());
             let nonheap_nondescriptor = module
                 .getattr("NonHeapNonDescriptorInt")
                 .unwrap()
@@ -2406,10 +1735,53 @@ class NonHeapNonDescriptorInt:
         })
     }
 
+    #[test]
+    fn test_getattr_opt() {
+        Python::attach(|py| {
+            let module = PyModule::from_code(
+                py,
+                cr#"
+class Test:
+    class_str_attribute = "class_string"
+
+    @property
+    def error(self):
+        raise ValueError("This is an intentional error")
+                "#,
+                c"test.py",
+                &generate_unique_module_name("test"),
+            )
+            .unwrap();
+
+            // Get the class Test
+            let class_test = module.getattr_opt("Test").unwrap().unwrap();
+
+            // Test attribute that exist
+            let cls_attr_str = class_test
+                .getattr_opt("class_str_attribute")
+                .unwrap()
+                .unwrap();
+            assert_eq!(cls_attr_str.extract::<String>().unwrap(), "class_string");
+
+            // Test non-existent attribute
+            let do_not_exist = class_test.getattr_opt("doNotExist").unwrap();
+            assert!(do_not_exist.is_none());
+
+            // Test error attribute
+            let instance = class_test.call0().unwrap();
+            let error = instance.getattr_opt("error");
+            assert!(error.is_err());
+            assert!(error
+                .unwrap_err()
+                .to_string()
+                .contains("This is an intentional error"));
+        });
+    }
+
     #[test]
     fn test_call_for_non_existing_method() {
-        Python::with_gil(|py| {
-            let a = py.eval("42", None, None).unwrap();
+        Python::attach(|py| {
+            let a = py.eval(c"42", None, None).unwrap();
             a.call_method0("__str__").unwrap(); // ok
             assert!(a.call_method("nonexistent_method", (1,), None).is_err());
             assert!(a.call_method0("nonexistent_method").is_err());
@@ -2419,26 +1791,26 @@ class NonHeapNonDescriptorInt:
 
     #[test]
     fn test_call_with_kwargs() {
-        Python::with_gil(|py| {
-            let list = vec![3, 6, 5, 4, 7].to_object(py);
-            let dict = vec![("reverse", true)].into_py_dict_bound(py);
-            list.call_method_bound(py, "sort", (), Some(&dict)).unwrap();
-            assert_eq!(list.extract::<Vec<i32>>(py).unwrap(), vec![7, 6, 5, 4, 3]);
+        Python::attach(|py| {
+            let list = vec![3, 6, 5, 4, 7].into_pyobject(py).unwrap();
+            let dict = vec![("reverse", true)].into_py_dict(py).unwrap();
+            list.call_method("sort", (), Some(&dict)).unwrap();
+            assert_eq!(list.extract::<Vec<i32>>().unwrap(), vec![7, 6, 5, 4, 3]);
         });
     }
 
     #[test]
     fn test_call_method0() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let module = PyModule::from_code(
                 py,
-                r#"
+                cr#"
 class SimpleClass:
     def foo(self):
         return 42
 "#,
-                file!(),
-                "test_module",
+                c_str!(file!()),
+                &generate_unique_module_name("test_module"),
             )
             .expect("module creation failed");
 
@@ -2456,23 +1828,24 @@ class SimpleClass:
 
     #[test]
     fn test_type() {
-        Python::with_gil(|py| {
-            let obj = py.eval("42", None, None).unwrap();
+        Python::attach(|py| {
+            let obj = py.eval(c"42", None, None).unwrap();
             assert_eq!(obj.get_type().as_type_ptr(), obj.get_type_ptr());
         });
     }
 
     #[test]
     fn test_dir() {
-        Python::with_gil(|py| {
-            let obj = py.eval("42", None, None).unwrap();
+        Python::attach(|py| {
+            let obj = py.eval(c"42", None, None).unwrap();
             let dir = py
-                .eval("dir(42)", None, None)
+                .eval(c"dir(42)", None, None)
                 .unwrap()
-                .downcast::<PyList>()
+                .cast_into::<PyList>()
                 .unwrap();
             let a = obj
                 .dir()
+                .unwrap()
                 .into_iter()
                 .map(|x| x.extract::<String>().unwrap());
             let b = dir.into_iter().map(|x| x.extract::<String>().unwrap());
@@ -2482,9 +1855,9 @@ class SimpleClass:
 
     #[test]
     fn test_hasattr() {
-        Python::with_gil(|py| {
-            let x = 5.to_object(py).into_ref(py);
-            assert!(x.is_instance_of::<PyLong>());
+        Python::attach(|py| {
+            let x = 5i32.into_pyobject(py).unwrap();
+            assert!(x.is_instance_of::<PyInt>());
 
             assert!(x.hasattr("to_bytes").unwrap());
             assert!(!x.hasattr("bbbbbbytes").unwrap());
@@ -2493,6 +1866,7 @@ class SimpleClass:
 
     #[cfg(feature = "macros")]
     #[test]
+    #[allow(unknown_lints, non_local_definitions)]
     fn test_hasattr_error() {
         use crate::exceptions::PyValueError;
         use crate::prelude::*;
@@ -2502,14 +1876,14 @@ class SimpleClass:
 
         #[pymethods(crate = "crate")]
         impl GetattrFail {
-            fn __getattr__(&self, attr: PyObject) -> PyResult<PyObject> {
+            fn __getattr__(&self, attr: Py<PyAny>) -> PyResult<Py<PyAny>> {
                 Err(PyValueError::new_err(attr))
             }
         }
 
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let obj = Py::new(py, GetattrFail).unwrap();
-            let obj = obj.as_ref(py).as_ref();
+            let obj = obj.bind(py).as_any();
 
             assert!(obj
                 .hasattr("foo")
@@ -2520,95 +1894,95 @@ class SimpleClass:
 
     #[test]
     fn test_nan_eq() {
-        Python::with_gil(|py| {
-            let nan = py.eval("float('nan')", None, None).unwrap();
-            assert!(nan.compare(nan).is_err());
+        Python::attach(|py| {
+            let nan = py.eval(c"float('nan')", None, None).unwrap();
+            assert!(nan.compare(&nan).is_err());
         });
     }
 
     #[test]
     fn test_any_is_instance_of() {
-        Python::with_gil(|py| {
-            let x = 5.to_object(py).into_ref(py);
-            assert!(x.is_instance_of::<PyLong>());
+        Python::attach(|py| {
+            let x = 5i32.into_pyobject(py).unwrap();
+            assert!(x.is_instance_of::<PyInt>());
 
-            let l = vec![x, x].to_object(py).into_ref(py);
+            let l = vec![&x, &x].into_pyobject(py).unwrap();
             assert!(l.is_instance_of::<PyList>());
         });
     }
 
     #[test]
     fn test_any_is_instance() {
-        Python::with_gil(|py| {
-            let l = vec![1u8, 2].to_object(py).into_ref(py);
-            assert!(l.is_instance(py.get_type::<PyList>()).unwrap());
+        Python::attach(|py| {
+            let l = vec![1i8, 2].into_pyobject(py).unwrap();
+            assert!(l.is_instance(&py.get_type::<PyList>()).unwrap());
         });
     }
 
     #[test]
     fn test_any_is_exact_instance_of() {
-        Python::with_gil(|py| {
-            let x = 5.to_object(py).into_ref(py);
-            assert!(x.is_exact_instance_of::<PyLong>());
+        Python::attach(|py| {
+            let x = 5i32.into_pyobject(py).unwrap();
+            assert!(x.is_exact_instance_of::<PyInt>());
 
-            let t = PyBool::new_bound(py, true);
-            assert!(t.is_instance_of::<PyLong>());
-            assert!(!t.is_exact_instance_of::<PyLong>());
+            let t = PyBool::new(py, true);
+            assert!(t.is_instance_of::<PyInt>());
+            assert!(!t.is_exact_instance_of::<PyInt>());
             assert!(t.is_exact_instance_of::<PyBool>());
 
-            let l = vec![x, x].to_object(py).into_ref(py);
+            let l = vec![&x, &x].into_pyobject(py).unwrap();
             assert!(l.is_exact_instance_of::<PyList>());
         });
     }
 
     #[test]
     fn test_any_is_exact_instance() {
-        Python::with_gil(|py| {
-            let t = PyBool::new_bound(py, true);
-            assert!(t
-                .is_instance(&py.get_type::<PyLong>().as_borrowed())
-                .unwrap());
-            assert!(!t.is_exact_instance(&py.get_type::<PyLong>().as_borrowed()));
-            assert!(t.is_exact_instance(&py.get_type::<PyBool>().as_borrowed()));
+        Python::attach(|py| {
+            let t = PyBool::new(py, true);
+            assert!(t.is_instance(&py.get_type::<PyInt>()).unwrap());
+            assert!(!t.is_exact_instance(&py.get_type::<PyInt>()));
+            assert!(t.is_exact_instance(&py.get_type::<PyBool>()));
         });
     }
 
     #[test]
     fn test_any_contains() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let v: Vec<i32> = vec![1, 1, 2, 3, 5, 8];
-            let ob = v.to_object(py).into_ref(py);
+            let ob = v.into_pyobject(py).unwrap();
 
-            let bad_needle = 7i32.to_object(py);
+            let bad_needle = 7i32.into_pyobject(py).unwrap();
             assert!(!ob.contains(&bad_needle).unwrap());
 
-            let good_needle = 8i32.to_object(py);
+            let good_needle = 8i32.into_pyobject(py).unwrap();
             assert!(ob.contains(&good_needle).unwrap());
 
-            let type_coerced_needle = 8f32.to_object(py);
+            let type_coerced_needle = 8f32.into_pyobject(py).unwrap();
             assert!(ob.contains(&type_coerced_needle).unwrap());
 
             let n: u32 = 42;
-            let bad_haystack = n.to_object(py).into_ref(py);
-            let irrelevant_needle = 0i32.to_object(py);
+            let bad_haystack = n.into_pyobject(py).unwrap();
+            let irrelevant_needle = 0i32.into_pyobject(py).unwrap();
             assert!(bad_haystack.contains(&irrelevant_needle).is_err());
         });
     }
 
     // This is intentionally not a test, it's a generic function used by the tests below.
-    fn test_eq_methods_generic<T>(list: &[T])
+    fn test_eq_methods_generic<'a, T>(list: &'a [T])
     where
-        T: PartialEq + PartialOrd + ToPyObject,
+        T: PartialEq + PartialOrd,
+        for<'py> &'a T: IntoPyObject<'py>,
+        for<'py> <&'a T as IntoPyObject<'py>>::Error: Debug,
     {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             for a in list {
                 for b in list {
-                    let a_py = a.to_object(py).into_ref(py);
-                    let b_py = b.to_object(py).into_ref(py);
+                    let a_py = a.into_pyobject(py).unwrap().into_any().into_bound();
+                    let b_py = b.into_pyobject(py).unwrap().into_any().into_bound();
 
                     assert_eq!(
                         a.lt(b),
-                        a_py.lt(b_py).unwrap(),
+                        a_py.lt(&b_py).unwrap(),
                         "{} < {} should be {}.",
                         a_py,
                         b_py,
@@ -2616,7 +1990,7 @@ class SimpleClass:
                     );
                     assert_eq!(
                         a.le(b),
-                        a_py.le(b_py).unwrap(),
+                        a_py.le(&b_py).unwrap(),
                         "{} <= {} should be {}.",
                         a_py,
                         b_py,
@@ -2624,7 +1998,7 @@ class SimpleClass:
                     );
                     assert_eq!(
                         a.eq(b),
-                        a_py.eq(b_py).unwrap(),
+                        a_py.eq(&b_py).unwrap(),
                         "{} == {} should be {}.",
                         a_py,
                         b_py,
@@ -2632,7 +2006,7 @@ class SimpleClass:
                     );
                     assert_eq!(
                         a.ne(b),
-                        a_py.ne(b_py).unwrap(),
+                        a_py.ne(&b_py).unwrap(),
                         "{} != {} should be {}.",
                         a_py,
                         b_py,
@@ -2640,7 +2014,7 @@ class SimpleClass:
                     );
                     assert_eq!(
                         a.gt(b),
-                        a_py.gt(b_py).unwrap(),
+                        a_py.gt(&b_py).unwrap(),
                         "{} > {} should be {}.",
                         a_py,
                         b_py,
@@ -2648,7 +2022,7 @@ class SimpleClass:
                     );
                     assert_eq!(
                         a.ge(b),
-                        a_py.ge(b_py).unwrap(),
+                        a_py.ge(&b_py).unwrap(),
                         "{} >= {} should be {}.",
                         a_py,
                         b_py,
@@ -2662,13 +2036,13 @@ class SimpleClass:
     #[test]
     fn test_eq_methods_integers() {
         let ints = [-4, -4, 1, 2, 0, -100, 1_000_000];
-        test_eq_methods_generic(&ints);
+        test_eq_methods_generic::<i32>(&ints);
     }
 
     #[test]
     fn test_eq_methods_strings() {
         let strings = ["Let's", "test", "some", "eq", "methods"];
-        test_eq_methods_generic(&strings);
+        test_eq_methods_generic::<&str>(&strings);
     }
 
     #[test]
@@ -2683,22 +2057,22 @@ class SimpleClass:
             10.0 / 3.0,
             -1_000_000.0,
         ];
-        test_eq_methods_generic(&floats);
+        test_eq_methods_generic::<f64>(&floats);
     }
 
     #[test]
     fn test_eq_methods_bools() {
         let bools = [true, false];
-        test_eq_methods_generic(&bools);
+        test_eq_methods_generic::<bool>(&bools);
     }
 
     #[test]
     fn test_rich_compare_type_error() {
-        Python::with_gil(|py| {
-            let py_int = 1.to_object(py).into_ref(py);
-            let py_str = "1".to_object(py).into_ref(py);
+        Python::attach(|py| {
+            let py_int = 1i32.into_pyobject(py).unwrap();
+            let py_str = "1".into_pyobject(py).unwrap();
 
-            assert!(py_int.rich_compare(py_str, CompareOp::Lt).is_err());
+            assert!(py_int.rich_compare(&py_str, CompareOp::Lt).is_err());
             assert!(!py_int
                 .rich_compare(py_str, CompareOp::Eq)
                 .unwrap()
@@ -2707,43 +2081,50 @@ class SimpleClass:
         })
     }
 
-    #[test]
-    #[allow(deprecated)]
-    fn test_is_ellipsis() {
-        Python::with_gil(|py| {
-            let v = py
-                .eval("...", None, None)
-                .map_err(|e| e.display(py))
-                .unwrap();
-
-            assert!(v.is_ellipsis());
-
-            let not_ellipsis = 5.to_object(py).into_ref(py);
-            assert!(!not_ellipsis.is_ellipsis());
-        });
-    }
-
     #[test]
     fn test_is_callable() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             assert!(PyList::type_object(py).is_callable());
 
-            let not_callable = 5.to_object(py).into_ref(py);
+            let not_callable = 5i32.into_pyobject(py).unwrap();
             assert!(!not_callable.is_callable());
         });
     }
 
     #[test]
     fn test_is_empty() {
-        Python::with_gil(|py| {
-            let empty_list: &PyAny = PyList::empty(py);
+        Python::attach(|py| {
+            let empty_list = PyList::empty(py).into_any();
             assert!(empty_list.is_empty().unwrap());
 
-            let list: &PyAny = PyList::new(py, vec![1, 2, 3]);
+            let list = PyList::new(py, vec![1, 2, 3]).unwrap().into_any();
             assert!(!list.is_empty().unwrap());
 
-            let not_container = 5.to_object(py).into_ref(py);
+            let not_container = 5i32.into_pyobject(py).unwrap();
             assert!(not_container.is_empty().is_err());
         });
     }
+
+    #[cfg(feature = "macros")]
+    #[test]
+    #[allow(unknown_lints, non_local_definitions)]
+    fn test_fallible_dir() {
+        use crate::exceptions::PyValueError;
+        use crate::prelude::*;
+
+        #[pyclass(crate = "crate")]
+        struct DirFail;
+
+        #[pymethods(crate = "crate")]
+        impl DirFail {
+            fn __dir__(&self) -> PyResult<Py<PyAny>> {
+                Err(PyValueError::new_err("uh-oh!"))
+            }
+        }
+
+        Python::attach(|py| {
+            let obj = Bound::new(py, DirFail).unwrap();
+            assert!(obj.dir().unwrap_err().is_instance_of::<PyValueError>(py));
+        })
+    }
 }
diff --git a/src/types/boolobject.rs b/src/types/boolobject.rs
index c0c4e4ba5c2..c5de574db5b 100644
--- a/src/types/boolobject.rs
+++ b/src/types/boolobject.rs
@@ -1,51 +1,44 @@
+use super::any::PyAnyMethods;
+use crate::conversion::IntoPyObject;
 #[cfg(feature = "experimental-inspect")]
 use crate::inspect::types::TypeInfo;
+#[cfg(feature = "experimental-inspect")]
+use crate::inspect::TypeHint;
+use crate::PyErr;
 use crate::{
-    exceptions::PyTypeError, ffi, ffi_ptr_ext::FfiPtrExt, instance::Bound, Borrowed, FromPyObject,
-    IntoPy, PyAny, PyNativeType, PyObject, PyResult, Python, ToPyObject,
+    exceptions::PyTypeError, ffi, ffi_ptr_ext::FfiPtrExt, instance::Bound,
+    types::typeobject::PyTypeMethods, Borrowed, FromPyObject, PyAny, Python,
 };
-
-use super::any::PyAnyMethods;
+use std::convert::Infallible;
+use std::ptr;
 
 /// Represents a Python `bool`.
+///
+/// Values of this type are accessed via PyO3's smart pointers, e.g. as
+/// [`Py<PyBool>`][crate::Py] or [`Bound<'py, PyBool>`][Bound].
+///
+/// For APIs available on `bool` objects, see the [`PyBoolMethods`] trait which is implemented for
+/// [`Bound<'py, PyBool>`][Bound].
 #[repr(transparent)]
 pub struct PyBool(PyAny);
 
 pyobject_native_type!(PyBool, ffi::PyObject, pyobject_native_static_type_object!(ffi::PyBool_Type), #checkfunction=ffi::PyBool_Check);
 
 impl PyBool {
-    /// Deprecated form of [`PyBool::new_bound`]
-    #[cfg_attr(
-        not(feature = "gil-refs"),
-        deprecated(
-            since = "0.21.0",
-            note = "`PyBool::new` will be replaced by `PyBool::new_bound` in a future PyO3 version"
-        )
-    )]
-    #[inline]
-    pub fn new(py: Python<'_>, val: bool) -> &PyBool {
-        unsafe { py.from_borrowed_ptr(if val { ffi::Py_True() } else { ffi::Py_False() }) }
-    }
-
     /// Depending on `val`, returns `true` or `false`.
     ///
     /// # Note
     /// This returns a [`Borrowed`] reference to one of Pythons `True` or
     /// `False` singletons
     #[inline]
-    pub fn new_bound(py: Python<'_>, val: bool) -> Borrowed<'_, '_, Self> {
+    pub fn new(py: Python<'_>, val: bool) -> Borrowed<'_, '_, Self> {
+        // SAFETY: `Py_True` and `Py_False` are global singletons which are known to be boolean objects
         unsafe {
             if val { ffi::Py_True() } else { ffi::Py_False() }
-                .assume_borrowed(py)
-                .downcast_unchecked()
+                .assume_borrowed_unchecked(py)
+                .cast_unchecked()
         }
     }
-
-    /// Gets whether this boolean is `true`.
-    #[inline]
-    pub fn is_true(&self) -> bool {
-        self.as_borrowed().is_true()
-    }
 }
 
 /// Implementation of functionality for [`PyBool`].
@@ -54,7 +47,7 @@ impl PyBool {
 /// syntax these methods are separated into a trait, because stable Rust does not yet support
 /// `arbitrary_self_types`.
 #[doc(alias = "PyBool")]
-pub trait PyBoolMethods<'py> {
+pub trait PyBoolMethods<'py>: crate::sealed::Sealed {
     /// Gets whether this boolean is `true`.
     fn is_true(&self) -> bool;
 }
@@ -62,31 +55,120 @@ pub trait PyBoolMethods<'py> {
 impl<'py> PyBoolMethods<'py> for Bound<'py, PyBool> {
     #[inline]
     fn is_true(&self) -> bool {
-        self.as_ptr() == unsafe { crate::ffi::Py_True() }
+        unsafe { ptr::eq(self.as_ptr(), ffi::Py_True()) }
     }
 }
 
-/// Converts a Rust `bool` to a Python `bool`.
-impl ToPyObject for bool {
+/// Compare `Bound<PyBool>` with `bool`.
+impl PartialEq<bool> for Bound<'_, PyBool> {
     #[inline]
-    fn to_object(&self, py: Python<'_>) -> PyObject {
-        unsafe {
-            PyObject::from_borrowed_ptr(
-                py,
-                if *self {
-                    ffi::Py_True()
-                } else {
-                    ffi::Py_False()
-                },
-            )
-        }
+    fn eq(&self, other: &bool) -> bool {
+        self.as_borrowed() == *other
+    }
+}
+
+/// Compare `&Bound<PyBool>` with `bool`.
+impl PartialEq<bool> for &'_ Bound<'_, PyBool> {
+    #[inline]
+    fn eq(&self, other: &bool) -> bool {
+        self.as_borrowed() == *other
+    }
+}
+
+/// Compare `Bound<PyBool>` with `&bool`.
+impl PartialEq<&'_ bool> for Bound<'_, PyBool> {
+    #[inline]
+    fn eq(&self, other: &&bool) -> bool {
+        self.as_borrowed() == **other
+    }
+}
+
+/// Compare `bool` with `Bound<PyBool>`
+impl PartialEq<Bound<'_, PyBool>> for bool {
+    #[inline]
+    fn eq(&self, other: &Bound<'_, PyBool>) -> bool {
+        *self == other.as_borrowed()
+    }
+}
+
+/// Compare `bool` with `&Bound<PyBool>`
+impl PartialEq<&'_ Bound<'_, PyBool>> for bool {
+    #[inline]
+    fn eq(&self, other: &&'_ Bound<'_, PyBool>) -> bool {
+        *self == other.as_borrowed()
+    }
+}
+
+/// Compare `&bool` with `Bound<PyBool>`
+impl PartialEq<Bound<'_, PyBool>> for &'_ bool {
+    #[inline]
+    fn eq(&self, other: &Bound<'_, PyBool>) -> bool {
+        **self == other.as_borrowed()
+    }
+}
+
+/// Compare `Borrowed<PyBool>` with `bool`
+impl PartialEq<bool> for Borrowed<'_, '_, PyBool> {
+    #[inline]
+    fn eq(&self, other: &bool) -> bool {
+        self.is_true() == *other
+    }
+}
+
+/// Compare `Borrowed<PyBool>` with `&bool`
+impl PartialEq<&bool> for Borrowed<'_, '_, PyBool> {
+    #[inline]
+    fn eq(&self, other: &&bool) -> bool {
+        self.is_true() == **other
     }
 }
 
-impl IntoPy<PyObject> for bool {
+/// Compare `bool` with `Borrowed<PyBool>`
+impl PartialEq<Borrowed<'_, '_, PyBool>> for bool {
     #[inline]
-    fn into_py(self, py: Python<'_>) -> PyObject {
-        PyBool::new_bound(py, self).into_py(py)
+    fn eq(&self, other: &Borrowed<'_, '_, PyBool>) -> bool {
+        *self == other.is_true()
+    }
+}
+
+/// Compare `&bool` with `Borrowed<PyBool>`
+impl PartialEq<Borrowed<'_, '_, PyBool>> for &'_ bool {
+    #[inline]
+    fn eq(&self, other: &Borrowed<'_, '_, PyBool>) -> bool {
+        **self == other.is_true()
+    }
+}
+
+impl<'py> IntoPyObject<'py> for bool {
+    type Target = PyBool;
+    type Output = Borrowed<'py, 'py, Self::Target>;
+    type Error = Infallible;
+
+    #[cfg(feature = "experimental-inspect")]
+    const OUTPUT_TYPE: TypeHint = TypeHint::builtin("bool");
+
+    #[inline]
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        Ok(PyBool::new(py, self))
+    }
+
+    #[cfg(feature = "experimental-inspect")]
+    fn type_output() -> TypeInfo {
+        TypeInfo::builtin("bool")
+    }
+}
+
+impl<'py> IntoPyObject<'py> for &bool {
+    type Target = PyBool;
+    type Output = Borrowed<'py, 'py, Self::Target>;
+    type Error = Infallible;
+
+    #[cfg(feature = "experimental-inspect")]
+    const OUTPUT_TYPE: TypeHint = bool::OUTPUT_TYPE;
+
+    #[inline]
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        (*self).into_pyobject(py)
     }
 
     #[cfg(feature = "experimental-inspect")]
@@ -98,19 +180,28 @@ impl IntoPy<PyObject> for bool {
 /// Converts a Python `bool` to a Rust `bool`.
 ///
 /// Fails with `TypeError` if the input is not a Python `bool`.
-impl FromPyObject<'_> for bool {
-    fn extract_bound(obj: &Bound<'_, PyAny>) -> PyResult<Self> {
-        let err = match obj.downcast::<PyBool>() {
+impl FromPyObject<'_, '_> for bool {
+    type Error = PyErr;
+
+    #[cfg(feature = "experimental-inspect")]
+    const INPUT_TYPE: TypeHint = TypeHint::builtin("bool");
+
+    fn extract(obj: Borrowed<'_, '_, PyAny>) -> Result<Self, Self::Error> {
+        let err = match obj.cast::<PyBool>() {
             Ok(obj) => return Ok(obj.is_true()),
             Err(err) => err,
         };
 
-        if obj
-            .get_type()
-            .name()
-            .map_or(false, |name| name == "numpy.bool_")
-        {
-            let missing_conversion = |obj: &Bound<'_, PyAny>| {
+        let is_numpy_bool = {
+            let ty = obj.get_type();
+            ty.module().is_ok_and(|module| module == "numpy")
+                && ty
+                    .name()
+                    .is_ok_and(|name| name == "bool_" || name == "bool")
+        };
+
+        if is_numpy_bool {
+            let missing_conversion = |obj: Borrowed<'_, '_, PyAny>| {
                 PyTypeError::new_err(format!(
                     "object of type '{}' does not define a '__bool__' conversion",
                     obj.get_type()
@@ -140,7 +231,7 @@ impl FromPyObject<'_> for bool {
                     .lookup_special(crate::intern!(obj.py(), "__bool__"))?
                     .ok_or_else(|| missing_conversion(obj))?;
 
-                let obj = meth.call0()?.downcast_into::<PyBool>()?;
+                let obj = meth.call0()?.cast_into::<PyBool>()?;
                 return Ok(obj.is_true());
             }
         }
@@ -156,29 +247,89 @@ impl FromPyObject<'_> for bool {
 
 #[cfg(test)]
 mod tests {
-    use crate::types::any::PyAnyMethods;
-    use crate::types::boolobject::PyBoolMethods;
-    use crate::types::PyBool;
+    use crate::types::{PyAnyMethods, PyBool, PyBoolMethods};
+    use crate::IntoPyObject;
     use crate::Python;
-    use crate::ToPyObject;
 
     #[test]
     fn test_true() {
-        Python::with_gil(|py| {
-            assert!(PyBool::new_bound(py, true).is_true());
-            let t = PyBool::new_bound(py, true);
-            assert!(t.as_any().extract::<bool>().unwrap());
-            assert!(true.to_object(py).is(&*PyBool::new_bound(py, true)));
+        Python::attach(|py| {
+            assert!(PyBool::new(py, true).is_true());
+            let t = PyBool::new(py, true);
+            assert!(t.extract::<bool>().unwrap());
+            assert!(true.into_pyobject(py).unwrap().is(&*PyBool::new(py, true)));
         });
     }
 
     #[test]
     fn test_false() {
-        Python::with_gil(|py| {
-            assert!(!PyBool::new_bound(py, false).is_true());
-            let t = PyBool::new_bound(py, false);
-            assert!(!t.as_any().extract::<bool>().unwrap());
-            assert!(false.to_object(py).is(&*PyBool::new_bound(py, false)));
+        Python::attach(|py| {
+            assert!(!PyBool::new(py, false).is_true());
+            let t = PyBool::new(py, false);
+            assert!(!t.extract::<bool>().unwrap());
+            assert!(false
+                .into_pyobject(py)
+                .unwrap()
+                .is(&*PyBool::new(py, false)));
         });
     }
+
+    #[test]
+    fn test_pybool_comparisons() {
+        Python::attach(|py| {
+            let py_bool = PyBool::new(py, true);
+            let py_bool_false = PyBool::new(py, false);
+            let rust_bool = true;
+
+            // Bound<'_, PyBool> == bool
+            assert_eq!(*py_bool, rust_bool);
+            assert_ne!(*py_bool_false, rust_bool);
+
+            // Bound<'_, PyBool> == &bool
+            assert_eq!(*py_bool, &rust_bool);
+            assert_ne!(*py_bool_false, &rust_bool);
+
+            // &Bound<'_, PyBool> == bool
+            assert_eq!(&*py_bool, rust_bool);
+            assert_ne!(&*py_bool_false, rust_bool);
+
+            // &Bound<'_, PyBool> == &bool
+            assert_eq!(&*py_bool, &rust_bool);
+            assert_ne!(&*py_bool_false, &rust_bool);
+
+            // bool == Bound<'_, PyBool>
+            assert_eq!(rust_bool, *py_bool);
+            assert_ne!(rust_bool, *py_bool_false);
+
+            // bool == &Bound<'_, PyBool>
+            assert_eq!(rust_bool, &*py_bool);
+            assert_ne!(rust_bool, &*py_bool_false);
+
+            // &bool == Bound<'_, PyBool>
+            assert_eq!(&rust_bool, *py_bool);
+            assert_ne!(&rust_bool, *py_bool_false);
+
+            // &bool == &Bound<'_, PyBool>
+            assert_eq!(&rust_bool, &*py_bool);
+            assert_ne!(&rust_bool, &*py_bool_false);
+
+            // Borrowed<'_, '_, PyBool> == bool
+            assert_eq!(py_bool, rust_bool);
+            assert_ne!(py_bool_false, rust_bool);
+
+            // Borrowed<'_, '_, PyBool> == &bool
+            assert_eq!(py_bool, &rust_bool);
+            assert_ne!(py_bool_false, &rust_bool);
+
+            // bool == Borrowed<'_, '_, PyBool>
+            assert_eq!(rust_bool, py_bool);
+            assert_ne!(rust_bool, py_bool_false);
+
+            // &bool == Borrowed<'_, '_, PyBool>
+            assert_eq!(&rust_bool, py_bool);
+            assert_ne!(&rust_bool, py_bool_false);
+            assert_eq!(py_bool, rust_bool);
+            assert_ne!(py_bool_false, rust_bool);
+        })
+    }
 }
diff --git a/src/types/bytearray.rs b/src/types/bytearray.rs
index 7f0fdf9ebbe..4ff3e4bbb71 100644
--- a/src/types/bytearray.rs
+++ b/src/types/bytearray.rs
@@ -2,58 +2,36 @@ use crate::err::{PyErr, PyResult};
 use crate::ffi_ptr_ext::FfiPtrExt;
 use crate::instance::{Borrowed, Bound};
 use crate::py_result_ext::PyResultExt;
-use crate::types::any::PyAnyMethods;
-use crate::{ffi, AsPyPointer, PyAny, PyNativeType, Python};
-use std::os::raw::c_char;
+use crate::sync::with_critical_section;
+use crate::{ffi, PyAny, Python};
 use std::slice;
 
 /// Represents a Python `bytearray`.
+///
+/// Values of this type are accessed via PyO3's smart pointers, e.g. as
+/// [`Py<PyByteArray>`][crate::Py] or [`Bound<'py, PyByteArray>`][Bound].
+///
+/// For APIs available on `bytearray` objects, see the [`PyByteArrayMethods`] trait which is implemented for
+/// [`Bound<'py, PyByteArray>`][Bound].
 #[repr(transparent)]
 pub struct PyByteArray(PyAny);
 
 pyobject_native_type_core!(PyByteArray, pyobject_native_static_type_object!(ffi::PyByteArray_Type), #checkfunction=ffi::PyByteArray_Check);
 
 impl PyByteArray {
-    /// Deprecated form of [`PyByteArray::new_bound`]
-    #[cfg_attr(
-        not(feature = "gil-refs"),
-        deprecated(
-            since = "0.21.0",
-            note = "`PyByteArray::new` will be replaced by `PyByteArray::new_bound` in a future PyO3 version"
-        )
-    )]
-    pub fn new<'py>(py: Python<'py>, src: &[u8]) -> &'py PyByteArray {
-        Self::new_bound(py, src).into_gil_ref()
-    }
-
     /// Creates a new Python bytearray object.
     ///
     /// The byte string is initialized by copying the data from the `&[u8]`.
-    pub fn new_bound<'py>(py: Python<'py>, src: &[u8]) -> Bound<'py, PyByteArray> {
-        let ptr = src.as_ptr() as *const c_char;
+    pub fn new<'py>(py: Python<'py>, src: &[u8]) -> Bound<'py, PyByteArray> {
+        let ptr = src.as_ptr().cast();
         let len = src.len() as ffi::Py_ssize_t;
         unsafe {
             ffi::PyByteArray_FromStringAndSize(ptr, len)
                 .assume_owned(py)
-                .downcast_into_unchecked()
+                .cast_into_unchecked()
         }
     }
 
-    /// Deprecated form of [`PyByteArray::new_bound_with`]
-    #[cfg_attr(
-        not(feature = "gil-refs"),
-        deprecated(
-            since = "0.21.0",
-            note = "`PyByteArray::new_with` will be replaced by `PyByteArray::new_bound_with` in a future PyO3 version"
-        )
-    )]
-    pub fn new_with<F>(py: Python<'_>, len: usize, init: F) -> PyResult<&PyByteArray>
-    where
-        F: FnOnce(&mut [u8]) -> PyResult<()>,
-    {
-        Self::new_bound_with(py, len, init).map(Bound::into_gil_ref)
-    }
-
     /// Creates a new Python `bytearray` object with an `init` closure to write its contents.
     /// Before calling `init` the bytearray is zero-initialised.
     /// * If Python raises a MemoryError on the allocation, `new_with` will return
@@ -67,8 +45,8 @@ impl PyByteArray {
     /// use pyo3::{prelude::*, types::PyByteArray};
     ///
     /// # fn main() -> PyResult<()> {
-    /// Python::with_gil(|py| -> PyResult<()> {
-    ///     let py_bytearray = PyByteArray::new_bound_with(py, 10, |bytes: &mut [u8]| {
+    /// Python::attach(|py| -> PyResult<()> {
+    ///     let py_bytearray = PyByteArray::new_with(py, 10, |bytes: &mut [u8]| {
     ///         bytes.copy_from_slice(b"Hello Rust");
     ///         Ok(())
     ///     })?;
@@ -78,11 +56,7 @@ impl PyByteArray {
     /// })
     /// # }
     /// ```
-    pub fn new_bound_with<F>(
-        py: Python<'_>,
-        len: usize,
-        init: F,
-    ) -> PyResult<Bound<'_, PyByteArray>>
+    pub fn new_with<F>(py: Python<'_>, len: usize, init: F) -> PyResult<Bound<'_, PyByteArray>>
     where
         F: FnOnce(&mut [u8]) -> PyResult<()>,
     {
@@ -91,7 +65,7 @@ impl PyByteArray {
             let pybytearray: Bound<'_, Self> =
                 ffi::PyByteArray_FromStringAndSize(std::ptr::null(), len as ffi::Py_ssize_t)
                     .assume_owned_or_err(py)?
-                    .downcast_into_unchecked();
+                    .cast_into_unchecked();
 
             let buffer: *mut u8 = ffi::PyByteArray_AsString(pybytearray.as_ptr()).cast();
             debug_assert!(!buffer.is_null());
@@ -103,191 +77,15 @@ impl PyByteArray {
         }
     }
 
-    /// Deprecated form of [`PyByteArray::from_bound`]
-    #[cfg_attr(
-        not(feature = "gil-refs"),
-        deprecated(
-            since = "0.21.0",
-            note = "`PyByteArray::from` will be replaced by `PyByteArray::from_bound` in a future PyO3 version"
-        )
-    )]
-    pub fn from(src: &PyAny) -> PyResult<&PyByteArray> {
-        unsafe {
-            src.py()
-                .from_owned_ptr_or_err(ffi::PyByteArray_FromObject(src.as_ptr()))
-        }
-    }
-
     /// Creates a new Python `bytearray` object from another Python object that
     /// implements the buffer protocol.
-    pub fn from_bound<'py>(src: &Bound<'py, PyAny>) -> PyResult<Bound<'py, PyByteArray>> {
+    pub fn from<'py>(src: &Bound<'py, PyAny>) -> PyResult<Bound<'py, PyByteArray>> {
         unsafe {
             ffi::PyByteArray_FromObject(src.as_ptr())
                 .assume_owned_or_err(src.py())
-                .downcast_into_unchecked()
+                .cast_into_unchecked()
         }
     }
-
-    /// Gets the length of the bytearray.
-    #[inline]
-    pub fn len(&self) -> usize {
-        self.as_borrowed().len()
-    }
-
-    /// Checks if the bytearray is empty.
-    pub fn is_empty(&self) -> bool {
-        self.as_borrowed().is_empty()
-    }
-
-    /// Gets the start of the buffer containing the contents of the bytearray.
-    ///
-    /// # Safety
-    ///
-    /// See the safety requirements of [`PyByteArray::as_bytes`] and [`PyByteArray::as_bytes_mut`].
-    pub fn data(&self) -> *mut u8 {
-        self.as_borrowed().data()
-    }
-
-    /// Extracts a slice of the `ByteArray`'s entire buffer.
-    ///
-    /// # Safety
-    ///
-    /// Mutation of the `bytearray` invalidates the slice. If it is used afterwards, the behavior is
-    /// undefined.
-    ///
-    /// These mutations may occur in Python code as well as from Rust:
-    /// - Calling methods like [`PyByteArray::as_bytes_mut`] and [`PyByteArray::resize`] will
-    /// invalidate the slice.
-    /// - Actions like dropping objects or raising exceptions can invoke `__del__`methods or signal
-    /// handlers, which may execute arbitrary Python code. This means that if Python code has a
-    /// reference to the `bytearray` you cannot safely use the vast majority of PyO3's API whilst
-    /// using the slice.
-    ///
-    /// As a result, this slice should only be used for short-lived operations without executing any
-    /// Python code, such as copying into a Vec.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// use pyo3::prelude::*;
-    /// use pyo3::exceptions::PyRuntimeError;
-    /// use pyo3::types::PyByteArray;
-    ///
-    /// #[pyfunction]
-    /// fn a_valid_function(bytes: &PyByteArray) -> PyResult<()> {
-    ///     let section = {
-    ///         // SAFETY: We promise to not let the interpreter regain control
-    ///         // or invoke any PyO3 APIs while using the slice.
-    ///         let slice = unsafe { bytes.as_bytes() };
-    ///
-    ///         // Copy only a section of `bytes` while avoiding
-    ///         // `to_vec` which copies the entire thing.
-    ///         let section = slice
-    ///             .get(6..11)
-    ///             .ok_or_else(|| PyRuntimeError::new_err("input is not long enough"))?;
-    ///         Vec::from(section)
-    ///     };
-    ///
-    ///     // Now we can do things with `section` and call PyO3 APIs again.
-    ///     // ...
-    ///     # assert_eq!(&section, b"world");
-    ///
-    ///     Ok(())
-    /// }
-    /// # fn main() -> PyResult<()> {
-    /// #     Python::with_gil(|py| -> PyResult<()> {
-    /// #         let fun = wrap_pyfunction!(a_valid_function, py)?;
-    /// #         let locals = pyo3::types::PyDict::new_bound(py);
-    /// #         locals.set_item("a_valid_function", fun)?;
-    /// #
-    /// #         py.run_bound(
-    /// # r#"b = bytearray(b"hello world")
-    /// # a_valid_function(b)
-    /// #
-    /// # try:
-    /// #     a_valid_function(bytearray())
-    /// # except RuntimeError as e:
-    /// #     assert str(e) == 'input is not long enough'"#,
-    /// #             None,
-    /// #             Some(&locals),
-    /// #         )?;
-    /// #
-    /// #         Ok(())
-    /// #     })
-    /// # }
-    /// ```
-    ///
-    /// # Incorrect usage
-    ///
-    /// The following `bug` function is unsound ⚠️
-    ///
-    /// ```rust,no_run
-    /// # use pyo3::prelude::*;
-    /// # use pyo3::types::PyByteArray;
-    ///
-    /// # #[allow(dead_code)]
-    /// #[pyfunction]
-    /// fn bug(py: Python<'_>, bytes: &PyByteArray) {
-    ///     let slice = unsafe { bytes.as_bytes() };
-    ///
-    ///     // This explicitly yields control back to the Python interpreter...
-    ///     // ...but it's not always this obvious. Many things do this implicitly.
-    ///     py.allow_threads(|| {
-    ///         // Python code could be mutating through its handle to `bytes`,
-    ///         // which makes reading it a data race, which is undefined behavior.
-    ///         println!("{:?}", slice[0]);
-    ///     });
-    ///
-    ///     // Python code might have mutated it, so we can not rely on the slice
-    ///     // remaining valid. As such this is also undefined behavior.
-    ///     println!("{:?}", slice[0]);
-    /// }
-    /// ```
-    pub unsafe fn as_bytes(&self) -> &[u8] {
-        self.as_borrowed().as_bytes()
-    }
-
-    /// Extracts a mutable slice of the `ByteArray`'s entire buffer.
-    ///
-    /// # Safety
-    ///
-    /// Any other accesses of the `bytearray`'s buffer invalidate the slice. If it is used
-    /// afterwards, the behavior is undefined. The safety requirements of [`PyByteArray::as_bytes`]
-    /// apply to this function as well.
-    #[allow(clippy::mut_from_ref)]
-    pub unsafe fn as_bytes_mut(&self) -> &mut [u8] {
-        self.as_borrowed().as_bytes_mut()
-    }
-
-    /// Copies the contents of the bytearray to a Rust vector.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use pyo3::prelude::*;
-    /// # use pyo3::types::PyByteArray;
-    /// # Python::with_gil(|py| {
-    /// let bytearray = PyByteArray::new_bound(py, b"Hello World.");
-    /// let mut copied_message = bytearray.to_vec();
-    /// assert_eq!(b"Hello World.", copied_message.as_slice());
-    ///
-    /// copied_message[11] = b'!';
-    /// assert_eq!(b"Hello World!", copied_message.as_slice());
-    ///
-    /// pyo3::py_run!(py, bytearray, "assert bytearray == b'Hello World.'");
-    /// # });
-    /// ```
-    pub fn to_vec(&self) -> Vec<u8> {
-        self.as_borrowed().to_vec()
-    }
-
-    /// Resizes the bytearray object to the new length `len`.
-    ///
-    /// Note that this will invalidate any pointers obtained by [PyByteArray::data], as well as
-    /// any (unsafe) slices obtained from [PyByteArray::as_bytes] and [PyByteArray::as_bytes_mut].
-    pub fn resize(&self, len: usize) -> PyResult<()> {
-        self.as_borrowed().resize(len)
-    }
 }
 
 /// Implementation of functionality for [`PyByteArray`].
@@ -296,7 +94,7 @@ impl PyByteArray {
 /// syntax these methods are separated into a trait, because stable Rust does not yet support
 /// `arbitrary_self_types`.
 #[doc(alias = "PyByteArray")]
-pub trait PyByteArrayMethods<'py> {
+pub trait PyByteArrayMethods<'py>: crate::sealed::Sealed {
     /// Gets the length of the bytearray.
     fn len(&self) -> usize;
 
@@ -307,7 +105,7 @@ pub trait PyByteArrayMethods<'py> {
     ///
     /// # Safety
     ///
-    /// See the safety requirements of [`PyByteArray::as_bytes`] and [`PyByteArray::as_bytes_mut`].
+    /// See the safety requirements of [`PyByteArrayMethods::as_bytes`] and [`PyByteArrayMethods::as_bytes_mut`].
     fn data(&self) -> *mut u8;
 
     /// Extracts a slice of the `ByteArray`'s entire buffer.
@@ -318,37 +116,38 @@ pub trait PyByteArrayMethods<'py> {
     /// undefined.
     ///
     /// These mutations may occur in Python code as well as from Rust:
-    /// - Calling methods like [`PyByteArray::as_bytes_mut`] and [`PyByteArray::resize`] will
-    /// invalidate the slice.
+    /// - Calling methods like [`PyByteArrayMethods::as_bytes_mut`] and [`PyByteArrayMethods::resize`] will
+    ///   invalidate the slice.
     /// - Actions like dropping objects or raising exceptions can invoke `__del__`methods or signal
-    /// handlers, which may execute arbitrary Python code. This means that if Python code has a
-    /// reference to the `bytearray` you cannot safely use the vast majority of PyO3's API whilst
-    /// using the slice.
+    ///   handlers, which may execute arbitrary Python code. This means that if Python code has a
+    ///   reference to the `bytearray` you cannot safely use the vast majority of PyO3's API whilst
+    ///   using the slice.
     ///
     /// As a result, this slice should only be used for short-lived operations without executing any
     /// Python code, such as copying into a Vec.
+    /// For free-threaded Python support see also [`with_critical_section`].
     ///
     /// # Examples
     ///
     /// ```rust
     /// use pyo3::prelude::*;
     /// use pyo3::exceptions::PyRuntimeError;
+    /// use pyo3::sync::with_critical_section;
     /// use pyo3::types::PyByteArray;
     ///
     /// #[pyfunction]
-    /// fn a_valid_function(bytes: &PyByteArray) -> PyResult<()> {
-    ///     let section = {
-    ///         // SAFETY: We promise to not let the interpreter regain control
+    /// fn a_valid_function(bytes: &Bound<'_, PyByteArray>) -> PyResult<()> {
+    ///     let section = with_critical_section(bytes, || {
+    ///         // SAFETY: We promise to not let the interpreter regain control over the bytearray
     ///         // or invoke any PyO3 APIs while using the slice.
     ///         let slice = unsafe { bytes.as_bytes() };
     ///
     ///         // Copy only a section of `bytes` while avoiding
     ///         // `to_vec` which copies the entire thing.
-    ///         let section = slice
-    ///             .get(6..11)
-    ///             .ok_or_else(|| PyRuntimeError::new_err("input is not long enough"))?;
-    ///         Vec::from(section)
-    ///     };
+    ///         slice.get(6..11)
+    ///             .map(Vec::from)
+    ///             .ok_or_else(|| PyRuntimeError::new_err("input is not long enough"))
+    ///     })?;
     ///
     ///     // Now we can do things with `section` and call PyO3 APIs again.
     ///     // ...
@@ -357,13 +156,12 @@ pub trait PyByteArrayMethods<'py> {
     ///     Ok(())
     /// }
     /// # fn main() -> PyResult<()> {
-    /// #     Python::with_gil(|py| -> PyResult<()> {
+    /// #     Python::attach(|py| -> PyResult<()> {
     /// #         let fun = wrap_pyfunction!(a_valid_function, py)?;
-    /// #         let locals = pyo3::types::PyDict::new_bound(py);
+    /// #         let locals = pyo3::types::PyDict::new(py);
     /// #         locals.set_item("a_valid_function", fun)?;
     /// #
-    /// #         py.run_bound(
-    /// # r#"b = bytearray(b"hello world")
+    /// #         py.run(cr#"b = bytearray(b"hello world")
     /// # a_valid_function(b)
     /// #
     /// # try:
@@ -389,12 +187,15 @@ pub trait PyByteArrayMethods<'py> {
     ///
     /// # #[allow(dead_code)]
     /// #[pyfunction]
-    /// fn bug(py: Python<'_>, bytes: &PyByteArray) {
+    /// fn bug(py: Python<'_>, bytes: &Bound<'_, PyByteArray>) {
+    ///     // No critical section is being used.
+    ///     // This means that for no-gil Python another thread could be modifying the
+    ///     // bytearray concurrently and thus invalidate `slice` any time.
     ///     let slice = unsafe { bytes.as_bytes() };
     ///
     ///     // This explicitly yields control back to the Python interpreter...
     ///     // ...but it's not always this obvious. Many things do this implicitly.
-    ///     py.allow_threads(|| {
+    ///     py.detach(|| {
     ///         // Python code could be mutating through its handle to `bytes`,
     ///         // which makes reading it a data race, which is undefined behavior.
     ///         println!("{:?}", slice[0]);
@@ -412,7 +213,7 @@ pub trait PyByteArrayMethods<'py> {
     /// # Safety
     ///
     /// Any other accesses of the `bytearray`'s buffer invalidate the slice. If it is used
-    /// afterwards, the behavior is undefined. The safety requirements of [`PyByteArray::as_bytes`]
+    /// afterwards, the behavior is undefined. The safety requirements of [`PyByteArrayMethods::as_bytes`]
     /// apply to this function as well.
     #[allow(clippy::mut_from_ref)]
     unsafe fn as_bytes_mut(&self) -> &mut [u8];
@@ -424,8 +225,8 @@ pub trait PyByteArrayMethods<'py> {
     /// ```
     /// # use pyo3::prelude::*;
     /// # use pyo3::types::PyByteArray;
-    /// # Python::with_gil(|py| {
-    /// let bytearray = PyByteArray::new_bound(py, b"Hello World.");
+    /// # Python::attach(|py| {
+    /// let bytearray = PyByteArray::new(py, b"Hello World.");
     /// let mut copied_message = bytearray.to_vec();
     /// assert_eq!(b"Hello World.", copied_message.as_slice());
     ///
@@ -439,8 +240,8 @@ pub trait PyByteArrayMethods<'py> {
 
     /// Resizes the bytearray object to the new length `len`.
     ///
-    /// Note that this will invalidate any pointers obtained by [PyByteArray::data], as well as
-    /// any (unsafe) slices obtained from [PyByteArray::as_bytes] and [PyByteArray::as_bytes_mut].
+    /// Note that this will invalidate any pointers obtained by [PyByteArrayMethods::data], as well as
+    /// any (unsafe) slices obtained from [PyByteArrayMethods::as_bytes] and [PyByteArrayMethods::as_bytes_mut].
     fn resize(&self, len: usize) -> PyResult<()>;
 }
 
@@ -460,16 +261,23 @@ impl<'py> PyByteArrayMethods<'py> for Bound<'py, PyByteArray> {
     }
 
     unsafe fn as_bytes(&self) -> &[u8] {
-        self.as_borrowed().as_bytes()
+        unsafe { self.as_borrowed().as_bytes() }
     }
 
     #[allow(clippy::mut_from_ref)]
     unsafe fn as_bytes_mut(&self) -> &mut [u8] {
-        self.as_borrowed().as_bytes_mut()
+        unsafe { self.as_borrowed().as_bytes_mut() }
     }
 
     fn to_vec(&self) -> Vec<u8> {
-        unsafe { self.as_bytes() }.to_vec()
+        with_critical_section(self, || {
+            // SAFETY:
+            //  * `self` is a `Bound` object, which guarantees that the Python GIL is held.
+            //  * For no-gil Python, a critical section is used in lieu of the GIL.
+            //  * We don't interact with the interpreter
+            //  * We don't mutate the underlying slice
+            unsafe { self.as_bytes() }.to_vec()
+        })
     }
 
     fn resize(&self, len: usize) -> PyResult<()> {
@@ -490,23 +298,13 @@ impl<'a> Borrowed<'a, '_, PyByteArray> {
     }
 
     #[allow(clippy::wrong_self_convention)]
-    unsafe fn as_bytes(self) -> &'a [u8] {
-        slice::from_raw_parts(self.data(), self.len())
+    pub(crate) unsafe fn as_bytes(self) -> &'a [u8] {
+        unsafe { slice::from_raw_parts(self.data(), self.len()) }
     }
 
     #[allow(clippy::wrong_self_convention)]
     unsafe fn as_bytes_mut(self) -> &'a mut [u8] {
-        slice::from_raw_parts_mut(self.data(), self.len())
-    }
-}
-
-impl<'py> TryFrom<&'py PyAny> for &'py PyByteArray {
-    type Error = crate::PyErr;
-
-    /// Creates a new Python `bytearray` object from another Python object that
-    /// implements the buffer protocol.
-    fn try_from(value: &'py PyAny) -> Result<Self, Self::Error> {
-        PyByteArray::from_bound(&value.as_borrowed()).map(Bound::into_gil_ref)
+        unsafe { slice::from_raw_parts_mut(self.data(), self.len()) }
     }
 }
 
@@ -516,33 +314,29 @@ impl<'py> TryFrom<&Bound<'py, PyAny>> for Bound<'py, PyByteArray> {
     /// Creates a new Python `bytearray` object from another Python object that
     /// implements the buffer protocol.
     fn try_from(value: &Bound<'py, PyAny>) -> Result<Self, Self::Error> {
-        PyByteArray::from_bound(value)
+        PyByteArray::from(value)
     }
 }
 
 #[cfg(test)]
 mod tests {
-    use crate::types::any::PyAnyMethods;
-    use crate::types::bytearray::PyByteArrayMethods;
-    use crate::types::string::PyStringMethods;
-    use crate::types::PyByteArray;
-    use crate::{exceptions, Bound, PyAny};
-    use crate::{PyObject, Python};
+    use crate::types::{PyAnyMethods, PyByteArray, PyByteArrayMethods};
+    use crate::{exceptions, Bound, Py, PyAny, Python};
 
     #[test]
     fn test_len() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let src = b"Hello Python";
-            let bytearray = PyByteArray::new_bound(py, src);
+            let bytearray = PyByteArray::new(py, src);
             assert_eq!(src.len(), bytearray.len());
         });
     }
 
     #[test]
     fn test_as_bytes() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let src = b"Hello Python";
-            let bytearray = PyByteArray::new_bound(py, src);
+            let bytearray = PyByteArray::new(py, src);
 
             let slice = unsafe { bytearray.as_bytes() };
             assert_eq!(src, slice);
@@ -552,9 +346,9 @@ mod tests {
 
     #[test]
     fn test_as_bytes_mut() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let src = b"Hello Python";
-            let bytearray = PyByteArray::new_bound(py, src);
+            let bytearray = PyByteArray::new(py, src);
 
             let slice = unsafe { bytearray.as_bytes_mut() };
             assert_eq!(src, slice);
@@ -562,18 +356,15 @@ mod tests {
 
             slice[0..5].copy_from_slice(b"Hi...");
 
-            assert_eq!(
-                bytearray.str().unwrap().to_cow().unwrap(),
-                "bytearray(b'Hi... Python')"
-            );
+            assert_eq!(bytearray.str().unwrap(), "bytearray(b'Hi... Python')");
         });
     }
 
     #[test]
     fn test_to_vec() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let src = b"Hello Python";
-            let bytearray = PyByteArray::new_bound(py, src);
+            let bytearray = PyByteArray::new(py, src);
 
             let vec = bytearray.to_vec();
             assert_eq!(src, vec.as_slice());
@@ -582,12 +373,12 @@ mod tests {
 
     #[test]
     fn test_from() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let src = b"Hello Python";
-            let bytearray = PyByteArray::new_bound(py, src);
+            let bytearray = PyByteArray::new(py, src);
 
-            let ba: PyObject = bytearray.into();
-            let bytearray = PyByteArray::from_bound(ba.bind(py)).unwrap();
+            let ba: Py<PyAny> = bytearray.into();
+            let bytearray = PyByteArray::from(ba.bind(py)).unwrap();
 
             assert_eq!(src, unsafe { bytearray.as_bytes() });
         });
@@ -595,8 +386,8 @@ mod tests {
 
     #[test]
     fn test_from_err() {
-        Python::with_gil(|py| {
-            if let Err(err) = PyByteArray::from_bound(py.None().bind(py)) {
+        Python::attach(|py| {
+            if let Err(err) = PyByteArray::from(py.None().bind(py)) {
                 assert!(err.is_instance_of::<exceptions::PyTypeError>(py));
             } else {
                 panic!("error");
@@ -606,9 +397,9 @@ mod tests {
 
     #[test]
     fn test_try_from() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let src = b"Hello Python";
-            let bytearray: &Bound<'_, PyAny> = &PyByteArray::new_bound(py, src);
+            let bytearray: &Bound<'_, PyAny> = &PyByteArray::new(py, src);
             let bytearray: Bound<'_, PyByteArray> = TryInto::try_into(bytearray).unwrap();
 
             assert_eq!(src, unsafe { bytearray.as_bytes() });
@@ -617,9 +408,9 @@ mod tests {
 
     #[test]
     fn test_resize() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let src = b"Hello Python";
-            let bytearray = PyByteArray::new_bound(py, src);
+            let bytearray = PyByteArray::new(py, src);
 
             bytearray.resize(20).unwrap();
             assert_eq!(20, bytearray.len());
@@ -628,8 +419,8 @@ mod tests {
 
     #[test]
     fn test_byte_array_new_with() -> super::PyResult<()> {
-        Python::with_gil(|py| -> super::PyResult<()> {
-            let py_bytearray = PyByteArray::new_bound_with(py, 10, |b: &mut [u8]| {
+        Python::attach(|py| -> super::PyResult<()> {
+            let py_bytearray = PyByteArray::new_with(py, 10, |b: &mut [u8]| {
                 b.copy_from_slice(b"Hello Rust");
                 Ok(())
             })?;
@@ -641,8 +432,8 @@ mod tests {
 
     #[test]
     fn test_byte_array_new_with_zero_initialised() -> super::PyResult<()> {
-        Python::with_gil(|py| -> super::PyResult<()> {
-            let py_bytearray = PyByteArray::new_bound_with(py, 10, |_b: &mut [u8]| Ok(()))?;
+        Python::attach(|py| -> super::PyResult<()> {
+            let py_bytearray = PyByteArray::new_with(py, 10, |_b: &mut [u8]| Ok(()))?;
             let bytearray: &[u8] = unsafe { py_bytearray.as_bytes() };
             assert_eq!(bytearray, &[0; 10]);
             Ok(())
@@ -652,8 +443,8 @@ mod tests {
     #[test]
     fn test_byte_array_new_with_error() {
         use crate::exceptions::PyValueError;
-        Python::with_gil(|py| {
-            let py_bytearray_result = PyByteArray::new_bound_with(py, 10, |_b: &mut [u8]| {
+        Python::attach(|py| {
+            let py_bytearray_result = PyByteArray::new_with(py, 10, |_b: &mut [u8]| {
                 Err(PyValueError::new_err("Hello Crustaceans!"))
             });
             assert!(py_bytearray_result.is_err());
@@ -663,4 +454,129 @@ mod tests {
                 .is_instance_of::<PyValueError>(py));
         })
     }
+
+    // * wasm has no threading support
+    // * CPython 3.13t is unsound => test fails
+    #[cfg(all(
+        not(target_family = "wasm"),
+        any(Py_3_14, not(all(Py_3_13, Py_GIL_DISABLED)))
+    ))]
+    #[test]
+    fn test_data_integrity_in_critical_section() {
+        use crate::instance::Py;
+        use crate::sync::{with_critical_section, MutexExt};
+
+        use std::sync::atomic::{AtomicBool, Ordering};
+        use std::sync::Mutex;
+        use std::thread;
+        use std::thread::ScopedJoinHandle;
+        use std::time::Duration;
+
+        const SIZE: usize = 1_000_000;
+        const DATA_VALUE: u8 = 42;
+
+        fn make_byte_array(py: Python<'_>, size: usize, value: u8) -> Bound<'_, PyByteArray> {
+            PyByteArray::new_with(py, size, |b| {
+                b.fill(value);
+                Ok(())
+            })
+            .unwrap()
+        }
+
+        let data: Mutex<Py<PyByteArray>> = Mutex::new(Python::attach(|py| {
+            make_byte_array(py, SIZE, DATA_VALUE).unbind()
+        }));
+
+        fn get_data<'py>(
+            data: &Mutex<Py<PyByteArray>>,
+            py: Python<'py>,
+        ) -> Bound<'py, PyByteArray> {
+            data.lock_py_attached(py).unwrap().bind(py).clone()
+        }
+
+        fn set_data(data: &Mutex<Py<PyByteArray>>, new: Bound<'_, PyByteArray>) {
+            let py = new.py();
+            *data.lock_py_attached(py).unwrap() = new.unbind()
+        }
+
+        let running = AtomicBool::new(true);
+        let extending = AtomicBool::new(false);
+
+        // continuously extends and resets the bytearray in data
+        let worker1 = || {
+            let mut rounds = 0;
+            while running.load(Ordering::SeqCst) && rounds < 50 {
+                Python::attach(|py| {
+                    let byte_array = get_data(&data, py);
+                    extending.store(true, Ordering::SeqCst);
+                    byte_array
+                        .call_method("extend", (&byte_array,), None)
+                        .unwrap();
+                    extending.store(false, Ordering::SeqCst);
+                    set_data(&data, make_byte_array(py, SIZE, DATA_VALUE));
+                    rounds += 1;
+                });
+            }
+        };
+
+        // continuously checks the integrity of bytearray in data
+        let worker2 = || {
+            while running.load(Ordering::SeqCst) {
+                if !extending.load(Ordering::SeqCst) {
+                    // wait until we have a chance to read inconsistent state
+                    continue;
+                }
+                Python::attach(|py| {
+                    let read = get_data(&data, py);
+                    if read.len() == SIZE {
+                        // extend is still not done => wait even more
+                        return;
+                    }
+                    with_critical_section(&read, || {
+                        // SAFETY: we are in a critical section
+                        // This is the whole point of the test: make sure that a
+                        // critical section is sufficient to ensure that the data
+                        // read is consistent.
+                        unsafe {
+                            let bytes = read.as_bytes();
+                            assert!(bytes.iter().rev().take(50).all(|v| *v == DATA_VALUE
+                                && bytes.iter().take(50).all(|v| *v == DATA_VALUE)));
+                        }
+                    });
+                });
+            }
+        };
+
+        thread::scope(|s| {
+            let mut handle1 = Some(s.spawn(worker1));
+            let mut handle2 = Some(s.spawn(worker2));
+            let mut handles = [&mut handle1, &mut handle2];
+
+            let t0 = std::time::Instant::now();
+            while t0.elapsed() < Duration::from_secs(1) {
+                for handle in &mut handles {
+                    if handle
+                        .as_ref()
+                        .map(ScopedJoinHandle::is_finished)
+                        .unwrap_or(false)
+                    {
+                        let res = handle.take().unwrap().join();
+                        if res.is_err() {
+                            running.store(false, Ordering::SeqCst);
+                        }
+                        res.unwrap();
+                    }
+                }
+                if handles.iter().any(|handle| handle.is_none()) {
+                    break;
+                }
+            }
+            running.store(false, Ordering::SeqCst);
+            for handle in &mut handles {
+                if let Some(handle) = handle.take() {
+                    handle.join().unwrap()
+                }
+            }
+        });
+    }
 }
diff --git a/src/types/bytes.rs b/src/types/bytes.rs
index 0861af630a5..c6fa1d65329 100644
--- a/src/types/bytes.rs
+++ b/src/types/bytes.rs
@@ -1,62 +1,69 @@
 use crate::ffi_ptr_ext::FfiPtrExt;
 use crate::instance::{Borrowed, Bound};
-use crate::types::any::PyAnyMethods;
-use crate::{ffi, Py, PyAny, PyNativeType, PyResult, Python};
+use crate::{ffi, Py, PyAny, PyResult, Python};
 use std::ops::Index;
-use std::os::raw::c_char;
 use std::slice::SliceIndex;
 use std::str;
 
 /// Represents a Python `bytes` object.
 ///
 /// This type is immutable.
+///
+/// Values of this type are accessed via PyO3's smart pointers, e.g. as
+/// [`Py<PyBytes>`][crate::Py] or [`Bound<'py, PyBytes>`][Bound].
+///
+/// For APIs available on `bytes` objects, see the [`PyBytesMethods`] trait which is implemented for
+/// [`Bound<'py, PyBytes>`][Bound].
+///
+/// # Equality
+///
+/// For convenience, [`Bound<'py, PyBytes>`][Bound] implements [`PartialEq<[u8]>`][PartialEq] to allow comparing the
+/// data in the Python bytes to a Rust `[u8]` byte slice.
+///
+/// This is not always the most appropriate way to compare Python bytes, as Python bytes subclasses
+/// may have different equality semantics. In situations where subclasses overriding equality might
+/// be relevant, use [`PyAnyMethods::eq`](crate::types::any::PyAnyMethods::eq), at cost of the
+/// additional overhead of a Python method call.
+///
+/// ```rust
+/// # use pyo3::prelude::*;
+/// use pyo3::types::PyBytes;
+///
+/// # Python::attach(|py| {
+/// let py_bytes = PyBytes::new(py, b"foo".as_slice());
+/// // via PartialEq<[u8]>
+/// assert_eq!(py_bytes, b"foo".as_slice());
+///
+/// // via Python equality
+/// let other = PyBytes::new(py, b"foo".as_slice());
+/// assert!(py_bytes.as_any().eq(other).unwrap());
+///
+/// // Note that `eq` will convert its argument to Python using `IntoPyObject`.
+/// // Byte collections are specialized, so that the following slice will indeed
+/// // convert into a `bytes` object and not a `list`:
+/// assert!(py_bytes.as_any().eq(b"foo".as_slice()).unwrap());
+/// # });
+/// ```
 #[repr(transparent)]
 pub struct PyBytes(PyAny);
 
 pyobject_native_type_core!(PyBytes, pyobject_native_static_type_object!(ffi::PyBytes_Type), #checkfunction=ffi::PyBytes_Check);
 
 impl PyBytes {
-    /// Deprecated form of [`PyBytes::new_bound`].
-    #[cfg_attr(
-        not(feature = "gil-refs"),
-        deprecated(
-            since = "0.21.0",
-            note = "`PyBytes::new` will be replaced by `PyBytes::new_bound` in a future PyO3 version"
-        )
-    )]
-    pub fn new<'p>(py: Python<'p>, s: &[u8]) -> &'p PyBytes {
-        Self::new_bound(py, s).into_gil_ref()
-    }
-
     /// Creates a new Python bytestring object.
     /// The bytestring is initialized by copying the data from the `&[u8]`.
     ///
     /// Panics if out of memory.
-    pub fn new_bound<'p>(py: Python<'p>, s: &[u8]) -> Bound<'p, PyBytes> {
-        let ptr = s.as_ptr() as *const c_char;
+    pub fn new<'p>(py: Python<'p>, s: &[u8]) -> Bound<'p, PyBytes> {
+        let ptr = s.as_ptr().cast();
         let len = s.len() as ffi::Py_ssize_t;
         unsafe {
             ffi::PyBytes_FromStringAndSize(ptr, len)
                 .assume_owned(py)
-                .downcast_into_unchecked()
+                .cast_into_unchecked()
         }
     }
 
-    /// Deprecated form of [`PyBytes::new_bound_with`].
-    #[cfg_attr(
-        not(feature = "gil-refs"),
-        deprecated(
-            since = "0.21.0",
-            note = "`PyBytes::new_with` will be replaced by `PyBytes::new_bound_with` in a future PyO3 version"
-        )
-    )]
-    pub fn new_with<F>(py: Python<'_>, len: usize, init: F) -> PyResult<&PyBytes>
-    where
-        F: FnOnce(&mut [u8]) -> PyResult<()>,
-    {
-        Self::new_bound_with(py, len, init).map(Bound::into_gil_ref)
-    }
-
     /// Creates a new Python `bytes` object with an `init` closure to write its contents.
     /// Before calling `init` the bytes' contents are zero-initialised.
     /// * If Python raises a MemoryError on the allocation, `new_with` will return
@@ -70,8 +77,8 @@ impl PyBytes {
     /// use pyo3::{prelude::*, types::PyBytes};
     ///
     /// # fn main() -> PyResult<()> {
-    /// Python::with_gil(|py| -> PyResult<()> {
-    ///     let py_bytes = PyBytes::new_bound_with(py, 10, |bytes: &mut [u8]| {
+    /// Python::attach(|py| -> PyResult<()> {
+    ///     let py_bytes = PyBytes::new_with(py, 10, |bytes: &mut [u8]| {
     ///         bytes.copy_from_slice(b"Hello Rust");
     ///         Ok(())
     ///     })?;
@@ -81,14 +88,15 @@ impl PyBytes {
     /// })
     /// # }
     /// ```
-    pub fn new_bound_with<F>(py: Python<'_>, len: usize, init: F) -> PyResult<Bound<'_, PyBytes>>
+    #[inline]
+    pub fn new_with<F>(py: Python<'_>, len: usize, init: F) -> PyResult<Bound<'_, PyBytes>>
     where
         F: FnOnce(&mut [u8]) -> PyResult<()>,
     {
         unsafe {
             let pyptr = ffi::PyBytes_FromStringAndSize(std::ptr::null(), len as ffi::Py_ssize_t);
             // Check for an allocation error and return it
-            let pybytes = pyptr.assume_owned_or_err(py)?.downcast_into_unchecked();
+            let pybytes = pyptr.assume_owned_or_err(py)?.cast_into_unchecked();
             let buffer: *mut u8 = ffi::PyBytes_AsString(pyptr).cast();
             debug_assert!(!buffer.is_null());
             // Zero-initialise the uninitialised bytestring
@@ -99,21 +107,6 @@ impl PyBytes {
         }
     }
 
-    /// Deprecated form of [`PyBytes::bound_from_ptr`].
-    ///
-    /// # Safety
-    /// See [`PyBytes::bound_from_ptr`].
-    #[cfg_attr(
-        not(feature = "gil-refs"),
-        deprecated(
-            since = "0.21.0",
-            note = "`PyBytes::from_ptr` will be replaced by `PyBytes::bound_from_ptr` in a future PyO3 version"
-        )
-    )]
-    pub unsafe fn from_ptr(py: Python<'_>, ptr: *const u8, len: usize) -> &PyBytes {
-        Self::bound_from_ptr(py, ptr, len).into_gil_ref()
-    }
-
     /// Creates a new Python byte string object from a raw pointer and length.
     ///
     /// Panics if out of memory.
@@ -124,16 +117,12 @@ impl PyBytes {
     /// leading pointer of a slice of length `len`. [As with
     /// `std::slice::from_raw_parts`, this is
     /// unsafe](https://doc.rust-lang.org/std/slice/fn.from_raw_parts.html#safety).
-    pub unsafe fn bound_from_ptr(py: Python<'_>, ptr: *const u8, len: usize) -> Bound<'_, PyBytes> {
-        ffi::PyBytes_FromStringAndSize(ptr as *const _, len as isize)
-            .assume_owned(py)
-            .downcast_into_unchecked()
-    }
-
-    /// Gets the Python string as a byte slice.
-    #[inline]
-    pub fn as_bytes(&self) -> &[u8] {
-        self.as_borrowed().as_bytes()
+    pub unsafe fn from_ptr(py: Python<'_>, ptr: *const u8, len: usize) -> Bound<'_, PyBytes> {
+        unsafe {
+            ffi::PyBytes_FromStringAndSize(ptr.cast(), len as isize)
+                .assume_owned(py)
+                .cast_into_unchecked()
+        }
     }
 }
 
@@ -143,7 +132,7 @@ impl PyBytes {
 /// syntax these methods are separated into a trait, because stable Rust does not yet support
 /// `arbitrary_self_types`.
 #[doc(alias = "PyBytes")]
-pub trait PyBytesMethods<'py> {
+pub trait PyBytesMethods<'py>: crate::sealed::Sealed {
     /// Gets the Python string as a byte slice.
     fn as_bytes(&self) -> &[u8];
 }
@@ -158,7 +147,7 @@ impl<'py> PyBytesMethods<'py> for Bound<'py, PyBytes> {
 impl<'a> Borrowed<'a, '_, PyBytes> {
     /// Gets the Python string as a byte slice.
     #[allow(clippy::wrong_self_convention)]
-    fn as_bytes(self) -> &'a [u8] {
+    pub(crate) fn as_bytes(self) -> &'a [u8] {
         unsafe {
             let buffer = ffi::PyBytes_AsString(self.as_ptr()) as *const u8;
             let length = ffi::PyBytes_Size(self.as_ptr()) as usize;
@@ -178,7 +167,7 @@ impl Py<PyBytes> {
 }
 
 /// This is the same way [Vec] is indexed.
-impl<I: SliceIndex<[u8]>> Index<I> for PyBytes {
+impl<I: SliceIndex<[u8]>> Index<I> for Bound<'_, PyBytes> {
     type Output = I::Output;
 
     fn index(&self, index: I) -> &Self::Output {
@@ -186,23 +175,128 @@ impl<I: SliceIndex<[u8]>> Index<I> for PyBytes {
     }
 }
 
-/// This is the same way [Vec] is indexed.
-impl<I: SliceIndex<[u8]>> Index<I> for Bound<'_, PyBytes> {
-    type Output = I::Output;
+/// Compares whether the Python bytes object is equal to the [u8].
+///
+/// In some cases Python equality might be more appropriate; see the note on [`PyBytes`].
+impl PartialEq<[u8]> for Bound<'_, PyBytes> {
+    #[inline]
+    fn eq(&self, other: &[u8]) -> bool {
+        self.as_borrowed() == *other
+    }
+}
 
-    fn index(&self, index: I) -> &Self::Output {
-        &self.as_bytes()[index]
+/// Compares whether the Python bytes object is equal to the [u8].
+///
+/// In some cases Python equality might be more appropriate; see the note on [`PyBytes`].
+impl PartialEq<&'_ [u8]> for Bound<'_, PyBytes> {
+    #[inline]
+    fn eq(&self, other: &&[u8]) -> bool {
+        self.as_borrowed() == **other
+    }
+}
+
+/// Compares whether the Python bytes object is equal to the [u8].
+///
+/// In some cases Python equality might be more appropriate; see the note on [`PyBytes`].
+impl PartialEq<Bound<'_, PyBytes>> for [u8] {
+    #[inline]
+    fn eq(&self, other: &Bound<'_, PyBytes>) -> bool {
+        *self == other.as_borrowed()
+    }
+}
+
+/// Compares whether the Python bytes object is equal to the [u8].
+///
+/// In some cases Python equality might be more appropriate; see the note on [`PyBytes`].
+impl PartialEq<&'_ Bound<'_, PyBytes>> for [u8] {
+    #[inline]
+    fn eq(&self, other: &&Bound<'_, PyBytes>) -> bool {
+        *self == other.as_borrowed()
+    }
+}
+
+/// Compares whether the Python bytes object is equal to the [u8].
+///
+/// In some cases Python equality might be more appropriate; see the note on [`PyBytes`].
+impl PartialEq<Bound<'_, PyBytes>> for &'_ [u8] {
+    #[inline]
+    fn eq(&self, other: &Bound<'_, PyBytes>) -> bool {
+        **self == other.as_borrowed()
+    }
+}
+
+/// Compares whether the Python bytes object is equal to the [u8].
+///
+/// In some cases Python equality might be more appropriate; see the note on [`PyBytes`].
+impl PartialEq<[u8]> for &'_ Bound<'_, PyBytes> {
+    #[inline]
+    fn eq(&self, other: &[u8]) -> bool {
+        self.as_borrowed() == other
+    }
+}
+
+/// Compares whether the Python bytes object is equal to the [u8].
+///
+/// In some cases Python equality might be more appropriate; see the note on [`PyBytes`].
+impl PartialEq<[u8]> for Borrowed<'_, '_, PyBytes> {
+    #[inline]
+    fn eq(&self, other: &[u8]) -> bool {
+        self.as_bytes() == other
+    }
+}
+
+/// Compares whether the Python bytes object is equal to the [u8].
+///
+/// In some cases Python equality might be more appropriate; see the note on [`PyBytes`].
+impl PartialEq<&[u8]> for Borrowed<'_, '_, PyBytes> {
+    #[inline]
+    fn eq(&self, other: &&[u8]) -> bool {
+        *self == **other
+    }
+}
+
+/// Compares whether the Python bytes object is equal to the [u8].
+///
+/// In some cases Python equality might be more appropriate; see the note on [`PyBytes`].
+impl PartialEq<Borrowed<'_, '_, PyBytes>> for [u8] {
+    #[inline]
+    fn eq(&self, other: &Borrowed<'_, '_, PyBytes>) -> bool {
+        other == self
+    }
+}
+
+/// Compares whether the Python bytes object is equal to the [u8].
+///
+/// In some cases Python equality might be more appropriate; see the note on [`PyBytes`].
+impl PartialEq<Borrowed<'_, '_, PyBytes>> for &'_ [u8] {
+    #[inline]
+    fn eq(&self, other: &Borrowed<'_, '_, PyBytes>) -> bool {
+        other == self
+    }
+}
+
+impl<'a> AsRef<[u8]> for Borrowed<'a, '_, PyBytes> {
+    #[inline]
+    fn as_ref(&self) -> &'a [u8] {
+        self.as_bytes()
+    }
+}
+
+impl AsRef<[u8]> for Bound<'_, PyBytes> {
+    #[inline]
+    fn as_ref(&self) -> &[u8] {
+        self.as_bytes()
     }
 }
 
 #[cfg(test)]
-#[cfg_attr(not(feature = "gil-refs"), allow(deprecated))]
 mod tests {
     use super::*;
+    use crate::types::PyAnyMethods as _;
 
     #[test]
     fn test_bytes_index() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let bytes = PyBytes::new(py, b"Hello World");
             assert_eq!(bytes[1], b'e');
         });
@@ -210,8 +304,8 @@ mod tests {
 
     #[test]
     fn test_bound_bytes_index() {
-        Python::with_gil(|py| {
-            let bytes = PyBytes::new_bound(py, b"Hello World");
+        Python::attach(|py| {
+            let bytes = PyBytes::new(py, b"Hello World");
             assert_eq!(bytes[1], b'e');
 
             let bytes = &bytes;
@@ -221,7 +315,7 @@ mod tests {
 
     #[test]
     fn test_bytes_new_with() -> super::PyResult<()> {
-        Python::with_gil(|py| -> super::PyResult<()> {
+        Python::attach(|py| -> super::PyResult<()> {
             let py_bytes = PyBytes::new_with(py, 10, |b: &mut [u8]| {
                 b.copy_from_slice(b"Hello Rust");
                 Ok(())
@@ -234,7 +328,7 @@ mod tests {
 
     #[test]
     fn test_bytes_new_with_zero_initialised() -> super::PyResult<()> {
-        Python::with_gil(|py| -> super::PyResult<()> {
+        Python::attach(|py| -> super::PyResult<()> {
             let py_bytes = PyBytes::new_with(py, 10, |_b: &mut [u8]| Ok(()))?;
             let bytes: &[u8] = py_bytes.extract()?;
             assert_eq!(bytes, &[0; 10]);
@@ -245,7 +339,7 @@ mod tests {
     #[test]
     fn test_bytes_new_with_error() {
         use crate::exceptions::PyValueError;
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let py_bytes_result = PyBytes::new_with(py, 10, |_b: &mut [u8]| {
                 Err(PyValueError::new_err("Hello Crustaceans!"))
             });
@@ -256,4 +350,62 @@ mod tests {
                 .is_instance_of::<PyValueError>(py));
         });
     }
+
+    #[test]
+    fn test_comparisons() {
+        Python::attach(|py| {
+            let b = b"hello, world".as_slice();
+            let py_bytes = PyBytes::new(py, b);
+
+            assert_eq!(py_bytes, b"hello, world".as_slice());
+
+            assert_eq!(py_bytes, b);
+            assert_eq!(&py_bytes, b);
+            assert_eq!(b, py_bytes);
+            assert_eq!(b, &py_bytes);
+
+            assert_eq!(py_bytes, *b);
+            assert_eq!(&py_bytes, *b);
+            assert_eq!(*b, py_bytes);
+            assert_eq!(*b, &py_bytes);
+
+            let py_string = py_bytes.as_borrowed();
+
+            assert_eq!(py_string, b);
+            assert_eq!(&py_string, b);
+            assert_eq!(b, py_string);
+            assert_eq!(b, &py_string);
+
+            assert_eq!(py_string, *b);
+            assert_eq!(*b, py_string);
+        })
+    }
+
+    #[test]
+    #[cfg(not(Py_LIMITED_API))]
+    fn test_as_string() {
+        Python::attach(|py| {
+            let b = b"hello, world".as_slice();
+            let py_bytes = PyBytes::new(py, b);
+            unsafe {
+                assert_eq!(
+                    ffi::PyBytes_AsString(py_bytes.as_ptr()) as *const std::ffi::c_char,
+                    ffi::PyBytes_AS_STRING(py_bytes.as_ptr()) as *const std::ffi::c_char
+                );
+            }
+        })
+    }
+
+    #[test]
+    fn test_as_ref_slice() {
+        Python::attach(|py| {
+            let b = b"hello, world";
+            let py_bytes = PyBytes::new(py, b);
+            let ref_bound: &[u8] = py_bytes.as_ref();
+            assert_eq!(ref_bound, b);
+            let py_bytes_borrowed = py_bytes.as_borrowed();
+            let ref_borrowed: &[u8] = py_bytes_borrowed.as_ref();
+            assert_eq!(ref_borrowed, b);
+        })
+    }
 }
diff --git a/src/types/capsule.rs b/src/types/capsule.rs
index 30e77391171..8f109884c6e 100644
--- a/src/types/capsule.rs
+++ b/src/types/capsule.rs
@@ -1,10 +1,14 @@
+#![deny(clippy::undocumented_unsafe_blocks)]
+
 use crate::ffi_ptr_ext::FfiPtrExt;
 use crate::py_result_ext::PyResultExt;
-use crate::{ffi, PyAny, PyNativeType};
-use crate::{pyobject_native_type_core, PyErr, PyResult};
+use crate::{ffi, PyAny};
 use crate::{Bound, Python};
+use crate::{PyErr, PyResult};
+use std::ffi::{c_char, c_int, c_void};
 use std::ffi::{CStr, CString};
-use std::os::raw::{c_char, c_int, c_void};
+use std::mem::offset_of;
+use std::ptr::{self, NonNull};
 
 /// Represents a Python Capsule
 /// as described in [Capsules](https://docs.python.org/3/c-api/capsule.html#capsules):
@@ -14,27 +18,29 @@ use std::os::raw::{c_char, c_int, c_void};
 /// > in one module available to other modules, so the regular import mechanism can
 /// > be used to access C APIs defined in dynamically loaded modules.
 ///
+/// Values of this type are accessed via PyO3's smart pointers, e.g. as
+/// [`Py<PyCapsule>`][crate::Py] or [`Bound<'py, PyCapsule>`][Bound].
+///
+/// For APIs available on capsule objects, see the [`PyCapsuleMethods`] trait which is implemented for
+/// [`Bound<'py, PyCapsule>`][Bound].
 ///
 /// # Example
 /// ```
-/// use pyo3::{prelude::*, types::PyCapsule};
-/// use std::ffi::CString;
+/// use pyo3::{prelude::*, types::PyCapsule, ffi::c_str};
 ///
 /// #[repr(C)]
 /// struct Foo {
 ///     pub val: u32,
 /// }
 ///
-/// let r = Python::with_gil(|py| -> PyResult<()> {
+/// let r = Python::attach(|py| -> PyResult<()> {
 ///     let foo = Foo { val: 123 };
-///     let name = CString::new("builtins.capsule").unwrap();
-///
-///     let capsule = PyCapsule::new_bound(py, foo, Some(name.clone()))?;
+///     let capsule = PyCapsule::new(py, foo, Some(c"builtins.capsule".to_owned()))?;
 ///
 ///     let module = PyModule::import(py, "builtins")?;
 ///     module.add("capsule", capsule)?;
 ///
-///     let cap: &Foo = unsafe { PyCapsule::import(py, name.as_ref())? };
+///     let cap: &Foo = unsafe { PyCapsule::import(py, c"builtins.capsule")? };
 ///     assert_eq!(cap.val, 123);
 ///     Ok(())
 /// });
@@ -46,22 +52,6 @@ pub struct PyCapsule(PyAny);
 pyobject_native_type_core!(PyCapsule, pyobject_native_static_type_object!(ffi::PyCapsule_Type), #checkfunction=ffi::PyCapsule_CheckExact);
 
 impl PyCapsule {
-    /// Deprecated form of [`PyCapsule::new_bound`].
-    #[cfg_attr(
-        not(feature = "gil-refs"),
-        deprecated(
-            since = "0.21.0",
-            note = "`PyCapsule::new` will be replaced by `PyCapsule::new_bound` in a future PyO3 version"
-        )
-    )]
-    pub fn new<T: 'static + Send + AssertNotZeroSized>(
-        py: Python<'_>,
-        value: T,
-        name: Option<CString>,
-    ) -> PyResult<&Self> {
-        Self::new_bound(py, value, name).map(Bound::into_gil_ref)
-    }
-
     /// Constructs a new capsule whose contents are `value`, associated with `name`.
     /// `name` is the identifier for the capsule; if it is stored as an attribute of a module,
     /// the name should be in the format `"modulename.attribute"`.
@@ -72,14 +62,17 @@ impl PyCapsule {
     /// # Example
     ///
     /// ```
-    /// use pyo3::{prelude::*, types::PyCapsule};
-    /// use std::ffi::CString;
+    /// use pyo3::{prelude::*, types::PyCapsule, ffi::c_str};
+    /// use std::ffi::CStr;
+    /// use std::ptr::NonNull;
+    ///
+    /// // this can be c"foo" on Rust 1.77+
+    /// const NAME: &CStr = c"foo";
     ///
-    /// Python::with_gil(|py| {
-    ///     let name = CString::new("foo").unwrap();
-    ///     let capsule = PyCapsule::new_bound(py, 123_u32, Some(name)).unwrap();
-    ///     let val = unsafe { capsule.reference::<u32>() };
-    ///     assert_eq!(*val, 123);
+    /// Python::attach(|py| {
+    ///     let capsule = PyCapsule::new(py, 123_u32, Some(NAME.to_owned())).unwrap();
+    ///     let val: NonNull<u32> = capsule.pointer_checked(Some(NAME)).unwrap().cast();
+    ///     assert_eq!(unsafe { *val.as_ref() }, 123);
     /// });
     /// ```
     ///
@@ -89,36 +82,16 @@ impl PyCapsule {
     /// use pyo3::{prelude::*, types::PyCapsule};
     /// use std::ffi::CString;
     ///
-    /// Python::with_gil(|py| {
-    ///     let capsule = PyCapsule::new_bound(py, (), None).unwrap();  // Oops! `()` is zero sized!
+    /// Python::attach(|py| {
+    ///     let capsule = PyCapsule::new(py, (), None).unwrap();  // Oops! `()` is zero sized!
     /// });
     /// ```
-    pub fn new_bound<T: 'static + Send + AssertNotZeroSized>(
+    pub fn new<T: 'static + Send + AssertNotZeroSized>(
         py: Python<'_>,
         value: T,
         name: Option<CString>,
     ) -> PyResult<Bound<'_, Self>> {
-        Self::new_bound_with_destructor(py, value, name, |_, _| {})
-    }
-
-    /// Deprecated form of [`PyCapsule::new_bound_with_destructor`].
-    #[cfg_attr(
-        not(feature = "gil-refs"),
-        deprecated(
-            since = "0.21.0",
-            note = "`PyCapsule::new_with_destructor` will be replaced by `PyCapsule::new_bound_with_destructor` in a future PyO3 version"
-        )
-    )]
-    pub fn new_with_destructor<
-        T: 'static + Send + AssertNotZeroSized,
-        F: FnOnce(T, *mut c_void) + Send,
-    >(
-        py: Python<'_>,
-        value: T,
-        name: Option<CString>,
-        destructor: F,
-    ) -> PyResult<&'_ Self> {
-        Self::new_bound_with_destructor(py, value, name, destructor).map(Bound::into_gil_ref)
+        Self::new_with_destructor(py, value, name, |_, _| {})
     }
 
     /// Constructs a new capsule whose contents are `value`, associated with `name`.
@@ -128,7 +101,7 @@ impl PyCapsule {
     ///
     /// The `destructor` must be `Send`, because there is no guarantee which thread it will eventually
     /// be called from.
-    pub fn new_bound_with_destructor<
+    pub fn new_with_destructor<
         T: 'static + Send + AssertNotZeroSized,
         F: FnOnce(T, *mut c_void) + Send,
     >(
@@ -140,23 +113,25 @@ impl PyCapsule {
         AssertNotZeroSized::assert_not_zero_sized(&value);
 
         // Sanity check for capsule layout
-        debug_assert_eq!(memoffset::offset_of!(CapsuleContents::<T, F>, value), 0);
+        debug_assert_eq!(offset_of!(CapsuleContents::<T, F>, value), 0);
 
         let name_ptr = name.as_ref().map_or(std::ptr::null(), |name| name.as_ptr());
-        let val = Box::new(CapsuleContents {
+        let val = Box::into_raw(Box::new(CapsuleContents {
             value,
             destructor,
             name,
-        });
-
+        }));
+
+        // SAFETY:
+        // - `val` is a non-null pointer to valid capsule data
+        // - `name_ptr` is either a valid C string or null
+        // - `destructor` will delete this data when called
+        // - thread is attached to the Python interpreter
+        // - `PyCapsule_New` returns a new reference or null on error
         unsafe {
-            ffi::PyCapsule_New(
-                Box::into_raw(val).cast(),
-                name_ptr,
-                Some(capsule_destructor::<T, F>),
-            )
-            .assume_owned_or_err(py)
-            .downcast_into_unchecked()
+            ffi::PyCapsule_New(val.cast(), name_ptr, Some(capsule_destructor::<T, F>))
+                .assume_owned_or_err(py)
+                .cast_into_unchecked()
         }
     }
 
@@ -169,92 +144,15 @@ impl PyCapsule {
     ///
     /// It must be known that the capsule imported by `name` contains an item of type `T`.
     pub unsafe fn import<'py, T>(py: Python<'py>, name: &CStr) -> PyResult<&'py T> {
-        let ptr = ffi::PyCapsule_Import(name.as_ptr(), false as c_int);
+        // SAFETY: `name` is a valid C string, thread is attached to the Python interpreter
+        let ptr = unsafe { ffi::PyCapsule_Import(name.as_ptr(), false as c_int) };
         if ptr.is_null() {
             Err(PyErr::fetch(py))
         } else {
-            Ok(&*ptr.cast::<T>())
+            // SAFETY: caller has upheld the safety contract
+            Ok(unsafe { &*ptr.cast::<T>() })
         }
     }
-
-    /// Sets the context pointer in the capsule.
-    ///
-    /// Returns an error if this capsule is not valid.
-    ///
-    /// # Notes
-    ///
-    /// The context is treated much like the value of the capsule, but should likely act as
-    /// a place to store any state management when using the capsule.
-    ///
-    /// If you want to store a Rust value as the context, and drop it from the destructor, use
-    /// `Box::into_raw` to convert it into a pointer, see the example.
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// use std::sync::mpsc::{channel, Sender};
-    /// use libc::c_void;
-    /// use pyo3::{prelude::*, types::PyCapsule};
-    ///
-    /// let (tx, rx) = channel::<String>();
-    ///
-    /// fn destructor(val: u32, context: *mut c_void) {
-    ///     let ctx = unsafe { *Box::from_raw(context.cast::<Sender<String>>()) };
-    ///     ctx.send("Destructor called!".to_string()).unwrap();
-    /// }
-    ///
-    /// Python::with_gil(|py| {
-    ///     let capsule =
-    ///         PyCapsule::new_bound_with_destructor(py, 123, None, destructor as fn(u32, *mut c_void))
-    ///             .unwrap();
-    ///     let context = Box::new(tx);  // `Sender<String>` is our context, box it up and ship it!
-    ///     capsule.set_context(Box::into_raw(context).cast()).unwrap();
-    ///     // This scope will end, causing our destructor to be called...
-    /// });
-    ///
-    /// assert_eq!(rx.recv(), Ok("Destructor called!".to_string()));
-    /// ```
-    pub fn set_context(&self, context: *mut c_void) -> PyResult<()> {
-        self.as_borrowed().set_context(context)
-    }
-
-    /// Gets the current context stored in the capsule. If there is no context, the pointer
-    /// will be null.
-    ///
-    /// Returns an error if this capsule is not valid.
-    pub fn context(&self) -> PyResult<*mut c_void> {
-        self.as_borrowed().context()
-    }
-
-    /// Obtains a reference to the value of this capsule.
-    ///
-    /// # Safety
-    ///
-    /// It must be known that this capsule is valid and its pointer is to an item of type `T`.
-    pub unsafe fn reference<T>(&self) -> &T {
-        self.as_borrowed().reference()
-    }
-
-    /// Gets the raw `c_void` pointer to the value in this capsule.
-    ///
-    /// Returns null if this capsule is not valid.
-    pub fn pointer(&self) -> *mut c_void {
-        self.as_borrowed().pointer()
-    }
-
-    /// Checks if this is a valid capsule.
-    ///
-    /// Returns true if the stored `pointer()` is non-null.
-    pub fn is_valid(&self) -> bool {
-        self.as_borrowed().is_valid()
-    }
-
-    /// Retrieves the name of this capsule, if set.
-    ///
-    /// Returns an error if this capsule is not valid.
-    pub fn name(&self) -> PyResult<Option<&CStr>> {
-        self.as_borrowed().name()
-    }
 }
 
 /// Implementation of functionality for [`PyCapsule`].
@@ -262,8 +160,18 @@ impl PyCapsule {
 /// These methods are defined for the `Bound<'py, PyCapsule>` smart pointer, so to use method call
 /// syntax these methods are separated into a trait, because stable Rust does not yet support
 /// `arbitrary_self_types`.
+///
+/// # Name checking
+///
+/// Capsules contain pointers to arbitrary data which is cast to a specific type at runtime. This is
+/// inherently quite dangerous, so Python allows capsules to be "named" to provide a hint as to
+/// what data is contained in the capsule. Although not a perfect solution, this is better than
+/// nothing.
+///
+/// The methods in this trait take the `name` as an `Option<&CStr>`, which is compared to the name
+/// stored in the capsule (with `None` being used to indicate the capsule has no name).
 #[doc(alias = "PyCapsule")]
-pub trait PyCapsuleMethods<'py> {
+pub trait PyCapsuleMethods<'py>: crate::sealed::Sealed {
     /// Sets the context pointer in the capsule.
     ///
     /// Returns an error if this capsule is not valid.
@@ -279,8 +187,8 @@ pub trait PyCapsuleMethods<'py> {
     /// # Example
     ///
     /// ```
+    /// use std::ffi::c_void;
     /// use std::sync::mpsc::{channel, Sender};
-    /// use libc::c_void;
     /// use pyo3::{prelude::*, types::PyCapsule};
     ///
     /// let (tx, rx) = channel::<String>();
@@ -290,9 +198,9 @@ pub trait PyCapsuleMethods<'py> {
     ///     ctx.send("Destructor called!".to_string()).unwrap();
     /// }
     ///
-    /// Python::with_gil(|py| {
+    /// Python::attach(|py| {
     ///     let capsule =
-    ///         PyCapsule::new_bound_with_destructor(py, 123, None, destructor as fn(u32, *mut c_void))
+    ///         PyCapsule::new_with_destructor(py, 123, None, destructor as fn(u32, *mut c_void))
     ///             .unwrap();
     ///     let context = Box::new(tx);  // `Sender<String>` is our context, box it up and ship it!
     ///     capsule.set_context(Box::into_raw(context).cast()).unwrap();
@@ -309,32 +217,69 @@ pub trait PyCapsuleMethods<'py> {
     /// Returns an error if this capsule is not valid.
     fn context(&self) -> PyResult<*mut c_void>;
 
-    /// Obtains a reference to the value of this capsule.
+    /// Obtains a reference dereferenced from the pointer of this capsule, without checking its name.
+    ///
+    /// Because this method encourages dereferencing the pointer for longer than necessary, it
+    /// is deprecated. Prefer to use [`pointer_checked()`][PyCapsuleMethods::pointer_checked]
+    /// and dereference the pointer only for as short a time as possible.
     ///
     /// # Safety
     ///
-    /// It must be known that this capsule is valid and its pointer is to an item of type `T`.
-    unsafe fn reference<T>(&self) -> &'py T;
-
-    /// Gets the raw `c_void` pointer to the value in this capsule.
+    /// This performs a dereference of the pointer returned from [`pointer()`][PyCapsuleMethods::pointer].
     ///
-    /// Returns null if this capsule is not valid.
+    /// See the safety notes on [`pointer_checked()`][PyCapsuleMethods::pointer_checked].
+    #[deprecated(since = "0.27.0", note = "to be removed, see `pointer_checked()`")]
+    unsafe fn reference<T>(&self) -> &T;
+
+    /// Gets the raw pointer stored in this capsule, without checking its name.
+    #[deprecated(since = "0.27.0", note = "use `pointer_checked()` instead")]
     fn pointer(&self) -> *mut c_void;
 
-    /// Checks if this is a valid capsule.
+    /// Gets the raw pointer stored in this capsule.
+    ///
+    /// Returns an error if the capsule is not [valid][`PyCapsuleMethods::is_valid_checked`] with the given `name`.
+    ///
+    /// # Safety
     ///
-    /// Returns true if the stored `pointer()` is non-null.
+    /// This function itself is not `unsafe`, but dereferencing the returned pointer to produce a reference
+    /// is very dangerous:
+    /// - The pointer will need to be [.cast()][NonNull::cast] to a concrete type before dereferencing.
+    ///   As per [name checking](#name-checking), there is no way to statically guarantee this cast is
+    ///   correct, the name is the best available hint to guard against accidental misuse.
+    /// - Arbitrary Python code can change the contents of the capsule, which may invalidate the
+    ///   pointer. The pointer and the reference produced by dereferencing the pointer should both
+    ///   be considered invalid after arbitrary Python code has run.
+    ///
+    /// Users should take care to cast to the correct type and consume the pointer for as little
+    /// duration as possible.
+    fn pointer_checked(&self, name: Option<&CStr>) -> PyResult<NonNull<c_void>>;
+
+    /// Checks if the capsule pointer is not null.
+    ///
+    /// This does not perform any check on the name of the capsule, which is the only mechanism
+    /// that Python provides to make sure that the pointer has the expected type. Prefer to use
+    /// [`is_valid_checked()`][Self::is_valid_checked()] instead.
+    #[deprecated(since = "0.27.0", note = "use `is_valid_checked()` instead")]
     fn is_valid(&self) -> bool;
 
+    /// Checks that the capsule name matches `name` and that the pointer is not null.
+    fn is_valid_checked(&self, name: Option<&CStr>) -> bool;
+
     /// Retrieves the name of this capsule, if set.
     ///
     /// Returns an error if this capsule is not valid.
-    fn name(&self) -> PyResult<Option<&'py CStr>>;
+    ///
+    /// See [`CapsuleName`] for details of how to consume the return value.
+    fn name(&self) -> PyResult<Option<CapsuleName>>;
 }
 
 impl<'py> PyCapsuleMethods<'py> for Bound<'py, PyCapsule> {
     #[allow(clippy::not_unsafe_ptr_arg_deref)]
     fn set_context(&self, context: *mut c_void) -> PyResult<()> {
+        // SAFETY:
+        // - `self.as_ptr()` is a valid object pointer
+        // - `context` is user-provided
+        // - thread is attached to the Python interpreter
         let result = unsafe { ffi::PyCapsule_SetContext(self.as_ptr(), context) };
         if result != 0 {
             Err(PyErr::fetch(self.py()))
@@ -344,6 +289,9 @@ impl<'py> PyCapsuleMethods<'py> for Bound<'py, PyCapsule> {
     }
 
     fn context(&self) -> PyResult<*mut c_void> {
+        // SAFETY:
+        // - `self.as_ptr()` is a valid object pointer
+        // - thread is attached to the Python interpreter
         let ctx = unsafe { ffi::PyCapsule_GetContext(self.as_ptr()) };
         if ctx.is_null() {
             ensure_no_error(self.py())?
@@ -351,11 +299,16 @@ impl<'py> PyCapsuleMethods<'py> for Bound<'py, PyCapsule> {
         Ok(ctx)
     }
 
-    unsafe fn reference<T>(&self) -> &'py T {
-        &*self.pointer().cast()
+    #[allow(deprecated)]
+    unsafe fn reference<T>(&self) -> &T {
+        // SAFETY:
+        // - caller has upheld the safety contract
+        // - thread is attached to the Python interpreter
+        unsafe { &*self.pointer().cast() }
     }
 
     fn pointer(&self) -> *mut c_void {
+        // SAFETY: arguments to `PyCapsule_GetPointer` are valid, errors are handled properly
         unsafe {
             let ptr = ffi::PyCapsule_GetPointer(self.as_ptr(), name_ptr_ignore_error(self));
             if ptr.is_null() {
@@ -365,28 +318,89 @@ impl<'py> PyCapsuleMethods<'py> for Bound<'py, PyCapsule> {
         }
     }
 
+    fn pointer_checked(&self, name: Option<&CStr>) -> PyResult<NonNull<c_void>> {
+        // SAFETY:
+        // - `self.as_ptr()` is a valid object pointer
+        // - `name_ptr` is either a valid C string or null
+        // - thread is attached to the Python interpreter
+        let ptr = unsafe { ffi::PyCapsule_GetPointer(self.as_ptr(), name_ptr(name)) };
+        NonNull::new(ptr).ok_or_else(|| PyErr::fetch(self.py()))
+    }
+
     fn is_valid(&self) -> bool {
-        // As well as if the stored pointer is null, PyCapsule_IsValid also returns false if
+        // SAFETY: As well as if the stored pointer is null, PyCapsule_IsValid also returns false if
         // self.as_ptr() is null or not a ptr to a PyCapsule object. Both of these are guaranteed
         // to not be the case thanks to invariants of this PyCapsule struct.
         let r = unsafe { ffi::PyCapsule_IsValid(self.as_ptr(), name_ptr_ignore_error(self)) };
         r != 0
     }
 
-    fn name(&self) -> PyResult<Option<&'py CStr>> {
-        unsafe {
-            let ptr = ffi::PyCapsule_GetName(self.as_ptr());
-            if ptr.is_null() {
+    fn is_valid_checked(&self, name: Option<&CStr>) -> bool {
+        // SAFETY:
+        // - `self.as_ptr()` is a valid object pointer
+        // - `name_ptr` is either a valid C string or null
+        // - thread is attached to the Python interpreter
+        let r = unsafe { ffi::PyCapsule_IsValid(self.as_ptr(), name_ptr(name)) };
+        r != 0
+    }
+
+    fn name(&self) -> PyResult<Option<CapsuleName>> {
+        // SAFETY:
+        // - `self.as_ptr()` is a valid object pointer
+        // - thread is attached to the Python interpreter
+        let name = unsafe { ffi::PyCapsule_GetName(self.as_ptr()) };
+
+        match NonNull::new(name.cast_mut()) {
+            Some(name) => Ok(Some(CapsuleName { ptr: name })),
+            None => {
                 ensure_no_error(self.py())?;
                 Ok(None)
-            } else {
-                Ok(Some(CStr::from_ptr(ptr)))
             }
         }
     }
 }
 
-// C layout, as PyCapsule::get_reference depends on `T` being first.
+/// The name given to a `capsule` object.
+///
+/// This is a thin wrapper around `*const c_char`, which can be accessed with the [`as_ptr`][Self::as_ptr]
+/// method. The [`as_cstr`][Self::as_cstr] method can be used as a convenience to access the name as a `&CStr`.
+///
+/// There is no guarantee that this capsule name pointer valid for any length of time, as arbitrary
+/// Python code may change the name of a capsule object (by reaching native code which calls
+/// [`PyCapsule_SetName`][ffi::PyCapsule_SetName]). See the safety notes on [`as_cstr`][Self::as_cstr].
+#[derive(Clone, Copy)]
+pub struct CapsuleName {
+    /// Pointer to the name c-string, known to be non-null.
+    ptr: NonNull<c_char>,
+}
+
+impl CapsuleName {
+    /// Returns the capsule name as a `&CStr`.
+    ///
+    /// Note: this method is a thin wrapper around [`CStr::from_ptr`] so (as of Rust 1.91) incurs a
+    /// length calculation on each call.
+    ///
+    /// # Safety
+    ///
+    /// There is no guarantee that the capsule name remains valid for any length of time, as arbitrary
+    /// Python code may change the name of the capsule. The caller should be aware of any conventions
+    /// of the capsule in question related to the lifetime of the name (many capsule names are
+    /// statically allocated, i.e. have the `'static` lifetime, but Python does not require this).
+    ///
+    /// The returned lifetime `'a` is not related to the lifetime of the capsule itself, and the caller is
+    /// responsible for using the `&CStr` for as short a time as possible.
+    pub unsafe fn as_cstr<'a>(self) -> &'a CStr {
+        // SAFETY: caller has upheld the safety contract
+        unsafe { CStr::from_ptr(self.as_ptr()) }
+    }
+
+    /// Returns the raw pointer to the capsule name.
+    pub fn as_ptr(self) -> *const c_char {
+        self.ptr.as_ptr().cast_const()
+    }
+}
+
+// C layout, as casting the capsule pointer to `T` depends on `T` being first.
 #[repr(C)]
 struct CapsuleContents<T: 'static + Send, D: FnOnce(T, *mut c_void) + Send> {
     /// Value of the capsule
@@ -401,12 +415,37 @@ struct CapsuleContents<T: 'static + Send, D: FnOnce(T, *mut c_void) + Send> {
 unsafe extern "C" fn capsule_destructor<T: 'static + Send, F: FnOnce(T, *mut c_void) + Send>(
     capsule: *mut ffi::PyObject,
 ) {
-    let ptr = ffi::PyCapsule_GetPointer(capsule, ffi::PyCapsule_GetName(capsule));
-    let ctx = ffi::PyCapsule_GetContext(capsule);
-    let CapsuleContents {
+    /// Gets the pointer and context from the capsule.
+    ///
+    /// # Safety
+    ///
+    /// - `capsule` must be a valid capsule object
+    unsafe fn get_pointer_ctx(capsule: *mut ffi::PyObject) -> (*mut c_void, *mut c_void) {
+        // SAFETY: `capsule` is known to be a borrowed reference to the capsule being destroyed
+        let name = unsafe { ffi::PyCapsule_GetName(capsule) };
+
+        // SAFETY:
+        // - `capsule` is known to be a borrowed reference to the capsule being destroyed
+        // - `name` is known to be the capsule's name
+        let ptr = unsafe { ffi::PyCapsule_GetPointer(capsule, name) };
+
+        // SAFETY:
+        // - `capsule` is known to be a borrowed reference to the capsule being destroyed
+        let ctx = unsafe { ffi::PyCapsule_GetContext(capsule) };
+
+        (ptr, ctx)
+    }
+
+    // SAFETY: `capsule` is known to be a valid capsule object
+    let (ptr, ctx) = unsafe { get_pointer_ctx(capsule) };
+
+    // SAFETY: `capsule` was knowingly constructed with a boxed `CapsuleContents<T, F>`
+    // and is now being destroyed, so we can move the data from the box.
+    let CapsuleContents::<T, F> {
         value, destructor, ..
-    } = *Box::from_raw(ptr.cast::<CapsuleContents<T, F>>());
-    destructor(value, ctx)
+    } = *unsafe { Box::from_raw(ptr.cast()) };
+
+    destructor(value, ctx);
 }
 
 /// Guarantee `T` is not zero sized at compile time.
@@ -433,25 +472,37 @@ fn ensure_no_error(py: Python<'_>) -> PyResult<()> {
 }
 
 fn name_ptr_ignore_error(slf: &Bound<'_, PyCapsule>) -> *const c_char {
+    // SAFETY:
+    // - `slf` is known to be a valid capsule object
+    // - thread is attached to the Python interpreter
     let ptr = unsafe { ffi::PyCapsule_GetName(slf.as_ptr()) };
     if ptr.is_null() {
+        // SAFETY: thread is attached to the Python interpreter
         unsafe { ffi::PyErr_Clear() };
     }
     ptr
 }
 
+fn name_ptr(name: Option<&CStr>) -> *const c_char {
+    match name {
+        Some(name) => name.as_ptr(),
+        None => ptr::null(),
+    }
+}
+
 #[cfg(test)]
 mod tests {
-    use libc::c_void;
-
     use crate::prelude::PyModule;
     use crate::types::capsule::PyCapsuleMethods;
+    use crate::types::module::PyModuleMethods;
     use crate::{types::PyCapsule, Py, PyResult, Python};
-    use std::ffi::CString;
+    use std::ffi::{c_void, CStr};
     use std::sync::mpsc::{channel, Sender};
 
+    const NAME: &CStr = c"foo";
+
     #[test]
-    fn test_pycapsule_struct() -> PyResult<()> {
+    fn test_pycapsule_struct() {
         #[repr(C)]
         struct Foo {
             pub val: u32,
@@ -463,18 +514,24 @@ mod tests {
             }
         }
 
-        Python::with_gil(|py| -> PyResult<()> {
+        Python::attach(|py| {
             let foo = Foo { val: 123 };
-            let name = CString::new("foo").unwrap();
-
-            let cap = PyCapsule::new_bound(py, foo, Some(name.clone()))?;
-            assert!(cap.is_valid());
 
-            let foo_capi = unsafe { cap.reference::<Foo>() };
-            assert_eq!(foo_capi.val, 123);
-            assert_eq!(foo_capi.get_val(), 123);
-            assert_eq!(cap.name().unwrap(), Some(name.as_ref()));
-            Ok(())
+            let cap = PyCapsule::new(py, foo, Some(NAME.to_owned())).unwrap();
+            assert!(cap.is_valid_checked(Some(NAME)));
+
+            let foo_capi = cap.pointer_checked(Some(NAME)).unwrap().cast::<Foo>();
+            // SAFETY: `foo_capi` contains a `Foo` and will be valid for the duration of the assert
+            assert_eq!(unsafe { foo_capi.as_ref() }.val, 123);
+            // SAFETY: as above
+            assert_eq!(unsafe { foo_capi.as_ref() }.get_val(), 123);
+            assert_eq!(
+                // SAFETY: `cap.name()` has a non-null name
+                unsafe { CStr::from_ptr(cap.name().unwrap().unwrap().as_ptr()) },
+                NAME
+            );
+            // SAFETY: as above
+            assert_eq!(unsafe { cap.name().unwrap().unwrap().as_cstr() }, NAME)
         })
     }
 
@@ -484,79 +541,84 @@ mod tests {
             x
         }
 
-        let cap: Py<PyCapsule> = Python::with_gil(|py| {
-            let name = CString::new("foo").unwrap();
-            let cap = PyCapsule::new_bound(py, foo as fn(u32) -> u32, Some(name)).unwrap();
+        let cap: Py<PyCapsule> = Python::attach(|py| {
+            let cap = PyCapsule::new(py, foo as fn(u32) -> u32, Some(NAME.to_owned())).unwrap();
             cap.into()
         });
 
-        Python::with_gil(|py| {
-            let f = unsafe { cap.as_ref(py).reference::<fn(u32) -> u32>() };
-            assert_eq!(f(123), 123);
+        Python::attach(move |py| {
+            let f = cap
+                .bind(py)
+                .pointer_checked(Some(NAME))
+                .unwrap()
+                .cast::<fn(u32) -> u32>();
+            // SAFETY: `f` contains a `fn(u32) -> u32` and will be valid for the duration of the assert
+            assert_eq!(unsafe { f.as_ref() }(123), 123);
         });
     }
 
     #[test]
-    fn test_pycapsule_context() -> PyResult<()> {
-        Python::with_gil(|py| {
-            let name = CString::new("foo").unwrap();
-            let cap = PyCapsule::new_bound(py, 0, Some(name))?;
+    fn test_pycapsule_context() {
+        Python::attach(|py| {
+            let cap = PyCapsule::new(py, 0, Some(NAME.to_owned())).unwrap();
 
-            let c = cap.context()?;
+            let c = cap.context().unwrap();
             assert!(c.is_null());
 
             let ctx = Box::new(123_u32);
-            cap.set_context(Box::into_raw(ctx).cast())?;
+            cap.set_context(Box::into_raw(ctx).cast()).unwrap();
 
-            let ctx_ptr: *mut c_void = cap.context()?;
+            let ctx_ptr: *mut c_void = cap.context().unwrap();
+            // SAFETY: `ctx_ptr` contains a boxed `u32` which is being moved out of the capsule
             let ctx = unsafe { *Box::from_raw(ctx_ptr.cast::<u32>()) };
             assert_eq!(ctx, 123);
-            Ok(())
         })
     }
 
     #[test]
-    fn test_pycapsule_import() -> PyResult<()> {
+    fn test_pycapsule_import() {
         #[repr(C)]
         struct Foo {
             pub val: u32,
         }
 
-        Python::with_gil(|py| -> PyResult<()> {
+        Python::attach(|py| {
             let foo = Foo { val: 123 };
-            let name = CString::new("builtins.capsule").unwrap();
+            let name = c"builtins.capsule";
 
-            let capsule = PyCapsule::new_bound(py, foo, Some(name.clone()))?;
+            let capsule = PyCapsule::new(py, foo, Some(name.to_owned())).unwrap();
 
-            let module = PyModule::import(py, "builtins")?;
-            module.add("capsule", capsule)?;
+            let module = PyModule::import(py, "builtins").unwrap();
+            module.add("capsule", capsule).unwrap();
 
             // check error when wrong named passed for capsule.
-            let wrong_name = CString::new("builtins.non_existant").unwrap();
-            let result: PyResult<&Foo> = unsafe { PyCapsule::import(py, wrong_name.as_ref()) };
+            // SAFETY: this function will fail so the cast is never done
+            let result: PyResult<&Foo> = unsafe { PyCapsule::import(py, c"builtins.non_existant") };
             assert!(result.is_err());
 
-            // corret name is okay.
-            let cap: &Foo = unsafe { PyCapsule::import(py, name.as_ref())? };
+            // correct name is okay.
+            // SAFETY: we know the capsule at `name` contains a `Foo`
+            let cap: &Foo = unsafe { PyCapsule::import(py, name) }.unwrap();
             assert_eq!(cap.val, 123);
-            Ok(())
         })
     }
 
     #[test]
     fn test_vec_storage() {
-        let cap: Py<PyCapsule> = Python::with_gil(|py| {
-            let name = CString::new("foo").unwrap();
-
+        let cap: Py<PyCapsule> = Python::attach(|py| {
             let stuff: Vec<u8> = vec![1, 2, 3, 4];
-            let cap = PyCapsule::new_bound(py, stuff, Some(name)).unwrap();
-
+            let cap = PyCapsule::new(py, stuff, Some(NAME.to_owned())).unwrap();
             cap.into()
         });
 
-        Python::with_gil(|py| {
-            let ctx: &Vec<u8> = unsafe { cap.as_ref(py).reference() };
-            assert_eq!(ctx, &[1, 2, 3, 4]);
+        Python::attach(move |py| {
+            let stuff = cap
+                .bind(py)
+                .pointer_checked(Some(NAME))
+                .unwrap()
+                .cast::<Vec<u8>>();
+            // SAFETY: `stuff` contains a `Vec<u8>` and will be valid for the duration of the assert
+            assert_eq!(unsafe { stuff.as_ref() }, &[1, 2, 3, 4]);
         })
     }
 
@@ -564,17 +626,17 @@ mod tests {
     fn test_vec_context() {
         let context: Vec<u8> = vec![1, 2, 3, 4];
 
-        let cap: Py<PyCapsule> = Python::with_gil(|py| {
-            let name = CString::new("foo").unwrap();
-            let cap = PyCapsule::new_bound(py, 0, Some(name)).unwrap();
+        let cap: Py<PyCapsule> = Python::attach(|py| {
+            let cap = PyCapsule::new(py, 0, Some(NAME.to_owned())).unwrap();
             cap.set_context(Box::into_raw(Box::new(&context)).cast())
                 .unwrap();
 
             cap.into()
         });
 
-        Python::with_gil(|py| {
-            let ctx_ptr: *mut c_void = cap.as_ref(py).context().unwrap();
+        Python::attach(move |py| {
+            let ctx_ptr: *mut c_void = cap.bind(py).context().unwrap();
+            // SAFETY: `ctx_ptr` contains a boxed `&Vec<u8>` which is being moved out of the capsule
             let ctx = unsafe { *Box::from_raw(ctx_ptr.cast::<&Vec<u8>>()) };
             assert_eq!(ctx, &vec![1_u8, 2, 3, 4]);
         })
@@ -586,13 +648,14 @@ mod tests {
 
         fn destructor(_val: u32, ctx: *mut c_void) {
             assert!(!ctx.is_null());
+            // SAFETY: `ctx` is known to be a boxed `Sender<bool>` needing deletion
             let context = unsafe { *Box::from_raw(ctx.cast::<Sender<bool>>()) };
             context.send(true).unwrap();
         }
 
-        Python::with_gil(|py| {
-            let name = CString::new("foo").unwrap();
-            let cap = PyCapsule::new_bound_with_destructor(py, 0, Some(name), destructor).unwrap();
+        Python::attach(move |py| {
+            let cap =
+                PyCapsule::new_with_destructor(py, 0, Some(NAME.to_owned()), destructor).unwrap();
             cap.set_context(Box::into_raw(Box::new(tx)).cast()).unwrap();
         });
 
@@ -602,11 +665,15 @@ mod tests {
 
     #[test]
     fn test_pycapsule_no_name() {
-        Python::with_gil(|py| {
-            let cap = PyCapsule::new_bound(py, 0usize, None).unwrap();
-
-            assert_eq!(unsafe { cap.reference::<usize>() }, &0usize);
-            assert_eq!(cap.name().unwrap(), None);
+        Python::attach(|py| {
+            let cap = PyCapsule::new(py, 0usize, None).unwrap();
+
+            assert_eq!(
+                // SAFETY: `cap` is known to contain a `usize`
+                unsafe { cap.pointer_checked(None).unwrap().cast::<usize>().as_ref() },
+                &0usize
+            );
+            assert!(cap.name().unwrap().is_none());
             assert_eq!(cap.context().unwrap(), std::ptr::null_mut());
         });
     }
diff --git a/src/types/code.rs b/src/types/code.rs
index 8956deb1a71..1a2068e6ab7 100644
--- a/src/types/code.rs
+++ b/src/types/code.rs
@@ -1,12 +1,148 @@
-use crate::ffi;
-use crate::PyAny;
+use super::PyAnyMethods as _;
+use super::PyDict;
+use crate::ffi_ptr_ext::FfiPtrExt;
+use crate::py_result_ext::PyResultExt;
+#[cfg(any(Py_LIMITED_API, PyPy))]
+use crate::sync::PyOnceLock;
+#[cfg(any(Py_LIMITED_API, PyPy))]
+use crate::types::{PyType, PyTypeMethods};
+#[cfg(any(Py_LIMITED_API, PyPy))]
+use crate::Py;
+use crate::{ffi, Bound, PyAny, PyErr, PyResult, Python};
+use std::ffi::CStr;
 
 /// Represents a Python code object.
+///
+/// Values of this type are accessed via PyO3's smart pointers, e.g. as
+/// [`Py<PyCode>`][crate::Py] or [`Bound<'py, PyCode>`][crate::Bound].
 #[repr(transparent)]
 pub struct PyCode(PyAny);
 
+#[cfg(not(any(Py_LIMITED_API, PyPy)))]
 pyobject_native_type_core!(
     PyCode,
     pyobject_native_static_type_object!(ffi::PyCode_Type),
     #checkfunction=ffi::PyCode_Check
 );
+
+#[cfg(any(Py_LIMITED_API, PyPy))]
+pyobject_native_type_core!(PyCode, |py| {
+    static TYPE: PyOnceLock<Py<PyType>> = PyOnceLock::new();
+    TYPE.import(py, "types", "CodeType").unwrap().as_type_ptr()
+});
+
+/// Compilation mode of [`PyCode::compile`]
+pub enum PyCodeInput {
+    /// Python grammar for isolated expressions
+    Eval,
+    /// Python grammar for sequences of statements as read from a file
+    File,
+}
+
+impl PyCode {
+    /// Compiles code in the given context.
+    ///
+    /// `input` decides whether `code` is treated as
+    /// - [`PyCodeInput::Eval`]: an isolated expression
+    /// - [`PyCodeInput::File`]: a sequence of statements
+    pub fn compile<'py>(
+        py: Python<'py>,
+        code: &CStr,
+        filename: &CStr,
+        input: PyCodeInput,
+    ) -> PyResult<Bound<'py, PyCode>> {
+        let start = match input {
+            PyCodeInput::Eval => ffi::Py_eval_input,
+            PyCodeInput::File => ffi::Py_file_input,
+        };
+        unsafe {
+            ffi::Py_CompileString(code.as_ptr(), filename.as_ptr(), start)
+                .assume_owned_or_err(py)
+                .cast_into_unchecked()
+        }
+    }
+}
+
+/// Implementation of functionality for [`PyCode`].
+///
+/// These methods are defined for the `Bound<'py, PyCode>` smart pointer, so to use method call
+/// syntax these methods are separated into a trait, because stable Rust does not yet support
+/// `arbitrary_self_types`.
+pub trait PyCodeMethods<'py> {
+    /// Runs code object.
+    ///
+    /// If `globals` is `None`, it defaults to Python module `__main__`.
+    /// If `locals` is `None`, it defaults to the value of `globals`.
+    fn run(
+        &self,
+        globals: Option<&Bound<'py, PyDict>>,
+        locals: Option<&Bound<'py, PyDict>>,
+    ) -> PyResult<Bound<'py, PyAny>>;
+}
+
+impl<'py> PyCodeMethods<'py> for Bound<'py, PyCode> {
+    fn run(
+        &self,
+        globals: Option<&Bound<'py, PyDict>>,
+        locals: Option<&Bound<'py, PyDict>>,
+    ) -> PyResult<Bound<'py, PyAny>> {
+        let mptr = unsafe {
+            ffi::compat::PyImport_AddModuleRef(c"__main__".as_ptr())
+                .assume_owned_or_err(self.py())?
+        };
+        let attr = mptr.getattr(crate::intern!(self.py(), "__dict__"))?;
+        let globals = match globals {
+            Some(globals) => globals,
+            None => attr.cast::<PyDict>()?,
+        };
+        let locals = locals.unwrap_or(globals);
+
+        // If `globals` don't provide `__builtins__`, most of the code will fail if Python
+        // version is <3.10. That's probably not what user intended, so insert `__builtins__`
+        // for them.
+        //
+        // See also:
+        // - https://github.com/python/cpython/pull/24564 (the same fix in CPython 3.10)
+        // - https://github.com/PyO3/pyo3/issues/3370
+        let builtins_s = crate::intern!(self.py(), "__builtins__");
+        let has_builtins = globals.contains(builtins_s)?;
+        if !has_builtins {
+            crate::sync::with_critical_section(globals, || {
+                // check if another thread set __builtins__ while this thread was blocked on the critical section
+                let has_builtins = globals.contains(builtins_s)?;
+                if !has_builtins {
+                    // Inherit current builtins.
+                    let builtins = unsafe { ffi::PyEval_GetBuiltins() };
+
+                    // `PyDict_SetItem` doesn't take ownership of `builtins`, but `PyEval_GetBuiltins`
+                    // seems to return a borrowed reference, so no leak here.
+                    if unsafe {
+                        ffi::PyDict_SetItem(globals.as_ptr(), builtins_s.as_ptr(), builtins)
+                    } == -1
+                    {
+                        return Err(PyErr::fetch(self.py()));
+                    }
+                }
+                Ok(())
+            })?;
+        }
+
+        unsafe {
+            ffi::PyEval_EvalCode(self.as_ptr(), globals.as_ptr(), locals.as_ptr())
+                .assume_owned_or_err(self.py())
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn test_type_object() {
+        use crate::types::PyTypeMethods;
+        use crate::{PyTypeInfo, Python};
+
+        Python::attach(|py| {
+            assert_eq!(super::PyCode::type_object(py).name().unwrap(), "code");
+        })
+    }
+}
diff --git a/src/types/complex.rs b/src/types/complex.rs
index dafda97dbd5..7f9ac4e6191 100644
--- a/src/types/complex.rs
+++ b/src/types/complex.rs
@@ -1,8 +1,18 @@
-use crate::{ffi, types::any::PyAnyMethods, Bound, PyAny, PyNativeType, Python};
-use std::os::raw::c_double;
+#[cfg(not(any(Py_LIMITED_API, PyPy, GraalPy)))]
+use crate::py_result_ext::PyResultExt;
+#[cfg(not(any(Py_LIMITED_API, PyPy, GraalPy)))]
+use crate::types::any::PyAnyMethods;
+use crate::{ffi, Bound, PyAny, Python};
+use std::ffi::c_double;
 
 /// Represents a Python [`complex`](https://docs.python.org/3/library/functions.html#complex) object.
 ///
+/// Values of this type are accessed via PyO3's smart pointers, e.g. as
+/// [`Py<PyComplex>`][crate::Py] or [`Bound<'py, PyComplex>`][Bound].
+///
+/// For APIs available on `complex` objects, see the [`PyComplexMethods`] trait which is implemented for
+/// [`Bound<'py, PyComplex>`][Bound].
+///
 /// Note that `PyComplex` supports only basic operations. For advanced operations
 /// consider using [num-complex](https://docs.rs/num-complex)'s [`Complex`] type instead.
 /// This optional dependency can be activated with the `num-complex` feature flag.
@@ -11,6 +21,8 @@ use std::os::raw::c_double;
 #[repr(transparent)]
 pub struct PyComplex(PyAny);
 
+pyobject_subclassable_native_type!(PyComplex, ffi::PyComplexObject);
+
 pyobject_native_type!(
     PyComplex,
     ffi::PyComplexObject,
@@ -19,87 +31,35 @@ pyobject_native_type!(
 );
 
 impl PyComplex {
-    /// Deprecated form of [`PyComplex::from_doubles_bound`]
-    #[cfg_attr(
-        not(feature = "gil-refs"),
-        deprecated(
-            since = "0.21.0",
-            note = "`PyComplex::from_doubles` will be replaced by `PyComplex::from_doubles_bound` in a future PyO3 version"
-        )
-    )]
-    pub fn from_doubles(py: Python<'_>, real: c_double, imag: c_double) -> &PyComplex {
-        Self::from_doubles_bound(py, real, imag).into_gil_ref()
-    }
     /// Creates a new `PyComplex` from the given real and imaginary values.
-    pub fn from_doubles_bound(
-        py: Python<'_>,
-        real: c_double,
-        imag: c_double,
-    ) -> Bound<'_, PyComplex> {
+    pub fn from_doubles(py: Python<'_>, real: c_double, imag: c_double) -> Bound<'_, PyComplex> {
         use crate::ffi_ptr_ext::FfiPtrExt;
         unsafe {
             ffi::PyComplex_FromDoubles(real, imag)
                 .assume_owned(py)
-                .downcast_into_unchecked()
+                .cast_into_unchecked()
         }
     }
-    /// Returns the real part of the complex number.
-    pub fn real(&self) -> c_double {
-        self.as_borrowed().real()
-    }
-    /// Returns the imaginary part of the complex number.
-    pub fn imag(&self) -> c_double {
-        self.as_borrowed().imag()
-    }
 }
 
-#[cfg(not(any(Py_LIMITED_API, PyPy)))]
+#[cfg(not(any(Py_LIMITED_API, PyPy, GraalPy)))]
 mod not_limited_impls {
-    use crate::ffi_ptr_ext::FfiPtrExt;
     use crate::Borrowed;
 
     use super::*;
     use std::ops::{Add, Div, Mul, Neg, Sub};
 
-    impl PyComplex {
-        /// Returns `|self|`.
-        pub fn abs(&self) -> c_double {
-            self.as_borrowed().abs()
-        }
-        /// Returns `self` raised to the power of `other`.
-        pub fn pow<'py>(&'py self, other: &'py PyComplex) -> &'py PyComplex {
-            self.as_borrowed().pow(&other.as_borrowed()).into_gil_ref()
-        }
-    }
-
-    #[inline(always)]
-    pub(super) unsafe fn complex_operation<'py>(
-        l: Borrowed<'_, 'py, PyComplex>,
-        r: Borrowed<'_, 'py, PyComplex>,
-        operation: unsafe extern "C" fn(ffi::Py_complex, ffi::Py_complex) -> ffi::Py_complex,
-    ) -> *mut ffi::PyObject {
-        let l_val = (*l.as_ptr().cast::<ffi::PyComplexObject>()).cval;
-        let r_val = (*r.as_ptr().cast::<ffi::PyComplexObject>()).cval;
-        ffi::PyComplex_FromCComplex(operation(l_val, r_val))
-    }
-
     macro_rules! bin_ops {
-        ($trait:ident, $fn:ident, $op:tt, $ffi:path) => {
+        ($trait:ident, $fn:ident, $op:tt) => {
             impl<'py> $trait for Borrowed<'_, 'py, PyComplex> {
                 type Output = Bound<'py, PyComplex>;
                 fn $fn(self, other: Self) -> Self::Output {
-                    unsafe {
-                        complex_operation(self, other, $ffi)
-                            .assume_owned(self.py())
-                            .downcast_into_unchecked()
-                    }
-                }
-            }
-
-            impl<'py> $trait for &'py PyComplex {
-                type Output = &'py PyComplex;
-                fn $fn(self, other: &'py PyComplex) -> &'py PyComplex {
-                    (self.as_borrowed() $op other.as_borrowed()).into_gil_ref()
+                    PyAnyMethods::$fn(self.as_any(), other)
+                    .cast_into().expect(
+                        concat!("Complex method ",
+                            stringify!($fn),
+                            " failed.")
+                        )
                 }
             }
 
@@ -133,31 +93,17 @@ mod not_limited_impls {
         };
     }
 
-    bin_ops!(Add, add, +, ffi::_Py_c_sum);
-    bin_ops!(Sub, sub, -, ffi::_Py_c_diff);
-    bin_ops!(Mul, mul, *, ffi::_Py_c_prod);
-    bin_ops!(Div, div, /, ffi::_Py_c_quot);
-
-    impl<'py> Neg for &'py PyComplex {
-        type Output = &'py PyComplex;
-        fn neg(self) -> &'py PyComplex {
-            unsafe {
-                let val = (*self.as_ptr().cast::<ffi::PyComplexObject>()).cval;
-                self.py()
-                    .from_owned_ptr(ffi::PyComplex_FromCComplex(ffi::_Py_c_neg(val)))
-            }
-        }
-    }
+    bin_ops!(Add, add, +);
+    bin_ops!(Sub, sub, -);
+    bin_ops!(Mul, mul, *);
+    bin_ops!(Div, div, /);
 
     impl<'py> Neg for Borrowed<'_, 'py, PyComplex> {
         type Output = Bound<'py, PyComplex>;
         fn neg(self) -> Self::Output {
-            unsafe {
-                let val = (*self.as_ptr().cast::<ffi::PyComplexObject>()).cval;
-                ffi::PyComplex_FromCComplex(ffi::_Py_c_neg(val))
-                    .assume_owned(self.py())
-                    .downcast_into_unchecked()
-            }
+            PyAnyMethods::neg(self.as_any())
+                .cast_into()
+                .expect("Complex method __neg__ failed.")
         }
     }
 
@@ -183,9 +129,9 @@ mod not_limited_impls {
 
         #[test]
         fn test_add() {
-            Python::with_gil(|py| {
-                let l = PyComplex::from_doubles_bound(py, 3.0, 1.2);
-                let r = PyComplex::from_doubles_bound(py, 1.0, 2.6);
+            Python::attach(|py| {
+                let l = PyComplex::from_doubles(py, 3.0, 1.2);
+                let r = PyComplex::from_doubles(py, 1.0, 2.6);
                 let res = l + r;
                 assert_approx_eq!(res.real(), 4.0);
                 assert_approx_eq!(res.imag(), 3.8);
@@ -194,9 +140,9 @@ mod not_limited_impls {
 
         #[test]
         fn test_sub() {
-            Python::with_gil(|py| {
-                let l = PyComplex::from_doubles_bound(py, 3.0, 1.2);
-                let r = PyComplex::from_doubles_bound(py, 1.0, 2.6);
+            Python::attach(|py| {
+                let l = PyComplex::from_doubles(py, 3.0, 1.2);
+                let r = PyComplex::from_doubles(py, 1.0, 2.6);
                 let res = l - r;
                 assert_approx_eq!(res.real(), 2.0);
                 assert_approx_eq!(res.imag(), -1.4);
@@ -205,9 +151,9 @@ mod not_limited_impls {
 
         #[test]
         fn test_mul() {
-            Python::with_gil(|py| {
-                let l = PyComplex::from_doubles_bound(py, 3.0, 1.2);
-                let r = PyComplex::from_doubles_bound(py, 1.0, 2.6);
+            Python::attach(|py| {
+                let l = PyComplex::from_doubles(py, 3.0, 1.2);
+                let r = PyComplex::from_doubles(py, 1.0, 2.6);
                 let res = l * r;
                 assert_approx_eq!(res.real(), -0.12);
                 assert_approx_eq!(res.imag(), 9.0);
@@ -216,9 +162,9 @@ mod not_limited_impls {
 
         #[test]
         fn test_div() {
-            Python::with_gil(|py| {
-                let l = PyComplex::from_doubles_bound(py, 3.0, 1.2);
-                let r = PyComplex::from_doubles_bound(py, 1.0, 2.6);
+            Python::attach(|py| {
+                let l = PyComplex::from_doubles(py, 3.0, 1.2);
+                let r = PyComplex::from_doubles(py, 1.0, 2.6);
                 let res = l / r;
                 assert_approx_eq!(res.real(), 0.788_659_793_814_432_9);
                 assert_approx_eq!(res.imag(), -0.850_515_463_917_525_7);
@@ -227,8 +173,8 @@ mod not_limited_impls {
 
         #[test]
         fn test_neg() {
-            Python::with_gil(|py| {
-                let val = PyComplex::from_doubles_bound(py, 3.0, 1.2);
+            Python::attach(|py| {
+                let val = PyComplex::from_doubles(py, 3.0, 1.2);
                 let res = -val;
                 assert_approx_eq!(res.real(), -3.0);
                 assert_approx_eq!(res.imag(), -1.2);
@@ -237,17 +183,17 @@ mod not_limited_impls {
 
         #[test]
         fn test_abs() {
-            Python::with_gil(|py| {
-                let val = PyComplex::from_doubles_bound(py, 3.0, 1.2);
+            Python::attach(|py| {
+                let val = PyComplex::from_doubles(py, 3.0, 1.2);
                 assert_approx_eq!(val.abs(), 3.231_098_884_280_702_2);
             });
         }
 
         #[test]
         fn test_pow() {
-            Python::with_gil(|py| {
-                let l = PyComplex::from_doubles_bound(py, 3.0, 1.2);
-                let r = PyComplex::from_doubles_bound(py, 1.2, 2.6);
+            Python::attach(|py| {
+                let l = PyComplex::from_doubles(py, 3.0, 1.2);
+                let r = PyComplex::from_doubles(py, 1.2, 2.6);
                 let val = l.pow(&r);
                 assert_approx_eq!(val.real(), -1.419_309_997_016_603_7);
                 assert_approx_eq!(val.imag(), -0.541_297_466_033_544_6);
@@ -262,16 +208,16 @@ mod not_limited_impls {
 /// syntax these methods are separated into a trait, because stable Rust does not yet support
 /// `arbitrary_self_types`.
 #[doc(alias = "PyComplex")]
-pub trait PyComplexMethods<'py> {
+pub trait PyComplexMethods<'py>: crate::sealed::Sealed {
     /// Returns the real part of the complex number.
     fn real(&self) -> c_double;
     /// Returns the imaginary part of the complex number.
     fn imag(&self) -> c_double;
     /// Returns `|self|`.
-    #[cfg(not(any(Py_LIMITED_API, PyPy)))]
+    #[cfg(not(any(Py_LIMITED_API, PyPy, GraalPy)))]
     fn abs(&self) -> c_double;
     /// Returns `self` raised to the power of `other`.
-    #[cfg(not(any(Py_LIMITED_API, PyPy)))]
+    #[cfg(not(any(Py_LIMITED_API, PyPy, GraalPy)))]
     fn pow(&self, other: &Bound<'py, PyComplex>) -> Bound<'py, PyComplex>;
 }
 
@@ -284,26 +230,22 @@ impl<'py> PyComplexMethods<'py> for Bound<'py, PyComplex> {
         unsafe { ffi::PyComplex_ImagAsDouble(self.as_ptr()) }
     }
 
-    #[cfg(not(any(Py_LIMITED_API, PyPy)))]
+    #[cfg(not(any(Py_LIMITED_API, PyPy, GraalPy)))]
     fn abs(&self) -> c_double {
-        unsafe {
-            let val = (*self.as_ptr().cast::<ffi::PyComplexObject>()).cval;
-            ffi::_Py_c_abs(val)
-        }
+        PyAnyMethods::abs(self.as_any())
+            .cast_into()
+            .expect("Complex method __abs__ failed.")
+            .extract()
+            .expect("Failed to extract to c double.")
     }
 
-    #[cfg(not(any(Py_LIMITED_API, PyPy)))]
+    #[cfg(not(any(Py_LIMITED_API, PyPy, GraalPy)))]
     fn pow(&self, other: &Bound<'py, PyComplex>) -> Bound<'py, PyComplex> {
-        use crate::ffi_ptr_ext::FfiPtrExt;
-        unsafe {
-            not_limited_impls::complex_operation(
-                self.as_borrowed(),
-                other.as_borrowed(),
-                ffi::_Py_c_pow,
-            )
-            .assume_owned(self.py())
-            .downcast_into_unchecked()
-        }
+        Python::attach(|py| {
+            PyAnyMethods::pow(self.as_any(), other, py.None())
+                .cast_into()
+                .expect("Complex method __pow__ failed.")
+        })
     }
 }
 
@@ -315,10 +257,8 @@ mod tests {
 
     #[test]
     fn test_from_double() {
-        use assert_approx_eq::assert_approx_eq;
-
-        Python::with_gil(|py| {
-            let complex = PyComplex::from_doubles_bound(py, 3.0, 1.2);
+        Python::attach(|py| {
+            let complex = PyComplex::from_doubles(py, 3.0, 1.2);
             assert_approx_eq!(complex.real(), 3.0);
             assert_approx_eq!(complex.imag(), 1.2);
         });
diff --git a/src/types/datetime.rs b/src/types/datetime.rs
index d46a2b77c33..8c57aa8a43a 100644
--- a/src/types/datetime.rs
+++ b/src/types/datetime.rs
@@ -3,32 +3,38 @@
 //! For more details about these types, see the [Python
 //! documentation](https://docs.python.org/3/library/datetime.html)
 
+#[cfg(not(Py_LIMITED_API))]
+use crate::err::PyErr;
 use crate::err::PyResult;
+#[cfg(not(Py_3_9))]
+use crate::exceptions::PyImportError;
+#[cfg(not(Py_LIMITED_API))]
 use crate::ffi::{
-    self, PyDateTime_CAPI, PyDateTime_FromTimestamp, PyDateTime_IMPORT, PyDate_FromTimestamp,
-};
-use crate::ffi::{
-    PyDateTime_DATE_GET_FOLD, PyDateTime_DATE_GET_HOUR, PyDateTime_DATE_GET_MICROSECOND,
-    PyDateTime_DATE_GET_MINUTE, PyDateTime_DATE_GET_SECOND,
-};
-use crate::ffi::{
+    self, PyDateTime_CAPI, PyDateTime_DATE_GET_FOLD, PyDateTime_DATE_GET_HOUR,
+    PyDateTime_DATE_GET_MICROSECOND, PyDateTime_DATE_GET_MINUTE, PyDateTime_DATE_GET_SECOND,
     PyDateTime_DELTA_GET_DAYS, PyDateTime_DELTA_GET_MICROSECONDS, PyDateTime_DELTA_GET_SECONDS,
+    PyDateTime_FromTimestamp, PyDateTime_GET_DAY, PyDateTime_GET_MONTH, PyDateTime_GET_YEAR,
+    PyDateTime_IMPORT, PyDateTime_TIME_GET_FOLD, PyDateTime_TIME_GET_HOUR,
+    PyDateTime_TIME_GET_MICROSECOND, PyDateTime_TIME_GET_MINUTE, PyDateTime_TIME_GET_SECOND,
+    PyDate_FromTimestamp,
 };
-use crate::ffi::{PyDateTime_GET_DAY, PyDateTime_GET_MONTH, PyDateTime_GET_YEAR};
-use crate::ffi::{
-    PyDateTime_TIME_GET_FOLD, PyDateTime_TIME_GET_HOUR, PyDateTime_TIME_GET_MICROSECOND,
-    PyDateTime_TIME_GET_MINUTE, PyDateTime_TIME_GET_SECOND,
-};
-use crate::ffi_ptr_ext::FfiPtrExt;
-use crate::instance::PyNativeType;
-use crate::py_result_ext::PyResultExt;
-use crate::types::any::PyAnyMethods;
-use crate::types::PyTuple;
-use crate::{Bound, IntoPy, Py, PyAny, PyErr, Python};
-use std::os::raw::c_int;
-#[cfg(feature = "chrono")]
-use std::ptr;
-
+#[cfg(all(Py_3_10, not(Py_LIMITED_API)))]
+use crate::ffi::{PyDateTime_DATE_GET_TZINFO, PyDateTime_TIME_GET_TZINFO, Py_IsNone};
+#[cfg(Py_LIMITED_API)]
+use crate::type_object::PyTypeInfo;
+#[cfg(Py_LIMITED_API)]
+use crate::types::typeobject::PyTypeMethods;
+#[cfg(Py_LIMITED_API)]
+use crate::types::IntoPyDict;
+use crate::types::{any::PyAnyMethods, PyString, PyType};
+#[cfg(not(Py_LIMITED_API))]
+use crate::{ffi_ptr_ext::FfiPtrExt, py_result_ext::PyResultExt, types::PyTuple, BoundObject};
+use crate::{sync::PyOnceLock, Py};
+use crate::{Borrowed, Bound, IntoPyObject, PyAny, Python};
+#[cfg(not(Py_LIMITED_API))]
+use std::ffi::c_int;
+
+#[cfg(not(Py_LIMITED_API))]
 fn ensure_datetime_api(py: Python<'_>) -> PyResult<&'static PyDateTime_CAPI> {
     if let Some(api) = unsafe { pyo3_ffi::PyDateTimeAPI().as_ref() } {
         Ok(api)
@@ -41,6 +47,7 @@ fn ensure_datetime_api(py: Python<'_>) -> PyResult<&'static PyDateTime_CAPI> {
     }
 }
 
+#[cfg(not(Py_LIMITED_API))]
 fn expect_datetime_api(py: Python<'_>) -> &'static PyDateTime_CAPI {
     ensure_datetime_api(py).expect("failed to import `datetime` C API")
 }
@@ -56,7 +63,7 @@ fn expect_datetime_api(py: Python<'_>) -> &'static PyDateTime_CAPI {
 // # Safety
 //
 // These functions must only be called when the GIL is held!
-
+#[cfg(not(Py_LIMITED_API))]
 macro_rules! ffi_fun_with_autoinit {
     ($(#[$outer:meta] unsafe fn $name: ident($arg: ident: *mut PyObject) -> $ret: ty;)*) => {
         $(
@@ -67,8 +74,8 @@ macro_rules! ffi_fun_with_autoinit {
             /// Must only be called while the GIL is held
             unsafe fn $name($arg: *mut crate::ffi::PyObject) -> $ret {
 
-                let _ = ensure_datetime_api(Python::assume_gil_acquired());
-                crate::ffi::$name($arg)
+                let _ = ensure_datetime_api(unsafe { Python::assume_attached() });
+                unsafe { crate::ffi::$name($arg) }
             }
         )*
 
@@ -76,6 +83,7 @@ macro_rules! ffi_fun_with_autoinit {
     };
 }
 
+#[cfg(not(Py_LIMITED_API))]
 ffi_fun_with_autoinit! {
     /// Check if `op` is a `PyDateTimeAPI.DateType` or subtype.
     unsafe fn PyDate_Check(op: *mut PyObject) -> c_int;
@@ -96,6 +104,7 @@ ffi_fun_with_autoinit! {
 // Access traits
 
 /// Trait for accessing the date components of a struct containing a date.
+#[cfg(not(Py_LIMITED_API))]
 pub trait PyDateAccess {
     /// Returns the year, as a positive int.
     ///
@@ -119,6 +128,7 @@ pub trait PyDateAccess {
 /// Note: These access the individual components of a (day, second,
 /// microsecond) representation of the delta, they are *not* intended as
 /// aliases for calculating the total duration in each of these units.
+#[cfg(not(Py_LIMITED_API))]
 pub trait PyDeltaAccess {
     /// Returns the number of days, as an int from -999999999 to 999999999.
     ///
@@ -128,16 +138,17 @@ pub trait PyDeltaAccess {
     /// Returns the number of seconds, as an int from 0 through 86399.
     ///
     /// Implementations should conform to the upstream documentation:
-    /// <https://docs.python.org/3/c-api/datetime.html#c.PyDateTime_DELTA_GET_DAYS>
+    /// <https://docs.python.org/3/c-api/datetime.html#c.PyDateTime_DELTA_GET_SECONDS>
     fn get_seconds(&self) -> i32;
     /// Returns the number of microseconds, as an int from 0 through 999999.
     ///
     /// Implementations should conform to the upstream documentation:
-    /// <https://docs.python.org/3/c-api/datetime.html#c.PyDateTime_DELTA_GET_DAYS>
+    /// <https://docs.python.org/3/c-api/datetime.html#c.PyDateTime_DELTA_GET_MICROSECONDS>
     fn get_microseconds(&self) -> i32;
 }
 
 /// Trait for accessing the time components of a struct containing a time.
+#[cfg(not(Py_LIMITED_API))]
 pub trait PyTimeAccess {
     /// Returns the hour, as an int from 0 through 23.
     ///
@@ -170,29 +181,22 @@ pub trait PyTimeAccess {
 
 /// Trait for accessing the components of a struct containing a tzinfo.
 pub trait PyTzInfoAccess<'py> {
-    /// Deprecated form of `get_tzinfo_bound`.
-    #[cfg_attr(
-        not(feature = "gil-refs"),
-        deprecated(
-            since = "0.21.0",
-            note = "`get_tzinfo` will be replaced by `get_tzinfo_bound` in a future PyO3 version"
-        )
-    )]
-    fn get_tzinfo(&self) -> Option<&'py PyTzInfo> {
-        self.get_tzinfo_bound().map(Bound::into_gil_ref)
-    }
-
     /// Returns the tzinfo (which may be None).
     ///
     /// Implementations should conform to the upstream documentation:
     /// <https://docs.python.org/3/c-api/datetime.html#c.PyDateTime_DATE_GET_TZINFO>
     /// <https://docs.python.org/3/c-api/datetime.html#c.PyDateTime_TIME_GET_TZINFO>
-    fn get_tzinfo_bound(&self) -> Option<Bound<'py, PyTzInfo>>;
+    fn get_tzinfo(&self) -> Option<Bound<'py, PyTzInfo>>;
 }
 
-/// Bindings around `datetime.date`
+/// Bindings around `datetime.date`.
+///
+/// Values of this type are accessed via PyO3's smart pointers, e.g. as
+/// [`Py<PyDate>`][crate::Py] or [`Bound<'py, PyDate>`][Bound].
 #[repr(transparent)]
 pub struct PyDate(PyAny);
+
+#[cfg(not(Py_LIMITED_API))]
 pyobject_native_type!(
     PyDate,
     crate::ffi::PyDateTime_Date,
@@ -200,73 +204,63 @@ pyobject_native_type!(
     #module=Some("datetime"),
     #checkfunction=PyDate_Check
 );
+#[cfg(not(Py_LIMITED_API))]
+pyobject_subclassable_native_type!(PyDate, crate::ffi::PyDateTime_Date);
 
-impl PyDate {
-    /// Deprecated form of [`PyDate::new_bound`].
-    #[cfg_attr(
-        not(feature = "gil-refs"),
-        deprecated(
-            since = "0.21.0",
-            note = "`PyDate::new` will be replaced by `PyDate::new_bound` in a future PyO3 version"
-        )
-    )]
-    pub fn new(py: Python<'_>, year: i32, month: u8, day: u8) -> PyResult<&PyDate> {
-        Self::new_bound(py, year, month, day).map(Bound::into_gil_ref)
-    }
+#[cfg(Py_LIMITED_API)]
+pyobject_native_type_core!(
+    PyDate,
+    |py| {
+        static TYPE: PyOnceLock<Py<PyType>> = PyOnceLock::new();
+        TYPE.import(py, "datetime", "date").unwrap().as_type_ptr()
+    },
+    #module=Some("datetime")
+);
 
+impl PyDate {
     /// Creates a new `datetime.date`.
-    pub fn new_bound(py: Python<'_>, year: i32, month: u8, day: u8) -> PyResult<Bound<'_, PyDate>> {
-        let api = ensure_datetime_api(py)?;
-        unsafe {
-            (api.Date_FromDate)(year, c_int::from(month), c_int::from(day), api.DateType)
-                .assume_owned_or_err(py)
-                .downcast_into_unchecked()
+    pub fn new(py: Python<'_>, year: i32, month: u8, day: u8) -> PyResult<Bound<'_, PyDate>> {
+        #[cfg(not(Py_LIMITED_API))]
+        {
+            let api = ensure_datetime_api(py)?;
+            unsafe {
+                (api.Date_FromDate)(year, c_int::from(month), c_int::from(day), api.DateType)
+                    .assume_owned_or_err(py)
+                    .cast_into_unchecked()
+            }
         }
-    }
-
-    /// Deprecated form of [`PyDate::from_timestamp_bound`].
-    #[cfg_attr(
-        not(feature = "gil-refs"),
-        deprecated(
-            since = "0.21.0",
-            note = "`PyDate::from_timestamp` will be replaced by `PyDate::from_timestamp_bound` in a future PyO3 version"
-        )
-    )]
-    pub fn from_timestamp(py: Python<'_>, timestamp: i64) -> PyResult<&PyDate> {
-        Self::from_timestamp_bound(py, timestamp).map(Bound::into_gil_ref)
+        #[cfg(Py_LIMITED_API)]
+        Ok(Self::type_object(py)
+            .call((year, month, day), None)?
+            .cast_into()?)
     }
 
     /// Construct a `datetime.date` from a POSIX timestamp
     ///
     /// This is equivalent to `datetime.date.fromtimestamp`
-    pub fn from_timestamp_bound(py: Python<'_>, timestamp: i64) -> PyResult<Bound<'_, PyDate>> {
-        let time_tuple = PyTuple::new_bound(py, [timestamp]);
-
-        // safety ensure that the API is loaded
-        let _api = ensure_datetime_api(py)?;
-
-        unsafe {
-            PyDate_FromTimestamp(time_tuple.as_ptr())
-                .assume_owned_or_err(py)
-                .downcast_into_unchecked()
+    pub fn from_timestamp(py: Python<'_>, timestamp: i64) -> PyResult<Bound<'_, PyDate>> {
+        #[cfg(not(Py_LIMITED_API))]
+        {
+            let time_tuple = PyTuple::new(py, [timestamp])?;
+
+            // safety ensure that the API is loaded
+            let _api = ensure_datetime_api(py)?;
+
+            unsafe {
+                PyDate_FromTimestamp(time_tuple.as_ptr())
+                    .assume_owned_or_err(py)
+                    .cast_into_unchecked()
+            }
         }
-    }
-}
-
-impl PyDateAccess for PyDate {
-    fn get_year(&self) -> i32 {
-        self.as_borrowed().get_year()
-    }
 
-    fn get_month(&self) -> u8 {
-        self.as_borrowed().get_month()
-    }
-
-    fn get_day(&self) -> u8 {
-        self.as_borrowed().get_day()
+        #[cfg(Py_LIMITED_API)]
+        Ok(Self::type_object(py)
+            .call_method1("fromtimestamp", (timestamp,))?
+            .cast_into()?)
     }
 }
 
+#[cfg(not(Py_LIMITED_API))]
 impl PyDateAccess for Bound<'_, PyDate> {
     fn get_year(&self) -> i32 {
         unsafe { PyDateTime_GET_YEAR(self.as_ptr()) }
@@ -281,9 +275,14 @@ impl PyDateAccess for Bound<'_, PyDate> {
     }
 }
 
-/// Bindings for `datetime.datetime`
+/// Bindings for `datetime.datetime`.
+///
+/// Values of this type are accessed via PyO3's smart pointers, e.g. as
+/// [`Py<PyDateTime>`][crate::Py] or [`Bound<'py, PyDateTime>`][Bound].
 #[repr(transparent)]
 pub struct PyDateTime(PyAny);
+
+#[cfg(not(Py_LIMITED_API))]
 pyobject_native_type!(
     PyDateTime,
     crate::ffi::PyDateTime_DateTime,
@@ -291,45 +290,23 @@ pyobject_native_type!(
     #module=Some("datetime"),
     #checkfunction=PyDateTime_Check
 );
+#[cfg(not(Py_LIMITED_API))]
+pyobject_subclassable_native_type!(PyDateTime, crate::ffi::PyDateTime_DateTime);
 
-impl PyDateTime {
-    /// Deprecated form of [`PyDateTime::new_bound`].
-    #[cfg_attr(
-        not(feature = "gil-refs"),
-        deprecated(
-            since = "0.21.0",
-            note = "`PyDateTime::new` will be replaced by `PyDateTime::new_bound` in a future PyO3 version"
-        )
-    )]
-    #[allow(clippy::too_many_arguments)]
-    pub fn new<'py>(
-        py: Python<'py>,
-        year: i32,
-        month: u8,
-        day: u8,
-        hour: u8,
-        minute: u8,
-        second: u8,
-        microsecond: u32,
-        tzinfo: Option<&'py PyTzInfo>,
-    ) -> PyResult<&'py PyDateTime> {
-        Self::new_bound(
-            py,
-            year,
-            month,
-            day,
-            hour,
-            minute,
-            second,
-            microsecond,
-            tzinfo.map(PyTzInfo::as_borrowed).as_deref(),
-        )
-        .map(Bound::into_gil_ref)
-    }
+#[cfg(Py_LIMITED_API)]
+pyobject_native_type_core!(
+    PyDateTime,
+    |py| {
+        static TYPE: PyOnceLock<Py<PyType>> = PyOnceLock::new();
+        TYPE.import(py, "datetime", "datetime").unwrap().as_type_ptr()
+    },
+    #module=Some("datetime")
+);
 
+impl PyDateTime {
     /// Creates a new `datetime.datetime` object.
     #[allow(clippy::too_many_arguments)]
-    pub fn new_bound<'py>(
+    pub fn new<'py>(
         py: Python<'py>,
         year: i32,
         month: u8,
@@ -340,58 +317,33 @@ impl PyDateTime {
         microsecond: u32,
         tzinfo: Option<&Bound<'py, PyTzInfo>>,
     ) -> PyResult<Bound<'py, PyDateTime>> {
-        let api = ensure_datetime_api(py)?;
-        unsafe {
-            (api.DateTime_FromDateAndTime)(
-                year,
-                c_int::from(month),
-                c_int::from(day),
-                c_int::from(hour),
-                c_int::from(minute),
-                c_int::from(second),
-                microsecond as c_int,
-                opt_to_pyobj(tzinfo),
-                api.DateTimeType,
-            )
-            .assume_owned_or_err(py)
-            .downcast_into_unchecked()
+        #[cfg(not(Py_LIMITED_API))]
+        {
+            let api = ensure_datetime_api(py)?;
+            unsafe {
+                (api.DateTime_FromDateAndTime)(
+                    year,
+                    c_int::from(month),
+                    c_int::from(day),
+                    c_int::from(hour),
+                    c_int::from(minute),
+                    c_int::from(second),
+                    microsecond as c_int,
+                    opt_to_pyobj(tzinfo),
+                    api.DateTimeType,
+                )
+                .assume_owned_or_err(py)
+                .cast_into_unchecked()
+            }
         }
-    }
 
-    /// Deprecated form of [`PyDateTime::new_bound_with_fold`].
-    #[cfg_attr(
-        not(feature = "gil-refs"),
-        deprecated(
-            since = "0.21.0",
-            note = "`PyDateTime::new_with_fold` will be replaced by `PyDateTime::new_bound_with_fold` in a future PyO3 version"
-        )
-    )]
-    #[allow(clippy::too_many_arguments)]
-    pub fn new_with_fold<'py>(
-        py: Python<'py>,
-        year: i32,
-        month: u8,
-        day: u8,
-        hour: u8,
-        minute: u8,
-        second: u8,
-        microsecond: u32,
-        tzinfo: Option<&'py PyTzInfo>,
-        fold: bool,
-    ) -> PyResult<&'py PyDateTime> {
-        Self::new_bound_with_fold(
-            py,
-            year,
-            month,
-            day,
-            hour,
-            minute,
-            second,
-            microsecond,
-            tzinfo.map(PyTzInfo::as_borrowed).as_deref(),
-            fold,
-        )
-        .map(Bound::into_gil_ref)
+        #[cfg(Py_LIMITED_API)]
+        Ok(Self::type_object(py)
+            .call(
+                (year, month, day, hour, minute, second, microsecond, tzinfo),
+                None,
+            )?
+            .cast_into()?)
     }
 
     /// Alternate constructor that takes a `fold` parameter. A `true` value for this parameter
@@ -402,7 +354,7 @@ impl PyDateTime {
     /// represented time is ambiguous.
     /// See [PEP 495](https://www.python.org/dev/peps/pep-0495/) for more detail.
     #[allow(clippy::too_many_arguments)]
-    pub fn new_bound_with_fold<'py>(
+    pub fn new_with_fold<'py>(
         py: Python<'py>,
         year: i32,
         month: u8,
@@ -414,77 +366,66 @@ impl PyDateTime {
         tzinfo: Option<&Bound<'py, PyTzInfo>>,
         fold: bool,
     ) -> PyResult<Bound<'py, PyDateTime>> {
-        let api = ensure_datetime_api(py)?;
-        unsafe {
-            (api.DateTime_FromDateAndTimeAndFold)(
-                year,
-                c_int::from(month),
-                c_int::from(day),
-                c_int::from(hour),
-                c_int::from(minute),
-                c_int::from(second),
-                microsecond as c_int,
-                opt_to_pyobj(tzinfo),
-                c_int::from(fold),
-                api.DateTimeType,
-            )
-            .assume_owned_or_err(py)
-            .downcast_into_unchecked()
+        #[cfg(not(Py_LIMITED_API))]
+        {
+            let api = ensure_datetime_api(py)?;
+            unsafe {
+                (api.DateTime_FromDateAndTimeAndFold)(
+                    year,
+                    c_int::from(month),
+                    c_int::from(day),
+                    c_int::from(hour),
+                    c_int::from(minute),
+                    c_int::from(second),
+                    microsecond as c_int,
+                    opt_to_pyobj(tzinfo),
+                    c_int::from(fold),
+                    api.DateTimeType,
+                )
+                .assume_owned_or_err(py)
+                .cast_into_unchecked()
+            }
         }
-    }
 
-    /// Deprecated form of [`PyDateTime::from_timestamp_bound`].
-    #[cfg_attr(
-        not(feature = "gil-refs"),
-        deprecated(
-            since = "0.21.0",
-            note = "`PyDateTime::from_timestamp` will be replaced by `PyDateTime::from_timestamp_bound` in a future PyO3 version"
-        )
-    )]
-    pub fn from_timestamp<'py>(
-        py: Python<'py>,
-        timestamp: f64,
-        tzinfo: Option<&'py PyTzInfo>,
-    ) -> PyResult<&'py PyDateTime> {
-        Self::from_timestamp_bound(py, timestamp, tzinfo.map(PyTzInfo::as_borrowed).as_deref())
-            .map(Bound::into_gil_ref)
+        #[cfg(Py_LIMITED_API)]
+        Ok(Self::type_object(py)
+            .call(
+                (year, month, day, hour, minute, second, microsecond, tzinfo),
+                Some(&[("fold", fold)].into_py_dict(py)?),
+            )?
+            .cast_into()?)
     }
 
     /// Construct a `datetime` object from a POSIX timestamp
     ///
     /// This is equivalent to `datetime.datetime.fromtimestamp`
-    pub fn from_timestamp_bound<'py>(
+    pub fn from_timestamp<'py>(
         py: Python<'py>,
         timestamp: f64,
         tzinfo: Option<&Bound<'py, PyTzInfo>>,
     ) -> PyResult<Bound<'py, PyDateTime>> {
-        let args = IntoPy::<Py<PyTuple>>::into_py((timestamp, tzinfo), py).into_bound(py);
+        #[cfg(not(Py_LIMITED_API))]
+        {
+            let args = (timestamp, tzinfo).into_pyobject(py)?;
 
-        // safety ensure API is loaded
-        let _api = ensure_datetime_api(py)?;
+            // safety ensure API is loaded
+            let _api = ensure_datetime_api(py)?;
 
-        unsafe {
-            PyDateTime_FromTimestamp(args.as_ptr())
-                .assume_owned_or_err(py)
-                .downcast_into_unchecked()
+            unsafe {
+                PyDateTime_FromTimestamp(args.as_ptr())
+                    .assume_owned_or_err(py)
+                    .cast_into_unchecked()
+            }
         }
-    }
-}
-
-impl PyDateAccess for PyDateTime {
-    fn get_year(&self) -> i32 {
-        self.as_borrowed().get_year()
-    }
 
-    fn get_month(&self) -> u8 {
-        self.as_borrowed().get_month()
-    }
-
-    fn get_day(&self) -> u8 {
-        self.as_borrowed().get_day()
+        #[cfg(Py_LIMITED_API)]
+        Ok(Self::type_object(py)
+            .call_method1("fromtimestamp", (timestamp, tzinfo))?
+            .cast_into()?)
     }
 }
 
+#[cfg(not(Py_LIMITED_API))]
 impl PyDateAccess for Bound<'_, PyDateTime> {
     fn get_year(&self) -> i32 {
         unsafe { PyDateTime_GET_YEAR(self.as_ptr()) }
@@ -499,28 +440,7 @@ impl PyDateAccess for Bound<'_, PyDateTime> {
     }
 }
 
-impl PyTimeAccess for PyDateTime {
-    fn get_hour(&self) -> u8 {
-        self.as_borrowed().get_hour()
-    }
-
-    fn get_minute(&self) -> u8 {
-        self.as_borrowed().get_minute()
-    }
-
-    fn get_second(&self) -> u8 {
-        self.as_borrowed().get_second()
-    }
-
-    fn get_microsecond(&self) -> u32 {
-        self.as_borrowed().get_microsecond()
-    }
-
-    fn get_fold(&self) -> bool {
-        self.as_borrowed().get_fold()
-    }
-}
-
+#[cfg(not(Py_LIMITED_API))]
 impl PyTimeAccess for Bound<'_, PyDateTime> {
     fn get_hour(&self) -> u8 {
         unsafe { PyDateTime_DATE_GET_HOUR(self.as_ptr()) as u8 }
@@ -543,34 +463,58 @@ impl PyTimeAccess for Bound<'_, PyDateTime> {
     }
 }
 
-impl<'py> PyTzInfoAccess<'py> for &'py PyDateTime {
-    fn get_tzinfo_bound(&self) -> Option<Bound<'py, PyTzInfo>> {
-        self.as_borrowed().get_tzinfo_bound()
-    }
-}
-
 impl<'py> PyTzInfoAccess<'py> for Bound<'py, PyDateTime> {
-    fn get_tzinfo_bound(&self) -> Option<Bound<'py, PyTzInfo>> {
-        let ptr = self.as_ptr() as *mut ffi::PyDateTime_DateTime;
+    fn get_tzinfo(&self) -> Option<Bound<'py, PyTzInfo>> {
+        #[cfg(all(not(Py_3_10), not(Py_LIMITED_API)))]
         unsafe {
+            let ptr = self.as_ptr() as *mut ffi::PyDateTime_DateTime;
             if (*ptr).hastzinfo != 0 {
                 Some(
                     (*ptr)
                         .tzinfo
                         .assume_borrowed(self.py())
                         .to_owned()
-                        .downcast_into_unchecked(),
+                        .cast_into_unchecked(),
                 )
             } else {
                 None
             }
         }
+
+        #[cfg(all(Py_3_10, not(Py_LIMITED_API)))]
+        unsafe {
+            let res = PyDateTime_DATE_GET_TZINFO(self.as_ptr());
+            if Py_IsNone(res) == 1 {
+                None
+            } else {
+                Some(
+                    res.assume_borrowed(self.py())
+                        .to_owned()
+                        .cast_into_unchecked(),
+                )
+            }
+        }
+
+        #[cfg(Py_LIMITED_API)]
+        unsafe {
+            let tzinfo = self.getattr(intern!(self.py(), "tzinfo")).ok()?;
+            if tzinfo.is_none() {
+                None
+            } else {
+                Some(tzinfo.cast_into_unchecked())
+            }
+        }
     }
 }
 
-/// Bindings for `datetime.time`
+/// Bindings for `datetime.time`.
+///
+/// Values of this type are accessed via PyO3's smart pointers, e.g. as
+/// [`Py<PyTime>`][crate::Py] or [`Bound<'py, PyTime>`][Bound].
 #[repr(transparent)]
 pub struct PyTime(PyAny);
+
+#[cfg(not(Py_LIMITED_API))]
 pyobject_native_type!(
     PyTime,
     crate::ffi::PyDateTime_Time,
@@ -578,37 +522,22 @@ pyobject_native_type!(
     #module=Some("datetime"),
     #checkfunction=PyTime_Check
 );
+#[cfg(not(Py_LIMITED_API))]
+pyobject_subclassable_native_type!(PyTime, crate::ffi::PyDateTime_Time);
 
-impl PyTime {
-    /// Deprecated form of [`PyTime::new_bound`].
-    #[cfg_attr(
-        not(feature = "gil-refs"),
-        deprecated(
-            since = "0.21.0",
-            note = "`PyTime::new` will be replaced by `PyTime::new_bound` in a future PyO3 version"
-        )
-    )]
-    pub fn new<'py>(
-        py: Python<'py>,
-        hour: u8,
-        minute: u8,
-        second: u8,
-        microsecond: u32,
-        tzinfo: Option<&'py PyTzInfo>,
-    ) -> PyResult<&'py PyTime> {
-        Self::new_bound(
-            py,
-            hour,
-            minute,
-            second,
-            microsecond,
-            tzinfo.map(PyTzInfo::as_borrowed).as_deref(),
-        )
-        .map(Bound::into_gil_ref)
-    }
+#[cfg(Py_LIMITED_API)]
+pyobject_native_type_core!(
+    PyTime,
+    |py| {
+        static TYPE: PyOnceLock<Py<PyType>> = PyOnceLock::new();
+        TYPE.import(py, "datetime", "time").unwrap().as_type_ptr()
+    },
+    #module=Some("datetime")
+);
 
+impl PyTime {
     /// Creates a new `datetime.time` object.
-    pub fn new_bound<'py>(
+    pub fn new<'py>(
         py: Python<'py>,
         hour: u8,
         minute: u8,
@@ -616,52 +545,31 @@ impl PyTime {
         microsecond: u32,
         tzinfo: Option<&Bound<'py, PyTzInfo>>,
     ) -> PyResult<Bound<'py, PyTime>> {
-        let api = ensure_datetime_api(py)?;
-        unsafe {
-            (api.Time_FromTime)(
-                c_int::from(hour),
-                c_int::from(minute),
-                c_int::from(second),
-                microsecond as c_int,
-                opt_to_pyobj(tzinfo),
-                api.TimeType,
-            )
-            .assume_owned_or_err(py)
-            .downcast_into_unchecked()
+        #[cfg(not(Py_LIMITED_API))]
+        {
+            let api = ensure_datetime_api(py)?;
+            unsafe {
+                (api.Time_FromTime)(
+                    c_int::from(hour),
+                    c_int::from(minute),
+                    c_int::from(second),
+                    microsecond as c_int,
+                    opt_to_pyobj(tzinfo),
+                    api.TimeType,
+                )
+                .assume_owned_or_err(py)
+                .cast_into_unchecked()
+            }
         }
-    }
 
-    /// Deprecated form of [`PyTime::new_bound_with_fold`].
-    #[cfg_attr(
-        not(feature = "gil-refs"),
-        deprecated(
-            since = "0.21.0",
-            note = "`PyTime::new_with_fold` will be replaced by `PyTime::new_bound_with_fold` in a future PyO3 version"
-        )
-    )]
-    pub fn new_with_fold<'py>(
-        py: Python<'py>,
-        hour: u8,
-        minute: u8,
-        second: u8,
-        microsecond: u32,
-        tzinfo: Option<&'py PyTzInfo>,
-        fold: bool,
-    ) -> PyResult<&'py PyTime> {
-        Self::new_bound_with_fold(
-            py,
-            hour,
-            minute,
-            second,
-            microsecond,
-            tzinfo.map(PyTzInfo::as_borrowed).as_deref(),
-            fold,
-        )
-        .map(Bound::into_gil_ref)
+        #[cfg(Py_LIMITED_API)]
+        Ok(Self::type_object(py)
+            .call((hour, minute, second, microsecond, tzinfo), None)?
+            .cast_into()?)
     }
 
     /// Alternate constructor that takes a `fold` argument. See [`PyDateTime::new_with_fold`].
-    pub fn new_bound_with_fold<'py>(
+    pub fn new_with_fold<'py>(
         py: Python<'py>,
         hour: u8,
         minute: u8,
@@ -670,45 +578,35 @@ impl PyTime {
         tzinfo: Option<&Bound<'py, PyTzInfo>>,
         fold: bool,
     ) -> PyResult<Bound<'py, PyTime>> {
-        let api = ensure_datetime_api(py)?;
-        unsafe {
-            (api.Time_FromTimeAndFold)(
-                c_int::from(hour),
-                c_int::from(minute),
-                c_int::from(second),
-                microsecond as c_int,
-                opt_to_pyobj(tzinfo),
-                fold as c_int,
-                api.TimeType,
-            )
-            .assume_owned_or_err(py)
-            .downcast_into_unchecked()
+        #[cfg(not(Py_LIMITED_API))]
+        {
+            let api = ensure_datetime_api(py)?;
+            unsafe {
+                (api.Time_FromTimeAndFold)(
+                    c_int::from(hour),
+                    c_int::from(minute),
+                    c_int::from(second),
+                    microsecond as c_int,
+                    opt_to_pyobj(tzinfo),
+                    fold as c_int,
+                    api.TimeType,
+                )
+                .assume_owned_or_err(py)
+                .cast_into_unchecked()
+            }
         }
-    }
-}
-
-impl PyTimeAccess for PyTime {
-    fn get_hour(&self) -> u8 {
-        self.as_borrowed().get_hour()
-    }
-
-    fn get_minute(&self) -> u8 {
-        self.as_borrowed().get_minute()
-    }
-
-    fn get_second(&self) -> u8 {
-        self.as_borrowed().get_second()
-    }
 
-    fn get_microsecond(&self) -> u32 {
-        self.as_borrowed().get_microsecond()
-    }
-
-    fn get_fold(&self) -> bool {
-        self.as_borrowed().get_fold()
+        #[cfg(Py_LIMITED_API)]
+        Ok(Self::type_object(py)
+            .call(
+                (hour, minute, second, microsecond, tzinfo),
+                Some(&[("fold", fold)].into_py_dict(py)?),
+            )?
+            .cast_into()?)
     }
 }
 
+#[cfg(not(Py_LIMITED_API))]
 impl PyTimeAccess for Bound<'_, PyTime> {
     fn get_hour(&self) -> u8 {
         unsafe { PyDateTime_TIME_GET_HOUR(self.as_ptr()) as u8 }
@@ -731,38 +629,62 @@ impl PyTimeAccess for Bound<'_, PyTime> {
     }
 }
 
-impl<'py> PyTzInfoAccess<'py> for &'py PyTime {
-    fn get_tzinfo_bound(&self) -> Option<Bound<'py, PyTzInfo>> {
-        self.as_borrowed().get_tzinfo_bound()
-    }
-}
-
 impl<'py> PyTzInfoAccess<'py> for Bound<'py, PyTime> {
-    fn get_tzinfo_bound(&self) -> Option<Bound<'py, PyTzInfo>> {
-        let ptr = self.as_ptr() as *mut ffi::PyDateTime_Time;
+    fn get_tzinfo(&self) -> Option<Bound<'py, PyTzInfo>> {
+        #[cfg(all(not(Py_3_10), not(Py_LIMITED_API)))]
         unsafe {
+            let ptr = self.as_ptr() as *mut ffi::PyDateTime_Time;
             if (*ptr).hastzinfo != 0 {
                 Some(
                     (*ptr)
                         .tzinfo
                         .assume_borrowed(self.py())
                         .to_owned()
-                        .downcast_into_unchecked(),
+                        .cast_into_unchecked(),
                 )
             } else {
                 None
             }
         }
+
+        #[cfg(all(Py_3_10, not(Py_LIMITED_API)))]
+        unsafe {
+            let res = PyDateTime_TIME_GET_TZINFO(self.as_ptr());
+            if Py_IsNone(res) == 1 {
+                None
+            } else {
+                Some(
+                    res.assume_borrowed(self.py())
+                        .to_owned()
+                        .cast_into_unchecked(),
+                )
+            }
+        }
+
+        #[cfg(Py_LIMITED_API)]
+        unsafe {
+            let tzinfo = self.getattr(intern!(self.py(), "tzinfo")).ok()?;
+            if tzinfo.is_none() {
+                None
+            } else {
+                Some(tzinfo.cast_into_unchecked())
+            }
+        }
     }
 }
 
 /// Bindings for `datetime.tzinfo`.
 ///
+/// Values of this type are accessed via PyO3's smart pointers, e.g. as
+/// [`Py<PyTzInfo>`][crate::Py] or [`Bound<'py, PyTzInfo>`][Bound].
+///
 /// This is an abstract base class and cannot be constructed directly.
 /// For concrete time zone implementations, see [`timezone_utc`] and
 /// the [`zoneinfo` module](https://docs.python.org/3/library/zoneinfo.html).
 #[repr(transparent)]
 pub struct PyTzInfo(PyAny);
+
+#[cfg(not(Py_LIMITED_API))]
 pyobject_native_type!(
     PyTzInfo,
     crate::ffi::PyObject,
@@ -770,52 +692,108 @@ pyobject_native_type!(
     #module=Some("datetime"),
     #checkfunction=PyTZInfo_Check
 );
+#[cfg(not(Py_LIMITED_API))]
+pyobject_subclassable_native_type!(PyTzInfo, crate::ffi::PyObject);
 
-/// Deprecated form of [`timezone_utc_bound`].
-#[cfg_attr(
-    not(feature = "gil-refs"),
-    deprecated(
-        since = "0.21.0",
-        note = "`timezone_utc` will be replaced by `timezone_utc_bound` in a future PyO3 version"
-    )
-)]
-pub fn timezone_utc(py: Python<'_>) -> &PyTzInfo {
-    timezone_utc_bound(py).into_gil_ref()
-}
+#[cfg(Py_LIMITED_API)]
+pyobject_native_type_core!(
+    PyTzInfo,
+    |py| {
+        static TYPE: PyOnceLock<Py<PyType>> = PyOnceLock::new();
+        TYPE.import(py, "datetime", "tzinfo").unwrap().as_type_ptr()
+    },
+    #module=Some("datetime")
+);
 
-/// Equivalent to `datetime.timezone.utc`
-pub fn timezone_utc_bound(py: Python<'_>) -> Bound<'_, PyTzInfo> {
-    // TODO: this _could_ have a borrowed form `timezone_utc_borrowed`, but that seems
-    // like an edge case optimization and we'd prefer in PyO3 0.21 to use `Bound` as
-    // much as possible
-    unsafe {
-        expect_datetime_api(py)
-            .TimeZone_UTC
-            .assume_borrowed(py)
-            .to_owned()
-            .downcast_into_unchecked()
+impl PyTzInfo {
+    /// Equivalent to `datetime.timezone.utc`
+    pub fn utc(py: Python<'_>) -> PyResult<Borrowed<'static, '_, PyTzInfo>> {
+        #[cfg(not(Py_LIMITED_API))]
+        unsafe {
+            Ok(ensure_datetime_api(py)?
+                .TimeZone_UTC
+                .assume_borrowed(py)
+                .cast_unchecked())
+        }
+
+        #[cfg(Py_LIMITED_API)]
+        {
+            static UTC: PyOnceLock<Py<PyTzInfo>> = PyOnceLock::new();
+            UTC.get_or_try_init(py, || {
+                Ok(py
+                    .import("datetime")?
+                    .getattr("timezone")?
+                    .getattr("utc")?
+                    .cast_into()?
+                    .unbind())
+            })
+            .map(|utc| utc.bind_borrowed(py))
+        }
     }
-}
 
-/// Equivalent to `datetime.timezone` constructor
-///
-/// Only used internally
-#[cfg(feature = "chrono")]
-pub(crate) fn timezone_from_offset<'py>(
-    offset: &Bound<'py, PyDelta>,
-) -> PyResult<Bound<'py, PyTzInfo>> {
-    let py = offset.py();
-    let api = ensure_datetime_api(py)?;
-    unsafe {
-        (api.TimeZone_FromTimeZone)(offset.as_ptr(), ptr::null_mut())
-            .assume_owned_or_err(py)
-            .downcast_into_unchecked()
+    /// Equivalent to `zoneinfo.ZoneInfo` constructor
+    pub fn timezone<'py, T>(py: Python<'py>, iana_name: T) -> PyResult<Bound<'py, PyTzInfo>>
+    where
+        T: IntoPyObject<'py, Target = PyString>,
+    {
+        static ZONE_INFO: PyOnceLock<Py<PyType>> = PyOnceLock::new();
+
+        let zoneinfo = ZONE_INFO.import(py, "zoneinfo", "ZoneInfo");
+
+        #[cfg(not(Py_3_9))]
+        let zoneinfo = zoneinfo
+            .or_else(|_| ZONE_INFO.import(py, "backports.zoneinfo", "ZoneInfo"))
+            .map_err(|_| PyImportError::new_err("Could not import \"backports.zoneinfo.ZoneInfo\". ZoneInfo is required when converting timezone-aware DateTime's. Please install \"backports.zoneinfo\" on python < 3.9"));
+
+        zoneinfo?
+            .call1((iana_name,))?
+            .cast_into()
+            .map_err(Into::into)
+    }
+
+    /// Equivalent to `datetime.timezone` constructor
+    pub fn fixed_offset<'py, T>(py: Python<'py>, offset: T) -> PyResult<Bound<'py, PyTzInfo>>
+    where
+        T: IntoPyObject<'py, Target = PyDelta>,
+    {
+        #[cfg(not(Py_LIMITED_API))]
+        {
+            let api = ensure_datetime_api(py)?;
+            let delta = offset.into_pyobject(py).map_err(Into::into)?;
+            unsafe {
+                (api.TimeZone_FromTimeZone)(delta.as_ptr(), std::ptr::null_mut())
+                    .assume_owned_or_err(py)
+                    .cast_into_unchecked()
+            }
+        }
+
+        #[cfg(Py_LIMITED_API)]
+        {
+            static TIMEZONE: PyOnceLock<Py<PyType>> = PyOnceLock::new();
+            Ok(TIMEZONE
+                .import(py, "datetime", "timezone")?
+                .call1((offset,))?
+                .cast_into()?)
+        }
     }
 }
 
-/// Bindings for `datetime.timedelta`
+/// Equivalent to `datetime.timezone.utc`
+#[deprecated(since = "0.25.0", note = "use `PyTzInfo::utc` instead")]
+pub fn timezone_utc(py: Python<'_>) -> Bound<'_, PyTzInfo> {
+    PyTzInfo::utc(py)
+        .expect("failed to import datetime.timezone.utc")
+        .to_owned()
+}
+
+/// Bindings for `datetime.timedelta`.
+///
+/// Values of this type are accessed via PyO3's smart pointers, e.g. as
+/// [`Py<PyDelta>`][crate::Py] or [`Bound<'py, PyDelta>`][Bound].
 #[repr(transparent)]
 pub struct PyDelta(PyAny);
+
+#[cfg(not(Py_LIMITED_API))]
 pyobject_native_type!(
     PyDelta,
     crate::ffi::PyDateTime_Delta,
@@ -823,63 +801,54 @@ pyobject_native_type!(
     #module=Some("datetime"),
     #checkfunction=PyDelta_Check
 );
+#[cfg(not(Py_LIMITED_API))]
+pyobject_subclassable_native_type!(PyDelta, crate::ffi::PyDateTime_Delta);
 
-impl PyDelta {
-    /// Deprecated form of [`PyDelta::new_bound`].
-    #[cfg_attr(
-        not(feature = "gil-refs"),
-        deprecated(
-            since = "0.21.0",
-            note = "`PyDelta::new` will be replaced by `PyDelta::new_bound` in a future PyO3 version"
-        )
-    )]
-    pub fn new(
-        py: Python<'_>,
-        days: i32,
-        seconds: i32,
-        microseconds: i32,
-        normalize: bool,
-    ) -> PyResult<&PyDelta> {
-        Self::new_bound(py, days, seconds, microseconds, normalize).map(Bound::into_gil_ref)
-    }
+#[cfg(Py_LIMITED_API)]
+pyobject_native_type_core!(
+    PyDelta,
+    |py| {
+        static TYPE: PyOnceLock<Py<PyType>> = PyOnceLock::new();
+        TYPE.import(py, "datetime", "timedelta").unwrap().as_type_ptr()
+    },
+    #module=Some("datetime")
+);
 
+impl PyDelta {
     /// Creates a new `timedelta`.
-    pub fn new_bound(
+    pub fn new(
         py: Python<'_>,
         days: i32,
         seconds: i32,
         microseconds: i32,
         normalize: bool,
     ) -> PyResult<Bound<'_, PyDelta>> {
-        let api = ensure_datetime_api(py)?;
-        unsafe {
-            (api.Delta_FromDelta)(
-                days as c_int,
-                seconds as c_int,
-                microseconds as c_int,
-                normalize as c_int,
-                api.DeltaType,
-            )
-            .assume_owned_or_err(py)
-            .downcast_into_unchecked()
+        #[cfg(not(Py_LIMITED_API))]
+        {
+            let api = ensure_datetime_api(py)?;
+            unsafe {
+                (api.Delta_FromDelta)(
+                    days as c_int,
+                    seconds as c_int,
+                    microseconds as c_int,
+                    normalize as c_int,
+                    api.DeltaType,
+                )
+                .assume_owned_or_err(py)
+                .cast_into_unchecked()
+            }
         }
-    }
-}
-
-impl PyDeltaAccess for PyDelta {
-    fn get_days(&self) -> i32 {
-        self.as_borrowed().get_days()
-    }
 
-    fn get_seconds(&self) -> i32 {
-        self.as_borrowed().get_seconds()
-    }
-
-    fn get_microseconds(&self) -> i32 {
-        self.as_borrowed().get_microseconds()
+        #[cfg(Py_LIMITED_API)]
+        let _ = normalize;
+        #[cfg(Py_LIMITED_API)]
+        Ok(Self::type_object(py)
+            .call1((days, seconds, microseconds))?
+            .cast_into()?)
     }
 }
 
+#[cfg(not(Py_LIMITED_API))]
 impl PyDeltaAccess for Bound<'_, PyDelta> {
     fn get_days(&self) -> i32 {
         unsafe { PyDateTime_DELTA_GET_DAYS(self.as_ptr()) }
@@ -896,6 +865,7 @@ impl PyDeltaAccess for Bound<'_, PyDelta> {
 
 // Utility function which returns a borrowed reference to either
 // the underlying tzinfo or None.
+#[cfg(not(Py_LIMITED_API))]
 fn opt_to_pyobj(opt: Option<&Bound<'_, PyTzInfo>>) -> *mut ffi::PyObject {
     match opt {
         Some(tzi) => tzi.as_ptr(),
@@ -904,7 +874,6 @@ fn opt_to_pyobj(opt: Option<&Bound<'_, PyTzInfo>>) -> *mut ffi::PyObject {
 }
 
 #[cfg(test)]
-#[cfg_attr(not(feature = "gil-refs"), allow(deprecated))]
 mod tests {
     use super::*;
     #[cfg(feature = "macros")]
@@ -914,7 +883,7 @@ mod tests {
     #[cfg(feature = "macros")]
     #[cfg_attr(target_arch = "wasm32", ignore)] // DateTime import fails on wasm for mysterious reasons
     fn test_datetime_fromtimestamp() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let dt = PyDateTime::from_timestamp(py, 100.0, None).unwrap();
             py_run!(
                 py,
@@ -922,7 +891,8 @@ mod tests {
                 "import datetime; assert dt == datetime.datetime.fromtimestamp(100)"
             );
 
-            let dt = PyDateTime::from_timestamp(py, 100.0, Some(timezone_utc(py))).unwrap();
+            let utc = PyTzInfo::utc(py).unwrap();
+            let dt = PyDateTime::from_timestamp(py, 100.0, Some(&utc)).unwrap();
             py_run!(
                 py,
                 dt,
@@ -935,7 +905,7 @@ mod tests {
     #[cfg(feature = "macros")]
     #[cfg_attr(target_arch = "wasm32", ignore)] // DateTime import fails on wasm for mysterious reasons
     fn test_date_fromtimestamp() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let dt = PyDate::from_timestamp(py, 100).unwrap();
             py_run!(
                 py,
@@ -946,9 +916,10 @@ mod tests {
     }
 
     #[test]
+    #[cfg(not(Py_LIMITED_API))]
     #[cfg_attr(target_arch = "wasm32", ignore)] // DateTime import fails on wasm for mysterious reasons
     fn test_new_with_fold() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let a = PyDateTime::new_with_fold(py, 2021, 1, 23, 20, 32, 40, 341516, None, false);
             let b = PyDateTime::new_with_fold(py, 2021, 1, 23, 20, 32, 40, 341516, None, true);
 
@@ -959,12 +930,11 @@ mod tests {
 
     #[test]
     #[cfg_attr(target_arch = "wasm32", ignore)] // DateTime import fails on wasm for mysterious reasons
-    #[cfg_attr(not(feature = "gil-refs"), allow(deprecated))]
     fn test_get_tzinfo() {
-        crate::Python::with_gil(|py| {
-            let utc = timezone_utc(py);
+        crate::Python::attach(|py| {
+            let utc = PyTzInfo::utc(py).unwrap();
 
-            let dt = PyDateTime::new(py, 2018, 1, 1, 0, 0, 0, 0, Some(utc)).unwrap();
+            let dt = PyDateTime::new(py, 2018, 1, 1, 0, 0, 0, 0, Some(&utc)).unwrap();
 
             assert!(dt.get_tzinfo().unwrap().eq(utc).unwrap());
 
@@ -972,7 +942,7 @@ mod tests {
 
             assert!(dt.get_tzinfo().is_none());
 
-            let t = PyTime::new(py, 0, 0, 0, 0, Some(utc)).unwrap();
+            let t = PyTime::new(py, 0, 0, 0, 0, Some(&utc)).unwrap();
 
             assert!(t.get_tzinfo().unwrap().eq(utc).unwrap());
 
@@ -986,30 +956,32 @@ mod tests {
     #[cfg(all(feature = "macros", feature = "chrono"))]
     #[cfg_attr(target_arch = "wasm32", ignore)] // DateTime import fails on wasm for mysterious reasons
     fn test_timezone_from_offset() {
-        Python::with_gil(|py| {
+        use crate::types::PyNone;
+
+        Python::attach(|py| {
             assert!(
-                timezone_from_offset(&PyDelta::new_bound(py, 0, -3600, 0, true).unwrap())
+                PyTzInfo::fixed_offset(py, PyDelta::new(py, 0, -3600, 0, true).unwrap())
                     .unwrap()
-                    .call_method1("utcoffset", ((),))
+                    .call_method1("utcoffset", (PyNone::get(py),))
                     .unwrap()
-                    .extract::<&PyDelta>()
+                    .cast_into::<PyDelta>()
                     .unwrap()
                     .eq(PyDelta::new(py, 0, -3600, 0, true).unwrap())
                     .unwrap()
             );
 
             assert!(
-                timezone_from_offset(&PyDelta::new_bound(py, 0, 3600, 0, true).unwrap())
+                PyTzInfo::fixed_offset(py, PyDelta::new(py, 0, 3600, 0, true).unwrap())
                     .unwrap()
-                    .call_method1("utcoffset", ((),))
+                    .call_method1("utcoffset", (PyNone::get(py),))
                     .unwrap()
-                    .extract::<&PyDelta>()
+                    .cast_into::<PyDelta>()
                     .unwrap()
                     .eq(PyDelta::new(py, 0, 3600, 0, true).unwrap())
                     .unwrap()
             );
 
-            timezone_from_offset(&PyDelta::new_bound(py, 1, 0, 0, true).unwrap()).unwrap_err();
+            PyTzInfo::fixed_offset(py, PyDelta::new(py, 1, 0, 0, true).unwrap()).unwrap_err();
         })
     }
 }
diff --git a/src/types/dict.rs b/src/types/dict.rs
index 741d974e264..34add02c608 100644
--- a/src/types/dict.rs
+++ b/src/types/dict.rs
@@ -1,17 +1,23 @@
-use super::PyMapping;
 use crate::err::{self, PyErr, PyResult};
 use crate::ffi::Py_ssize_t;
 use crate::ffi_ptr_ext::FfiPtrExt;
 use crate::instance::{Borrowed, Bound};
 use crate::py_result_ext::PyResultExt;
-use crate::types::any::PyAnyMethods;
-use crate::types::{PyAny, PyList};
-use crate::{ffi, PyNativeType, Python, ToPyObject};
+use crate::types::{PyAny, PyList, PyMapping};
+use crate::{ffi, BoundObject, IntoPyObject, IntoPyObjectExt, Python};
 
 /// Represents a Python `dict`.
+///
+/// Values of this type are accessed via PyO3's smart pointers, e.g. as
+/// [`Py<PyDict>`][crate::Py] or [`Bound<'py, PyDict>`][Bound].
+///
+/// For APIs available on `dict` objects, see the [`PyDictMethods`] trait which is implemented for
+/// [`Bound<'py, PyDict>`][Bound].
 #[repr(transparent)]
 pub struct PyDict(PyAny);
 
+pyobject_subclassable_native_type!(PyDict, crate::ffi::PyDictObject);
+
 pyobject_native_type!(
     PyDict,
     ffi::PyDictObject,
@@ -20,11 +26,11 @@ pyobject_native_type!(
 );
 
 /// Represents a Python `dict_keys`.
-#[cfg(not(PyPy))]
+#[cfg(not(any(PyPy, GraalPy)))]
 #[repr(transparent)]
 pub struct PyDictKeys(PyAny);
 
-#[cfg(not(PyPy))]
+#[cfg(not(any(PyPy, GraalPy)))]
 pyobject_native_type_core!(
     PyDictKeys,
     pyobject_native_static_type_object!(ffi::PyDictKeys_Type),
@@ -32,11 +38,11 @@ pyobject_native_type_core!(
 );
 
 /// Represents a Python `dict_values`.
-#[cfg(not(PyPy))]
+#[cfg(not(any(PyPy, GraalPy)))]
 #[repr(transparent)]
 pub struct PyDictValues(PyAny);
 
-#[cfg(not(PyPy))]
+#[cfg(not(any(PyPy, GraalPy)))]
 pyobject_native_type_core!(
     PyDictValues,
     pyobject_native_static_type_object!(ffi::PyDictValues_Type),
@@ -44,11 +50,11 @@ pyobject_native_type_core!(
 );
 
 /// Represents a Python `dict_items`.
-#[cfg(not(PyPy))]
+#[cfg(not(any(PyPy, GraalPy)))]
 #[repr(transparent)]
 pub struct PyDictItems(PyAny);
 
-#[cfg(not(PyPy))]
+#[cfg(not(any(PyPy, GraalPy)))]
 pyobject_native_type_core!(
     PyDictItems,
     pyobject_native_static_type_object!(ffi::PyDictItems_Type),
@@ -56,29 +62,9 @@ pyobject_native_type_core!(
 );
 
 impl PyDict {
-    /// Deprecated form of [`new_bound`][PyDict::new_bound].
-    #[cfg_attr(
-        not(feature = "gil-refs"),
-        deprecated(
-            since = "0.21.0",
-            note = "`PyDict::new` will be replaced by `PyDict::new_bound` in a future PyO3 version"
-        )
-    )]
-    #[inline]
-    pub fn new(py: Python<'_>) -> &PyDict {
-        Self::new_bound(py).into_gil_ref()
-    }
-
     /// Creates a new empty dictionary.
-    pub fn new_bound(py: Python<'_>) -> Bound<'_, PyDict> {
-        unsafe { ffi::PyDict_New().assume_owned(py).downcast_into_unchecked() }
-    }
-
-    /// Deprecated form of [`from_sequence_bound`][PyDict::from_sequence_bound].
-    #[inline]
-    #[cfg(not(PyPy))]
-    pub fn from_sequence(seq: &PyAny) -> PyResult<&PyDict> {
-        Self::from_sequence_bound(&seq.as_borrowed()).map(Bound::into_gil_ref)
+    pub fn new(py: Python<'_>) -> Bound<'_, PyDict> {
+        unsafe { ffi::PyDict_New().assume_owned(py).cast_into_unchecked() }
     }
 
     /// Creates a new dictionary from the sequence given.
@@ -88,193 +74,15 @@ impl PyDict {
     ///
     /// Returns an error on invalid input. In the case of key collisions,
     /// this keeps the last entry seen.
-    #[cfg(not(PyPy))]
-    pub fn from_sequence_bound<'py>(seq: &Bound<'py, PyAny>) -> PyResult<Bound<'py, PyDict>> {
+    #[cfg(not(any(PyPy, GraalPy)))]
+    pub fn from_sequence<'py>(seq: &Bound<'py, PyAny>) -> PyResult<Bound<'py, PyDict>> {
         let py = seq.py();
-        let dict = Self::new_bound(py);
+        let dict = Self::new(py);
         err::error_on_minusone(py, unsafe {
             ffi::PyDict_MergeFromSeq2(dict.as_ptr(), seq.as_ptr(), 1)
         })?;
         Ok(dict)
     }
-
-    /// Returns a new dictionary that contains the same key-value pairs as self.
-    ///
-    /// This is equivalent to the Python expression `self.copy()`.
-    pub fn copy(&self) -> PyResult<&PyDict> {
-        self.as_borrowed().copy().map(Bound::into_gil_ref)
-    }
-
-    /// Empties an existing dictionary of all key-value pairs.
-    pub fn clear(&self) {
-        self.as_borrowed().clear()
-    }
-
-    /// Return the number of items in the dictionary.
-    ///
-    /// This is equivalent to the Python expression `len(self)`.
-    pub fn len(&self) -> usize {
-        self.as_borrowed().len()
-    }
-
-    /// Checks if the dict is empty, i.e. `len(self) == 0`.
-    pub fn is_empty(&self) -> bool {
-        self.as_borrowed().is_empty()
-    }
-
-    /// Determines if the dictionary contains the specified key.
-    ///
-    /// This is equivalent to the Python expression `key in self`.
-    pub fn contains<K>(&self, key: K) -> PyResult<bool>
-    where
-        K: ToPyObject,
-    {
-        self.as_borrowed().contains(key)
-    }
-
-    /// Gets an item from the dictionary.
-    ///
-    /// Returns `Ok(None)` if the item is not present. To get a `KeyError` for
-    /// non-existing keys, use [`PyAny::get_item`].
-    ///
-    /// Returns `Err(PyErr)` if Python magic methods `__hash__` or `__eq__` used in dictionary
-    /// lookup raise an exception, for example if the key `K` is not hashable. Usually it is
-    /// best to bubble this error up to the caller using the `?` operator.
-    ///
-    /// # Examples
-    ///
-    /// The following example calls `get_item` for the dictionary `{"a": 1}` with various
-    /// keys.
-    /// - `get_item("a")` returns `Ok(Some(...))`, with the `PyAny` being a reference to the Python
-    ///   int `1`.
-    /// - `get_item("b")` returns `Ok(None)`, because "b" is not in the dictionary.
-    /// - `get_item(dict)` returns an `Err(PyErr)`. The error will be a `TypeError` because a dict is not
-    ///   hashable.
-    ///
-    /// ```rust
-    /// use pyo3::prelude::*;
-    /// use pyo3::types::{IntoPyDict};
-    /// use pyo3::exceptions::{PyTypeError, PyKeyError};
-    ///
-    /// # fn main() {
-    /// # let _ =
-    /// Python::with_gil(|py| -> PyResult<()> {
-    ///     let dict = &[("a", 1)].into_py_dict_bound(py);
-    ///     // `a` is in the dictionary, with value 1
-    ///     assert!(dict.get_item("a")?.map_or(Ok(false), |x| x.eq(1))?);
-    ///     // `b` is not in the dictionary
-    ///     assert!(dict.get_item("b")?.is_none());
-    ///     // `dict` is not hashable, so this returns an error
-    ///     assert!(dict.get_item(dict).unwrap_err().is_instance_of::<PyTypeError>(py));
-    ///
-    ///     // `PyAny::get_item("b")` will raise a `KeyError` instead of returning `None`
-    ///     let any = dict.as_any();
-    ///     assert!(any.get_item("b").unwrap_err().is_instance_of::<PyKeyError>(py));
-    ///     Ok(())
-    /// });
-    /// # }
-    /// ```
-    pub fn get_item<K>(&self, key: K) -> PyResult<Option<&PyAny>>
-    where
-        K: ToPyObject,
-    {
-        match self.as_borrowed().get_item(key) {
-            Ok(Some(item)) => Ok(Some(item.into_gil_ref())),
-            Ok(None) => Ok(None),
-            Err(e) => Err(e),
-        }
-    }
-
-    /// Deprecated version of `get_item`.
-    #[deprecated(
-        since = "0.20.0",
-        note = "this is now equivalent to `PyDict::get_item`"
-    )]
-    #[inline]
-    pub fn get_item_with_error<K>(&self, key: K) -> PyResult<Option<&PyAny>>
-    where
-        K: ToPyObject,
-    {
-        self.get_item(key)
-    }
-
-    /// Sets an item value.
-    ///
-    /// This is equivalent to the Python statement `self[key] = value`.
-    pub fn set_item<K, V>(&self, key: K, value: V) -> PyResult<()>
-    where
-        K: ToPyObject,
-        V: ToPyObject,
-    {
-        self.as_borrowed().set_item(key, value)
-    }
-
-    /// Deletes an item.
-    ///
-    /// This is equivalent to the Python statement `del self[key]`.
-    pub fn del_item<K>(&self, key: K) -> PyResult<()>
-    where
-        K: ToPyObject,
-    {
-        self.as_borrowed().del_item(key)
-    }
-
-    /// Returns a list of dict keys.
-    ///
-    /// This is equivalent to the Python expression `list(dict.keys())`.
-    pub fn keys(&self) -> &PyList {
-        self.as_borrowed().keys().into_gil_ref()
-    }
-
-    /// Returns a list of dict values.
-    ///
-    /// This is equivalent to the Python expression `list(dict.values())`.
-    pub fn values(&self) -> &PyList {
-        self.as_borrowed().values().into_gil_ref()
-    }
-
-    /// Returns a list of dict items.
-    ///
-    /// This is equivalent to the Python expression `list(dict.items())`.
-    pub fn items(&self) -> &PyList {
-        self.as_borrowed().items().into_gil_ref()
-    }
-
-    /// Returns an iterator of `(key, value)` pairs in this dictionary.
-    ///
-    /// # Panics
-    ///
-    /// If PyO3 detects that the dictionary is mutated during iteration, it will panic.
-    /// It is allowed to modify values as you iterate over the dictionary, but only
-    /// so long as the set of keys does not change.
-    pub fn iter(&self) -> PyDictIterator<'_> {
-        PyDictIterator(self.as_borrowed().iter())
-    }
-
-    /// Returns `self` cast as a `PyMapping`.
-    pub fn as_mapping(&self) -> &PyMapping {
-        unsafe { self.downcast_unchecked() }
-    }
-
-    /// Update this dictionary with the key/value pairs from another.
-    ///
-    /// This is equivalent to the Python expression `self.update(other)`. If `other` is a `PyDict`, you may want
-    /// to use `self.update(other.as_mapping())`, note: `PyDict::as_mapping` is a zero-cost conversion.
-    pub fn update(&self, other: &PyMapping) -> PyResult<()> {
-        self.as_borrowed().update(&other.as_borrowed())
-    }
-
-    /// Add key/value pairs from another dictionary to this one only when they do not exist in this.
-    ///
-    /// This is equivalent to the Python expression `self.update({k: v for k, v in other.items() if k not in self})`.
-    /// If `other` is a `PyDict`, you may want to use `self.update_if_missing(other.as_mapping())`,
-    /// note: `PyDict::as_mapping` is a zero-cost conversion.
-    ///
-    /// This method uses [`PyDict_Merge`](https://docs.python.org/3/c-api/dict.html#c.PyDict_Merge) internally,
-    /// so should have the same performance as `update`.
-    pub fn update_if_missing(&self, other: &PyMapping) -> PyResult<()> {
-        self.as_borrowed().update_if_missing(&other.as_borrowed())
-    }
 }
 
 /// Implementation of functionality for [`PyDict`].
@@ -283,7 +91,7 @@ impl PyDict {
 /// syntax these methods are separated into a trait, because stable Rust does not yet support
 /// `arbitrary_self_types`.
 #[doc(alias = "PyDict")]
-pub trait PyDictMethods<'py> {
+pub trait PyDictMethods<'py>: crate::sealed::Sealed {
     /// Returns a new dictionary that contains the same key-value pairs as self.
     ///
     /// This is equivalent to the Python expression `self.copy()`.
@@ -305,7 +113,7 @@ pub trait PyDictMethods<'py> {
     /// This is equivalent to the Python expression `key in self`.
     fn contains<K>(&self, key: K) -> PyResult<bool>
     where
-        K: ToPyObject;
+        K: IntoPyObject<'py>;
 
     /// Gets an item from the dictionary.
     ///
@@ -314,22 +122,22 @@ pub trait PyDictMethods<'py> {
     /// To get a `KeyError` for non-existing keys, use `PyAny::get_item`.
     fn get_item<K>(&self, key: K) -> PyResult<Option<Bound<'py, PyAny>>>
     where
-        K: ToPyObject;
+        K: IntoPyObject<'py>;
 
     /// Sets an item value.
     ///
     /// This is equivalent to the Python statement `self[key] = value`.
     fn set_item<K, V>(&self, key: K, value: V) -> PyResult<()>
     where
-        K: ToPyObject,
-        V: ToPyObject;
+        K: IntoPyObject<'py>,
+        V: IntoPyObject<'py>;
 
     /// Deletes an item.
     ///
     /// This is equivalent to the Python statement `del self[key]`.
     fn del_item<K>(&self, key: K) -> PyResult<()>
     where
-        K: ToPyObject;
+        K: IntoPyObject<'py>;
 
     /// Returns a list of dict keys.
     ///
@@ -355,9 +163,26 @@ pub trait PyDictMethods<'py> {
     /// so long as the set of keys does not change.
     fn iter(&self) -> BoundDictIterator<'py>;
 
+    /// Iterates over the contents of this dictionary while holding a critical section on the dict.
+    /// This is useful when the GIL is disabled and the dictionary is shared between threads.
+    /// It is not guaranteed that the dictionary will not be modified during iteration when the
+    /// closure calls arbitrary Python code that releases the critical section held by the
+    /// iterator. Otherwise, the dictionary will not be modified during iteration.
+    ///
+    /// This method is a small performance optimization over `.iter().try_for_each()` when the
+    /// nightly feature is not enabled because we cannot implement an optimised version of
+    /// `iter().try_fold()` on stable yet. If your iteration is infallible then this method has the
+    /// same performance as `.iter().for_each()`.
+    fn locked_for_each<F>(&self, closure: F) -> PyResult<()>
+    where
+        F: Fn(Bound<'py, PyAny>, Bound<'py, PyAny>) -> PyResult<()>;
+
     /// Returns `self` cast as a `PyMapping`.
     fn as_mapping(&self) -> &Bound<'py, PyMapping>;
 
+    /// Returns `self` cast as a `PyMapping`.
+    fn into_mapping(self) -> Bound<'py, PyMapping>;
+
     /// Update this dictionary with the key/value pairs from another.
     ///
     /// This is equivalent to the Python expression `self.update(other)`. If `other` is a `PyDict`, you may want
@@ -380,7 +205,7 @@ impl<'py> PyDictMethods<'py> for Bound<'py, PyDict> {
         unsafe {
             ffi::PyDict_Copy(self.as_ptr())
                 .assume_owned_or_err(self.py())
-                .downcast_into_unchecked()
+                .cast_into_unchecked()
         }
     }
 
@@ -398,9 +223,9 @@ impl<'py> PyDictMethods<'py> for Bound<'py, PyDict> {
 
     fn contains<K>(&self, key: K) -> PyResult<bool>
     where
-        K: ToPyObject,
+        K: IntoPyObject<'py>,
     {
-        fn inner(dict: &Bound<'_, PyDict>, key: Bound<'_, PyAny>) -> PyResult<bool> {
+        fn inner(dict: &Bound<'_, PyDict>, key: Borrowed<'_, '_, PyAny>) -> PyResult<bool> {
             match unsafe { ffi::PyDict_Contains(dict.as_ptr(), key.as_ptr()) } {
                 1 => Ok(true),
                 0 => Ok(false),
@@ -409,41 +234,51 @@ impl<'py> PyDictMethods<'py> for Bound<'py, PyDict> {
         }
 
         let py = self.py();
-        inner(self, key.to_object(py).into_bound(py))
+        inner(
+            self,
+            key.into_pyobject_or_pyerr(py)?.into_any().as_borrowed(),
+        )
     }
 
     fn get_item<K>(&self, key: K) -> PyResult<Option<Bound<'py, PyAny>>>
     where
-        K: ToPyObject,
+        K: IntoPyObject<'py>,
     {
         fn inner<'py>(
             dict: &Bound<'py, PyDict>,
-            key: Bound<'_, PyAny>,
+            key: Borrowed<'_, '_, PyAny>,
         ) -> PyResult<Option<Bound<'py, PyAny>>> {
             let py = dict.py();
+            let mut result: *mut ffi::PyObject = std::ptr::null_mut();
             match unsafe {
-                ffi::PyDict_GetItemWithError(dict.as_ptr(), key.as_ptr())
-                    .assume_borrowed_or_opt(py)
-                    .map(Borrowed::to_owned)
+                ffi::compat::PyDict_GetItemRef(dict.as_ptr(), key.as_ptr(), &mut result)
             } {
-                some @ Some(_) => Ok(some),
-                None => PyErr::take(py).map(Err).transpose(),
+                std::ffi::c_int::MIN..=-1 => Err(PyErr::fetch(py)),
+                0 => Ok(None),
+                1..=std::ffi::c_int::MAX => {
+                    // Safety: PyDict_GetItemRef positive return value means the result is a valid
+                    // owned reference
+                    Ok(Some(unsafe { result.assume_owned_unchecked(py) }))
+                }
             }
         }
 
         let py = self.py();
-        inner(self, key.to_object(py).into_bound(py))
+        inner(
+            self,
+            key.into_pyobject_or_pyerr(py)?.into_any().as_borrowed(),
+        )
     }
 
     fn set_item<K, V>(&self, key: K, value: V) -> PyResult<()>
     where
-        K: ToPyObject,
-        V: ToPyObject,
+        K: IntoPyObject<'py>,
+        V: IntoPyObject<'py>,
     {
         fn inner(
             dict: &Bound<'_, PyDict>,
-            key: Bound<'_, PyAny>,
-            value: Bound<'_, PyAny>,
+            key: Borrowed<'_, '_, PyAny>,
+            value: Borrowed<'_, '_, PyAny>,
         ) -> PyResult<()> {
             err::error_on_minusone(dict.py(), unsafe {
                 ffi::PyDict_SetItem(dict.as_ptr(), key.as_ptr(), value.as_ptr())
@@ -453,30 +288,33 @@ impl<'py> PyDictMethods<'py> for Bound<'py, PyDict> {
         let py = self.py();
         inner(
             self,
-            key.to_object(py).into_bound(py),
-            value.to_object(py).into_bound(py),
+            key.into_pyobject_or_pyerr(py)?.into_any().as_borrowed(),
+            value.into_pyobject_or_pyerr(py)?.into_any().as_borrowed(),
         )
     }
 
     fn del_item<K>(&self, key: K) -> PyResult<()>
     where
-        K: ToPyObject,
+        K: IntoPyObject<'py>,
     {
-        fn inner(dict: &Bound<'_, PyDict>, key: Bound<'_, PyAny>) -> PyResult<()> {
+        fn inner(dict: &Bound<'_, PyDict>, key: Borrowed<'_, '_, PyAny>) -> PyResult<()> {
             err::error_on_minusone(dict.py(), unsafe {
                 ffi::PyDict_DelItem(dict.as_ptr(), key.as_ptr())
             })
         }
 
         let py = self.py();
-        inner(self, key.to_object(py).into_bound(py))
+        inner(
+            self,
+            key.into_pyobject_or_pyerr(py)?.into_any().as_borrowed(),
+        )
     }
 
     fn keys(&self) -> Bound<'py, PyList> {
         unsafe {
             ffi::PyDict_Keys(self.as_ptr())
                 .assume_owned(self.py())
-                .downcast_into_unchecked()
+                .cast_into_unchecked()
         }
     }
 
@@ -484,7 +322,7 @@ impl<'py> PyDictMethods<'py> for Bound<'py, PyDict> {
         unsafe {
             ffi::PyDict_Values(self.as_ptr())
                 .assume_owned(self.py())
-                .downcast_into_unchecked()
+                .cast_into_unchecked()
         }
     }
 
@@ -492,7 +330,7 @@ impl<'py> PyDictMethods<'py> for Bound<'py, PyDict> {
         unsafe {
             ffi::PyDict_Items(self.as_ptr())
                 .assume_owned(self.py())
-                .downcast_into_unchecked()
+                .cast_into_unchecked()
         }
     }
 
@@ -500,8 +338,31 @@ impl<'py> PyDictMethods<'py> for Bound<'py, PyDict> {
         BoundDictIterator::new(self.clone())
     }
 
+    fn locked_for_each<F>(&self, f: F) -> PyResult<()>
+    where
+        F: Fn(Bound<'py, PyAny>, Bound<'py, PyAny>) -> PyResult<()>,
+    {
+        #[cfg(feature = "nightly")]
+        {
+            // We don't need a critical section when the nightly feature is enabled because
+            // try_for_each is locked by the implementation of try_fold.
+            self.iter().try_for_each(|(key, value)| f(key, value))
+        }
+
+        #[cfg(not(feature = "nightly"))]
+        {
+            crate::sync::with_critical_section(self, || {
+                self.iter().try_for_each(|(key, value)| f(key, value))
+            })
+        }
+    }
+
     fn as_mapping(&self) -> &Bound<'py, PyMapping> {
-        unsafe { self.downcast_unchecked() }
+        unsafe { self.cast_unchecked() }
+    }
+
+    fn into_mapping(self) -> Bound<'py, PyMapping> {
+        unsafe { self.cast_into_unchecked() }
     }
 
     fn update(&self, other: &Bound<'_, PyMapping>) -> PyResult<()> {
@@ -517,107 +378,138 @@ impl<'py> PyDictMethods<'py> for Bound<'py, PyDict> {
     }
 }
 
+impl<'a, 'py> Borrowed<'a, 'py, PyDict> {
+    /// Iterates over the contents of this dictionary without incrementing reference counts.
+    ///
+    /// # Safety
+    /// It must be known that this dictionary will not be modified during iteration,
+    /// for example, when parsing arguments in a keyword arguments dictionary.
+    pub(crate) unsafe fn iter_borrowed(self) -> BorrowedDictIter<'a, 'py> {
+        BorrowedDictIter::new(self)
+    }
+}
+
 fn dict_len(dict: &Bound<'_, PyDict>) -> Py_ssize_t {
-    #[cfg(any(not(Py_3_8), PyPy, Py_LIMITED_API))]
+    #[cfg(any(not(Py_3_8), PyPy, GraalPy, Py_LIMITED_API, Py_GIL_DISABLED))]
     unsafe {
         ffi::PyDict_Size(dict.as_ptr())
     }
 
-    #[cfg(all(Py_3_8, not(PyPy), not(Py_LIMITED_API)))]
+    #[cfg(all(
+        Py_3_8,
+        not(PyPy),
+        not(GraalPy),
+        not(Py_LIMITED_API),
+        not(Py_GIL_DISABLED)
+    ))]
     unsafe {
         (*dict.as_ptr().cast::<ffi::PyDictObject>()).ma_used
     }
 }
 
 /// PyO3 implementation of an iterator for a Python `dict` object.
-pub struct PyDictIterator<'py>(BoundDictIterator<'py>);
+pub struct BoundDictIterator<'py> {
+    dict: Bound<'py, PyDict>,
+    inner: DictIterImpl,
+}
 
-impl<'py> Iterator for PyDictIterator<'py> {
-    type Item = (&'py PyAny, &'py PyAny);
+enum DictIterImpl {
+    DictIter {
+        ppos: ffi::Py_ssize_t,
+        di_used: ffi::Py_ssize_t,
+        remaining: ffi::Py_ssize_t,
+    },
+}
 
+impl DictIterImpl {
+    #[deny(unsafe_op_in_unsafe_fn)]
     #[inline]
-    fn next(&mut self) -> Option<Self::Item> {
-        let (key, value) = self.0.next()?;
-        Some((key.into_gil_ref(), value.into_gil_ref()))
-    }
+    /// Safety: the dict should be locked with a critical section on the free-threaded build
+    /// and otherwise not shared between threads in code that releases the GIL.
+    unsafe fn next_unchecked<'py>(
+        &mut self,
+        dict: &Bound<'py, PyDict>,
+    ) -> Option<(Bound<'py, PyAny>, Bound<'py, PyAny>)> {
+        match self {
+            Self::DictIter {
+                di_used,
+                remaining,
+                ppos,
+                ..
+            } => {
+                let ma_used = dict_len(dict);
+
+                // These checks are similar to what CPython does.
+                //
+                // If the dimension of the dict changes e.g. key-value pairs are removed
+                // or added during iteration, this will panic next time when `next` is called
+                if *di_used != ma_used {
+                    *di_used = -1;
+                    panic!("dictionary changed size during iteration");
+                };
 
-    #[inline]
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        self.0.size_hint()
-    }
-}
+                // If the dict is changed in such a way that the length remains constant
+                // then this will panic at the end of iteration - similar to this:
+                //
+                // d = {"a":1, "b":2, "c": 3}
+                //
+                // for k, v in d.items():
+                //     d[f"{k}_"] = 4
+                //     del d[k]
+                //     print(k)
+                //
+                if *remaining == -1 {
+                    *di_used = -1;
+                    panic!("dictionary keys changed during iteration");
+                };
 
-impl<'py> ExactSizeIterator for PyDictIterator<'py> {
-    fn len(&self) -> usize {
-        self.0.len()
+                let mut key: *mut ffi::PyObject = std::ptr::null_mut();
+                let mut value: *mut ffi::PyObject = std::ptr::null_mut();
+
+                if unsafe { ffi::PyDict_Next(dict.as_ptr(), ppos, &mut key, &mut value) != 0 } {
+                    *remaining -= 1;
+                    let py = dict.py();
+                    // Safety:
+                    // - PyDict_Next returns borrowed values
+                    // - we have already checked that `PyDict_Next` succeeded, so we can assume these to be non-null
+                    Some((
+                        unsafe { key.assume_borrowed_unchecked(py).to_owned() },
+                        unsafe { value.assume_borrowed_unchecked(py).to_owned() },
+                    ))
+                } else {
+                    None
+                }
+            }
+        }
     }
-}
-
-impl<'a> IntoIterator for &'a PyDict {
-    type Item = (&'a PyAny, &'a PyAny);
-    type IntoIter = PyDictIterator<'a>;
 
-    fn into_iter(self) -> Self::IntoIter {
-        self.iter()
+    #[cfg(Py_GIL_DISABLED)]
+    #[inline]
+    fn with_critical_section<F, R>(&mut self, dict: &Bound<'_, PyDict>, f: F) -> R
+    where
+        F: FnOnce(&mut Self) -> R,
+    {
+        match self {
+            Self::DictIter { .. } => crate::sync::with_critical_section(dict, || f(self)),
+        }
     }
 }
 
-/// PyO3 implementation of an iterator for a Python `dict` object.
-pub struct BoundDictIterator<'py> {
-    dict: Bound<'py, PyDict>,
-    ppos: ffi::Py_ssize_t,
-    di_used: ffi::Py_ssize_t,
-    len: ffi::Py_ssize_t,
-}
-
 impl<'py> Iterator for BoundDictIterator<'py> {
     type Item = (Bound<'py, PyAny>, Bound<'py, PyAny>);
 
     #[inline]
     fn next(&mut self) -> Option<Self::Item> {
-        let ma_used = dict_len(&self.dict);
-
-        // These checks are similar to what CPython does.
-        //
-        // If the dimension of the dict changes e.g. key-value pairs are removed
-        // or added during iteration, this will panic next time when `next` is called
-        if self.di_used != ma_used {
-            self.di_used = -1;
-            panic!("dictionary changed size during iteration");
-        };
-
-        // If the dict is changed in such a way that the length remains constant
-        // then this will panic at the end of iteration - similar to this:
-        //
-        // d = {"a":1, "b":2, "c": 3}
-        //
-        // for k, v in d.items():
-        //     d[f"{k}_"] = 4
-        //     del d[k]
-        //     print(k)
-        //
-        if self.len == -1 {
-            self.di_used = -1;
-            panic!("dictionary keys changed during iteration");
-        };
-
-        let mut key: *mut ffi::PyObject = std::ptr::null_mut();
-        let mut value: *mut ffi::PyObject = std::ptr::null_mut();
-
-        if unsafe { ffi::PyDict_Next(self.dict.as_ptr(), &mut self.ppos, &mut key, &mut value) }
-            != 0
+        #[cfg(Py_GIL_DISABLED)]
         {
-            self.len -= 1;
-            let py = self.dict.py();
-            // Safety:
-            // - PyDict_Next returns borrowed values
-            // - we have already checked that `PyDict_Next` succeeded, so we can assume these to be non-null
-            Some((
-                unsafe { key.assume_borrowed_unchecked(py) }.to_owned(),
-                unsafe { value.assume_borrowed_unchecked(py) }.to_owned(),
-            ))
-        } else {
-            None
+            self.inner
+                .with_critical_section(&self.dict, |inner| unsafe {
+                    inner.next_unchecked(&self.dict)
+                })
+        }
+        #[cfg(not(Py_GIL_DISABLED))]
+        {
+            unsafe { self.inner.next_unchecked(&self.dict) }
         }
     }
 
@@ -626,22 +518,155 @@ impl<'py> Iterator for BoundDictIterator<'py> {
         let len = self.len();
         (len, Some(len))
     }
+
+    #[inline]
+    fn count(self) -> usize
+    where
+        Self: Sized,
+    {
+        self.len()
+    }
+
+    #[inline]
+    #[cfg(Py_GIL_DISABLED)]
+    fn fold<B, F>(mut self, init: B, mut f: F) -> B
+    where
+        Self: Sized,
+        F: FnMut(B, Self::Item) -> B,
+    {
+        self.inner.with_critical_section(&self.dict, |inner| {
+            let mut accum = init;
+            while let Some(x) = unsafe { inner.next_unchecked(&self.dict) } {
+                accum = f(accum, x);
+            }
+            accum
+        })
+    }
+
+    #[inline]
+    #[cfg(all(Py_GIL_DISABLED, feature = "nightly"))]
+    fn try_fold<B, F, R>(&mut self, init: B, mut f: F) -> R
+    where
+        Self: Sized,
+        F: FnMut(B, Self::Item) -> R,
+        R: std::ops::Try<Output = B>,
+    {
+        self.inner.with_critical_section(&self.dict, |inner| {
+            let mut accum = init;
+            while let Some(x) = unsafe { inner.next_unchecked(&self.dict) } {
+                accum = f(accum, x)?
+            }
+            R::from_output(accum)
+        })
+    }
+
+    #[inline]
+    #[cfg(all(Py_GIL_DISABLED, not(feature = "nightly")))]
+    fn all<F>(&mut self, mut f: F) -> bool
+    where
+        Self: Sized,
+        F: FnMut(Self::Item) -> bool,
+    {
+        self.inner.with_critical_section(&self.dict, |inner| {
+            while let Some(x) = unsafe { inner.next_unchecked(&self.dict) } {
+                if !f(x) {
+                    return false;
+                }
+            }
+            true
+        })
+    }
+
+    #[inline]
+    #[cfg(all(Py_GIL_DISABLED, not(feature = "nightly")))]
+    fn any<F>(&mut self, mut f: F) -> bool
+    where
+        Self: Sized,
+        F: FnMut(Self::Item) -> bool,
+    {
+        self.inner.with_critical_section(&self.dict, |inner| {
+            while let Some(x) = unsafe { inner.next_unchecked(&self.dict) } {
+                if f(x) {
+                    return true;
+                }
+            }
+            false
+        })
+    }
+
+    #[inline]
+    #[cfg(all(Py_GIL_DISABLED, not(feature = "nightly")))]
+    fn find<P>(&mut self, mut predicate: P) -> Option<Self::Item>
+    where
+        Self: Sized,
+        P: FnMut(&Self::Item) -> bool,
+    {
+        self.inner.with_critical_section(&self.dict, |inner| {
+            while let Some(x) = unsafe { inner.next_unchecked(&self.dict) } {
+                if predicate(&x) {
+                    return Some(x);
+                }
+            }
+            None
+        })
+    }
+
+    #[inline]
+    #[cfg(all(Py_GIL_DISABLED, not(feature = "nightly")))]
+    fn find_map<B, F>(&mut self, mut f: F) -> Option<B>
+    where
+        Self: Sized,
+        F: FnMut(Self::Item) -> Option<B>,
+    {
+        self.inner.with_critical_section(&self.dict, |inner| {
+            while let Some(x) = unsafe { inner.next_unchecked(&self.dict) } {
+                if let found @ Some(_) = f(x) {
+                    return found;
+                }
+            }
+            None
+        })
+    }
+
+    #[inline]
+    #[cfg(all(Py_GIL_DISABLED, not(feature = "nightly")))]
+    fn position<P>(&mut self, mut predicate: P) -> Option<usize>
+    where
+        Self: Sized,
+        P: FnMut(Self::Item) -> bool,
+    {
+        self.inner.with_critical_section(&self.dict, |inner| {
+            let mut acc = 0;
+            while let Some(x) = unsafe { inner.next_unchecked(&self.dict) } {
+                if predicate(x) {
+                    return Some(acc);
+                }
+                acc += 1;
+            }
+            None
+        })
+    }
 }
 
-impl<'py> ExactSizeIterator for BoundDictIterator<'py> {
+impl ExactSizeIterator for BoundDictIterator<'_> {
     fn len(&self) -> usize {
-        self.len as usize
+        match self.inner {
+            DictIterImpl::DictIter { remaining, .. } => remaining as usize,
+        }
     }
 }
 
 impl<'py> BoundDictIterator<'py> {
     fn new(dict: Bound<'py, PyDict>) -> Self {
-        let len = dict_len(&dict);
-        BoundDictIterator {
+        let remaining = dict_len(&dict);
+
+        Self {
             dict,
-            ppos: 0,
-            di_used: len,
-            len,
+            inner: DictIterImpl::DictIter {
+                ppos: 0,
+                di_used: remaining,
+                remaining,
+            },
         }
     }
 }
@@ -655,95 +680,152 @@ impl<'py> IntoIterator for Bound<'py, PyDict> {
     }
 }
 
-/// Conversion trait that allows a sequence of tuples to be converted into `PyDict`
-/// Primary use case for this trait is `call` and `call_method` methods as keywords argument.
-pub trait IntoPyDict: Sized {
-    /// Converts self into a `PyDict` object pointer. Whether pointer owned or borrowed
-    /// depends on implementation.
-    #[cfg_attr(
-        not(feature = "gil-refs"),
-        deprecated(
-            since = "0.21.0",
-            note = "`IntoPyDict::into_py_dict` will be replaced by `IntoPyDict::into_py_dict_bound` in a future PyO3 version"
-        )
-    )]
-    fn into_py_dict(self, py: Python<'_>) -> &PyDict {
-        Self::into_py_dict_bound(self, py).into_gil_ref()
+impl<'py> IntoIterator for &Bound<'py, PyDict> {
+    type Item = (Bound<'py, PyAny>, Bound<'py, PyAny>);
+    type IntoIter = BoundDictIterator<'py>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.iter()
+    }
+}
+
+mod borrowed_iter {
+    use super::*;
+
+    /// Variant of the above which is used to iterate the items of the dictionary
+    /// without incrementing reference counts. This is only safe if it's known
+    /// that the dictionary will not be modified during iteration.
+    pub struct BorrowedDictIter<'a, 'py> {
+        dict: Borrowed<'a, 'py, PyDict>,
+        ppos: ffi::Py_ssize_t,
+        len: ffi::Py_ssize_t,
     }
 
+    impl<'a, 'py> Iterator for BorrowedDictIter<'a, 'py> {
+        type Item = (Borrowed<'a, 'py, PyAny>, Borrowed<'a, 'py, PyAny>);
+
+        #[inline]
+        fn next(&mut self) -> Option<Self::Item> {
+            let mut key: *mut ffi::PyObject = std::ptr::null_mut();
+            let mut value: *mut ffi::PyObject = std::ptr::null_mut();
+
+            // Safety: self.dict lives sufficiently long that the pointer is not dangling
+            if unsafe { ffi::PyDict_Next(self.dict.as_ptr(), &mut self.ppos, &mut key, &mut value) }
+                != 0
+            {
+                let py = self.dict.py();
+                self.len -= 1;
+                // Safety:
+                // - PyDict_Next returns borrowed values
+                // - we have already checked that `PyDict_Next` succeeded, so we can assume these to be non-null
+                Some(unsafe {
+                    (
+                        key.assume_borrowed_unchecked(py),
+                        value.assume_borrowed_unchecked(py),
+                    )
+                })
+            } else {
+                None
+            }
+        }
+
+        #[inline]
+        fn size_hint(&self) -> (usize, Option<usize>) {
+            let len = self.len();
+            (len, Some(len))
+        }
+
+        #[inline]
+        fn count(self) -> usize
+        where
+            Self: Sized,
+        {
+            self.len()
+        }
+    }
+
+    impl ExactSizeIterator for BorrowedDictIter<'_, '_> {
+        fn len(&self) -> usize {
+            self.len as usize
+        }
+    }
+
+    impl<'a, 'py> BorrowedDictIter<'a, 'py> {
+        pub(super) fn new(dict: Borrowed<'a, 'py, PyDict>) -> Self {
+            let len = dict_len(&dict);
+            BorrowedDictIter { dict, ppos: 0, len }
+        }
+    }
+}
+
+pub(crate) use borrowed_iter::BorrowedDictIter;
+
+/// Conversion trait that allows a sequence of tuples to be converted into `PyDict`
+/// Primary use case for this trait is `call` and `call_method` methods as keywords argument.
+pub trait IntoPyDict<'py>: Sized {
     /// Converts self into a `PyDict` object pointer. Whether pointer owned or borrowed
     /// depends on implementation.
-    fn into_py_dict_bound(self, py: Python<'_>) -> Bound<'_, PyDict>;
+    fn into_py_dict(self, py: Python<'py>) -> PyResult<Bound<'py, PyDict>>;
 }
 
-impl<T, I> IntoPyDict for I
+impl<'py, T, I> IntoPyDict<'py> for I
 where
-    T: PyDictItem,
+    T: PyDictItem<'py>,
     I: IntoIterator<Item = T>,
 {
-    fn into_py_dict_bound(self, py: Python<'_>) -> Bound<'_, PyDict> {
-        let dict = PyDict::new_bound(py);
-        for item in self {
-            dict.set_item(item.key(), item.value())
-                .expect("Failed to set_item on dict");
-        }
-        dict
+    fn into_py_dict(self, py: Python<'py>) -> PyResult<Bound<'py, PyDict>> {
+        let dict = PyDict::new(py);
+        self.into_iter().try_for_each(|item| {
+            let (key, value) = item.unpack();
+            dict.set_item(key, value)
+        })?;
+        Ok(dict)
     }
 }
 
 /// Represents a tuple which can be used as a PyDict item.
-pub trait PyDictItem {
-    type K: ToPyObject;
-    type V: ToPyObject;
-    fn key(&self) -> &Self::K;
-    fn value(&self) -> &Self::V;
+trait PyDictItem<'py> {
+    type K: IntoPyObject<'py>;
+    type V: IntoPyObject<'py>;
+    fn unpack(self) -> (Self::K, Self::V);
 }
 
-impl<K, V> PyDictItem for (K, V)
+impl<'py, K, V> PyDictItem<'py> for (K, V)
 where
-    K: ToPyObject,
-    V: ToPyObject,
+    K: IntoPyObject<'py>,
+    V: IntoPyObject<'py>,
 {
     type K = K;
     type V = V;
-    fn key(&self) -> &Self::K {
-        &self.0
-    }
-    fn value(&self) -> &Self::V {
-        &self.1
+
+    fn unpack(self) -> (Self::K, Self::V) {
+        (self.0, self.1)
     }
 }
 
-impl<K, V> PyDictItem for &(K, V)
+impl<'a, 'py, K, V> PyDictItem<'py> for &'a (K, V)
 where
-    K: ToPyObject,
-    V: ToPyObject,
+    &'a K: IntoPyObject<'py>,
+    &'a V: IntoPyObject<'py>,
 {
-    type K = K;
-    type V = V;
-    fn key(&self) -> &Self::K {
-        &self.0
-    }
-    fn value(&self) -> &Self::V {
-        &self.1
+    type K = &'a K;
+    type V = &'a V;
+
+    fn unpack(self) -> (Self::K, Self::V) {
+        (&self.0, &self.1)
     }
 }
 
 #[cfg(test)]
-#[cfg_attr(not(feature = "gil-refs"), allow(deprecated))]
 mod tests {
     use super::*;
-    #[cfg(not(PyPy))]
-    use crate::exceptions;
-    #[cfg(not(PyPy))]
-    use crate::types::PyList;
-    use crate::{types::PyTuple, Python, ToPyObject};
+    use crate::types::{PyAnyMethods as _, PyTuple};
     use std::collections::{BTreeMap, HashMap};
 
     #[test]
     fn test_new() {
-        Python::with_gil(|py| {
-            let dict = [(7, 32)].into_py_dict_bound(py);
+        Python::attach(|py| {
+            let dict = [(7, 32)].into_py_dict(py).unwrap();
             assert_eq!(
                 32,
                 dict.get_item(7i32)
@@ -761,11 +843,11 @@ mod tests {
     }
 
     #[test]
-    #[cfg(not(PyPy))]
+    #[cfg(not(any(PyPy, GraalPy)))]
     fn test_from_sequence() {
-        Python::with_gil(|py| {
-            let items = PyList::new(py, &vec![("a", 1), ("b", 2)]);
-            let dict = PyDict::from_sequence(items).unwrap();
+        Python::attach(|py| {
+            let items = PyList::new(py, vec![("a", 1), ("b", 2)]).unwrap();
+            let dict = PyDict::from_sequence(&items).unwrap();
             assert_eq!(
                 1,
                 dict.get_item("a")
@@ -792,18 +874,18 @@ mod tests {
     }
 
     #[test]
-    #[cfg(not(PyPy))]
+    #[cfg(not(any(PyPy, GraalPy)))]
     fn test_from_sequence_err() {
-        Python::with_gil(|py| {
-            let items = PyList::new(py, &vec!["a", "b"]);
-            assert!(PyDict::from_sequence(items).is_err());
+        Python::attach(|py| {
+            let items = PyList::new(py, vec!["a", "b"]).unwrap();
+            assert!(PyDict::from_sequence(&items).is_err());
         });
     }
 
     #[test]
     fn test_copy() {
-        Python::with_gil(|py| {
-            let dict = [(7, 32)].into_py_dict_bound(py);
+        Python::attach(|py| {
+            let dict = [(7, 32)].into_py_dict(py).unwrap();
 
             let ndict = dict.copy().unwrap();
             assert_eq!(
@@ -821,25 +903,22 @@ mod tests {
 
     #[test]
     fn test_len() {
-        Python::with_gil(|py| {
-            let mut v = HashMap::new();
-            let ob = v.to_object(py);
-            let dict: &PyDict = ob.downcast(py).unwrap();
+        Python::attach(|py| {
+            let mut v = HashMap::<i32, i32>::new();
+            let dict = (&v).into_pyobject(py).unwrap();
             assert_eq!(0, dict.len());
             v.insert(7, 32);
-            let ob = v.to_object(py);
-            let dict2: &PyDict = ob.downcast(py).unwrap();
+            let dict2 = v.into_pyobject(py).unwrap();
             assert_eq!(1, dict2.len());
         });
     }
 
     #[test]
     fn test_contains() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let mut v = HashMap::new();
             v.insert(7, 32);
-            let ob = v.to_object(py);
-            let dict: &PyDict = ob.downcast(py).unwrap();
+            let dict = v.into_pyobject(py).unwrap();
             assert!(dict.contains(7i32).unwrap());
             assert!(!dict.contains(8i32).unwrap());
         });
@@ -847,11 +926,10 @@ mod tests {
 
     #[test]
     fn test_get_item() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let mut v = HashMap::new();
             v.insert(7, 32);
-            let ob = v.to_object(py);
-            let dict: &PyDict = ob.downcast(py).unwrap();
+            let dict = v.into_pyobject(py).unwrap();
             assert_eq!(
                 32,
                 dict.get_item(7i32)
@@ -864,38 +942,48 @@ mod tests {
         });
     }
 
+    #[cfg(feature = "macros")]
     #[test]
-    #[allow(deprecated)]
-    #[cfg(not(PyPy))]
-    fn test_get_item_with_error() {
-        Python::with_gil(|py| {
-            let mut v = HashMap::new();
-            v.insert(7, 32);
-            let ob = v.to_object(py);
-            let dict: &PyDict = ob.downcast(py).unwrap();
-            assert_eq!(
-                32,
-                dict.get_item_with_error(7i32)
-                    .unwrap()
-                    .unwrap()
-                    .extract::<i32>()
-                    .unwrap()
-            );
-            assert!(dict.get_item_with_error(8i32).unwrap().is_none());
-            assert!(dict
-                .get_item_with_error(dict)
-                .unwrap_err()
-                .is_instance_of::<exceptions::PyTypeError>(py));
-        });
+    fn test_get_item_error_path() {
+        use crate::exceptions::PyTypeError;
+
+        #[crate::pyclass(crate = "crate")]
+        struct HashErrors;
+
+        #[crate::pymethods(crate = "crate")]
+        impl HashErrors {
+            #[new]
+            fn new() -> Self {
+                HashErrors {}
+            }
+
+            fn __hash__(&self) -> PyResult<isize> {
+                Err(PyTypeError::new_err("Error from __hash__"))
+            }
+        }
+
+        Python::attach(|py| {
+            let class = py.get_type::<HashErrors>();
+            let instance = class.call0().unwrap();
+            let d = PyDict::new(py);
+            match d.get_item(instance) {
+                Ok(_) => {
+                    panic!("this get_item call should always error")
+                }
+                Err(err) => {
+                    assert!(err.is_instance_of::<PyTypeError>(py));
+                    assert!(err.value(py).to_string().contains("Error from __hash__"));
+                }
+            }
+        })
     }
 
     #[test]
     fn test_set_item() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let mut v = HashMap::new();
             v.insert(7, 32);
-            let ob = v.to_object(py);
-            let dict: &PyDict = ob.downcast(py).unwrap();
+            let dict = v.into_pyobject(py).unwrap();
             assert!(dict.set_item(7i32, 42i32).is_ok()); // change
             assert!(dict.set_item(8i32, 123i32).is_ok()); // insert
             assert_eq!(
@@ -919,13 +1007,12 @@ mod tests {
 
     #[test]
     fn test_set_item_refcnt() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let cnt;
-            let obj = py.eval("object()", None, None).unwrap();
+            let obj = py.eval(c"object()", None, None).unwrap();
             {
-                let _pool = unsafe { crate::GILPool::new() };
                 cnt = obj.get_refcnt();
-                let _dict = [(10, obj)].into_py_dict_bound(py);
+                let _dict = [(10, &obj)].into_py_dict(py);
             }
             {
                 assert_eq!(cnt, obj.get_refcnt());
@@ -935,11 +1022,10 @@ mod tests {
 
     #[test]
     fn test_set_item_does_not_update_original_object() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let mut v = HashMap::new();
             v.insert(7, 32);
-            let ob = v.to_object(py);
-            let dict: &PyDict = ob.downcast(py).unwrap();
+            let dict = (&v).into_pyobject(py).unwrap();
             assert!(dict.set_item(7i32, 42i32).is_ok()); // change
             assert!(dict.set_item(8i32, 123i32).is_ok()); // insert
             assert_eq!(32i32, v[&7i32]); // not updated!
@@ -949,11 +1035,10 @@ mod tests {
 
     #[test]
     fn test_del_item() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let mut v = HashMap::new();
             v.insert(7, 32);
-            let ob = v.to_object(py);
-            let dict: &PyDict = ob.downcast(py).unwrap();
+            let dict = v.into_pyobject(py).unwrap();
             assert!(dict.del_item(7i32).is_ok());
             assert_eq!(0, dict.len());
             assert!(dict.get_item(7i32).unwrap().is_none());
@@ -962,11 +1047,10 @@ mod tests {
 
     #[test]
     fn test_del_item_does_not_update_original_object() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let mut v = HashMap::new();
             v.insert(7, 32);
-            let ob = v.to_object(py);
-            let dict: &PyDict = ob.downcast(py).unwrap();
+            let dict = (&v).into_pyobject(py).unwrap();
             assert!(dict.del_item(7i32).is_ok()); // change
             assert_eq!(32i32, *v.get(&7i32).unwrap()); // not updated!
         });
@@ -974,18 +1058,17 @@ mod tests {
 
     #[test]
     fn test_items() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let mut v = HashMap::new();
             v.insert(7, 32);
             v.insert(8, 42);
             v.insert(9, 123);
-            let ob = v.to_object(py);
-            let dict: &PyDict = ob.downcast(py).unwrap();
+            let dict = v.into_pyobject(py).unwrap();
             // Can't just compare against a vector of tuples since we don't have a guaranteed ordering.
             let mut key_sum = 0;
             let mut value_sum = 0;
             for el in dict.items() {
-                let tuple = el.downcast::<PyTuple>().unwrap();
+                let tuple = el.cast::<PyTuple>().unwrap();
                 key_sum += tuple.get_item(0).unwrap().extract::<i32>().unwrap();
                 value_sum += tuple.get_item(1).unwrap().extract::<i32>().unwrap();
             }
@@ -996,13 +1079,12 @@ mod tests {
 
     #[test]
     fn test_keys() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let mut v = HashMap::new();
             v.insert(7, 32);
             v.insert(8, 42);
             v.insert(9, 123);
-            let ob = v.to_object(py);
-            let dict: &PyDict = ob.downcast(py).unwrap();
+            let dict = v.into_pyobject(py).unwrap();
             // Can't just compare against a vector of tuples since we don't have a guaranteed ordering.
             let mut key_sum = 0;
             for el in dict.keys() {
@@ -1014,13 +1096,12 @@ mod tests {
 
     #[test]
     fn test_values() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let mut v = HashMap::new();
             v.insert(7, 32);
             v.insert(8, 42);
             v.insert(9, 123);
-            let ob = v.to_object(py);
-            let dict: &PyDict = ob.downcast(py).unwrap();
+            let dict = v.into_pyobject(py).unwrap();
             // Can't just compare against a vector of tuples since we don't have a guaranteed ordering.
             let mut values_sum = 0;
             for el in dict.values() {
@@ -1032,13 +1113,31 @@ mod tests {
 
     #[test]
     fn test_iter() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
+            let mut v = HashMap::new();
+            v.insert(7, 32);
+            v.insert(8, 42);
+            v.insert(9, 123);
+            let dict = v.into_pyobject(py).unwrap();
+            let mut key_sum = 0;
+            let mut value_sum = 0;
+            for (key, value) in dict {
+                key_sum += key.extract::<i32>().unwrap();
+                value_sum += value.extract::<i32>().unwrap();
+            }
+            assert_eq!(7 + 8 + 9, key_sum);
+            assert_eq!(32 + 42 + 123, value_sum);
+        });
+    }
+
+    #[test]
+    fn test_iter_bound() {
+        Python::attach(|py| {
             let mut v = HashMap::new();
             v.insert(7, 32);
             v.insert(8, 42);
             v.insert(9, 123);
-            let ob = v.to_object(py);
-            let dict: &PyDict = ob.downcast(py).unwrap();
+            let dict = v.into_pyobject(py).unwrap();
             let mut key_sum = 0;
             let mut value_sum = 0;
             for (key, value) in dict {
@@ -1052,16 +1151,15 @@ mod tests {
 
     #[test]
     fn test_iter_value_mutated() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let mut v = HashMap::new();
             v.insert(7, 32);
             v.insert(8, 42);
             v.insert(9, 123);
 
-            let ob = v.to_object(py);
-            let dict: &PyDict = ob.downcast(py).unwrap();
+            let dict = (&v).into_pyobject(py).unwrap();
 
-            for (key, value) in dict {
+            for (key, value) in &dict {
                 dict.set_item(key, value.extract::<i32>().unwrap() + 7)
                     .unwrap();
             }
@@ -1071,13 +1169,12 @@ mod tests {
     #[test]
     #[should_panic]
     fn test_iter_key_mutated() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let mut v = HashMap::new();
             for i in 0..10 {
                 v.insert(i * 2, i * 2);
             }
-            let ob = v.to_object(py);
-            let dict: &PyDict = ob.downcast(py).unwrap();
+            let dict = v.into_pyobject(py).unwrap();
 
             for (i, (key, value)) in dict.iter().enumerate() {
                 let key = key.extract::<i32>().unwrap();
@@ -1096,13 +1193,12 @@ mod tests {
     #[test]
     #[should_panic]
     fn test_iter_key_mutated_constant_len() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let mut v = HashMap::new();
             for i in 0..10 {
                 v.insert(i * 2, i * 2);
             }
-            let ob = v.to_object(py);
-            let dict: &PyDict = ob.downcast(py).unwrap();
+            let dict = v.into_pyobject(py).unwrap();
 
             for (i, (key, value)) in dict.iter().enumerate() {
                 let key = key.extract::<i32>().unwrap();
@@ -1120,13 +1216,12 @@ mod tests {
 
     #[test]
     fn test_iter_size_hint() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let mut v = HashMap::new();
             v.insert(7, 32);
             v.insert(8, 42);
             v.insert(9, 123);
-            let ob = v.to_object(py);
-            let dict: &PyDict = ob.downcast(py).unwrap();
+            let dict = (&v).into_pyobject(py).unwrap();
 
             let mut iter = dict.iter();
             assert_eq!(iter.size_hint(), (v.len(), Some(v.len())));
@@ -1146,13 +1241,12 @@ mod tests {
 
     #[test]
     fn test_into_iter() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let mut v = HashMap::new();
             v.insert(7, 32);
             v.insert(8, 42);
             v.insert(9, 123);
-            let ob = v.to_object(py);
-            let dict: &PyDict = ob.downcast(py).unwrap();
+            let dict = v.into_pyobject(py).unwrap();
             let mut key_sum = 0;
             let mut value_sum = 0;
             for (key, value) in dict {
@@ -1166,11 +1260,11 @@ mod tests {
 
     #[test]
     fn test_hashmap_into_dict() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let mut map = HashMap::<i32, i32>::new();
             map.insert(1, 1);
 
-            let py_map = map.into_py_dict_bound(py);
+            let py_map = map.into_py_dict(py).unwrap();
 
             assert_eq!(py_map.len(), 1);
             assert_eq!(
@@ -1187,11 +1281,11 @@ mod tests {
 
     #[test]
     fn test_btreemap_into_dict() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let mut map = BTreeMap::<i32, i32>::new();
             map.insert(1, 1);
 
-            let py_map = map.into_py_dict_bound(py);
+            let py_map = map.into_py_dict(py).unwrap();
 
             assert_eq!(py_map.len(), 1);
             assert_eq!(
@@ -1208,9 +1302,9 @@ mod tests {
 
     #[test]
     fn test_vec_into_dict() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let vec = vec![("a", 1), ("b", 2), ("c", 3)];
-            let py_map = vec.into_py_dict_bound(py);
+            let py_map = vec.into_py_dict(py).unwrap();
 
             assert_eq!(py_map.len(), 3);
             assert_eq!(
@@ -1227,9 +1321,9 @@ mod tests {
 
     #[test]
     fn test_slice_into_dict() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let arr = [("a", 1), ("b", 2), ("c", 3)];
-            let py_map = arr.into_py_dict_bound(py);
+            let py_map = arr.into_py_dict(py).unwrap();
 
             assert_eq!(py_map.len(), 3);
             assert_eq!(
@@ -1246,11 +1340,11 @@ mod tests {
 
     #[test]
     fn dict_as_mapping() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let mut map = HashMap::<i32, i32>::new();
             map.insert(1, 1);
 
-            let py_map = map.into_py_dict_bound(py);
+            let py_map = map.into_py_dict(py).unwrap();
 
             assert_eq!(py_map.as_mapping().len().unwrap(), 1);
             assert_eq!(
@@ -1265,56 +1359,64 @@ mod tests {
         });
     }
 
-    #[cfg(not(PyPy))]
+    #[test]
+    fn dict_into_mapping() {
+        Python::attach(|py| {
+            let mut map = HashMap::<i32, i32>::new();
+            map.insert(1, 1);
+
+            let py_map = map.into_py_dict(py).unwrap();
+
+            let py_mapping = py_map.into_mapping();
+            assert_eq!(py_mapping.len().unwrap(), 1);
+            assert_eq!(py_mapping.get_item(1).unwrap().extract::<i32>().unwrap(), 1);
+        });
+    }
+
+    #[cfg(not(any(PyPy, GraalPy)))]
     fn abc_dict(py: Python<'_>) -> Bound<'_, PyDict> {
         let mut map = HashMap::<&'static str, i32>::new();
         map.insert("a", 1);
         map.insert("b", 2);
         map.insert("c", 3);
-        map.into_py_dict_bound(py)
+        map.into_py_dict(py).unwrap()
     }
 
     #[test]
-    #[cfg(not(PyPy))]
+    #[cfg(not(any(PyPy, GraalPy)))]
     fn dict_keys_view() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let dict = abc_dict(py);
             let keys = dict.call_method0("keys").unwrap();
-            assert!(keys
-                .is_instance(&py.get_type::<PyDictKeys>().as_borrowed())
-                .unwrap());
+            assert!(keys.is_instance(&py.get_type::<PyDictKeys>()).unwrap());
         })
     }
 
     #[test]
-    #[cfg(not(PyPy))]
+    #[cfg(not(any(PyPy, GraalPy)))]
     fn dict_values_view() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let dict = abc_dict(py);
             let values = dict.call_method0("values").unwrap();
-            assert!(values
-                .is_instance(&py.get_type::<PyDictValues>().as_borrowed())
-                .unwrap());
+            assert!(values.is_instance(&py.get_type::<PyDictValues>()).unwrap());
         })
     }
 
     #[test]
-    #[cfg(not(PyPy))]
+    #[cfg(not(any(PyPy, GraalPy)))]
     fn dict_items_view() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let dict = abc_dict(py);
             let items = dict.call_method0("items").unwrap();
-            assert!(items
-                .is_instance(&py.get_type::<PyDictItems>().as_borrowed())
-                .unwrap());
+            assert!(items.is_instance(&py.get_type::<PyDictItems>()).unwrap());
         })
     }
 
     #[test]
     fn dict_update() {
-        Python::with_gil(|py| {
-            let dict = [("a", 1), ("b", 2), ("c", 3)].into_py_dict_bound(py);
-            let other = [("b", 4), ("c", 5), ("d", 6)].into_py_dict_bound(py);
+        Python::attach(|py| {
+            let dict = [("a", 1), ("b", 2), ("c", 3)].into_py_dict(py).unwrap();
+            let other = [("b", 4), ("c", 5), ("d", 6)].into_py_dict(py).unwrap();
             dict.update(other.as_mapping()).unwrap();
             assert_eq!(dict.len(), 4);
             assert_eq!(
@@ -1383,9 +1485,9 @@ mod tests {
 
     #[test]
     fn dict_update_if_missing() {
-        Python::with_gil(|py| {
-            let dict = [("a", 1), ("b", 2), ("c", 3)].into_py_dict_bound(py);
-            let other = [("b", 4), ("c", 5), ("d", 6)].into_py_dict_bound(py);
+        Python::attach(|py| {
+            let dict = [("a", 1), ("b", 2), ("c", 3)].into_py_dict(py).unwrap();
+            let other = [("b", 4), ("c", 5), ("d", 6)].into_py_dict(py).unwrap();
             dict.update_if_missing(other.as_mapping()).unwrap();
             assert_eq!(dict.len(), 4);
             assert_eq!(
@@ -1451,4 +1553,115 @@ mod tests {
             );
         })
     }
+
+    #[test]
+    fn test_iter_all() {
+        Python::attach(|py| {
+            let dict = [(1, true), (2, true), (3, true)].into_py_dict(py).unwrap();
+            assert!(dict.iter().all(|(_, v)| v.extract::<bool>().unwrap()));
+
+            let dict = [(1, true), (2, false), (3, true)].into_py_dict(py).unwrap();
+            assert!(!dict.iter().all(|(_, v)| v.extract::<bool>().unwrap()));
+        });
+    }
+
+    #[test]
+    fn test_iter_any() {
+        Python::attach(|py| {
+            let dict = [(1, true), (2, false), (3, false)]
+                .into_py_dict(py)
+                .unwrap();
+            assert!(dict.iter().any(|(_, v)| v.extract::<bool>().unwrap()));
+
+            let dict = [(1, false), (2, false), (3, false)]
+                .into_py_dict(py)
+                .unwrap();
+            assert!(!dict.iter().any(|(_, v)| v.extract::<bool>().unwrap()));
+        });
+    }
+
+    #[test]
+    #[allow(clippy::search_is_some)]
+    fn test_iter_find() {
+        Python::attach(|py| {
+            let dict = [(1, false), (2, true), (3, false)]
+                .into_py_dict(py)
+                .unwrap();
+
+            assert_eq!(
+                Some((2, true)),
+                dict.iter()
+                    .find(|(_, v)| v.extract::<bool>().unwrap())
+                    .map(|(k, v)| (k.extract().unwrap(), v.extract().unwrap()))
+            );
+
+            let dict = [(1, false), (2, false), (3, false)]
+                .into_py_dict(py)
+                .unwrap();
+
+            assert!(dict
+                .iter()
+                .find(|(_, v)| v.extract::<bool>().unwrap())
+                .is_none());
+        });
+    }
+
+    #[test]
+    #[allow(clippy::search_is_some)]
+    fn test_iter_position() {
+        Python::attach(|py| {
+            let dict = [(1, false), (2, false), (3, true)]
+                .into_py_dict(py)
+                .unwrap();
+            assert_eq!(
+                Some(2),
+                dict.iter().position(|(_, v)| v.extract::<bool>().unwrap())
+            );
+
+            let dict = [(1, false), (2, false), (3, false)]
+                .into_py_dict(py)
+                .unwrap();
+            assert!(dict
+                .iter()
+                .position(|(_, v)| v.extract::<bool>().unwrap())
+                .is_none());
+        });
+    }
+
+    #[test]
+    fn test_iter_fold() {
+        Python::attach(|py| {
+            let dict = [(1, 1), (2, 2), (3, 3)].into_py_dict(py).unwrap();
+            let sum = dict
+                .iter()
+                .fold(0, |acc, (_, v)| acc + v.extract::<i32>().unwrap());
+            assert_eq!(sum, 6);
+        });
+    }
+
+    #[test]
+    fn test_iter_try_fold() {
+        Python::attach(|py| {
+            let dict = [(1, 1), (2, 2), (3, 3)].into_py_dict(py).unwrap();
+            let sum = dict
+                .iter()
+                .try_fold(0, |acc, (_, v)| PyResult::Ok(acc + v.extract::<i32>()?))
+                .unwrap();
+            assert_eq!(sum, 6);
+
+            let dict = [(1, "foo"), (2, "bar")].into_py_dict(py).unwrap();
+            assert!(dict
+                .iter()
+                .try_fold(0, |acc, (_, v)| PyResult::Ok(acc + v.extract::<i32>()?))
+                .is_err());
+        });
+    }
+
+    #[test]
+    fn test_iter_count() {
+        Python::attach(|py| {
+            let dict = [(1, 1), (2, 2), (3, 3)].into_py_dict(py).unwrap();
+            assert_eq!(dict.iter().count(), 3);
+        })
+    }
 }
diff --git a/src/types/ellipsis.rs b/src/types/ellipsis.rs
index 4d091c6f9d0..523e13bbf9a 100644
--- a/src/types/ellipsis.rs
+++ b/src/types/ellipsis.rs
@@ -4,30 +4,24 @@ use crate::{
 };
 
 /// Represents the Python `Ellipsis` object.
+///
+/// Values of this type are accessed via PyO3's smart pointers, e.g. as
+/// [`Py<PyEllipsis>`][crate::Py] or [`Bound<'py, PyEllipsis>`][Bound].
 #[repr(transparent)]
 pub struct PyEllipsis(PyAny);
 
 pyobject_native_type_named!(PyEllipsis);
-pyobject_native_type_extract!(PyEllipsis);
 
 impl PyEllipsis {
     /// Returns the `Ellipsis` object.
-    #[cfg_attr(
-        not(feature = "gil-refs"),
-        deprecated(
-            since = "0.21.0",
-            note = "`PyEllipsis::get` will be replaced by `PyEllipsis::get_bound` in a future PyO3 version"
-        )
-    )]
     #[inline]
-    pub fn get(py: Python<'_>) -> &PyEllipsis {
-        Self::get_bound(py).into_gil_ref()
-    }
-
-    /// Returns the `Ellipsis` object.
-    #[inline]
-    pub fn get_bound(py: Python<'_>) -> Borrowed<'_, '_, PyEllipsis> {
-        unsafe { ffi::Py_Ellipsis().assume_borrowed(py).downcast_unchecked() }
+    pub fn get(py: Python<'_>) -> Borrowed<'_, '_, PyEllipsis> {
+        // SAFETY: `Py_Ellipsis` is a global singleton which is known to be the ellipsis object
+        unsafe {
+            ffi::Py_Ellipsis()
+                .assume_borrowed_unchecked(py)
+                .cast_unchecked()
+        }
     }
 }
 
@@ -41,14 +35,14 @@ unsafe impl PyTypeInfo for PyEllipsis {
     }
 
     #[inline]
-    fn is_type_of_bound(object: &Bound<'_, PyAny>) -> bool {
+    fn is_type_of(object: &Bound<'_, PyAny>) -> bool {
         // ellipsis is not usable as a base type
-        Self::is_exact_type_of_bound(object)
+        Self::is_exact_type_of(object)
     }
 
     #[inline]
-    fn is_exact_type_of_bound(object: &Bound<'_, PyAny>) -> bool {
-        object.is(&**Self::get_bound(object.py()))
+    fn is_exact_type_of(object: &Bound<'_, PyAny>) -> bool {
+        object.is(&**Self::get(object.py()))
     }
 }
 
@@ -60,25 +54,25 @@ mod tests {
 
     #[test]
     fn test_ellipsis_is_itself() {
-        Python::with_gil(|py| {
-            assert!(PyEllipsis::get_bound(py).is_instance_of::<PyEllipsis>());
-            assert!(PyEllipsis::get_bound(py).is_exact_instance_of::<PyEllipsis>());
+        Python::attach(|py| {
+            assert!(PyEllipsis::get(py).is_instance_of::<PyEllipsis>());
+            assert!(PyEllipsis::get(py).is_exact_instance_of::<PyEllipsis>());
         })
     }
 
     #[test]
     fn test_ellipsis_type_object_consistent() {
-        Python::with_gil(|py| {
-            assert!(PyEllipsis::get_bound(py)
+        Python::attach(|py| {
+            assert!(PyEllipsis::get(py)
                 .get_type()
-                .is(&PyEllipsis::type_object_bound(py)));
+                .is(PyEllipsis::type_object(py)));
         })
     }
 
     #[test]
     fn test_dict_is_not_ellipsis() {
-        Python::with_gil(|py| {
-            assert!(PyDict::new_bound(py).downcast::<PyEllipsis>().is_err());
+        Python::attach(|py| {
+            assert!(PyDict::new(py).cast::<PyEllipsis>().is_err());
         })
     }
 }
diff --git a/src/types/float.rs b/src/types/float.rs
index 766c597b2b4..5a3e22802aa 100644
--- a/src/types/float.rs
+++ b/src/types/float.rs
@@ -1,21 +1,30 @@
+use crate::conversion::IntoPyObject;
 #[cfg(feature = "experimental-inspect")]
 use crate::inspect::types::TypeInfo;
+#[cfg(feature = "experimental-inspect")]
+use crate::inspect::TypeHint;
 use crate::{
-    ffi, ffi_ptr_ext::FfiPtrExt, instance::Bound, FromPyObject, IntoPy, PyAny, PyErr, PyNativeType,
-    PyObject, PyResult, Python, ToPyObject,
+    ffi, ffi_ptr_ext::FfiPtrExt, instance::Bound, Borrowed, FromPyObject, PyAny, PyErr, Python,
 };
-use std::os::raw::c_double;
-
-use super::any::PyAnyMethods;
+use std::convert::Infallible;
+use std::ffi::c_double;
 
 /// Represents a Python `float` object.
 ///
+/// Values of this type are accessed via PyO3's smart pointers, e.g. as
+/// [`Py<PyFloat>`][crate::Py] or [`Bound<'py, PyFloat>`][Bound].
+///
+/// For APIs available on `float` objects, see the [`PyFloatMethods`] trait which is implemented for
+/// [`Bound<'py, PyFloat>`][Bound].
+///
 /// You can usually avoid directly working with this type
-/// by using [`ToPyObject`] and [`extract`](PyAny::extract)
-/// with `f32`/`f64`.
+/// by using [`IntoPyObject`] and [`extract`][crate::types::PyAnyMethods::extract]
+/// with [`f32`]/[`f64`].
 #[repr(transparent)]
 pub struct PyFloat(PyAny);
 
+pyobject_subclassable_native_type!(PyFloat, crate::ffi::PyFloatObject);
+
 pyobject_native_type!(
     PyFloat,
     ffi::PyFloatObject,
@@ -24,32 +33,14 @@ pyobject_native_type!(
 );
 
 impl PyFloat {
-    /// Deprecated form of [`PyFloat::new_bound`].
-    #[inline]
-    #[cfg_attr(
-        not(feature = "gil-refs"),
-        deprecated(
-            since = "0.21.0",
-            note = "`PyFloat::new` will be replaced by `PyFloat::new_bound` in a future PyO3 version"
-        )
-    )]
-    pub fn new(py: Python<'_>, val: f64) -> &'_ Self {
-        Self::new_bound(py, val).into_gil_ref()
-    }
-
     /// Creates a new Python `float` object.
-    pub fn new_bound(py: Python<'_>, val: c_double) -> Bound<'_, PyFloat> {
+    pub fn new(py: Python<'_>, val: c_double) -> Bound<'_, PyFloat> {
         unsafe {
             ffi::PyFloat_FromDouble(val)
                 .assume_owned(py)
-                .downcast_into_unchecked()
+                .cast_into_unchecked()
         }
     }
-
-    /// Gets the value of this float.
-    pub fn value(&self) -> c_double {
-        self.as_borrowed().value()
-    }
 }
 
 /// Implementation of functionality for [`PyFloat`].
@@ -58,7 +49,7 @@ impl PyFloat {
 /// syntax these methods are separated into a trait, because stable Rust does not yet support
 /// `arbitrary_self_types`.
 #[doc(alias = "PyFloat")]
-pub trait PyFloatMethods<'py> {
+pub trait PyFloatMethods<'py>: crate::sealed::Sealed {
     /// Gets the value of this float.
     fn value(&self) -> c_double;
 }
@@ -78,15 +69,36 @@ impl<'py> PyFloatMethods<'py> for Bound<'py, PyFloat> {
     }
 }
 
-impl ToPyObject for f64 {
-    fn to_object(&self, py: Python<'_>) -> PyObject {
-        PyFloat::new_bound(py, *self).into()
+impl<'py> IntoPyObject<'py> for f64 {
+    type Target = PyFloat;
+    type Output = Bound<'py, Self::Target>;
+    type Error = Infallible;
+
+    #[cfg(feature = "experimental-inspect")]
+    const OUTPUT_TYPE: TypeHint = TypeHint::builtin("float");
+
+    #[inline]
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        Ok(PyFloat::new(py, self))
+    }
+
+    #[cfg(feature = "experimental-inspect")]
+    fn type_output() -> TypeInfo {
+        TypeInfo::builtin("float")
     }
 }
 
-impl IntoPy<PyObject> for f64 {
-    fn into_py(self, py: Python<'_>) -> PyObject {
-        PyFloat::new_bound(py, self).into()
+impl<'py> IntoPyObject<'py> for &f64 {
+    type Target = PyFloat;
+    type Output = Bound<'py, Self::Target>;
+    type Error = Infallible;
+
+    #[cfg(feature = "experimental-inspect")]
+    const OUTPUT_TYPE: TypeHint = f64::OUTPUT_TYPE;
+
+    #[inline]
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        (*self).into_pyobject(py)
     }
 
     #[cfg(feature = "experimental-inspect")]
@@ -95,16 +107,21 @@ impl IntoPy<PyObject> for f64 {
     }
 }
 
-impl<'py> FromPyObject<'py> for f64 {
+impl<'py> FromPyObject<'_, 'py> for f64 {
+    type Error = PyErr;
+
+    #[cfg(feature = "experimental-inspect")]
+    const INPUT_TYPE: TypeHint = TypeHint::builtin("float");
+
     // PyFloat_AsDouble returns -1.0 upon failure
-    #![allow(clippy::float_cmp)]
-    fn extract_bound(obj: &Bound<'py, PyAny>) -> PyResult<Self> {
+    #[allow(clippy::float_cmp)]
+    fn extract(obj: Borrowed<'_, 'py, PyAny>) -> Result<Self, Self::Error> {
         // On non-limited API, .value() uses PyFloat_AS_DOUBLE which
         // allows us to have an optimized fast path for the case when
         // we have exactly a `float` object (it's not worth going through
         // `isinstance` machinery for subclasses).
         #[cfg(not(Py_LIMITED_API))]
-        if let Ok(float) = obj.downcast_exact::<PyFloat>() {
+        if let Ok(float) = obj.cast_exact::<PyFloat>() {
             return Ok(float.value());
         }
 
@@ -125,15 +142,36 @@ impl<'py> FromPyObject<'py> for f64 {
     }
 }
 
-impl ToPyObject for f32 {
-    fn to_object(&self, py: Python<'_>) -> PyObject {
-        PyFloat::new_bound(py, f64::from(*self)).into()
+impl<'py> IntoPyObject<'py> for f32 {
+    type Target = PyFloat;
+    type Output = Bound<'py, Self::Target>;
+    type Error = Infallible;
+
+    #[cfg(feature = "experimental-inspect")]
+    const OUTPUT_TYPE: TypeHint = TypeHint::builtin("float");
+
+    #[inline]
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        Ok(PyFloat::new(py, self.into()))
+    }
+
+    #[cfg(feature = "experimental-inspect")]
+    fn type_output() -> TypeInfo {
+        TypeInfo::builtin("float")
     }
 }
 
-impl IntoPy<PyObject> for f32 {
-    fn into_py(self, py: Python<'_>) -> PyObject {
-        PyFloat::new_bound(py, f64::from(self)).into()
+impl<'py> IntoPyObject<'py> for &f32 {
+    type Target = PyFloat;
+    type Output = Bound<'py, Self::Target>;
+    type Error = Infallible;
+
+    #[cfg(feature = "experimental-inspect")]
+    const OUTPUT_TYPE: TypeHint = f32::OUTPUT_TYPE;
+
+    #[inline]
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        (*self).into_pyobject(py)
     }
 
     #[cfg(feature = "experimental-inspect")]
@@ -142,8 +180,13 @@ impl IntoPy<PyObject> for f32 {
     }
 }
 
-impl<'py> FromPyObject<'py> for f32 {
-    fn extract_bound(obj: &Bound<'py, PyAny>) -> PyResult<Self> {
+impl<'a, 'py> FromPyObject<'a, 'py> for f32 {
+    type Error = <f64 as FromPyObject<'a, 'py>>::Error;
+
+    #[cfg(feature = "experimental-inspect")]
+    const INPUT_TYPE: TypeHint = TypeHint::builtin("float");
+
+    fn extract(obj: Borrowed<'_, 'py, PyAny>) -> Result<Self, Self::Error> {
         Ok(obj.extract::<f64>()? as f32)
     }
 
@@ -153,10 +196,90 @@ impl<'py> FromPyObject<'py> for f32 {
     }
 }
 
+macro_rules! impl_partial_eq_for_float {
+    ($float_type: ty) => {
+        impl PartialEq<$float_type> for Bound<'_, PyFloat> {
+            #[inline]
+            fn eq(&self, other: &$float_type) -> bool {
+                self.value() as $float_type == *other
+            }
+        }
+
+        impl PartialEq<$float_type> for &Bound<'_, PyFloat> {
+            #[inline]
+            fn eq(&self, other: &$float_type) -> bool {
+                self.value() as $float_type == *other
+            }
+        }
+
+        impl PartialEq<&$float_type> for Bound<'_, PyFloat> {
+            #[inline]
+            fn eq(&self, other: &&$float_type) -> bool {
+                self.value() as $float_type == **other
+            }
+        }
+
+        impl PartialEq<Bound<'_, PyFloat>> for $float_type {
+            #[inline]
+            fn eq(&self, other: &Bound<'_, PyFloat>) -> bool {
+                other.value() as $float_type == *self
+            }
+        }
+
+        impl PartialEq<&'_ Bound<'_, PyFloat>> for $float_type {
+            #[inline]
+            fn eq(&self, other: &&'_ Bound<'_, PyFloat>) -> bool {
+                other.value() as $float_type == *self
+            }
+        }
+
+        impl PartialEq<Bound<'_, PyFloat>> for &'_ $float_type {
+            #[inline]
+            fn eq(&self, other: &Bound<'_, PyFloat>) -> bool {
+                other.value() as $float_type == **self
+            }
+        }
+
+        impl PartialEq<$float_type> for Borrowed<'_, '_, PyFloat> {
+            #[inline]
+            fn eq(&self, other: &$float_type) -> bool {
+                self.value() as $float_type == *other
+            }
+        }
+
+        impl PartialEq<&$float_type> for Borrowed<'_, '_, PyFloat> {
+            #[inline]
+            fn eq(&self, other: &&$float_type) -> bool {
+                self.value() as $float_type == **other
+            }
+        }
+
+        impl PartialEq<Borrowed<'_, '_, PyFloat>> for $float_type {
+            #[inline]
+            fn eq(&self, other: &Borrowed<'_, '_, PyFloat>) -> bool {
+                other.value() as $float_type == *self
+            }
+        }
+
+        impl PartialEq<Borrowed<'_, '_, PyFloat>> for &$float_type {
+            #[inline]
+            fn eq(&self, other: &Borrowed<'_, '_, PyFloat>) -> bool {
+                other.value() as $float_type == **self
+            }
+        }
+    };
+}
+
+impl_partial_eq_for_float!(f64);
+impl_partial_eq_for_float!(f32);
+
 #[cfg(test)]
-#[cfg_attr(not(feature = "gil-refs"), allow(deprecated))]
 mod tests {
-    use crate::{types::PyFloat, Python, ToPyObject};
+    use crate::{
+        conversion::IntoPyObject,
+        types::{PyAnyMethods, PyFloat, PyFloatMethods},
+        Python,
+    };
 
     macro_rules! num_to_py_object_and_back (
         ($func_name:ident, $t1:ty, $t2:ty) => (
@@ -164,11 +287,11 @@ mod tests {
             fn $func_name() {
                 use assert_approx_eq::assert_approx_eq;
 
-                Python::with_gil(|py| {
+                Python::attach(|py| {
 
                 let val = 123 as $t1;
-                let obj = val.to_object(py);
-                assert_approx_eq!(obj.extract::<$t2>(py).unwrap(), val as $t2);
+                let obj = val.into_pyobject(py).unwrap();
+                assert_approx_eq!(obj.extract::<$t2>().unwrap(), val as $t2);
                 });
             }
         )
@@ -182,10 +305,73 @@ mod tests {
     fn test_float_value() {
         use assert_approx_eq::assert_approx_eq;
 
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let v = 1.23f64;
             let obj = PyFloat::new(py, 1.23);
             assert_approx_eq!(v, obj.value());
         });
     }
+
+    #[test]
+    fn test_pyfloat_comparisons() {
+        Python::attach(|py| {
+            let f_64 = 1.01f64;
+            let py_f64 = PyFloat::new(py, 1.01);
+            let py_f64_ref = &py_f64;
+            let py_f64_borrowed = py_f64.as_borrowed();
+
+            // Bound<'_, PyFloat> == f64 and vice versa
+            assert_eq!(py_f64, f_64);
+            assert_eq!(f_64, py_f64);
+
+            // Bound<'_, PyFloat> == &f64 and vice versa
+            assert_eq!(py_f64, &f_64);
+            assert_eq!(&f_64, py_f64);
+
+            // &Bound<'_, PyFloat> == &f64 and vice versa
+            assert_eq!(py_f64_ref, f_64);
+            assert_eq!(f_64, py_f64_ref);
+
+            // &Bound<'_, PyFloat> == &f64 and vice versa
+            assert_eq!(py_f64_ref, &f_64);
+            assert_eq!(&f_64, py_f64_ref);
+
+            // Borrowed<'_, '_, PyFloat> == f64 and vice versa
+            assert_eq!(py_f64_borrowed, f_64);
+            assert_eq!(f_64, py_f64_borrowed);
+
+            // Borrowed<'_, '_, PyFloat> == &f64 and vice versa
+            assert_eq!(py_f64_borrowed, &f_64);
+            assert_eq!(&f_64, py_f64_borrowed);
+
+            let f_32 = 2.02f32;
+            let py_f32 = PyFloat::new(py, 2.02);
+            let py_f32_ref = &py_f32;
+            let py_f32_borrowed = py_f32.as_borrowed();
+
+            // Bound<'_, PyFloat> == f32 and vice versa
+            assert_eq!(py_f32, f_32);
+            assert_eq!(f_32, py_f32);
+
+            // Bound<'_, PyFloat> == &f32 and vice versa
+            assert_eq!(py_f32, &f_32);
+            assert_eq!(&f_32, py_f32);
+
+            // &Bound<'_, PyFloat> == &f32 and vice versa
+            assert_eq!(py_f32_ref, f_32);
+            assert_eq!(f_32, py_f32_ref);
+
+            // &Bound<'_, PyFloat> == &f32 and vice versa
+            assert_eq!(py_f32_ref, &f_32);
+            assert_eq!(&f_32, py_f32_ref);
+
+            // Borrowed<'_, '_, PyFloat> == f32 and vice versa
+            assert_eq!(py_f32_borrowed, f_32);
+            assert_eq!(f_32, py_f32_borrowed);
+
+            // Borrowed<'_, '_, PyFloat> == &f32 and vice versa
+            assert_eq!(py_f32_borrowed, &f_32);
+            assert_eq!(&f_32, py_f32_borrowed);
+        });
+    }
 }
diff --git a/src/types/frame.rs b/src/types/frame.rs
index 0ab873b8003..8d88d4754ae 100644
--- a/src/types/frame.rs
+++ b/src/types/frame.rs
@@ -2,6 +2,9 @@ use crate::ffi;
 use crate::PyAny;
 
 /// Represents a Python frame.
+///
+/// Values of this type are accessed via PyO3's smart pointers, e.g. as
+/// [`Py<PyFrame>`][crate::Py] or [`Bound<'py, PyFrame>`][crate::Bound].
 #[repr(transparent)]
 pub struct PyFrame(PyAny);
 
diff --git a/src/types/frozenset.rs b/src/types/frozenset.rs
index fa56a9c69f7..45787a13b63 100644
--- a/src/types/frozenset.rs
+++ b/src/types/frozenset.rs
@@ -1,18 +1,17 @@
-#[cfg(Py_LIMITED_API)]
 use crate::types::PyIterator;
 use crate::{
     err::{self, PyErr, PyResult},
     ffi,
     ffi_ptr_ext::FfiPtrExt,
     py_result_ext::PyResultExt,
-    types::any::PyAnyMethods,
-    Bound, PyAny, PyNativeType, PyObject, Python, ToPyObject,
+    Bound, PyAny, Python,
 };
+use crate::{Borrowed, BoundObject, IntoPyObject, IntoPyObjectExt};
 use std::ptr;
 
 /// Allows building a Python `frozenset` one item at a time
 pub struct PyFrozenSetBuilder<'py> {
-    py_frozen_set: &'py PyFrozenSet,
+    py_frozen_set: Bound<'py, PyFrozenSet>,
 }
 
 impl<'py> PyFrozenSetBuilder<'py> {
@@ -28,28 +27,42 @@ impl<'py> PyFrozenSetBuilder<'py> {
     /// Adds an element to the set.
     pub fn add<K>(&mut self, key: K) -> PyResult<()>
     where
-        K: ToPyObject,
+        K: IntoPyObject<'py>,
     {
-        fn inner(frozenset: &PyFrozenSet, key: PyObject) -> PyResult<()> {
+        fn inner(frozenset: &Bound<'_, PyFrozenSet>, key: Borrowed<'_, '_, PyAny>) -> PyResult<()> {
             err::error_on_minusone(frozenset.py(), unsafe {
                 ffi::PySet_Add(frozenset.as_ptr(), key.as_ptr())
             })
         }
 
-        inner(self.py_frozen_set, key.to_object(self.py_frozen_set.py()))
+        inner(
+            &self.py_frozen_set,
+            key.into_pyobject(self.py_frozen_set.py())
+                .map_err(Into::into)?
+                .into_any()
+                .as_borrowed(),
+        )
     }
 
     /// Finish building the set and take ownership of its current value
-    pub fn finalize(self) -> &'py PyFrozenSet {
+    pub fn finalize(self) -> Bound<'py, PyFrozenSet> {
         self.py_frozen_set
     }
 }
 
-/// Represents a  Python `frozenset`
+/// Represents a  Python `frozenset`.
+///
+/// Values of this type are accessed via PyO3's smart pointers, e.g. as
+/// [`Py<PyFrozenSet>`][crate::Py] or [`Bound<'py, PyFrozenSet>`][Bound].
+///
+/// For APIs available on `frozenset` objects, see the [`PyFrozenSetMethods`] trait which is implemented for
+/// [`Bound<'py, PyFrozenSet>`][Bound].
 #[repr(transparent)]
 pub struct PyFrozenSet(PyAny);
 
-#[cfg(not(PyPy))]
+#[cfg(not(any(PyPy, GraalPy)))]
+pyobject_subclassable_native_type!(PyFrozenSet, crate::ffi::PySetObject);
+#[cfg(not(any(PyPy, GraalPy)))]
 pyobject_native_type!(
     PyFrozenSet,
     ffi::PySetObject,
@@ -57,7 +70,7 @@ pyobject_native_type!(
     #checkfunction=ffi::PyFrozenSet_Check
 );
 
-#[cfg(PyPy)]
+#[cfg(any(PyPy, GraalPy))]
 pyobject_native_type_core!(
     PyFrozenSet,
     pyobject_native_static_type_object!(ffi::PyFrozenSet_Type),
@@ -65,72 +78,28 @@ pyobject_native_type_core!(
 );
 
 impl PyFrozenSet {
-    /// Deprecated form of [`PyFrozenSet::new_bound`].
-    #[inline]
-    #[cfg_attr(
-        not(feature = "gil-refs"),
-        deprecated(
-            since = "0.21.0",
-            note = "`PyFrozenSet::new` will be replaced by `PyFrozenSet::new_bound` in a future PyO3 version"
-        )
-    )]
-    pub fn new<'a, 'p, T: ToPyObject + 'a>(
-        py: Python<'p>,
-        elements: impl IntoIterator<Item = &'a T>,
-    ) -> PyResult<&'p PyFrozenSet> {
-        Self::new_bound(py, elements).map(Bound::into_gil_ref)
-    }
-
     /// Creates a new frozenset.
     ///
     /// May panic when running out of memory.
     #[inline]
-    pub fn new_bound<'a, 'p, T: ToPyObject + 'a>(
-        py: Python<'p>,
-        elements: impl IntoIterator<Item = &'a T>,
-    ) -> PyResult<Bound<'p, PyFrozenSet>> {
-        new_from_iter(py, elements)
-    }
-
-    /// Deprecated form of [`PyFrozenSet::empty_bound`].
-    pub fn empty(py: Python<'_>) -> PyResult<&'_ PyFrozenSet> {
-        Self::empty_bound(py).map(Bound::into_gil_ref)
+    pub fn new<'py, T>(
+        py: Python<'py>,
+        elements: impl IntoIterator<Item = T>,
+    ) -> PyResult<Bound<'py, PyFrozenSet>>
+    where
+        T: IntoPyObject<'py>,
+    {
+        try_new_from_iter(py, elements)
     }
 
     /// Creates a new empty frozen set
-    pub fn empty_bound(py: Python<'_>) -> PyResult<Bound<'_, PyFrozenSet>> {
+    pub fn empty(py: Python<'_>) -> PyResult<Bound<'_, PyFrozenSet>> {
         unsafe {
             ffi::PyFrozenSet_New(ptr::null_mut())
                 .assume_owned_or_err(py)
-                .downcast_into_unchecked()
+                .cast_into_unchecked()
         }
     }
-
-    /// Return the number of items in the set.
-    /// This is equivalent to len(p) on a set.
-    #[inline]
-    pub fn len(&self) -> usize {
-        self.as_borrowed().len()
-    }
-
-    /// Check if set is empty.
-    pub fn is_empty(&self) -> bool {
-        self.as_borrowed().is_empty()
-    }
-
-    /// Determine if the set contains the specified key.
-    /// This is equivalent to the Python expression `key in self`.
-    pub fn contains<K>(&self, key: K) -> PyResult<bool>
-    where
-        K: ToPyObject,
-    {
-        self.as_borrowed().contains(key)
-    }
-
-    /// Returns an iterator of values in this frozen set.
-    pub fn iter(&self) -> PyFrozenSetIterator<'_> {
-        PyFrozenSetIterator(BoundFrozenSetIterator::new(self.as_borrowed().to_owned()))
-    }
 }
 
 /// Implementation of functionality for [`PyFrozenSet`].
@@ -139,7 +108,7 @@ impl PyFrozenSet {
 /// syntax these methods are separated into a trait, because stable Rust does not yet support
 /// `arbitrary_self_types`.
 #[doc(alias = "PyFrozenSet")]
-pub trait PyFrozenSetMethods<'py> {
+pub trait PyFrozenSetMethods<'py>: crate::sealed::Sealed {
     /// Returns the number of items in the set.
     ///
     /// This is equivalent to the Python expression `len(self)`.
@@ -155,7 +124,7 @@ pub trait PyFrozenSetMethods<'py> {
     /// This is equivalent to the Python expression `key in self`.
     fn contains<K>(&self, key: K) -> PyResult<bool>
     where
-        K: ToPyObject;
+        K: IntoPyObject<'py>;
 
     /// Returns an iterator of values in this set.
     fn iter(&self) -> BoundFrozenSetIterator<'py>;
@@ -169,9 +138,12 @@ impl<'py> PyFrozenSetMethods<'py> for Bound<'py, PyFrozenSet> {
 
     fn contains<K>(&self, key: K) -> PyResult<bool>
     where
-        K: ToPyObject,
+        K: IntoPyObject<'py>,
     {
-        fn inner(frozenset: &Bound<'_, PyFrozenSet>, key: Bound<'_, PyAny>) -> PyResult<bool> {
+        fn inner(
+            frozenset: &Bound<'_, PyFrozenSet>,
+            key: Borrowed<'_, '_, PyAny>,
+        ) -> PyResult<bool> {
             match unsafe { ffi::PySet_Contains(frozenset.as_ptr(), key.as_ptr()) } {
                 1 => Ok(true),
                 0 => Ok(false),
@@ -180,7 +152,10 @@ impl<'py> PyFrozenSetMethods<'py> for Bound<'py, PyFrozenSet> {
         }
 
         let py = self.py();
-        inner(self, key.to_object(py).into_bound(py))
+        inner(
+            self,
+            key.into_pyobject_or_pyerr(py)?.into_any().as_borrowed(),
+        )
     }
 
     fn iter(&self) -> BoundFrozenSetIterator<'py> {
@@ -188,163 +163,103 @@ impl<'py> PyFrozenSetMethods<'py> for Bound<'py, PyFrozenSet> {
     }
 }
 
-/// PyO3 implementation of an iterator for a Python `frozenset` object.
-pub struct PyFrozenSetIterator<'py>(BoundFrozenSetIterator<'py>);
-
-impl<'py> Iterator for PyFrozenSetIterator<'py> {
-    type Item = &'py super::PyAny;
-
-    /// Advances the iterator and returns the next value.
-    #[inline]
-    fn next(&mut self) -> Option<Self::Item> {
-        self.0.next().map(Bound::into_gil_ref)
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        self.0.size_hint()
-    }
-}
+impl<'py> IntoIterator for Bound<'py, PyFrozenSet> {
+    type Item = Bound<'py, PyAny>;
+    type IntoIter = BoundFrozenSetIterator<'py>;
 
-impl<'py> IntoIterator for &'py PyFrozenSet {
-    type Item = &'py PyAny;
-    type IntoIter = PyFrozenSetIterator<'py>;
     /// Returns an iterator of values in this set.
     fn into_iter(self) -> Self::IntoIter {
-        PyFrozenSetIterator(BoundFrozenSetIterator::new(self.as_borrowed().to_owned()))
+        BoundFrozenSetIterator::new(self)
     }
 }
 
-impl<'py> IntoIterator for Bound<'py, PyFrozenSet> {
+impl<'py> IntoIterator for &Bound<'py, PyFrozenSet> {
     type Item = Bound<'py, PyAny>;
     type IntoIter = BoundFrozenSetIterator<'py>;
 
     /// Returns an iterator of values in this set.
     fn into_iter(self) -> Self::IntoIter {
-        BoundFrozenSetIterator::new(self)
+        self.iter()
     }
 }
 
-#[cfg(Py_LIMITED_API)]
-mod impl_ {
-    use super::*;
-
-    /// PyO3 implementation of an iterator for a Python `set` object.
-    pub struct BoundFrozenSetIterator<'p> {
-        it: Bound<'p, PyIterator>,
-    }
-
-    impl<'py> BoundFrozenSetIterator<'py> {
-        pub(super) fn new(frozenset: Bound<'py, PyFrozenSet>) -> Self {
-            Self {
-                it: PyIterator::from_bound_object(&frozenset).unwrap(),
-            }
-        }
-    }
-
-    impl<'py> Iterator for BoundFrozenSetIterator<'py> {
-        type Item = Bound<'py, super::PyAny>;
+/// PyO3 implementation of an iterator for a Python `frozenset` object.
+pub struct BoundFrozenSetIterator<'p> {
+    it: Bound<'p, PyIterator>,
+    // Remaining elements in the frozenset
+    remaining: usize,
+}
 
-        /// Advances the iterator and returns the next value.
-        #[inline]
-        fn next(&mut self) -> Option<Self::Item> {
-            self.it.next().map(Result::unwrap)
+impl<'py> BoundFrozenSetIterator<'py> {
+    pub(super) fn new(set: Bound<'py, PyFrozenSet>) -> Self {
+        Self {
+            it: PyIterator::from_object(&set).unwrap(),
+            remaining: set.len(),
         }
     }
 }
 
-#[cfg(not(Py_LIMITED_API))]
-mod impl_ {
-    use super::*;
-
-    /// PyO3 implementation of an iterator for a Python `frozenset` object.
-    pub struct BoundFrozenSetIterator<'py> {
-        set: Bound<'py, PyFrozenSet>,
-        pos: ffi::Py_ssize_t,
-    }
+impl<'py> Iterator for BoundFrozenSetIterator<'py> {
+    type Item = Bound<'py, super::PyAny>;
 
-    impl<'py> BoundFrozenSetIterator<'py> {
-        pub(super) fn new(set: Bound<'py, PyFrozenSet>) -> Self {
-            Self { set, pos: 0 }
-        }
+    /// Advances the iterator and returns the next value.
+    fn next(&mut self) -> Option<Self::Item> {
+        self.remaining = self.remaining.saturating_sub(1);
+        self.it.next().map(Result::unwrap)
     }
 
-    impl<'py> Iterator for BoundFrozenSetIterator<'py> {
-        type Item = Bound<'py, PyAny>;
-
-        #[inline]
-        fn next(&mut self) -> Option<Self::Item> {
-            unsafe {
-                let mut key: *mut ffi::PyObject = std::ptr::null_mut();
-                let mut hash: ffi::Py_hash_t = 0;
-                if ffi::_PySet_NextEntry(self.set.as_ptr(), &mut self.pos, &mut key, &mut hash) != 0
-                {
-                    // _PySet_NextEntry returns borrowed object; for safety must make owned (see #890)
-                    Some(key.assume_borrowed(self.set.py()).to_owned())
-                } else {
-                    None
-                }
-            }
-        }
-
-        #[inline]
-        fn size_hint(&self) -> (usize, Option<usize>) {
-            let len = self.len();
-            (len, Some(len))
-        }
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        (self.remaining, Some(self.remaining))
     }
 
-    impl<'py> ExactSizeIterator for BoundFrozenSetIterator<'py> {
-        fn len(&self) -> usize {
-            self.set.len().saturating_sub(self.pos as usize)
-        }
+    #[inline]
+    fn count(self) -> usize
+    where
+        Self: Sized,
+    {
+        self.len()
     }
+}
 
-    impl<'py> ExactSizeIterator for PyFrozenSetIterator<'py> {
-        fn len(&self) -> usize {
-            self.0.len()
-        }
+impl ExactSizeIterator for BoundFrozenSetIterator<'_> {
+    fn len(&self) -> usize {
+        self.remaining
     }
 }
 
-pub use impl_::*;
-
 #[inline]
-pub(crate) fn new_from_iter<T: ToPyObject>(
-    py: Python<'_>,
+pub(crate) fn try_new_from_iter<'py, T>(
+    py: Python<'py>,
     elements: impl IntoIterator<Item = T>,
-) -> PyResult<Bound<'_, PyFrozenSet>> {
-    fn inner<'py>(
-        py: Python<'py>,
-        elements: &mut dyn Iterator<Item = PyObject>,
-    ) -> PyResult<Bound<'py, PyFrozenSet>> {
-        let set = unsafe {
-            // We create the  `Py` pointer because its Drop cleans up the set if user code panics.
-            ffi::PyFrozenSet_New(std::ptr::null_mut())
-                .assume_owned_or_err(py)?
-                .downcast_into_unchecked()
-        };
-        let ptr = set.as_ptr();
-
-        for obj in elements {
-            err::error_on_minusone(py, unsafe { ffi::PySet_Add(ptr, obj.as_ptr()) })?;
-        }
-
-        Ok(set)
-    }
-
-    let mut iter = elements.into_iter().map(|e| e.to_object(py));
-    inner(py, &mut iter)
+) -> PyResult<Bound<'py, PyFrozenSet>>
+where
+    T: IntoPyObject<'py>,
+{
+    let set = unsafe {
+        // We create the  `Py` pointer because its Drop cleans up the set if user code panics.
+        ffi::PyFrozenSet_New(std::ptr::null_mut())
+            .assume_owned_or_err(py)?
+            .cast_into_unchecked()
+    };
+    let ptr = set.as_ptr();
+
+    for e in elements {
+        let obj = e.into_pyobject_or_pyerr(py)?;
+        err::error_on_minusone(py, unsafe { ffi::PySet_Add(ptr, obj.as_ptr()) })?;
+    }
+
+    Ok(set)
 }
 
 #[cfg(test)]
-#[cfg_attr(not(feature = "gil-refs"), allow(deprecated))]
 mod tests {
     use super::*;
+    use crate::types::PyAnyMethods as _;
 
     #[test]
     fn test_frozenset_new_and_len() {
-        Python::with_gil(|py| {
-            let set = PyFrozenSet::new(py, &[1]).unwrap();
+        Python::attach(|py| {
+            let set = PyFrozenSet::new(py, [1]).unwrap();
             assert_eq!(1, set.len());
 
             let v = vec![1];
@@ -354,7 +269,7 @@ mod tests {
 
     #[test]
     fn test_frozenset_empty() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let set = PyFrozenSet::empty(py).unwrap();
             assert_eq!(0, set.len());
             assert!(set.is_empty());
@@ -363,34 +278,38 @@ mod tests {
 
     #[test]
     fn test_frozenset_contains() {
-        Python::with_gil(|py| {
-            let set = PyFrozenSet::new(py, &[1]).unwrap();
+        Python::attach(|py| {
+            let set = PyFrozenSet::new(py, [1]).unwrap();
             assert!(set.contains(1).unwrap());
         });
     }
 
     #[test]
     fn test_frozenset_iter() {
-        Python::with_gil(|py| {
-            let set = PyFrozenSet::new(py, &[1]).unwrap();
+        Python::attach(|py| {
+            let set = PyFrozenSet::new(py, [1]).unwrap();
 
-            // iter method
             for el in set {
                 assert_eq!(1i32, el.extract::<i32>().unwrap());
             }
+        });
+    }
 
-            // intoiterator iteration
-            for el in set {
+    #[test]
+    fn test_frozenset_iter_bound() {
+        Python::attach(|py| {
+            let set = PyFrozenSet::new(py, [1]).unwrap();
+
+            for el in &set {
                 assert_eq!(1i32, el.extract::<i32>().unwrap());
             }
         });
     }
 
     #[test]
-    #[cfg(not(Py_LIMITED_API))]
     fn test_frozenset_iter_size_hint() {
-        Python::with_gil(|py| {
-            let set = PyFrozenSet::new(py, &[1]).unwrap();
+        Python::attach(|py| {
+            let set = PyFrozenSet::new(py, [1]).unwrap();
             let mut iter = set.iter();
 
             // Exact size
@@ -402,23 +321,11 @@ mod tests {
         });
     }
 
-    #[test]
-    #[cfg(Py_LIMITED_API)]
-    fn test_frozenset_iter_size_hint() {
-        Python::with_gil(|py| {
-            let set = PyFrozenSet::new(py, &[1]).unwrap();
-            let iter = set.iter();
-
-            // No known bounds
-            assert_eq!(iter.size_hint(), (0, None));
-        });
-    }
-
     #[test]
     fn test_frozenset_builder() {
         use super::PyFrozenSetBuilder;
 
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let mut builder = PyFrozenSetBuilder::new(py).unwrap();
 
             // add an item
@@ -434,4 +341,12 @@ mod tests {
             assert!(!set.contains(3).unwrap());
         });
     }
+
+    #[test]
+    fn test_iter_count() {
+        Python::attach(|py| {
+            let set = PyFrozenSet::new(py, vec![1, 2, 3]).unwrap();
+            assert_eq!(set.iter().count(), 3);
+        })
+    }
 }
diff --git a/src/types/function.rs b/src/types/function.rs
index 79f91cfe081..af41b6a2a4c 100644
--- a/src/types/function.rs
+++ b/src/types/function.rs
@@ -1,107 +1,61 @@
-use crate::derive_utils::PyFunctionArguments;
 use crate::ffi_ptr_ext::FfiPtrExt;
-use crate::methods::PyMethodDefDestructor;
-use crate::prelude::*;
+use crate::impl_::pyfunction::create_py_c_function;
 use crate::py_result_ext::PyResultExt;
 use crate::types::capsule::PyCapsuleMethods;
 use crate::{
     ffi,
     impl_::pymethods::{self, PyMethodDef},
-    types::{PyCapsule, PyDict, PyString, PyTuple},
+    types::{PyCapsule, PyDict, PyModule, PyTuple},
 };
+use crate::{Bound, PyAny, PyResult, Python};
 use std::cell::UnsafeCell;
 use std::ffi::CStr;
+use std::ptr::NonNull;
 
 /// Represents a builtin Python function object.
+///
+/// Values of this type are accessed via PyO3's smart pointers, e.g. as
+/// [`Py<PyCFunction>`][crate::Py] or [`Bound<'py, PyCFunction>`][Bound].
 #[repr(transparent)]
 pub struct PyCFunction(PyAny);
 
 pyobject_native_type_core!(PyCFunction, pyobject_native_static_type_object!(ffi::PyCFunction_Type), #checkfunction=ffi::PyCFunction_Check);
 
 impl PyCFunction {
-    /// Deprecated form of [`PyCFunction::new_with_keywords_bound`]
-    #[cfg_attr(
-        not(feature = "gil-refs"),
-        deprecated(
-            since = "0.21.0",
-            note = "`PyCFunction::new_with_keywords` will be replaced by `PyCFunction::new_with_keywords_bound` in a future PyO3 version"
-        )
-    )]
-    pub fn new_with_keywords<'a>(
-        fun: ffi::PyCFunctionWithKeywords,
-        name: &'static str,
-        doc: &'static str,
-        py_or_module: PyFunctionArguments<'a>,
-    ) -> PyResult<&'a Self> {
-        Self::new_with_keywords_bound(fun, name, doc, py_or_module).map(Bound::into_gil_ref)
-    }
-
     /// Create a new built-in function with keywords (*args and/or **kwargs).
-    pub fn new_with_keywords_bound<'a>(
+    ///
+    /// To create `name` and `doc` static strings on Rust versions older than 1.77 (which added c"" literals),
+    /// use the [`c_str!`](crate::ffi::c_str) macro.
+    pub fn new_with_keywords<'py>(
+        py: Python<'py>,
         fun: ffi::PyCFunctionWithKeywords,
-        name: &'static str,
-        doc: &'static str,
-        py_or_module: PyFunctionArguments<'a>,
-    ) -> PyResult<Bound<'a, Self>> {
-        Self::internal_new(
-            &PyMethodDef::cfunction_with_keywords(
-                name,
-                pymethods::PyCFunctionWithKeywords(fun),
-                doc,
-            ),
-            py_or_module,
-        )
-    }
-
-    /// Deprecated form of [`PyCFunction::new`]
-    #[cfg_attr(
-        not(feature = "gil-refs"),
-        deprecated(
-            since = "0.21.0",
-            note = "`PyCFunction::new` will be replaced by `PyCFunction::new_bound` in a future PyO3 version"
-        )
-    )]
-    pub fn new<'a>(
-        fun: ffi::PyCFunction,
-        name: &'static str,
-        doc: &'static str,
-        py_or_module: PyFunctionArguments<'a>,
-    ) -> PyResult<&'a Self> {
-        Self::new_bound(fun, name, doc, py_or_module).map(Bound::into_gil_ref)
+        name: &'static CStr,
+        doc: &'static CStr,
+        module: Option<&Bound<'py, PyModule>>,
+    ) -> PyResult<Bound<'py, Self>> {
+        let def = PyMethodDef::cfunction_with_keywords(name, fun, doc).into_raw();
+        // FIXME: stop leaking the def
+        let def = Box::leak(Box::new(def));
+        // Safety: def is static
+        unsafe { create_py_c_function(py, def, module) }
     }
 
     /// Create a new built-in function which takes no arguments.
-    pub fn new_bound<'a>(
+    ///
+    /// To create `name` and `doc` static strings on Rust versions older than 1.77 (which added c"" literals),
+    /// use the [`c_str!`](crate::ffi::c_str) macro.
+    pub fn new<'py>(
+        py: Python<'py>,
         fun: ffi::PyCFunction,
-        name: &'static str,
-        doc: &'static str,
-        py_or_module: PyFunctionArguments<'a>,
-    ) -> PyResult<Bound<'a, Self>> {
-        Self::internal_new(
-            &PyMethodDef::noargs(name, pymethods::PyCFunction(fun), doc),
-            py_or_module,
-        )
-    }
-
-    /// Deprecated form of [`PyCFunction::new_closure`]
-    #[cfg_attr(
-        not(feature = "gil-refs"),
-        deprecated(
-            since = "0.21.0",
-            note = "`PyCFunction::new_closure` will be replaced by `PyCFunction::new_closure_bound` in a future PyO3 version"
-        )
-    )]
-    pub fn new_closure<'a, F, R>(
-        py: Python<'a>,
-        name: Option<&'static str>,
-        doc: Option<&'static str>,
-        closure: F,
-    ) -> PyResult<&'a PyCFunction>
-    where
-        F: Fn(&PyTuple, Option<&PyDict>) -> R + Send + 'static,
-        R: crate::callback::IntoPyCallbackOutput<*mut ffi::PyObject>,
-    {
-        Self::new_closure_bound(py, name, doc, closure).map(Bound::into_gil_ref)
+        name: &'static CStr,
+        doc: &'static CStr,
+        module: Option<&Bound<'py, PyModule>>,
+    ) -> PyResult<Bound<'py, Self>> {
+        let def = PyMethodDef::noargs(name, fun, doc).into_raw();
+        // FIXME: stop leaking the def
+        let def = Box::leak(Box::new(def));
+        // Safety: def is static
+        unsafe { create_py_c_function(py, def, module) }
     }
 
     /// Create a new function from a closure.
@@ -112,86 +66,58 @@ impl PyCFunction {
     /// # use pyo3::prelude::*;
     /// # use pyo3::{py_run, types::{PyCFunction, PyDict, PyTuple}};
     ///
-    /// Python::with_gil(|py| {
-    ///     let add_one = |args: &PyTuple, _kwargs: Option<&PyDict>| -> PyResult<_> {
+    /// Python::attach(|py| {
+    ///     let add_one = |args: &Bound<'_, PyTuple>, _kwargs: Option<&Bound<'_, PyDict>>| -> PyResult<_> {
     ///         let i = args.extract::<(i64,)>()?.0;
     ///         Ok(i+1)
     ///     };
-    ///     let add_one = PyCFunction::new_closure_bound(py, None, None, add_one).unwrap();
+    ///     let add_one = PyCFunction::new_closure(py, None, None, add_one).unwrap();
     ///     py_run!(py, add_one, "assert add_one(42) == 43");
     /// });
     /// ```
-    pub fn new_closure_bound<'a, F, R>(
-        py: Python<'a>,
-        name: Option<&'static str>,
-        doc: Option<&'static str>,
+    pub fn new_closure<'py, F, R>(
+        py: Python<'py>,
+        name: Option<&'static CStr>,
+        doc: Option<&'static CStr>,
         closure: F,
-    ) -> PyResult<Bound<'a, Self>>
+    ) -> PyResult<Bound<'py, Self>>
     where
-        F: Fn(&PyTuple, Option<&PyDict>) -> R + Send + 'static,
-        R: crate::callback::IntoPyCallbackOutput<*mut ffi::PyObject>,
+        F: Fn(&Bound<'_, PyTuple>, Option<&Bound<'_, PyDict>>) -> R + Send + 'static,
+        for<'p> R: crate::impl_::callback::IntoPyCallbackOutput<'p, *mut ffi::PyObject>,
     {
-        let method_def = pymethods::PyMethodDef::cfunction_with_keywords(
-            name.unwrap_or("pyo3-closure\0"),
-            pymethods::PyCFunctionWithKeywords(run_closure::<F, R>),
-            doc.unwrap_or("\0"),
-        );
-        let (def, def_destructor) = method_def.as_method_def()?;
+        let name = name.unwrap_or(c"pyo3-closure");
+        let doc = doc.unwrap_or(c"");
+        let method_def =
+            pymethods::PyMethodDef::cfunction_with_keywords(name, run_closure::<F, R>, doc);
+        let def = method_def.into_raw();
 
-        let capsule = PyCapsule::new_bound(
+        let capsule = PyCapsule::new(
             py,
             ClosureDestructor::<F> {
                 closure,
                 def: UnsafeCell::new(def),
-                def_destructor,
             },
-            Some(closure_capsule_name().to_owned()),
+            Some(CLOSURE_CAPSULE_NAME.to_owned()),
         )?;
 
-        // Safety: just created the capsule with type ClosureDestructor<F> above
-        let data = unsafe { capsule.reference::<ClosureDestructor<F>>() };
-
-        unsafe {
-            ffi::PyCFunction_NewEx(data.def.get(), capsule.as_ptr(), std::ptr::null_mut())
-                .assume_owned_or_err(py)
-                .downcast_into_unchecked()
-        }
-    }
-
-    #[doc(hidden)]
-    pub fn internal_new<'py>(
-        method_def: &PyMethodDef,
-        py_or_module: PyFunctionArguments<'py>,
-    ) -> PyResult<Bound<'py, Self>> {
-        let (py, module) = py_or_module.into_py_and_maybe_module();
-        let (mod_ptr, module_name): (_, Option<Py<PyString>>) = if let Some(m) = module {
-            let mod_ptr = m.as_ptr();
-            (mod_ptr, Some(m.name()?.into_py(py)))
-        } else {
-            (std::ptr::null_mut(), None)
-        };
-        let (def, destructor) = method_def.as_method_def()?;
-
-        // FIXME: stop leaking the def and destructor
-        let def = Box::into_raw(Box::new(def));
-        std::mem::forget(destructor);
+        let data: NonNull<ClosureDestructor<F>> =
+            capsule.pointer_checked(Some(CLOSURE_CAPSULE_NAME))?.cast();
 
-        let module_name_ptr = module_name
-            .as_ref()
-            .map_or(std::ptr::null_mut(), Py::as_ptr);
+        // SAFETY: The capsule has just been created with the value, and will exist as long as
+        // the function object exists.
+        let method_def = unsafe { data.as_ref().def.get() };
 
+        // SAFETY: The arguments to `PyCFunction_NewEx` are valid, we are attached to the
+        // interpreter and we know the function either returns a new reference or errors.
         unsafe {
-            ffi::PyCFunction_NewEx(def, mod_ptr, module_name_ptr)
+            ffi::PyCFunction_NewEx(method_def, capsule.as_ptr(), std::ptr::null_mut())
                 .assume_owned_or_err(py)
-                .downcast_into_unchecked()
+                .cast_into_unchecked()
         }
     }
 }
 
-fn closure_capsule_name() -> &'static CStr {
-    // TODO replace this with const CStr once MSRV new enough
-    CStr::from_bytes_with_nul(b"pyo3-closure\0").unwrap()
-}
+static CLOSURE_CAPSULE_NAME: &CStr = c"pyo3-closure";
 
 unsafe extern "C" fn run_closure<F, R>(
     capsule_ptr: *mut ffi::PyObject,
@@ -199,22 +125,27 @@ unsafe extern "C" fn run_closure<F, R>(
     kwargs: *mut ffi::PyObject,
 ) -> *mut ffi::PyObject
 where
-    F: Fn(&PyTuple, Option<&PyDict>) -> R + Send + 'static,
-    R: crate::callback::IntoPyCallbackOutput<*mut ffi::PyObject>,
+    F: Fn(&Bound<'_, PyTuple>, Option<&Bound<'_, PyDict>>) -> R + Send + 'static,
+    for<'py> R: crate::impl_::callback::IntoPyCallbackOutput<'py, *mut ffi::PyObject>,
 {
-    crate::impl_::trampoline::cfunction_with_keywords(
-        capsule_ptr,
-        args,
-        kwargs,
-        |py, capsule_ptr, args, kwargs| {
-            let boxed_fn: &ClosureDestructor<F> =
-                &*(ffi::PyCapsule_GetPointer(capsule_ptr, closure_capsule_name().as_ptr())
-                    as *mut ClosureDestructor<F>);
-            let args = py.from_borrowed_ptr::<PyTuple>(args);
-            let kwargs = py.from_borrowed_ptr_or_opt::<PyDict>(kwargs);
-            crate::callback::convert(py, (boxed_fn.closure)(args, kwargs))
-        },
-    )
+    unsafe {
+        crate::impl_::trampoline::cfunction_with_keywords(
+            capsule_ptr,
+            args,
+            kwargs,
+            |py, capsule_ptr, args, kwargs| {
+                let boxed_fn: &ClosureDestructor<F> =
+                    &*(ffi::PyCapsule_GetPointer(capsule_ptr, CLOSURE_CAPSULE_NAME.as_ptr())
+                        as *mut ClosureDestructor<F>);
+                let args = Bound::ref_from_ptr(py, &args).cast_unchecked::<PyTuple>();
+                let kwargs = Bound::ref_from_ptr_or_opt(py, &kwargs)
+                    .as_ref()
+                    .map(|b| b.cast_unchecked::<PyDict>());
+                let result = (boxed_fn.closure)(args, kwargs);
+                crate::impl_::callback::convert(py, result)
+            },
+        )
+    }
 }
 
 struct ClosureDestructor<F> {
@@ -222,18 +153,18 @@ struct ClosureDestructor<F> {
     // Wrapped in UnsafeCell because Python C-API wants a *mut pointer
     // to this member.
     def: UnsafeCell<ffi::PyMethodDef>,
-    // Used to destroy the cstrings in `def`, if necessary.
-    #[allow(dead_code)]
-    def_destructor: PyMethodDefDestructor,
 }
 
 // Safety: F is send and none of the fields are ever mutated
 unsafe impl<F: Send> Send for ClosureDestructor<F> {}
 
 /// Represents a Python function object.
+///
+/// Values of this type are accessed via PyO3's smart pointers, e.g. as
+/// [`Py<PyFunction>`][crate::Py] or [`Bound<'py, PyFunction>`][Bound].
 #[repr(transparent)]
-#[cfg(all(not(Py_LIMITED_API), not(all(PyPy, not(Py_3_8)))))]
+#[cfg(not(Py_LIMITED_API))]
 pub struct PyFunction(PyAny);
 
-#[cfg(all(not(Py_LIMITED_API), not(all(PyPy, not(Py_3_8)))))]
+#[cfg(not(Py_LIMITED_API))]
 pyobject_native_type_core!(PyFunction, pyobject_native_static_type_object!(ffi::PyFunction_Type), #checkfunction=ffi::PyFunction_Check);
diff --git a/src/types/genericalias.rs b/src/types/genericalias.rs
new file mode 100644
index 00000000000..3efafb065aa
--- /dev/null
+++ b/src/types/genericalias.rs
@@ -0,0 +1,63 @@
+use crate::err::PyResult;
+use crate::ffi_ptr_ext::FfiPtrExt;
+use crate::py_result_ext::PyResultExt;
+use crate::{ffi, Bound, PyAny, Python};
+
+/// Represents a Python [`types.GenericAlias`](https://docs.python.org/3/library/types.html#types.GenericAlias) object.
+///
+/// Values of this type are accessed via PyO3's smart pointers, e.g. as
+/// [`Py<PyGenericAlias>`][crate::Py] or [`Bound<'py, PyGenericAlias>`][Bound].
+///
+/// This type is particularly convenient for users implementing
+/// [`__class_getitem__`](https://docs.python.org/3/reference/datamodel.html#object.__class_getitem__)
+/// for PyO3 classes to allow runtime parameterization.
+#[repr(transparent)]
+pub struct PyGenericAlias(PyAny);
+
+pyobject_native_type!(
+    PyGenericAlias,
+    ffi::PyDictObject,
+    pyobject_native_static_type_object!(ffi::Py_GenericAliasType)
+);
+
+impl PyGenericAlias {
+    /// Creates a new Python GenericAlias object.
+    ///
+    /// origin should be a non-parameterized generic class.
+    /// args should be a tuple (possibly of length 1) of types which parameterize origin.
+    pub fn new<'py>(
+        py: Python<'py>,
+        origin: &Bound<'py, PyAny>,
+        args: &Bound<'py, PyAny>,
+    ) -> PyResult<Bound<'py, PyGenericAlias>> {
+        unsafe {
+            ffi::Py_GenericAlias(origin.as_ptr(), args.as_ptr())
+                .assume_owned_or_err(py)
+                .cast_into_unchecked()
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::instance::BoundObject;
+    use crate::types::any::PyAnyMethods;
+    use crate::Python;
+
+    use super::PyGenericAlias;
+
+    // Tests that PyGenericAlias::new is identical to types.GenericAlias
+    // created from Python.
+    #[test]
+    fn equivalency_test() {
+        Python::attach(|py| {
+            let list_int = py.eval(c"list[int]", None, None).unwrap().into_bound();
+
+            let cls = py.eval(c"list", None, None).unwrap().into_bound();
+            let key = py.eval(c"(int,)", None, None).unwrap().into_bound();
+            let generic_alias = PyGenericAlias::new(py, &cls, &key).unwrap();
+
+            assert!(generic_alias.eq(list_int).unwrap());
+        })
+    }
+}
diff --git a/src/types/iterator.rs b/src/types/iterator.rs
index 848a8e692ca..7105e1058c6 100644
--- a/src/types/iterator.rs
+++ b/src/types/iterator.rs
@@ -1,22 +1,26 @@
 use crate::ffi_ptr_ext::FfiPtrExt;
 use crate::instance::Borrowed;
 use crate::py_result_ext::PyResultExt;
-use crate::{
-    ffi, AsPyPointer, Bound, PyAny, PyDowncastError, PyErr, PyNativeType, PyResult, PyTypeCheck,
-};
+use crate::sync::PyOnceLock;
+use crate::types::{PyType, PyTypeMethods};
+use crate::{ffi, Bound, Py, PyAny, PyErr, PyResult};
 
 /// A Python iterator object.
 ///
+/// Values of this type are accessed via PyO3's smart pointers, e.g. as
+/// [`Py<PyIterator>`][crate::Py] or [`Bound<'py, PyIterator>`][Bound].
+///
 /// # Examples
 ///
 /// ```rust
 /// use pyo3::prelude::*;
+/// use pyo3::ffi::c_str;
 ///
 /// # fn main() -> PyResult<()> {
-/// Python::with_gil(|py| -> PyResult<()> {
-///     let list = py.eval_bound("iter([1, 2, 3, 4])", None, None)?;
+/// Python::attach(|py| -> PyResult<()> {
+///     let list = py.eval(c"iter([1, 2, 3, 4])", None, None)?;
 ///     let numbers: PyResult<Vec<usize>> = list
-///         .iter()?
+///         .try_iter()?
 ///         .map(|i| i.and_then(|i|i.extract::<usize>()))
 ///         .collect();
 ///     let sum: usize = numbers?.iter().sum();
@@ -27,53 +31,62 @@ use crate::{
 /// ```
 #[repr(transparent)]
 pub struct PyIterator(PyAny);
-pyobject_native_type_named!(PyIterator);
-pyobject_native_type_extract!(PyIterator);
 
-impl PyIterator {
-    /// Deprecated form of `PyIterator::from_bound_object`.
-    #[cfg_attr(
-        not(feature = "gil-refs"),
-        deprecated(
-            since = "0.21.0",
-            note = "`PyIterator::from_object` will be replaced by `PyIterator::from_bound_object` in a future PyO3 version"
-        )
-    )]
-    pub fn from_object(obj: &PyAny) -> PyResult<&PyIterator> {
-        Self::from_bound_object(&obj.as_borrowed()).map(Bound::into_gil_ref)
-    }
+pyobject_native_type_core!(
+    PyIterator,
+    |py| {
+        static TYPE: PyOnceLock<Py<PyType>> = PyOnceLock::new();
+        TYPE.import(py, "collections.abc", "Iterator")
+            .unwrap()
+            .as_type_ptr()
+    },
+    #module=Some("collections.abc"),
+    #checkfunction=ffi::PyIter_Check
+);
 
+impl PyIterator {
     /// Builds an iterator for an iterable Python object; the equivalent of calling `iter(obj)` in Python.
     ///
-    /// Usually it is more convenient to write [`obj.iter()`][crate::types::any::PyAnyMethods::iter],
+    /// Usually it is more convenient to write [`obj.try_iter()`][crate::types::any::PyAnyMethods::try_iter],
     /// which is a more concise way of calling this function.
-    pub fn from_bound_object<'py>(obj: &Bound<'py, PyAny>) -> PyResult<Bound<'py, PyIterator>> {
+    pub fn from_object<'py>(obj: &Bound<'py, PyAny>) -> PyResult<Bound<'py, PyIterator>> {
         unsafe {
             ffi::PyObject_GetIter(obj.as_ptr())
                 .assume_owned_or_err(obj.py())
-                .downcast_into_unchecked()
+                .cast_into_unchecked()
         }
     }
 }
 
-impl<'p> Iterator for &'p PyIterator {
-    type Item = PyResult<&'p PyAny>;
-
-    /// Retrieves the next item from an iterator.
-    ///
-    /// Returns `None` when the iterator is exhausted.
-    /// If an exception occurs, returns `Some(Err(..))`.
-    /// Further `next()` calls after an exception occurs are likely
-    /// to repeatedly result in the same exception.
-    fn next(&mut self) -> Option<Self::Item> {
-        self.as_borrowed()
-            .next()
-            .map(|result| result.map(Bound::into_gil_ref))
-    }
+/// Outcomes from sending a value into a python generator
+#[derive(Debug)]
+#[cfg(all(not(PyPy), Py_3_10))]
+pub enum PySendResult<'py> {
+    /// The generator yielded a new value
+    Next(Bound<'py, PyAny>),
+    /// The generator completed, returning a (possibly None) final value
+    Return(Bound<'py, PyAny>),
+}
 
-    #[cfg(not(Py_LIMITED_API))]
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        self.as_borrowed().size_hint()
+#[cfg(all(not(PyPy), Py_3_10))]
+impl<'py> Bound<'py, PyIterator> {
+    /// Sends a value into a python generator. This is the equivalent of calling `generator.send(value)` in Python.
+    /// This resumes the generator and continues its execution until the next `yield` or `return` statement.
+    /// If the generator exits without returning a value, this function returns a `StopException`.
+    /// The first call to `send` must be made with `None` as the argument to start the generator, failing to do so will raise a `TypeError`.
+    #[inline]
+    pub fn send(&self, value: &Bound<'py, PyAny>) -> PyResult<PySendResult<'py>> {
+        let py = self.py();
+        let mut result = std::ptr::null_mut();
+        match unsafe { ffi::PyIter_Send(self.as_ptr(), value.as_ptr(), &mut result) } {
+            ffi::PySendResult::PYGEN_ERROR => Err(PyErr::fetch(py)),
+            ffi::PySendResult::PYGEN_RETURN => Ok(PySendResult::Return(unsafe {
+                result.assume_owned_unchecked(py)
+            })),
+            ffi::PySendResult::PYGEN_NEXT => Ok(PySendResult::Next(unsafe {
+                result.assume_owned_unchecked(py)
+            })),
+        }
     }
 }
 
@@ -111,53 +124,31 @@ impl<'py> Borrowed<'_, 'py, PyIterator> {
     }
 }
 
-impl PyTypeCheck for PyIterator {
-    const NAME: &'static str = "Iterator";
-
-    fn type_check(object: &Bound<'_, PyAny>) -> bool {
-        unsafe { ffi::PyIter_Check(object.as_ptr()) != 0 }
-    }
-}
-
-#[allow(deprecated)]
-impl<'v> crate::PyTryFrom<'v> for PyIterator {
-    fn try_from<V: Into<&'v PyAny>>(value: V) -> Result<&'v PyIterator, PyDowncastError<'v>> {
-        let value = value.into();
-        unsafe {
-            if ffi::PyIter_Check(value.as_ptr()) != 0 {
-                Ok(value.downcast_unchecked())
-            } else {
-                Err(PyDowncastError::new(value, "Iterator"))
-            }
-        }
-    }
-
-    fn try_from_exact<V: Into<&'v PyAny>>(value: V) -> Result<&'v PyIterator, PyDowncastError<'v>> {
-        value.into().downcast()
-    }
+impl<'py> IntoIterator for &Bound<'py, PyIterator> {
+    type Item = PyResult<Bound<'py, PyAny>>;
+    type IntoIter = Bound<'py, PyIterator>;
 
-    #[inline]
-    unsafe fn try_from_unchecked<V: Into<&'v PyAny>>(value: V) -> &'v PyIterator {
-        let ptr = value.into() as *const _ as *const PyIterator;
-        &*ptr
+    fn into_iter(self) -> Self::IntoIter {
+        self.clone()
     }
 }
 
 #[cfg(test)]
-#[cfg_attr(not(feature = "gil-refs"), allow(deprecated))]
 mod tests {
     use super::PyIterator;
+    #[cfg(all(not(PyPy), Py_3_10))]
+    use super::PySendResult;
     use crate::exceptions::PyTypeError;
-    use crate::gil::GILPool;
-    use crate::types::{PyDict, PyList};
-    use crate::{Py, PyAny, Python, ToPyObject};
+    #[cfg(all(not(PyPy), Py_3_10))]
+    use crate::types::PyNone;
+    use crate::types::{PyAnyMethods, PyDict, PyList, PyListMethods};
+    use crate::{IntoPyObject, PyTypeInfo, Python};
 
     #[test]
     fn vec_iter() {
-        Python::with_gil(|py| {
-            let obj = vec![10, 20].to_object(py);
-            let inst = obj.as_ref(py);
-            let mut it = inst.iter().unwrap();
+        Python::attach(|py| {
+            let inst = vec![10, 20].into_pyobject(py).unwrap();
+            let mut it = inst.try_iter().unwrap();
             assert_eq!(
                 10_i32,
                 it.next().unwrap().unwrap().extract::<'_, i32>().unwrap()
@@ -172,15 +163,15 @@ mod tests {
 
     #[test]
     fn iter_refcnt() {
-        let (obj, count) = Python::with_gil(|py| {
-            let obj = vec![10, 20].to_object(py);
-            let count = obj.get_refcnt(py);
-            (obj, count)
+        let (obj, count) = Python::attach(|py| {
+            let obj = vec![10, 20].into_pyobject(py).unwrap();
+            let count = obj.get_refcnt();
+            (obj.unbind(), count)
         });
 
-        Python::with_gil(|py| {
-            let inst = obj.as_ref(py);
-            let mut it = inst.iter().unwrap();
+        Python::attach(|py| {
+            let inst = obj.bind(py);
+            let mut it = inst.try_iter().unwrap();
 
             assert_eq!(
                 10_i32,
@@ -188,35 +179,29 @@ mod tests {
             );
         });
 
-        Python::with_gil(|py| {
+        Python::attach(move |py| {
             assert_eq!(count, obj.get_refcnt(py));
         });
     }
 
     #[test]
     fn iter_item_refcnt() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let count;
-            let obj = py.eval("object()", None, None).unwrap();
+            let obj = py.eval(c"object()", None, None).unwrap();
             let list = {
-                let _pool = unsafe { GILPool::new() };
                 let list = PyList::empty(py);
                 list.append(10).unwrap();
-                list.append(obj).unwrap();
+                list.append(&obj).unwrap();
                 count = obj.get_refcnt();
-                list.to_object(py)
+                list
             };
 
             {
-                let _pool = unsafe { GILPool::new() };
-                let inst = list.as_ref(py);
-                let mut it = inst.iter().unwrap();
-
-                assert_eq!(
-                    10_i32,
-                    it.next().unwrap().unwrap().extract::<'_, i32>().unwrap()
-                );
-                assert!(it.next().unwrap().unwrap().is(obj));
+                let mut it = list.iter();
+
+                assert_eq!(10_i32, it.next().unwrap().extract::<'_, i32>().unwrap());
+                assert!(it.next().unwrap().is(&obj));
                 assert!(it.next().is_none());
             }
             assert_eq!(count, obj.get_refcnt());
@@ -225,7 +210,7 @@ mod tests {
 
     #[test]
     fn fibonacci_generator() {
-        let fibonacci_generator = r#"
+        let fibonacci_generator = cr#"
 def fibonacci(target):
     a = 1
     b = 1
@@ -234,12 +219,12 @@ def fibonacci(target):
         a, b = b, a + b
 "#;
 
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let context = PyDict::new(py);
-            py.run(fibonacci_generator, None, Some(context)).unwrap();
+            py.run(fibonacci_generator, None, Some(&context)).unwrap();
 
-            let generator = py.eval("fibonacci(5)", None, Some(context)).unwrap();
-            for (actual, expected) in generator.iter().unwrap().zip(&[1, 1, 2, 3, 5]) {
+            let generator = py.eval(c"fibonacci(5)", None, Some(&context)).unwrap();
+            for (actual, expected) in generator.try_iter().unwrap().zip(&[1, 1, 2, 3, 5]) {
                 let actual = actual.unwrap().extract::<usize>().unwrap();
                 assert_eq!(actual, *expected)
             }
@@ -247,22 +232,78 @@ def fibonacci(target):
     }
 
     #[test]
-    fn int_not_iterable() {
-        Python::with_gil(|py| {
-            let x = 5.to_object(py);
-            let err = PyIterator::from_object(x.as_ref(py)).unwrap_err();
+    #[cfg(all(not(PyPy), Py_3_10))]
+    fn send_generator() {
+        let generator = cr#"
+def gen():
+    value = None
+    while(True):
+        value = yield value
+        if value is None:
+            return
+"#;
 
-            assert!(err.is_instance_of::<PyTypeError>(py));
+        Python::attach(|py| {
+            let context = PyDict::new(py);
+            py.run(generator, None, Some(&context)).unwrap();
+
+            let generator = py.eval(c"gen()", None, Some(&context)).unwrap();
+
+            let one = 1i32.into_pyobject(py).unwrap();
+            assert!(matches!(
+                generator.try_iter().unwrap().send(&PyNone::get(py)).unwrap(),
+                PySendResult::Next(value) if value.is_none()
+            ));
+            assert!(matches!(
+                generator.try_iter().unwrap().send(&one).unwrap(),
+                PySendResult::Next(value) if value.is(&one)
+            ));
+            assert!(matches!(
+                generator.try_iter().unwrap().send(&PyNone::get(py)).unwrap(),
+                PySendResult::Return(value) if value.is_none()
+            ));
+        });
+    }
+
+    #[test]
+    fn fibonacci_generator_bound() {
+        use crate::types::any::PyAnyMethods;
+        use crate::Bound;
+
+        let fibonacci_generator = cr#"
+def fibonacci(target):
+    a = 1
+    b = 1
+    for _ in range(target):
+        yield a
+        a, b = b, a + b
+"#;
+
+        Python::attach(|py| {
+            let context = PyDict::new(py);
+            py.run(fibonacci_generator, None, Some(&context)).unwrap();
+
+            let generator: Bound<'_, PyIterator> = py
+                .eval(c"fibonacci(5)", None, Some(&context))
+                .unwrap()
+                .cast_into()
+                .unwrap();
+            let mut items = vec![];
+            for actual in &generator {
+                let actual = actual.unwrap().extract::<usize>().unwrap();
+                items.push(actual);
+            }
+            assert_eq!(items, [1, 1, 2, 3, 5]);
         });
     }
 
     #[test]
+    fn int_not_iterable() {
+        Python::attach(|py| {
+            let x = 5i32.into_pyobject(py).unwrap();
+            let err = PyIterator::from_object(&x).unwrap_err();
 
-    fn iterator_try_from() {
-        Python::with_gil(|py| {
-            let obj: Py<PyAny> = vec![10, 20].to_object(py).as_ref(py).iter().unwrap().into();
-            let iter: &PyIterator = obj.downcast(py).unwrap();
-            assert!(obj.is(iter));
+            assert!(err.is_instance_of::<PyTypeError>(py));
         });
     }
 
@@ -278,14 +319,14 @@ def fibonacci(target):
 
         #[crate::pymethods(crate = "crate")]
         impl Downcaster {
-            fn downcast_iterator(&mut self, obj: &PyAny) {
-                self.failed = Some(obj.downcast::<PyIterator>().unwrap_err().into());
+            fn downcast_iterator(&mut self, obj: &crate::Bound<'_, crate::PyAny>) {
+                self.failed = Some(obj.cast::<PyIterator>().unwrap_err().into());
             }
         }
 
         // Regression test for 2913
-        Python::with_gil(|py| {
-            let downcaster = Py::new(py, Downcaster { failed: None }).unwrap();
+        Python::attach(|py| {
+            let downcaster = crate::Py::new(py, Downcaster { failed: None }).unwrap();
             crate::py_run!(
                 py,
                 downcaster,
@@ -308,7 +349,7 @@ def fibonacci(target):
 
             assert_eq!(
                 downcaster.borrow_mut(py).failed.take().unwrap().to_string(),
-                "TypeError: 'MySequence' object cannot be converted to 'Iterator'"
+                "TypeError: 'MySequence' object cannot be cast as 'Iterator'"
             );
         });
     }
@@ -317,12 +358,12 @@ def fibonacci(target):
     #[cfg(feature = "macros")]
     fn python_class_iterator() {
         #[crate::pyfunction(crate = "crate")]
-        fn assert_iterator(obj: &PyAny) {
-            assert!(obj.downcast::<PyIterator>().is_ok())
+        fn assert_iterator(obj: &crate::Bound<'_, crate::PyAny>) {
+            assert!(obj.cast::<PyIterator>().is_ok())
         }
 
         // Regression test for 2913
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let assert_iterator = crate::wrap_pyfunction!(assert_iterator, py).unwrap();
             crate::py_run!(
                 py,
@@ -341,11 +382,20 @@ def fibonacci(target):
     #[test]
     #[cfg(not(Py_LIMITED_API))]
     fn length_hint_becomes_size_hint_lower_bound() {
-        Python::with_gil(|py| {
-            let list = py.eval("[1, 2, 3]", None, None).unwrap();
-            let iter = list.iter().unwrap();
+        Python::attach(|py| {
+            let list = py.eval(c"[1, 2, 3]", None, None).unwrap();
+            let iter = list.try_iter().unwrap();
             let hint = iter.size_hint();
             assert_eq!(hint, (3, None));
         });
     }
+
+    #[test]
+    fn test_type_object() {
+        Python::attach(|py| {
+            let abc = PyIterator::type_object(py);
+            let iter = py.eval(c"iter(())", None, None).unwrap();
+            assert!(iter.is_instance(&abc).unwrap());
+        })
+    }
 }
diff --git a/src/types/list.rs b/src/types/list.rs
index 1389d25ed29..53b686e8e18 100644
--- a/src/types/list.rs
+++ b/src/types/list.rs
@@ -1,18 +1,21 @@
-use std::convert::TryInto;
-use std::iter::FusedIterator;
-
 use crate::err::{self, PyResult};
 use crate::ffi::{self, Py_ssize_t};
 use crate::ffi_ptr_ext::FfiPtrExt;
-use crate::instance::Borrowed;
 use crate::internal_tricks::get_ssize_index;
-use crate::types::{PySequence, PyTuple};
-use crate::{Bound, PyAny, PyNativeType, PyObject, Python, ToPyObject};
-
-use crate::types::any::PyAnyMethods;
 use crate::types::sequence::PySequenceMethods;
+use crate::types::{PySequence, PyTuple};
+use crate::{Borrowed, Bound, BoundObject, IntoPyObject, IntoPyObjectExt, PyAny, PyErr, Python};
+use std::iter::FusedIterator;
+#[cfg(feature = "nightly")]
+use std::num::NonZero;
 
 /// Represents a Python `list`.
+///
+/// Values of this type are accessed via PyO3's smart pointers, e.g. as
+/// [`Py<PyList>`][crate::Py] or [`Bound<'py, PyList>`][Bound].
+///
+/// For APIs available on `list` objects, see the [`PyListMethods`] trait which is implemented for
+/// [`Bound<'py, PyList>`][Bound].
 #[repr(transparent)]
 pub struct PyList(PyAny);
 
@@ -20,10 +23,10 @@ pyobject_native_type_core!(PyList, pyobject_native_static_type_object!(ffi::PyLi
 
 #[inline]
 #[track_caller]
-pub(crate) fn new_from_iter<'py>(
+pub(crate) fn try_new_from_iter<'py>(
     py: Python<'py>,
-    elements: &mut dyn ExactSizeIterator<Item = PyObject>,
-) -> Bound<'py, PyList> {
+    mut elements: impl ExactSizeIterator<Item = PyResult<Bound<'py, PyAny>>>,
+) -> PyResult<Bound<'py, PyList>> {
     unsafe {
         // PyList_New checks for overflow but has a bad error message, so we check ourselves
         let len: Py_ssize_t = elements
@@ -36,48 +39,30 @@ pub(crate) fn new_from_iter<'py>(
         // We create the `Bound` pointer here for two reasons:
         // - panics if the ptr is null
         // - its Drop cleans up the list if user code or the asserts panic.
-        let list = ptr.assume_owned(py).downcast_into_unchecked();
-
-        let mut counter: Py_ssize_t = 0;
-
-        for obj in elements.take(len as usize) {
-            #[cfg(not(Py_LIMITED_API))]
-            ffi::PyList_SET_ITEM(ptr, counter, obj.into_ptr());
-            #[cfg(Py_LIMITED_API)]
-            ffi::PyList_SetItem(ptr, counter, obj.into_ptr());
-            counter += 1;
-        }
+        let list = ptr.assume_owned(py).cast_into_unchecked();
+
+        let count = (&mut elements)
+            .take(len as usize)
+            .try_fold(0, |count, item| {
+                #[cfg(not(Py_LIMITED_API))]
+                ffi::PyList_SET_ITEM(ptr, count, item?.into_ptr());
+                #[cfg(Py_LIMITED_API)]
+                ffi::PyList_SetItem(ptr, count, item?.into_ptr());
+                Ok::<_, PyErr>(count + 1)
+            })?;
 
         assert!(elements.next().is_none(), "Attempted to create PyList but `elements` was larger than reported by its `ExactSizeIterator` implementation.");
-        assert_eq!(len, counter, "Attempted to create PyList but `elements` was smaller than reported by its `ExactSizeIterator` implementation.");
+        assert_eq!(len, count, "Attempted to create PyList but `elements` was smaller than reported by its `ExactSizeIterator` implementation.");
 
-        list
+        Ok(list)
     }
 }
 
 impl PyList {
-    /// Deprecated form of [`PyList::new_bound`].
-    #[inline]
-    #[track_caller]
-    #[cfg_attr(
-        not(feature = "gil-refs"),
-        deprecated(
-            since = "0.21.0",
-            note = "`PyList::new` will be replaced by `PyList::new_bound` in a future PyO3 version"
-        )
-    )]
-    pub fn new<T, U>(py: Python<'_>, elements: impl IntoIterator<Item = T, IntoIter = U>) -> &PyList
-    where
-        T: ToPyObject,
-        U: ExactSizeIterator<Item = T>,
-    {
-        Self::new_bound(py, elements).into_gil_ref()
-    }
-
     /// Constructs a new list with the given elements.
     ///
     /// If you want to create a [`PyList`] with elements of different or unknown types, or from an
-    /// iterable that doesn't implement [`ExactSizeIterator`], use [`PyList::append`].
+    /// iterable that doesn't implement [`ExactSizeIterator`], use [`PyListMethods::append`].
     ///
     /// # Examples
     ///
@@ -85,12 +70,13 @@ impl PyList {
     /// use pyo3::prelude::*;
     /// use pyo3::types::PyList;
     ///
-    /// # fn main() {
-    /// Python::with_gil(|py| {
+    /// # fn main() -> PyResult<()> {
+    /// Python::attach(|py| {
     ///     let elements: Vec<i32> = vec![0, 1, 2, 3, 4, 5];
-    ///     let list = PyList::new_bound(py, elements);
+    ///     let list = PyList::new(py, elements)?;
     ///     assert_eq!(format!("{:?}", list), "[0, 1, 2, 3, 4, 5]");
-    /// });
+    /// # Ok(())
+    /// })
     /// # }
     /// ```
     ///
@@ -100,193 +86,31 @@ impl PyList {
     /// All standard library structures implement this trait correctly, if they do, so calling this
     /// function with (for example) [`Vec`]`<T>` or `&[T]` will always succeed.
     #[track_caller]
-    pub fn new_bound<T, U>(
-        py: Python<'_>,
+    pub fn new<'py, T, U>(
+        py: Python<'py>,
         elements: impl IntoIterator<Item = T, IntoIter = U>,
-    ) -> Bound<'_, PyList>
+    ) -> PyResult<Bound<'py, PyList>>
     where
-        T: ToPyObject,
+        T: IntoPyObject<'py>,
         U: ExactSizeIterator<Item = T>,
     {
-        let mut iter = elements.into_iter().map(|e| e.to_object(py));
-        new_from_iter(py, &mut iter)
-    }
-
-    /// Deprecated form of [`PyList::empty_bound`].
-    #[inline]
-    #[cfg_attr(
-        not(feature = "gil-refs"),
-        deprecated(
-            since = "0.21.0",
-            note = "`PyList::empty` will be replaced by `PyList::empty_bound` in a future PyO3 version"
-        )
-    )]
-    pub fn empty(py: Python<'_>) -> &PyList {
-        Self::empty_bound(py).into_gil_ref()
+        let iter = elements.into_iter().map(|e| e.into_bound_py_any(py));
+        try_new_from_iter(py, iter)
     }
 
     /// Constructs a new empty list.
-    pub fn empty_bound(py: Python<'_>) -> Bound<'_, PyList> {
-        unsafe {
-            ffi::PyList_New(0)
-                .assume_owned(py)
-                .downcast_into_unchecked()
-        }
-    }
-
-    /// Returns the length of the list.
-    pub fn len(&self) -> usize {
-        self.as_borrowed().len()
-    }
-
-    /// Checks if the list is empty.
-    pub fn is_empty(&self) -> bool {
-        self.as_borrowed().is_empty()
-    }
-
-    /// Returns `self` cast as a `PySequence`.
-    pub fn as_sequence(&self) -> &PySequence {
-        unsafe { self.downcast_unchecked() }
-    }
-
-    /// Gets the list item at the specified index.
-    /// # Example
-    /// ```
-    /// use pyo3::{prelude::*, types::PyList};
-    /// Python::with_gil(|py| {
-    ///     let list = PyList::new_bound(py, [2, 3, 5, 7]);
-    ///     let obj = list.get_item(0);
-    ///     assert_eq!(obj.unwrap().extract::<i32>().unwrap(), 2);
-    /// });
-    /// ```
-    pub fn get_item(&self, index: usize) -> PyResult<&PyAny> {
-        self.as_borrowed().get_item(index).map(Bound::into_gil_ref)
-    }
-
-    /// Gets the list item at the specified index. Undefined behavior on bad index. Use with caution.
-    ///
-    /// # Safety
-    ///
-    /// Caller must verify that the index is within the bounds of the list.
-    #[cfg(not(Py_LIMITED_API))]
-    pub unsafe fn get_item_unchecked(&self, index: usize) -> &PyAny {
-        self.as_borrowed().get_item_unchecked(index).into_gil_ref()
-    }
-
-    /// Takes the slice `self[low:high]` and returns it as a new list.
-    ///
-    /// Indices must be nonnegative, and out-of-range indices are clipped to
-    /// `self.len()`.
-    pub fn get_slice(&self, low: usize, high: usize) -> &PyList {
-        self.as_borrowed().get_slice(low, high).into_gil_ref()
-    }
-
-    /// Sets the item at the specified index.
-    ///
-    /// Raises `IndexError` if the index is out of range.
-    pub fn set_item<I>(&self, index: usize, item: I) -> PyResult<()>
-    where
-        I: ToPyObject,
-    {
-        self.as_borrowed().set_item(index, item)
-    }
-
-    /// Deletes the `index`th element of self.
-    ///
-    /// This is equivalent to the Python statement `del self[i]`.
-    #[inline]
-    pub fn del_item(&self, index: usize) -> PyResult<()> {
-        self.as_borrowed().del_item(index)
-    }
-
-    /// Assigns the sequence `seq` to the slice of `self` from `low` to `high`.
-    ///
-    /// This is equivalent to the Python statement `self[low:high] = v`.
-    #[inline]
-    pub fn set_slice(&self, low: usize, high: usize, seq: &PyAny) -> PyResult<()> {
-        self.as_borrowed().set_slice(low, high, &seq.as_borrowed())
-    }
-
-    /// Deletes the slice from `low` to `high` from `self`.
-    ///
-    /// This is equivalent to the Python statement `del self[low:high]`.
-    #[inline]
-    pub fn del_slice(&self, low: usize, high: usize) -> PyResult<()> {
-        self.as_borrowed().del_slice(low, high)
-    }
-
-    /// Appends an item to the list.
-    pub fn append<I>(&self, item: I) -> PyResult<()>
-    where
-        I: ToPyObject,
-    {
-        self.as_borrowed().append(item)
-    }
-
-    /// Inserts an item at the specified index.
-    ///
-    /// If `index >= self.len()`, inserts at the end.
-    pub fn insert<I>(&self, index: usize, item: I) -> PyResult<()>
-    where
-        I: ToPyObject,
-    {
-        self.as_borrowed().insert(index, item)
-    }
-
-    /// Determines if self contains `value`.
-    ///
-    /// This is equivalent to the Python expression `value in self`.
-    #[inline]
-    pub fn contains<V>(&self, value: V) -> PyResult<bool>
-    where
-        V: ToPyObject,
-    {
-        self.as_borrowed().contains(value)
-    }
-
-    /// Returns the first index `i` for which `self[i] == value`.
-    ///
-    /// This is equivalent to the Python expression `self.index(value)`.
-    #[inline]
-    pub fn index<V>(&self, value: V) -> PyResult<usize>
-    where
-        V: ToPyObject,
-    {
-        self.as_borrowed().index(value)
-    }
-
-    /// Returns an iterator over this list's items.
-    pub fn iter(&self) -> PyListIterator<'_> {
-        PyListIterator(self.as_borrowed().iter())
-    }
-
-    /// Sorts the list in-place. Equivalent to the Python expression `l.sort()`.
-    pub fn sort(&self) -> PyResult<()> {
-        self.as_borrowed().sort()
-    }
-
-    /// Reverses the list in-place. Equivalent to the Python expression `l.reverse()`.
-    pub fn reverse(&self) -> PyResult<()> {
-        self.as_borrowed().reverse()
-    }
-
-    /// Return a new tuple containing the contents of the list; equivalent to the Python expression `tuple(list)`.
-    ///
-    /// This method is equivalent to `self.as_sequence().to_tuple()` and faster than `PyTuple::new(py, this_list)`.
-    pub fn to_tuple(&self) -> &PyTuple {
-        self.as_borrowed().to_tuple().into_gil_ref()
+    pub fn empty(py: Python<'_>) -> Bound<'_, PyList> {
+        unsafe { ffi::PyList_New(0).assume_owned(py).cast_into_unchecked() }
     }
 }
 
-index_impls!(PyList, "list", PyList::len, PyList::get_slice);
-
 /// Implementation of functionality for [`PyList`].
 ///
 /// These methods are defined for the `Bound<'py, PyList>` smart pointer, so to use method call
 /// syntax these methods are separated into a trait, because stable Rust does not yet support
 /// `arbitrary_self_types`.
 #[doc(alias = "PyList")]
-pub trait PyListMethods<'py> {
+pub trait PyListMethods<'py>: crate::sealed::Sealed {
     /// Returns the length of the list.
     fn len(&self) -> usize;
 
@@ -296,23 +120,33 @@ pub trait PyListMethods<'py> {
     /// Returns `self` cast as a `PySequence`.
     fn as_sequence(&self) -> &Bound<'py, PySequence>;
 
+    /// Returns `self` cast as a `PySequence`.
+    fn into_sequence(self) -> Bound<'py, PySequence>;
+
     /// Gets the list item at the specified index.
     /// # Example
     /// ```
     /// use pyo3::{prelude::*, types::PyList};
-    /// Python::with_gil(|py| {
-    ///     let list = PyList::new_bound(py, [2, 3, 5, 7]);
+    /// Python::attach(|py| {
+    ///     let list = PyList::new(py, [2, 3, 5, 7]).unwrap();
     ///     let obj = list.get_item(0);
     ///     assert_eq!(obj.unwrap().extract::<i32>().unwrap(), 2);
     /// });
     /// ```
     fn get_item(&self, index: usize) -> PyResult<Bound<'py, PyAny>>;
 
-    /// Gets the list item at the specified index. Undefined behavior on bad index. Use with caution.
+    /// Gets the list item at the specified index. Undefined behavior on bad index, or if the list
+    /// contains a null pointer at the specified index. Use with caution.
     ///
     /// # Safety
     ///
-    /// Caller must verify that the index is within the bounds of the list.
+    /// - Caller must verify that the index is within the bounds of the list.
+    /// - A null pointer is only legal in a list which is in the process of being initialized, callers
+    ///   can typically assume the list item is non-null unless they are knowingly filling an
+    ///   uninitialized list. (If a list were to contain a null pointer element, accessing it from Python
+    ///   typically causes a segfault.)
+    /// - On the free-threaded build, caller must verify they have exclusive access to the list
+    ///   via a lock or by holding the innermost critical section on the list.
     #[cfg(not(Py_LIMITED_API))]
     unsafe fn get_item_unchecked(&self, index: usize) -> Bound<'py, PyAny>;
 
@@ -327,7 +161,7 @@ pub trait PyListMethods<'py> {
     /// Raises `IndexError` if the index is out of range.
     fn set_item<I>(&self, index: usize, item: I) -> PyResult<()>
     where
-        I: ToPyObject;
+        I: IntoPyObject<'py>;
 
     /// Deletes the `index`th element of self.
     ///
@@ -347,32 +181,43 @@ pub trait PyListMethods<'py> {
     /// Appends an item to the list.
     fn append<I>(&self, item: I) -> PyResult<()>
     where
-        I: ToPyObject;
+        I: IntoPyObject<'py>;
 
     /// Inserts an item at the specified index.
     ///
     /// If `index >= self.len()`, inserts at the end.
     fn insert<I>(&self, index: usize, item: I) -> PyResult<()>
     where
-        I: ToPyObject;
+        I: IntoPyObject<'py>;
 
     /// Determines if self contains `value`.
     ///
     /// This is equivalent to the Python expression `value in self`.
     fn contains<V>(&self, value: V) -> PyResult<bool>
     where
-        V: ToPyObject;
+        V: IntoPyObject<'py>;
 
     /// Returns the first index `i` for which `self[i] == value`.
     ///
     /// This is equivalent to the Python expression `self.index(value)`.
     fn index<V>(&self, value: V) -> PyResult<usize>
     where
-        V: ToPyObject;
+        V: IntoPyObject<'py>;
 
     /// Returns an iterator over this list's items.
     fn iter(&self) -> BoundListIterator<'py>;
 
+    /// Iterates over the contents of this list while holding a critical section on the list.
+    /// This is useful when the GIL is disabled and the list is shared between threads.
+    /// It is not guaranteed that the list will not be modified during iteration when the
+    /// closure calls arbitrary Python code that releases the critical section held by the
+    /// iterator. Otherwise, the list will not be modified during iteration.
+    ///
+    /// This is equivalent to for_each if the GIL is enabled.
+    fn locked_for_each<F>(&self, closure: F) -> PyResult<()>
+    where
+        F: Fn(Bound<'py, PyAny>) -> PyResult<()>;
+
     /// Sorts the list in-place. Equivalent to the Python expression `l.sort()`.
     fn sort(&self) -> PyResult<()>;
 
@@ -406,25 +251,28 @@ impl<'py> PyListMethods<'py> for Bound<'py, PyList> {
 
     /// Returns `self` cast as a `PySequence`.
     fn as_sequence(&self) -> &Bound<'py, PySequence> {
-        unsafe { self.downcast_unchecked() }
+        unsafe { self.cast_unchecked() }
+    }
+
+    /// Returns `self` cast as a `PySequence`.
+    fn into_sequence(self) -> Bound<'py, PySequence> {
+        unsafe { self.cast_into_unchecked() }
     }
 
     /// Gets the list item at the specified index.
     /// # Example
     /// ```
     /// use pyo3::{prelude::*, types::PyList};
-    /// Python::with_gil(|py| {
-    ///     let list = PyList::new_bound(py, [2, 3, 5, 7]);
+    /// Python::attach(|py| {
+    ///     let list = PyList::new(py, [2, 3, 5, 7]).unwrap();
     ///     let obj = list.get_item(0);
     ///     assert_eq!(obj.unwrap().extract::<i32>().unwrap(), 2);
     /// });
     /// ```
     fn get_item(&self, index: usize) -> PyResult<Bound<'py, PyAny>> {
         unsafe {
-            // PyList_GetItem return borrowed ptr; must make owned for safety (see #890).
-            ffi::PyList_GetItem(self.as_ptr(), index as Py_ssize_t)
-                .assume_borrowed_or_err(self.py())
-                .map(Borrowed::to_owned)
+            ffi::compat::PyList_GetItemRef(self.as_ptr(), index as Py_ssize_t)
+                .assume_owned_or_err(self.py())
         }
     }
 
@@ -435,10 +283,13 @@ impl<'py> PyListMethods<'py> for Bound<'py, PyList> {
     /// Caller must verify that the index is within the bounds of the list.
     #[cfg(not(Py_LIMITED_API))]
     unsafe fn get_item_unchecked(&self, index: usize) -> Bound<'py, PyAny> {
+        // SAFETY: caller has upheld the safety contract
+        unsafe {
+            ffi::PyList_GET_ITEM(self.as_ptr(), index as Py_ssize_t)
+                .assume_borrowed_unchecked(self.py())
+        }
         // PyList_GET_ITEM return borrowed ptr; must make owned for safety (see #890).
-        ffi::PyList_GET_ITEM(self.as_ptr(), index as Py_ssize_t)
-            .assume_borrowed(self.py())
-            .to_owned()
+        .to_owned()
     }
 
     /// Takes the slice `self[low:high]` and returns it as a new list.
@@ -449,7 +300,7 @@ impl<'py> PyListMethods<'py> for Bound<'py, PyList> {
         unsafe {
             ffi::PyList_GetSlice(self.as_ptr(), get_ssize_index(low), get_ssize_index(high))
                 .assume_owned(self.py())
-                .downcast_into_unchecked()
+                .cast_into_unchecked()
         }
     }
 
@@ -458,7 +309,7 @@ impl<'py> PyListMethods<'py> for Bound<'py, PyList> {
     /// Raises `IndexError` if the index is out of range.
     fn set_item<I>(&self, index: usize, item: I) -> PyResult<()>
     where
-        I: ToPyObject,
+        I: IntoPyObject<'py>,
     {
         fn inner(list: &Bound<'_, PyList>, index: usize, item: Bound<'_, PyAny>) -> PyResult<()> {
             err::error_on_minusone(list.py(), unsafe {
@@ -467,7 +318,7 @@ impl<'py> PyListMethods<'py> for Bound<'py, PyList> {
         }
 
         let py = self.py();
-        inner(self, index, item.to_object(py).into_bound(py))
+        inner(self, index, item.into_bound_py_any(py)?)
     }
 
     /// Deletes the `index`th element of self.
@@ -504,16 +355,19 @@ impl<'py> PyListMethods<'py> for Bound<'py, PyList> {
     /// Appends an item to the list.
     fn append<I>(&self, item: I) -> PyResult<()>
     where
-        I: ToPyObject,
+        I: IntoPyObject<'py>,
     {
-        fn inner(list: &Bound<'_, PyList>, item: Bound<'_, PyAny>) -> PyResult<()> {
+        fn inner(list: &Bound<'_, PyList>, item: Borrowed<'_, '_, PyAny>) -> PyResult<()> {
             err::error_on_minusone(list.py(), unsafe {
                 ffi::PyList_Append(list.as_ptr(), item.as_ptr())
             })
         }
 
         let py = self.py();
-        inner(self, item.to_object(py).into_bound(py))
+        inner(
+            self,
+            item.into_pyobject_or_pyerr(py)?.into_any().as_borrowed(),
+        )
     }
 
     /// Inserts an item at the specified index.
@@ -521,16 +375,24 @@ impl<'py> PyListMethods<'py> for Bound<'py, PyList> {
     /// If `index >= self.len()`, inserts at the end.
     fn insert<I>(&self, index: usize, item: I) -> PyResult<()>
     where
-        I: ToPyObject,
+        I: IntoPyObject<'py>,
     {
-        fn inner(list: &Bound<'_, PyList>, index: usize, item: Bound<'_, PyAny>) -> PyResult<()> {
+        fn inner(
+            list: &Bound<'_, PyList>,
+            index: usize,
+            item: Borrowed<'_, '_, PyAny>,
+        ) -> PyResult<()> {
             err::error_on_minusone(list.py(), unsafe {
                 ffi::PyList_Insert(list.as_ptr(), get_ssize_index(index), item.as_ptr())
             })
         }
 
         let py = self.py();
-        inner(self, index, item.to_object(py).into_bound(py))
+        inner(
+            self,
+            index,
+            item.into_pyobject_or_pyerr(py)?.into_any().as_borrowed(),
+        )
     }
 
     /// Determines if self contains `value`.
@@ -539,7 +401,7 @@ impl<'py> PyListMethods<'py> for Bound<'py, PyList> {
     #[inline]
     fn contains<V>(&self, value: V) -> PyResult<bool>
     where
-        V: ToPyObject,
+        V: IntoPyObject<'py>,
     {
         self.as_sequence().contains(value)
     }
@@ -550,7 +412,7 @@ impl<'py> PyListMethods<'py> for Bound<'py, PyList> {
     #[inline]
     fn index<V>(&self, value: V) -> PyResult<usize>
     where
-        V: ToPyObject,
+        V: IntoPyObject<'py>,
     {
         self.as_sequence().index(value)
     }
@@ -560,6 +422,14 @@ impl<'py> PyListMethods<'py> for Bound<'py, PyList> {
         BoundListIterator::new(self.clone())
     }
 
+    /// Iterates over a list while holding a critical section, calling a closure on each item
+    fn locked_for_each<F>(&self, closure: F) -> PyResult<()>
+    where
+        F: Fn(Bound<'py, PyAny>) -> PyResult<()>,
+    {
+        crate::sync::with_critical_section(self, || self.iter().try_for_each(closure))
+    }
+
     /// Sorts the list in-place. Equivalent to the Python expression `l.sort()`.
     fn sort(&self) -> PyResult<()> {
         err::error_on_minusone(self.py(), unsafe { ffi::PyList_Sort(self.as_ptr()) })
@@ -577,119 +447,475 @@ impl<'py> PyListMethods<'py> for Bound<'py, PyList> {
         unsafe {
             ffi::PyList_AsTuple(self.as_ptr())
                 .assume_owned(self.py())
-                .downcast_into_unchecked()
+                .cast_into_unchecked()
         }
     }
 }
 
+// New types for type checking when using BoundListIterator associated methods, like
+// BoundListIterator::next_unchecked.
+struct Index(usize);
+struct Length(usize);
+
 /// Used by `PyList::iter()`.
-pub struct PyListIterator<'a>(BoundListIterator<'a>);
+pub struct BoundListIterator<'py> {
+    list: Bound<'py, PyList>,
+    index: Index,
+    length: Length,
+}
 
-impl<'a> Iterator for PyListIterator<'a> {
-    type Item = &'a PyAny;
+impl<'py> BoundListIterator<'py> {
+    fn new(list: Bound<'py, PyList>) -> Self {
+        Self {
+            index: Index(0),
+            length: Length(list.len()),
+            list,
+        }
+    }
+
+    /// # Safety
+    ///
+    /// On the free-threaded build, caller must verify they have exclusive
+    /// access to the list by holding a lock or by holding the innermost
+    /// critical section on the list.
+    #[inline]
+    #[cfg(not(Py_LIMITED_API))]
+    #[deny(unsafe_op_in_unsafe_fn)]
+    unsafe fn next_unchecked(
+        index: &mut Index,
+        length: &mut Length,
+        list: &Bound<'py, PyList>,
+    ) -> Option<Bound<'py, PyAny>> {
+        let length = length.0.min(list.len());
+        let my_index = index.0;
+
+        if index.0 < length {
+            let item = unsafe { list.get_item_unchecked(my_index) };
+            index.0 += 1;
+            Some(item)
+        } else {
+            None
+        }
+    }
+
+    #[cfg(Py_LIMITED_API)]
+    fn next(
+        index: &mut Index,
+        length: &mut Length,
+        list: &Bound<'py, PyList>,
+    ) -> Option<Bound<'py, PyAny>> {
+        let length = length.0.min(list.len());
+        let my_index = index.0;
+
+        if index.0 < length {
+            let item = list.get_item(my_index).expect("get-item failed");
+            index.0 += 1;
+            Some(item)
+        } else {
+            None
+        }
+    }
+
+    #[inline]
+    #[cfg(not(feature = "nightly"))]
+    fn nth(
+        index: &mut Index,
+        length: &mut Length,
+        list: &Bound<'py, PyList>,
+        n: usize,
+    ) -> Option<Bound<'py, PyAny>> {
+        let length = length.0.min(list.len());
+        let target_index = index.0 + n;
+        if target_index < length {
+            let item = {
+                #[cfg(Py_LIMITED_API)]
+                {
+                    list.get_item(target_index).expect("get-item failed")
+                }
+
+                #[cfg(not(Py_LIMITED_API))]
+                {
+                    unsafe { list.get_item_unchecked(target_index) }
+                }
+            };
+            index.0 = target_index + 1;
+            Some(item)
+        } else {
+            None
+        }
+    }
+
+    /// # Safety
+    ///
+    /// On the free-threaded build, caller must verify they have exclusive
+    /// access to the list by holding a lock or by holding the innermost
+    /// critical section on the list.
+    #[inline]
+    #[cfg(not(Py_LIMITED_API))]
+    #[deny(unsafe_op_in_unsafe_fn)]
+    unsafe fn next_back_unchecked(
+        index: &mut Index,
+        length: &mut Length,
+        list: &Bound<'py, PyList>,
+    ) -> Option<Bound<'py, PyAny>> {
+        let current_length = length.0.min(list.len());
+
+        if index.0 < current_length {
+            let item = unsafe { list.get_item_unchecked(current_length - 1) };
+            length.0 = current_length - 1;
+            Some(item)
+        } else {
+            None
+        }
+    }
+
+    #[inline]
+    #[cfg(Py_LIMITED_API)]
+    fn next_back(
+        index: &mut Index,
+        length: &mut Length,
+        list: &Bound<'py, PyList>,
+    ) -> Option<Bound<'py, PyAny>> {
+        let current_length = (length.0).min(list.len());
+
+        if index.0 < current_length {
+            let item = list.get_item(current_length - 1).expect("get-item failed");
+            length.0 = current_length - 1;
+            Some(item)
+        } else {
+            None
+        }
+    }
+
+    #[inline]
+    #[cfg(not(feature = "nightly"))]
+    fn nth_back(
+        index: &mut Index,
+        length: &mut Length,
+        list: &Bound<'py, PyList>,
+        n: usize,
+    ) -> Option<Bound<'py, PyAny>> {
+        let length_size = length.0.min(list.len());
+        if index.0 + n < length_size {
+            let target_index = length_size - n - 1;
+            let item = {
+                #[cfg(not(Py_LIMITED_API))]
+                {
+                    unsafe { list.get_item_unchecked(target_index) }
+                }
+
+                #[cfg(Py_LIMITED_API)]
+                {
+                    list.get_item(target_index).expect("get-item failed")
+                }
+            };
+            length.0 = target_index;
+            Some(item)
+        } else {
+            None
+        }
+    }
+
+    #[allow(dead_code)]
+    fn with_critical_section<R>(
+        &mut self,
+        f: impl FnOnce(&mut Index, &mut Length, &Bound<'py, PyList>) -> R,
+    ) -> R {
+        let Self {
+            index,
+            length,
+            list,
+        } = self;
+        crate::sync::with_critical_section(list, || f(index, length, list))
+    }
+}
+
+impl<'py> Iterator for BoundListIterator<'py> {
+    type Item = Bound<'py, PyAny>;
 
     #[inline]
     fn next(&mut self) -> Option<Self::Item> {
-        self.0.next().map(Bound::into_gil_ref)
+        #[cfg(not(Py_LIMITED_API))]
+        {
+            self.with_critical_section(|index, length, list| unsafe {
+                Self::next_unchecked(index, length, list)
+            })
+        }
+        #[cfg(Py_LIMITED_API)]
+        {
+            let Self {
+                index,
+                length,
+                list,
+            } = self;
+            Self::next(index, length, list)
+        }
+    }
+
+    #[inline]
+    #[cfg(not(feature = "nightly"))]
+    fn nth(&mut self, n: usize) -> Option<Self::Item> {
+        self.with_critical_section(|index, length, list| Self::nth(index, length, list, n))
     }
 
     #[inline]
     fn size_hint(&self) -> (usize, Option<usize>) {
-        self.0.size_hint()
+        let len = self.len();
+        (len, Some(len))
     }
-}
 
-impl<'a> DoubleEndedIterator for PyListIterator<'a> {
     #[inline]
-    fn next_back(&mut self) -> Option<Self::Item> {
-        self.0.next_back().map(Bound::into_gil_ref)
+    fn count(self) -> usize
+    where
+        Self: Sized,
+    {
+        self.len()
+    }
+
+    #[inline]
+    fn last(mut self) -> Option<Self::Item>
+    where
+        Self: Sized,
+    {
+        self.next_back()
+    }
+
+    #[inline]
+    #[cfg(all(Py_GIL_DISABLED, not(feature = "nightly")))]
+    fn fold<B, F>(mut self, init: B, mut f: F) -> B
+    where
+        Self: Sized,
+        F: FnMut(B, Self::Item) -> B,
+    {
+        self.with_critical_section(|index, length, list| {
+            let mut accum = init;
+            while let Some(x) = unsafe { Self::next_unchecked(index, length, list) } {
+                accum = f(accum, x);
+            }
+            accum
+        })
+    }
+
+    #[inline]
+    #[cfg(all(Py_GIL_DISABLED, feature = "nightly"))]
+    fn try_fold<B, F, R>(&mut self, init: B, mut f: F) -> R
+    where
+        Self: Sized,
+        F: FnMut(B, Self::Item) -> R,
+        R: std::ops::Try<Output = B>,
+    {
+        self.with_critical_section(|index, length, list| {
+            let mut accum = init;
+            while let Some(x) = unsafe { Self::next_unchecked(index, length, list) } {
+                accum = f(accum, x)?
+            }
+            R::from_output(accum)
+        })
+    }
+
+    #[inline]
+    #[cfg(all(Py_GIL_DISABLED, not(feature = "nightly")))]
+    fn all<F>(&mut self, mut f: F) -> bool
+    where
+        Self: Sized,
+        F: FnMut(Self::Item) -> bool,
+    {
+        self.with_critical_section(|index, length, list| {
+            while let Some(x) = unsafe { Self::next_unchecked(index, length, list) } {
+                if !f(x) {
+                    return false;
+                }
+            }
+            true
+        })
+    }
+
+    #[inline]
+    #[cfg(all(Py_GIL_DISABLED, not(feature = "nightly")))]
+    fn any<F>(&mut self, mut f: F) -> bool
+    where
+        Self: Sized,
+        F: FnMut(Self::Item) -> bool,
+    {
+        self.with_critical_section(|index, length, list| {
+            while let Some(x) = unsafe { Self::next_unchecked(index, length, list) } {
+                if f(x) {
+                    return true;
+                }
+            }
+            false
+        })
+    }
+
+    #[inline]
+    #[cfg(all(Py_GIL_DISABLED, not(feature = "nightly")))]
+    fn find<P>(&mut self, mut predicate: P) -> Option<Self::Item>
+    where
+        Self: Sized,
+        P: FnMut(&Self::Item) -> bool,
+    {
+        self.with_critical_section(|index, length, list| {
+            while let Some(x) = unsafe { Self::next_unchecked(index, length, list) } {
+                if predicate(&x) {
+                    return Some(x);
+                }
+            }
+            None
+        })
+    }
+
+    #[inline]
+    #[cfg(all(Py_GIL_DISABLED, not(feature = "nightly")))]
+    fn find_map<B, F>(&mut self, mut f: F) -> Option<B>
+    where
+        Self: Sized,
+        F: FnMut(Self::Item) -> Option<B>,
+    {
+        self.with_critical_section(|index, length, list| {
+            while let Some(x) = unsafe { Self::next_unchecked(index, length, list) } {
+                if let found @ Some(_) = f(x) {
+                    return found;
+                }
+            }
+            None
+        })
     }
-}
 
-impl<'a> ExactSizeIterator for PyListIterator<'a> {
-    fn len(&self) -> usize {
-        self.0.len()
+    #[inline]
+    #[cfg(all(Py_GIL_DISABLED, not(feature = "nightly")))]
+    fn position<P>(&mut self, mut predicate: P) -> Option<usize>
+    where
+        Self: Sized,
+        P: FnMut(Self::Item) -> bool,
+    {
+        self.with_critical_section(|index, length, list| {
+            let mut acc = 0;
+            while let Some(x) = unsafe { Self::next_unchecked(index, length, list) } {
+                if predicate(x) {
+                    return Some(acc);
+                }
+                acc += 1;
+            }
+            None
+        })
     }
-}
 
-impl FusedIterator for PyListIterator<'_> {}
-
-impl<'a> IntoIterator for &'a PyList {
-    type Item = &'a PyAny;
-    type IntoIter = PyListIterator<'a>;
+    #[inline]
+    #[cfg(feature = "nightly")]
+    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>> {
+        self.with_critical_section(|index, length, list| {
+            let max_len = length.0.min(list.len());
+            let currently_at = index.0;
+            if currently_at >= max_len {
+                if n == 0 {
+                    return Ok(());
+                } else {
+                    return Err(unsafe { NonZero::new_unchecked(n) });
+                }
+            }
 
-    fn into_iter(self) -> Self::IntoIter {
-        self.iter()
+            let items_left = max_len - currently_at;
+            if n <= items_left {
+                index.0 += n;
+                Ok(())
+            } else {
+                index.0 = max_len;
+                let remainder = n - items_left;
+                Err(unsafe { NonZero::new_unchecked(remainder) })
+            }
+        })
     }
 }
 
-/// Used by `PyList::iter()`.
-pub struct BoundListIterator<'py> {
-    list: Bound<'py, PyList>,
-    index: usize,
-    length: usize,
-}
-
-impl<'py> BoundListIterator<'py> {
-    fn new(list: Bound<'py, PyList>) -> Self {
-        let length: usize = list.len();
-        BoundListIterator {
-            list,
-            index: 0,
-            length,
+impl DoubleEndedIterator for BoundListIterator<'_> {
+    #[inline]
+    fn next_back(&mut self) -> Option<Self::Item> {
+        #[cfg(not(Py_LIMITED_API))]
+        {
+            self.with_critical_section(|index, length, list| unsafe {
+                Self::next_back_unchecked(index, length, list)
+            })
+        }
+        #[cfg(Py_LIMITED_API)]
+        {
+            let Self {
+                index,
+                length,
+                list,
+            } = self;
+            Self::next_back(index, length, list)
         }
     }
 
-    unsafe fn get_item(&self, index: usize) -> Bound<'py, PyAny> {
-        #[cfg(any(Py_LIMITED_API, PyPy))]
-        let item = self.list.get_item(index).expect("list.get failed");
-        #[cfg(not(any(Py_LIMITED_API, PyPy)))]
-        let item = self.list.get_item_unchecked(index);
-        item
+    #[inline]
+    #[cfg(not(feature = "nightly"))]
+    fn nth_back(&mut self, n: usize) -> Option<Self::Item> {
+        self.with_critical_section(|index, length, list| Self::nth_back(index, length, list, n))
     }
-}
-
-impl<'py> Iterator for BoundListIterator<'py> {
-    type Item = Bound<'py, PyAny>;
 
     #[inline]
-    fn next(&mut self) -> Option<Self::Item> {
-        let length = self.length.min(self.list.len());
-
-        if self.index < length {
-            let item = unsafe { self.get_item(self.index) };
-            self.index += 1;
-            Some(item)
-        } else {
-            None
-        }
+    #[cfg(all(Py_GIL_DISABLED, not(feature = "nightly")))]
+    fn rfold<B, F>(mut self, init: B, mut f: F) -> B
+    where
+        Self: Sized,
+        F: FnMut(B, Self::Item) -> B,
+    {
+        self.with_critical_section(|index, length, list| {
+            let mut accum = init;
+            while let Some(x) = unsafe { Self::next_back_unchecked(index, length, list) } {
+                accum = f(accum, x);
+            }
+            accum
+        })
     }
 
     #[inline]
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        let len = self.len();
-        (len, Some(len))
+    #[cfg(all(Py_GIL_DISABLED, feature = "nightly"))]
+    fn try_rfold<B, F, R>(&mut self, init: B, mut f: F) -> R
+    where
+        Self: Sized,
+        F: FnMut(B, Self::Item) -> R,
+        R: std::ops::Try<Output = B>,
+    {
+        self.with_critical_section(|index, length, list| {
+            let mut accum = init;
+            while let Some(x) = unsafe { Self::next_back_unchecked(index, length, list) } {
+                accum = f(accum, x)?
+            }
+            R::from_output(accum)
+        })
     }
-}
 
-impl DoubleEndedIterator for BoundListIterator<'_> {
     #[inline]
-    fn next_back(&mut self) -> Option<Self::Item> {
-        let length = self.length.min(self.list.len());
+    #[cfg(feature = "nightly")]
+    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>> {
+        self.with_critical_section(|index, length, list| {
+            let max_len = length.0.min(list.len());
+            let currently_at = index.0;
+            if currently_at >= max_len {
+                if n == 0 {
+                    return Ok(());
+                } else {
+                    return Err(unsafe { NonZero::new_unchecked(n) });
+                }
+            }
 
-        if self.index < length {
-            let item = unsafe { self.get_item(length - 1) };
-            self.length = length - 1;
-            Some(item)
-        } else {
-            None
-        }
+            let items_left = max_len - currently_at;
+            if n <= items_left {
+                length.0 = max_len - n;
+                Ok(())
+            } else {
+                length.0 = currently_at;
+                let remainder = n - items_left;
+                Err(unsafe { NonZero::new_unchecked(remainder) })
+            }
+        })
     }
 }
 
 impl ExactSizeIterator for BoundListIterator<'_> {
     fn len(&self) -> usize {
-        self.length.saturating_sub(self.index)
+        self.length.0.saturating_sub(self.index.0)
     }
 }
 
@@ -704,36 +930,48 @@ impl<'py> IntoIterator for Bound<'py, PyList> {
     }
 }
 
+impl<'py> IntoIterator for &Bound<'py, PyList> {
+    type Item = Bound<'py, PyAny>;
+    type IntoIter = BoundListIterator<'py>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.iter()
+    }
+}
+
 #[cfg(test)]
-#[cfg_attr(not(feature = "gil-refs"), allow(deprecated))]
 mod tests {
+    use crate::types::any::PyAnyMethods;
+    use crate::types::list::PyListMethods;
+    use crate::types::sequence::PySequenceMethods;
     use crate::types::{PyList, PyTuple};
-    use crate::Python;
-    use crate::{IntoPy, PyObject, ToPyObject};
+    use crate::{IntoPyObject, PyResult, Python};
+    #[cfg(feature = "nightly")]
+    use std::num::NonZero;
 
     #[test]
     fn test_new() {
-        Python::with_gil(|py| {
-            let list = PyList::new(py, [2, 3, 5, 7]);
-            assert_eq!(2, list[0].extract::<i32>().unwrap());
-            assert_eq!(3, list[1].extract::<i32>().unwrap());
-            assert_eq!(5, list[2].extract::<i32>().unwrap());
-            assert_eq!(7, list[3].extract::<i32>().unwrap());
+        Python::attach(|py| {
+            let list = PyList::new(py, [2, 3, 5, 7]).unwrap();
+            assert_eq!(2, list.get_item(0).unwrap().extract::<i32>().unwrap());
+            assert_eq!(3, list.get_item(1).unwrap().extract::<i32>().unwrap());
+            assert_eq!(5, list.get_item(2).unwrap().extract::<i32>().unwrap());
+            assert_eq!(7, list.get_item(3).unwrap().extract::<i32>().unwrap());
         });
     }
 
     #[test]
     fn test_len() {
-        Python::with_gil(|py| {
-            let list = PyList::new(py, [1, 2, 3, 4]);
+        Python::attach(|py| {
+            let list = PyList::new(py, [1, 2, 3, 4]).unwrap();
             assert_eq!(4, list.len());
         });
     }
 
     #[test]
     fn test_get_item() {
-        Python::with_gil(|py| {
-            let list = PyList::new(py, [2, 3, 5, 7]);
+        Python::attach(|py| {
+            let list = PyList::new(py, [2, 3, 5, 7]).unwrap();
             assert_eq!(2, list.get_item(0).unwrap().extract::<i32>().unwrap());
             assert_eq!(3, list.get_item(1).unwrap().extract::<i32>().unwrap());
             assert_eq!(5, list.get_item(2).unwrap().extract::<i32>().unwrap());
@@ -743,8 +981,8 @@ mod tests {
 
     #[test]
     fn test_get_slice() {
-        Python::with_gil(|py| {
-            let list = PyList::new(py, [2, 3, 5, 7]);
+        Python::attach(|py| {
+            let list = PyList::new(py, [2, 3, 5, 7]).unwrap();
             let slice = list.get_slice(1, 3);
             assert_eq!(2, slice.len());
             let slice = list.get_slice(1, 7);
@@ -754,29 +992,28 @@ mod tests {
 
     #[test]
     fn test_set_item() {
-        Python::with_gil(|py| {
-            let list = PyList::new(py, [2, 3, 5, 7]);
-            let val = 42i32.to_object(py);
-            let val2 = 42i32.to_object(py);
-            assert_eq!(2, list[0].extract::<i32>().unwrap());
+        Python::attach(|py| {
+            let list = PyList::new(py, [2, 3, 5, 7]).unwrap();
+            let val = 42i32.into_pyobject(py).unwrap();
+            let val2 = 42i32.into_pyobject(py).unwrap();
+            assert_eq!(2, list.get_item(0).unwrap().extract::<i32>().unwrap());
             list.set_item(0, val).unwrap();
-            assert_eq!(42, list[0].extract::<i32>().unwrap());
+            assert_eq!(42, list.get_item(0).unwrap().extract::<i32>().unwrap());
             assert!(list.set_item(10, val2).is_err());
         });
     }
 
     #[test]
     fn test_set_item_refcnt() {
-        Python::with_gil(|py| {
-            let obj = py.eval("object()", None, None).unwrap();
+        Python::attach(|py| {
+            let obj = py.eval(c"object()", None, None).unwrap();
             let cnt;
             {
-                let _pool = unsafe { crate::GILPool::new() };
                 let v = vec![2];
-                let ob = v.to_object(py);
-                let list: &PyList = ob.downcast(py).unwrap();
+                let ob = v.into_pyobject(py).unwrap();
+                let list = ob.cast::<PyList>().unwrap();
                 cnt = obj.get_refcnt();
-                list.set_item(0, obj).unwrap();
+                list.set_item(0, &obj).unwrap();
             }
 
             assert_eq!(cnt, obj.get_refcnt());
@@ -785,31 +1022,30 @@ mod tests {
 
     #[test]
     fn test_insert() {
-        Python::with_gil(|py| {
-            let list = PyList::new(py, [2, 3, 5, 7]);
-            let val = 42i32.to_object(py);
-            let val2 = 43i32.to_object(py);
+        Python::attach(|py| {
+            let list = PyList::new(py, [2, 3, 5, 7]).unwrap();
+            let val = 42i32.into_pyobject(py).unwrap();
+            let val2 = 43i32.into_pyobject(py).unwrap();
             assert_eq!(4, list.len());
-            assert_eq!(2, list[0].extract::<i32>().unwrap());
+            assert_eq!(2, list.get_item(0).unwrap().extract::<i32>().unwrap());
             list.insert(0, val).unwrap();
             list.insert(1000, val2).unwrap();
             assert_eq!(6, list.len());
-            assert_eq!(42, list[0].extract::<i32>().unwrap());
-            assert_eq!(2, list[1].extract::<i32>().unwrap());
-            assert_eq!(43, list[5].extract::<i32>().unwrap());
+            assert_eq!(42, list.get_item(0).unwrap().extract::<i32>().unwrap());
+            assert_eq!(2, list.get_item(1).unwrap().extract::<i32>().unwrap());
+            assert_eq!(43, list.get_item(5).unwrap().extract::<i32>().unwrap());
         });
     }
 
     #[test]
     fn test_insert_refcnt() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let cnt;
-            let obj = py.eval("object()", None, None).unwrap();
+            let obj = py.eval(c"object()", None, None).unwrap();
             {
-                let _pool = unsafe { crate::GILPool::new() };
                 let list = PyList::empty(py);
                 cnt = obj.get_refcnt();
-                list.insert(0, obj).unwrap();
+                list.insert(0, &obj).unwrap();
             }
 
             assert_eq!(cnt, obj.get_refcnt());
@@ -818,24 +1054,23 @@ mod tests {
 
     #[test]
     fn test_append() {
-        Python::with_gil(|py| {
-            let list = PyList::new(py, [2]);
+        Python::attach(|py| {
+            let list = PyList::new(py, [2]).unwrap();
             list.append(3).unwrap();
-            assert_eq!(2, list[0].extract::<i32>().unwrap());
-            assert_eq!(3, list[1].extract::<i32>().unwrap());
+            assert_eq!(2, list.get_item(0).unwrap().extract::<i32>().unwrap());
+            assert_eq!(3, list.get_item(1).unwrap().extract::<i32>().unwrap());
         });
     }
 
     #[test]
     fn test_append_refcnt() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let cnt;
-            let obj = py.eval("object()", None, None).unwrap();
+            let obj = py.eval(c"object()", None, None).unwrap();
             {
-                let _pool = unsafe { crate::GILPool::new() };
                 let list = PyList::empty(py);
                 cnt = obj.get_refcnt();
-                list.append(obj).unwrap();
+                list.append(&obj).unwrap();
             }
             assert_eq!(cnt, obj.get_refcnt());
         });
@@ -843,9 +1078,9 @@ mod tests {
 
     #[test]
     fn test_iter() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let v = vec![2, 3, 5, 7];
-            let list = PyList::new(py, &v);
+            let list = PyList::new(py, &v).unwrap();
             let mut idx = 0;
             for el in list {
                 assert_eq!(v[idx], el.extract::<i32>().unwrap());
@@ -857,10 +1092,10 @@ mod tests {
 
     #[test]
     fn test_iter_size_hint() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let v = vec![2, 3, 5, 7];
-            let ob = v.to_object(py);
-            let list: &PyList = ob.downcast(py).unwrap();
+            let ob = (&v).into_pyobject(py).unwrap();
+            let list = ob.cast::<PyList>().unwrap();
 
             let mut iter = list.iter();
             assert_eq!(iter.size_hint(), (v.len(), Some(v.len())));
@@ -876,10 +1111,10 @@ mod tests {
 
     #[test]
     fn test_iter_rev() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let v = vec![2, 3, 5, 7];
-            let ob = v.to_object(py);
-            let list: &PyList = ob.downcast(py).unwrap();
+            let ob = v.into_pyobject(py).unwrap();
+            let list = ob.cast::<PyList>().unwrap();
 
             let mut iter = list.iter().rev();
 
@@ -902,74 +1137,253 @@ mod tests {
         });
     }
 
+    #[test]
+    fn test_iter_all() {
+        Python::attach(|py| {
+            let list = PyList::new(py, [true, true, true]).unwrap();
+            assert!(list.iter().all(|x| x.extract::<bool>().unwrap()));
+
+            let list = PyList::new(py, [true, false, true]).unwrap();
+            assert!(!list.iter().all(|x| x.extract::<bool>().unwrap()));
+        });
+    }
+
+    #[test]
+    fn test_iter_any() {
+        Python::attach(|py| {
+            let list = PyList::new(py, [true, true, true]).unwrap();
+            assert!(list.iter().any(|x| x.extract::<bool>().unwrap()));
+
+            let list = PyList::new(py, [true, false, true]).unwrap();
+            assert!(list.iter().any(|x| x.extract::<bool>().unwrap()));
+
+            let list = PyList::new(py, [false, false, false]).unwrap();
+            assert!(!list.iter().any(|x| x.extract::<bool>().unwrap()));
+        });
+    }
+
+    #[test]
+    fn test_iter_find() {
+        Python::attach(|py: Python<'_>| {
+            let list = PyList::new(py, ["hello", "world"]).unwrap();
+            assert_eq!(
+                Some("world".to_string()),
+                list.iter()
+                    .find(|v| v.extract::<String>().unwrap() == "world")
+                    .map(|v| v.extract::<String>().unwrap())
+            );
+            assert_eq!(
+                None,
+                list.iter()
+                    .find(|v| v.extract::<String>().unwrap() == "foobar")
+                    .map(|v| v.extract::<String>().unwrap())
+            );
+        });
+    }
+
+    #[test]
+    fn test_iter_position() {
+        Python::attach(|py: Python<'_>| {
+            let list = PyList::new(py, ["hello", "world"]).unwrap();
+            assert_eq!(
+                Some(1),
+                list.iter()
+                    .position(|v| v.extract::<String>().unwrap() == "world")
+            );
+            assert_eq!(
+                None,
+                list.iter()
+                    .position(|v| v.extract::<String>().unwrap() == "foobar")
+            );
+        });
+    }
+
+    #[test]
+    fn test_iter_fold() {
+        Python::attach(|py: Python<'_>| {
+            let list = PyList::new(py, [1, 2, 3]).unwrap();
+            let sum = list
+                .iter()
+                .fold(0, |acc, v| acc + v.extract::<usize>().unwrap());
+            assert_eq!(sum, 6);
+        });
+    }
+
+    #[test]
+    fn test_iter_fold_out_of_bounds() {
+        Python::attach(|py: Python<'_>| {
+            let list = PyList::new(py, [1, 2, 3]).unwrap();
+            let sum = list.iter().fold(0, |_, _| {
+                // clear the list to create a pathological fold operation
+                // that mutates the list as it processes it
+                for _ in 0..3 {
+                    list.del_item(0).unwrap();
+                }
+                -5
+            });
+            assert_eq!(sum, -5);
+            assert_eq!(list.len(), 0);
+        });
+    }
+
+    #[test]
+    fn test_iter_rfold() {
+        Python::attach(|py: Python<'_>| {
+            let list = PyList::new(py, [1, 2, 3]).unwrap();
+            let sum = list
+                .iter()
+                .rfold(0, |acc, v| acc + v.extract::<usize>().unwrap());
+            assert_eq!(sum, 6);
+        });
+    }
+
+    #[test]
+    fn test_iter_try_fold() {
+        Python::attach(|py: Python<'_>| {
+            let list = PyList::new(py, [1, 2, 3]).unwrap();
+            let sum = list
+                .iter()
+                .try_fold(0, |acc, v| PyResult::Ok(acc + v.extract::<usize>()?))
+                .unwrap();
+            assert_eq!(sum, 6);
+
+            let list = PyList::new(py, ["foo", "bar"]).unwrap();
+            assert!(list
+                .iter()
+                .try_fold(0, |acc, v| PyResult::Ok(acc + v.extract::<usize>()?))
+                .is_err());
+        });
+    }
+
+    #[test]
+    fn test_iter_try_rfold() {
+        Python::attach(|py: Python<'_>| {
+            let list = PyList::new(py, [1, 2, 3]).unwrap();
+            let sum = list
+                .iter()
+                .try_rfold(0, |acc, v| PyResult::Ok(acc + v.extract::<usize>()?))
+                .unwrap();
+            assert_eq!(sum, 6);
+
+            let list = PyList::new(py, ["foo", "bar"]).unwrap();
+            assert!(list
+                .iter()
+                .try_rfold(0, |acc, v| PyResult::Ok(acc + v.extract::<usize>()?))
+                .is_err());
+        });
+    }
+
     #[test]
     fn test_into_iter() {
-        Python::with_gil(|py| {
-            let list = PyList::new(py, [1, 2, 3, 4]);
+        Python::attach(|py| {
+            let list = PyList::new(py, [1, 2, 3, 4]).unwrap();
             for (i, item) in list.iter().enumerate() {
                 assert_eq!((i + 1) as i32, item.extract::<i32>().unwrap());
             }
         });
     }
 
+    #[test]
+    fn test_into_iter_bound() {
+        use crate::types::any::PyAnyMethods;
+
+        Python::attach(|py| {
+            let list = PyList::new(py, [1, 2, 3, 4]).unwrap();
+            let mut items = vec![];
+            for item in &list {
+                items.push(item.extract::<i32>().unwrap());
+            }
+            assert_eq!(items, vec![1, 2, 3, 4]);
+        });
+    }
+
+    #[test]
+    fn test_as_sequence() {
+        Python::attach(|py| {
+            let list = PyList::new(py, [1, 2, 3, 4]).unwrap();
+
+            assert_eq!(list.as_sequence().len().unwrap(), 4);
+            assert_eq!(
+                list.as_sequence()
+                    .get_item(1)
+                    .unwrap()
+                    .extract::<i32>()
+                    .unwrap(),
+                2
+            );
+        });
+    }
+
+    #[test]
+    fn test_into_sequence() {
+        Python::attach(|py| {
+            let list = PyList::new(py, [1, 2, 3, 4]).unwrap();
+
+            let sequence = list.into_sequence();
+
+            assert_eq!(sequence.len().unwrap(), 4);
+            assert_eq!(sequence.get_item(1).unwrap().extract::<i32>().unwrap(), 2);
+        });
+    }
+
     #[test]
     fn test_extract() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let v = vec![2, 3, 5, 7];
-            let list = PyList::new(py, &v);
-            let v2 = list.as_ref().extract::<Vec<i32>>().unwrap();
+            let list = PyList::new(py, &v).unwrap();
+            let v2 = list.as_any().extract::<Vec<i32>>().unwrap();
             assert_eq!(v, v2);
         });
     }
 
     #[test]
     fn test_sort() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let v = vec![7, 3, 2, 5];
-            let list = PyList::new(py, &v);
-            assert_eq!(7, list[0].extract::<i32>().unwrap());
-            assert_eq!(3, list[1].extract::<i32>().unwrap());
-            assert_eq!(2, list[2].extract::<i32>().unwrap());
-            assert_eq!(5, list[3].extract::<i32>().unwrap());
+            let list = PyList::new(py, &v).unwrap();
+            assert_eq!(7, list.get_item(0).unwrap().extract::<i32>().unwrap());
+            assert_eq!(3, list.get_item(1).unwrap().extract::<i32>().unwrap());
+            assert_eq!(2, list.get_item(2).unwrap().extract::<i32>().unwrap());
+            assert_eq!(5, list.get_item(3).unwrap().extract::<i32>().unwrap());
             list.sort().unwrap();
-            assert_eq!(2, list[0].extract::<i32>().unwrap());
-            assert_eq!(3, list[1].extract::<i32>().unwrap());
-            assert_eq!(5, list[2].extract::<i32>().unwrap());
-            assert_eq!(7, list[3].extract::<i32>().unwrap());
+            assert_eq!(2, list.get_item(0).unwrap().extract::<i32>().unwrap());
+            assert_eq!(3, list.get_item(1).unwrap().extract::<i32>().unwrap());
+            assert_eq!(5, list.get_item(2).unwrap().extract::<i32>().unwrap());
+            assert_eq!(7, list.get_item(3).unwrap().extract::<i32>().unwrap());
         });
     }
 
     #[test]
     fn test_reverse() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let v = vec![2, 3, 5, 7];
-            let list = PyList::new(py, &v);
-            assert_eq!(2, list[0].extract::<i32>().unwrap());
-            assert_eq!(3, list[1].extract::<i32>().unwrap());
-            assert_eq!(5, list[2].extract::<i32>().unwrap());
-            assert_eq!(7, list[3].extract::<i32>().unwrap());
+            let list = PyList::new(py, &v).unwrap();
+            assert_eq!(2, list.get_item(0).unwrap().extract::<i32>().unwrap());
+            assert_eq!(3, list.get_item(1).unwrap().extract::<i32>().unwrap());
+            assert_eq!(5, list.get_item(2).unwrap().extract::<i32>().unwrap());
+            assert_eq!(7, list.get_item(3).unwrap().extract::<i32>().unwrap());
             list.reverse().unwrap();
-            assert_eq!(7, list[0].extract::<i32>().unwrap());
-            assert_eq!(5, list[1].extract::<i32>().unwrap());
-            assert_eq!(3, list[2].extract::<i32>().unwrap());
-            assert_eq!(2, list[3].extract::<i32>().unwrap());
+            assert_eq!(7, list.get_item(0).unwrap().extract::<i32>().unwrap());
+            assert_eq!(5, list.get_item(1).unwrap().extract::<i32>().unwrap());
+            assert_eq!(3, list.get_item(2).unwrap().extract::<i32>().unwrap());
+            assert_eq!(2, list.get_item(3).unwrap().extract::<i32>().unwrap());
         });
     }
 
     #[test]
-    fn test_array_into_py() {
-        Python::with_gil(|py| {
-            let array: PyObject = [1, 2].into_py(py);
-            let list: &PyList = array.downcast(py).unwrap();
-            assert_eq!(1, list[0].extract::<i32>().unwrap());
-            assert_eq!(2, list[1].extract::<i32>().unwrap());
+    fn test_array_into_pyobject() {
+        Python::attach(|py| {
+            let array = [1, 2].into_pyobject(py).unwrap();
+            let list = array.cast::<PyList>().unwrap();
+            assert_eq!(1, list.get_item(0).unwrap().extract::<i32>().unwrap());
+            assert_eq!(2, list.get_item(1).unwrap().extract::<i32>().unwrap());
         });
     }
 
     #[test]
     fn test_list_get_item_invalid_index() {
-        Python::with_gil(|py| {
-            let list = PyList::new(py, [2, 3, 5, 7]);
+        Python::attach(|py| {
+            let list = PyList::new(py, [2, 3, 5, 7]).unwrap();
             let obj = list.get_item(5);
             assert!(obj.is_err());
             assert_eq!(
@@ -981,110 +1395,39 @@ mod tests {
 
     #[test]
     fn test_list_get_item_sanity() {
-        Python::with_gil(|py| {
-            let list = PyList::new(py, [2, 3, 5, 7]);
+        Python::attach(|py| {
+            let list = PyList::new(py, [2, 3, 5, 7]).unwrap();
             let obj = list.get_item(0);
             assert_eq!(obj.unwrap().extract::<i32>().unwrap(), 2);
         });
     }
 
-    #[cfg(not(any(Py_LIMITED_API, PyPy)))]
+    #[cfg(not(Py_LIMITED_API))]
     #[test]
     fn test_list_get_item_unchecked_sanity() {
-        Python::with_gil(|py| {
-            let list = PyList::new(py, [2, 3, 5, 7]);
+        Python::attach(|py| {
+            let list = PyList::new(py, [2, 3, 5, 7]).unwrap();
             let obj = unsafe { list.get_item_unchecked(0) };
             assert_eq!(obj.extract::<i32>().unwrap(), 2);
         });
     }
 
-    #[test]
-    fn test_list_index_trait() {
-        Python::with_gil(|py| {
-            let list = PyList::new(py, [2, 3, 5]);
-            assert_eq!(2, list[0].extract::<i32>().unwrap());
-            assert_eq!(3, list[1].extract::<i32>().unwrap());
-            assert_eq!(5, list[2].extract::<i32>().unwrap());
-        });
-    }
-
-    #[test]
-    #[should_panic]
-    fn test_list_index_trait_panic() {
-        Python::with_gil(|py| {
-            let list = PyList::new(py, [2, 3, 5]);
-            let _ = &list[7];
-        });
-    }
-
-    #[test]
-    fn test_list_index_trait_ranges() {
-        Python::with_gil(|py| {
-            let list = PyList::new(py, [2, 3, 5]);
-            assert_eq!(vec![3, 5], list[1..3].extract::<Vec<i32>>().unwrap());
-            assert_eq!(Vec::<i32>::new(), list[3..3].extract::<Vec<i32>>().unwrap());
-            assert_eq!(vec![3, 5], list[1..].extract::<Vec<i32>>().unwrap());
-            assert_eq!(Vec::<i32>::new(), list[3..].extract::<Vec<i32>>().unwrap());
-            assert_eq!(vec![2, 3, 5], list[..].extract::<Vec<i32>>().unwrap());
-            assert_eq!(vec![3, 5], list[1..=2].extract::<Vec<i32>>().unwrap());
-            assert_eq!(vec![2, 3], list[..2].extract::<Vec<i32>>().unwrap());
-            assert_eq!(vec![2, 3], list[..=1].extract::<Vec<i32>>().unwrap());
-        })
-    }
-
-    #[test]
-    #[should_panic = "range start index 5 out of range for list of length 3"]
-    fn test_list_index_trait_range_panic_start() {
-        Python::with_gil(|py| {
-            let list = PyList::new(py, [2, 3, 5]);
-            list[5..10].extract::<Vec<i32>>().unwrap();
-        })
-    }
-
-    #[test]
-    #[should_panic = "range end index 10 out of range for list of length 3"]
-    fn test_list_index_trait_range_panic_end() {
-        Python::with_gil(|py| {
-            let list = PyList::new(py, [2, 3, 5]);
-            list[1..10].extract::<Vec<i32>>().unwrap();
-        })
-    }
-
-    #[test]
-    #[should_panic = "slice index starts at 2 but ends at 1"]
-    fn test_list_index_trait_range_panic_wrong_order() {
-        Python::with_gil(|py| {
-            let list = PyList::new(py, [2, 3, 5]);
-            #[allow(clippy::reversed_empty_ranges)]
-            list[2..1].extract::<Vec<i32>>().unwrap();
-        })
-    }
-
-    #[test]
-    #[should_panic = "range start index 8 out of range for list of length 3"]
-    fn test_list_index_trait_range_from_panic() {
-        Python::with_gil(|py| {
-            let list = PyList::new(py, [2, 3, 5]);
-            list[8..].extract::<Vec<i32>>().unwrap();
-        })
-    }
-
     #[test]
     fn test_list_del_item() {
-        Python::with_gil(|py| {
-            let list = PyList::new(py, [1, 1, 2, 3, 5, 8]);
+        Python::attach(|py| {
+            let list = PyList::new(py, [1, 1, 2, 3, 5, 8]).unwrap();
             assert!(list.del_item(10).is_err());
-            assert_eq!(1, list[0].extract::<i32>().unwrap());
+            assert_eq!(1, list.get_item(0).unwrap().extract::<i32>().unwrap());
             assert!(list.del_item(0).is_ok());
-            assert_eq!(1, list[0].extract::<i32>().unwrap());
+            assert_eq!(1, list.get_item(0).unwrap().extract::<i32>().unwrap());
             assert!(list.del_item(0).is_ok());
-            assert_eq!(2, list[0].extract::<i32>().unwrap());
+            assert_eq!(2, list.get_item(0).unwrap().extract::<i32>().unwrap());
             assert!(list.del_item(0).is_ok());
-            assert_eq!(3, list[0].extract::<i32>().unwrap());
+            assert_eq!(3, list.get_item(0).unwrap().extract::<i32>().unwrap());
             assert!(list.del_item(0).is_ok());
-            assert_eq!(5, list[0].extract::<i32>().unwrap());
+            assert_eq!(5, list.get_item(0).unwrap().extract::<i32>().unwrap());
             assert!(list.del_item(0).is_ok());
-            assert_eq!(8, list[0].extract::<i32>().unwrap());
+            assert_eq!(8, list.get_item(0).unwrap().extract::<i32>().unwrap());
             assert!(list.del_item(0).is_ok());
             assert_eq!(0, list.len());
             assert!(list.del_item(0).is_err());
@@ -1093,20 +1436,20 @@ mod tests {
 
     #[test]
     fn test_list_set_slice() {
-        Python::with_gil(|py| {
-            let list = PyList::new(py, [1, 1, 2, 3, 5, 8]);
-            let ins = PyList::new(py, [7, 4]);
-            list.set_slice(1, 4, ins).unwrap();
+        Python::attach(|py| {
+            let list = PyList::new(py, [1, 1, 2, 3, 5, 8]).unwrap();
+            let ins = PyList::new(py, [7, 4]).unwrap();
+            list.set_slice(1, 4, &ins).unwrap();
             assert_eq!([1, 7, 4, 5, 8], list.extract::<[i32; 5]>().unwrap());
-            list.set_slice(3, 100, PyList::empty(py)).unwrap();
+            list.set_slice(3, 100, &PyList::empty(py)).unwrap();
             assert_eq!([1, 7, 4], list.extract::<[i32; 3]>().unwrap());
         });
     }
 
     #[test]
     fn test_list_del_slice() {
-        Python::with_gil(|py| {
-            let list = PyList::new(py, [1, 1, 2, 3, 5, 8]);
+        Python::attach(|py| {
+            let list = PyList::new(py, [1, 1, 2, 3, 5, 8]).unwrap();
             list.del_slice(1, 4).unwrap();
             assert_eq!([1, 5, 8], list.extract::<[i32; 3]>().unwrap());
             list.del_slice(1, 100).unwrap();
@@ -1116,25 +1459,25 @@ mod tests {
 
     #[test]
     fn test_list_contains() {
-        Python::with_gil(|py| {
-            let list = PyList::new(py, [1, 1, 2, 3, 5, 8]);
+        Python::attach(|py| {
+            let list = PyList::new(py, [1, 1, 2, 3, 5, 8]).unwrap();
             assert_eq!(6, list.len());
 
-            let bad_needle = 7i32.to_object(py);
+            let bad_needle = 7i32.into_pyobject(py).unwrap();
             assert!(!list.contains(&bad_needle).unwrap());
 
-            let good_needle = 8i32.to_object(py);
+            let good_needle = 8i32.into_pyobject(py).unwrap();
             assert!(list.contains(&good_needle).unwrap());
 
-            let type_coerced_needle = 8f32.to_object(py);
+            let type_coerced_needle = 8f32.into_pyobject(py).unwrap();
             assert!(list.contains(&type_coerced_needle).unwrap());
         });
     }
 
     #[test]
     fn test_list_index() {
-        Python::with_gil(|py| {
-            let list = PyList::new(py, [1, 1, 2, 3, 5, 8]);
+        Python::attach(|py| {
+            let list = PyList::new(py, [1, 1, 2, 3, 5, 8]).unwrap();
             assert_eq!(0, list.index(1i32).unwrap());
             assert_eq!(2, list.index(2i32).unwrap());
             assert_eq!(3, list.index(3i32).unwrap());
@@ -1169,9 +1512,9 @@ mod tests {
         expected = "Attempted to create PyList but `elements` was larger than reported by its `ExactSizeIterator` implementation."
     )]
     fn too_long_iterator() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let iter = FaultyIter(0..usize::MAX, 73);
-            let _list = PyList::new(py, iter);
+            let _list = PyList::new(py, iter).unwrap();
         })
     }
 
@@ -1180,9 +1523,9 @@ mod tests {
         expected = "Attempted to create PyList but `elements` was smaller than reported by its `ExactSizeIterator` implementation."
     )]
     fn too_short_iterator() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let iter = FaultyIter(0..35, 73);
-            let _list = PyList::new(py, iter);
+            let _list = PyList::new(py, iter).unwrap();
         })
     }
 
@@ -1191,43 +1534,37 @@ mod tests {
         expected = "out of range integral type conversion attempted on `elements.len()`"
     )]
     fn overflowing_size() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let iter = FaultyIter(0..0, usize::MAX);
 
-            let _list = PyList::new(py, iter);
+            let _list = PyList::new(py, iter).unwrap();
         })
     }
 
-    #[cfg(feature = "macros")]
     #[test]
-    fn bad_clone_mem_leaks() {
-        use crate::{Py, PyAny};
+    fn bad_intopyobject_doesnt_cause_leaks() {
+        use crate::types::PyInt;
+        use std::convert::Infallible;
         use std::sync::atomic::{AtomicUsize, Ordering::SeqCst};
         static NEEDS_DESTRUCTING_COUNT: AtomicUsize = AtomicUsize::new(0);
 
-        #[crate::pyclass]
-        #[pyo3(crate = "crate")]
         struct Bad(usize);
 
-        impl Clone for Bad {
-            fn clone(&self) -> Self {
-                // This panic should not lead to a memory leak
-                assert_ne!(self.0, 42);
-                NEEDS_DESTRUCTING_COUNT.fetch_add(1, SeqCst);
-
-                Bad(self.0)
-            }
-        }
-
         impl Drop for Bad {
             fn drop(&mut self) {
                 NEEDS_DESTRUCTING_COUNT.fetch_sub(1, SeqCst);
             }
         }
 
-        impl ToPyObject for Bad {
-            fn to_object(&self, py: Python<'_>) -> Py<PyAny> {
-                self.to_owned().into_py(py)
+        impl<'py> IntoPyObject<'py> for Bad {
+            type Target = PyInt;
+            type Output = crate::Bound<'py, Self::Target>;
+            type Error = Infallible;
+
+            fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+                // This panic should not lead to a memory leak
+                assert_ne!(self.0, 42);
+                self.0.into_pyobject(py)
             }
         }
 
@@ -1250,10 +1587,10 @@ mod tests {
             }
         }
 
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             std::panic::catch_unwind(|| {
                 let iter = FaultyIter(0..50, 50);
-                let _list = PyList::new(py, iter);
+                let _list = PyList::new(py, iter).unwrap();
             })
             .unwrap_err();
         });
@@ -1267,11 +1604,180 @@ mod tests {
 
     #[test]
     fn test_list_to_tuple() {
-        Python::with_gil(|py| {
-            let list = PyList::new(py, vec![1, 2, 3]);
+        Python::attach(|py| {
+            let list = PyList::new(py, vec![1, 2, 3]).unwrap();
             let tuple = list.to_tuple();
-            let tuple_expected = PyTuple::new_bound(py, vec![1, 2, 3]);
+            let tuple_expected = PyTuple::new(py, vec![1, 2, 3]).unwrap();
             assert!(tuple.eq(tuple_expected).unwrap());
         })
     }
+
+    #[test]
+    fn test_iter_nth() {
+        Python::attach(|py| {
+            let v = vec![6, 7, 8, 9, 10];
+            let ob = (&v).into_pyobject(py).unwrap();
+            let list = ob.cast::<PyList>().unwrap();
+
+            let mut iter = list.iter();
+            iter.next();
+            assert_eq!(iter.nth(1).unwrap().extract::<i32>().unwrap(), 8);
+            assert_eq!(iter.nth(1).unwrap().extract::<i32>().unwrap(), 10);
+            assert!(iter.nth(1).is_none());
+
+            let v: Vec<i32> = vec![];
+            let ob = (&v).into_pyobject(py).unwrap();
+            let list = ob.cast::<PyList>().unwrap();
+
+            let mut iter = list.iter();
+            iter.next();
+            assert!(iter.nth(1).is_none());
+
+            let v = vec![1, 2, 3];
+            let ob = (&v).into_pyobject(py).unwrap();
+            let list = ob.cast::<PyList>().unwrap();
+
+            let mut iter = list.iter();
+            assert!(iter.nth(10).is_none());
+
+            let v = vec![6, 7, 8, 9, 10];
+            let ob = (&v).into_pyobject(py).unwrap();
+            let list = ob.cast::<PyList>().unwrap();
+            let mut iter = list.iter();
+            assert_eq!(iter.next().unwrap().extract::<i32>().unwrap(), 6);
+            assert_eq!(iter.nth(2).unwrap().extract::<i32>().unwrap(), 9);
+            assert_eq!(iter.next().unwrap().extract::<i32>().unwrap(), 10);
+
+            let mut iter = list.iter();
+            assert_eq!(iter.nth_back(1).unwrap().extract::<i32>().unwrap(), 9);
+            assert_eq!(iter.nth(2).unwrap().extract::<i32>().unwrap(), 8);
+            assert!(iter.next().is_none());
+        });
+    }
+
+    #[test]
+    fn test_iter_nth_back() {
+        Python::attach(|py| {
+            let v = vec![1, 2, 3, 4, 5];
+            let ob = (&v).into_pyobject(py).unwrap();
+            let list = ob.cast::<PyList>().unwrap();
+
+            let mut iter = list.iter();
+            assert_eq!(iter.nth_back(0).unwrap().extract::<i32>().unwrap(), 5);
+            assert_eq!(iter.nth_back(1).unwrap().extract::<i32>().unwrap(), 3);
+            assert!(iter.nth_back(2).is_none());
+
+            let v: Vec<i32> = vec![];
+            let ob = (&v).into_pyobject(py).unwrap();
+            let list = ob.cast::<PyList>().unwrap();
+
+            let mut iter = list.iter();
+            assert!(iter.nth_back(0).is_none());
+            assert!(iter.nth_back(1).is_none());
+
+            let v = vec![1, 2, 3];
+            let ob = (&v).into_pyobject(py).unwrap();
+            let list = ob.cast::<PyList>().unwrap();
+
+            let mut iter = list.iter();
+            assert!(iter.nth_back(5).is_none());
+
+            let v = vec![1, 2, 3, 4, 5];
+            let ob = (&v).into_pyobject(py).unwrap();
+            let list = ob.cast::<PyList>().unwrap();
+
+            let mut iter = list.iter();
+            iter.next_back(); // Consume the last element
+            assert_eq!(iter.nth_back(1).unwrap().extract::<i32>().unwrap(), 3);
+            assert_eq!(iter.next_back().unwrap().extract::<i32>().unwrap(), 2);
+            assert_eq!(iter.nth_back(0).unwrap().extract::<i32>().unwrap(), 1);
+
+            let v = vec![1, 2, 3, 4, 5];
+            let ob = (&v).into_pyobject(py).unwrap();
+            let list = ob.cast::<PyList>().unwrap();
+
+            let mut iter = list.iter();
+            assert_eq!(iter.nth_back(1).unwrap().extract::<i32>().unwrap(), 4);
+            assert_eq!(iter.nth_back(2).unwrap().extract::<i32>().unwrap(), 1);
+
+            let mut iter2 = list.iter();
+            iter2.next_back();
+            assert_eq!(iter2.nth_back(1).unwrap().extract::<i32>().unwrap(), 3);
+            assert_eq!(iter2.next_back().unwrap().extract::<i32>().unwrap(), 2);
+
+            let mut iter3 = list.iter();
+            iter3.nth(1);
+            assert_eq!(iter3.nth_back(2).unwrap().extract::<i32>().unwrap(), 3);
+            assert!(iter3.nth_back(0).is_none());
+        });
+    }
+
+    #[cfg(feature = "nightly")]
+    #[test]
+    fn test_iter_advance_by() {
+        Python::attach(|py| {
+            let v = vec![1, 2, 3, 4, 5];
+            let ob = (&v).into_pyobject(py).unwrap();
+            let list = ob.cast::<PyList>().unwrap();
+
+            let mut iter = list.iter();
+            assert_eq!(iter.advance_by(2), Ok(()));
+            assert_eq!(iter.next().unwrap().extract::<i32>().unwrap(), 3);
+            assert_eq!(iter.advance_by(0), Ok(()));
+            assert_eq!(iter.advance_by(100), Err(NonZero::new(98).unwrap()));
+
+            let mut iter2 = list.iter();
+            assert_eq!(iter2.advance_by(6), Err(NonZero::new(1).unwrap()));
+
+            let mut iter3 = list.iter();
+            assert_eq!(iter3.advance_by(5), Ok(()));
+
+            let mut iter4 = list.iter();
+            assert_eq!(iter4.advance_by(0), Ok(()));
+            assert_eq!(iter4.next().unwrap().extract::<i32>().unwrap(), 1);
+        })
+    }
+
+    #[cfg(feature = "nightly")]
+    #[test]
+    fn test_iter_advance_back_by() {
+        Python::attach(|py| {
+            let v = vec![1, 2, 3, 4, 5];
+            let ob = (&v).into_pyobject(py).unwrap();
+            let list = ob.cast::<PyList>().unwrap();
+
+            let mut iter = list.iter();
+            assert_eq!(iter.advance_back_by(2), Ok(()));
+            assert_eq!(iter.next_back().unwrap().extract::<i32>().unwrap(), 3);
+            assert_eq!(iter.advance_back_by(0), Ok(()));
+            assert_eq!(iter.advance_back_by(100), Err(NonZero::new(98).unwrap()));
+
+            let mut iter2 = list.iter();
+            assert_eq!(iter2.advance_back_by(6), Err(NonZero::new(1).unwrap()));
+
+            let mut iter3 = list.iter();
+            assert_eq!(iter3.advance_back_by(5), Ok(()));
+
+            let mut iter4 = list.iter();
+            assert_eq!(iter4.advance_back_by(0), Ok(()));
+            assert_eq!(iter4.next_back().unwrap().extract::<i32>().unwrap(), 5);
+        })
+    }
+
+    #[test]
+    fn test_iter_last() {
+        Python::attach(|py| {
+            let list = PyList::new(py, vec![1, 2, 3]).unwrap();
+            let last = list.iter().last();
+            assert_eq!(last.unwrap().extract::<i32>().unwrap(), 3);
+        })
+    }
+
+    #[test]
+    fn test_iter_count() {
+        Python::attach(|py| {
+            let list = PyList::new(py, vec![1, 2, 3]).unwrap();
+            assert_eq!(list.iter().count(), 3);
+        })
+    }
 }
diff --git a/src/types/mapping.rs b/src/types/mapping.rs
index 81bb2e63912..af5b26ba463 100644
--- a/src/types/mapping.rs
+++ b/src/types/mapping.rs
@@ -1,104 +1,60 @@
-use crate::err::{PyDowncastError, PyResult};
+use crate::conversion::IntoPyObject;
+use crate::err::PyResult;
 use crate::ffi_ptr_ext::FfiPtrExt;
 use crate::instance::Bound;
 use crate::py_result_ext::PyResultExt;
-use crate::sync::GILOnceCell;
+use crate::sync::PyOnceLock;
 use crate::type_object::PyTypeInfo;
 use crate::types::any::PyAnyMethods;
-use crate::types::{PyAny, PyDict, PySequence, PyType};
-use crate::{ffi, Py, PyNativeType, PyTypeCheck, Python, ToPyObject};
+use crate::types::{PyAny, PyDict, PyList, PyType, PyTypeMethods};
+use crate::{ffi, Py, Python};
 
 /// Represents a reference to a Python object supporting the mapping protocol.
+///
+/// Values of this type are accessed via PyO3's smart pointers, e.g. as
+/// [`Py<PyMapping>`][crate::Py] or [`Bound<'py, PyMapping>`][Bound].
+///
+/// For APIs available on mapping objects, see the [`PyMappingMethods`] trait which is implemented for
+/// [`Bound<'py, PyMapping>`][Bound].
 #[repr(transparent)]
 pub struct PyMapping(PyAny);
-pyobject_native_type_named!(PyMapping);
-pyobject_native_type_extract!(PyMapping);
-
-impl PyMapping {
-    /// Returns the number of objects in the mapping.
-    ///
-    /// This is equivalent to the Python expression `len(self)`.
-    #[inline]
-    pub fn len(&self) -> PyResult<usize> {
-        self.as_borrowed().len()
-    }
-
-    /// Returns whether the mapping is empty.
-    #[inline]
-    pub fn is_empty(&self) -> PyResult<bool> {
-        self.as_borrowed().is_empty()
-    }
 
-    /// Determines if the mapping contains the specified key.
-    ///
-    /// This is equivalent to the Python expression `key in self`.
-    pub fn contains<K>(&self, key: K) -> PyResult<bool>
-    where
-        K: ToPyObject,
-    {
-        self.as_borrowed().contains(key)
-    }
-
-    /// Gets the item in self with key `key`.
-    ///
-    /// Returns an `Err` if the item with specified key is not found, usually `KeyError`.
-    ///
-    /// This is equivalent to the Python expression `self[key]`.
-    #[inline]
-    pub fn get_item<K>(&self, key: K) -> PyResult<&PyAny>
-    where
-        K: ToPyObject,
-    {
-        self.as_borrowed().get_item(key).map(Bound::into_gil_ref)
-    }
-
-    /// Sets the item in self with key `key`.
-    ///
-    /// This is equivalent to the Python expression `self[key] = value`.
-    #[inline]
-    pub fn set_item<K, V>(&self, key: K, value: V) -> PyResult<()>
-    where
-        K: ToPyObject,
-        V: ToPyObject,
-    {
-        self.as_borrowed().set_item(key, value)
-    }
-
-    /// Deletes the item with key `key`.
-    ///
-    /// This is equivalent to the Python statement `del self[key]`.
-    #[inline]
-    pub fn del_item<K>(&self, key: K) -> PyResult<()>
-    where
-        K: ToPyObject,
-    {
-        self.as_borrowed().del_item(key)
-    }
+pyobject_native_type_named!(PyMapping);
 
-    /// Returns a sequence containing all keys in the mapping.
-    #[inline]
-    pub fn keys(&self) -> PyResult<&PySequence> {
-        self.as_borrowed().keys().map(Bound::into_gil_ref)
-    }
+unsafe impl PyTypeInfo for PyMapping {
+    const NAME: &'static str = "Mapping";
+    const MODULE: Option<&'static str> = Some("collections.abc");
 
-    /// Returns a sequence containing all values in the mapping.
     #[inline]
-    pub fn values(&self) -> PyResult<&PySequence> {
-        self.as_borrowed().values().map(Bound::into_gil_ref)
+    #[allow(clippy::redundant_closure_call)]
+    fn type_object_raw(py: Python<'_>) -> *mut ffi::PyTypeObject {
+        static TYPE: PyOnceLock<Py<PyType>> = PyOnceLock::new();
+        TYPE.import(py, "collections.abc", "Mapping")
+            .unwrap()
+            .as_type_ptr()
     }
 
-    /// Returns a sequence of tuples of all (key, value) pairs in the mapping.
     #[inline]
-    pub fn items(&self) -> PyResult<&PySequence> {
-        self.as_borrowed().items().map(Bound::into_gil_ref)
+    fn is_type_of(object: &Bound<'_, PyAny>) -> bool {
+        // Using `is_instance` for `collections.abc.Mapping` is slow, so provide
+        // optimized case dict as a well-known mapping
+        PyDict::is_type_of(object)
+            || object
+                .is_instance(&Self::type_object(object.py()).into_any())
+                .unwrap_or_else(|err| {
+                    err.write_unraisable(object.py(), Some(object));
+                    false
+                })
     }
+}
 
+impl PyMapping {
     /// Register a pyclass as a subclass of `collections.abc.Mapping` (from the Python standard
-    /// library). This is equvalent to `collections.abc.Mapping.register(T)` in Python.
-    /// This registration is required for a pyclass to be downcastable from `PyAny` to `PyMapping`.
+    /// library). This is equivalent to `collections.abc.Mapping.register(T)` in Python.
+    /// This registration is required for a pyclass to be castable from `PyAny` to `PyMapping`.
     pub fn register<T: PyTypeInfo>(py: Python<'_>) -> PyResult<()> {
-        let ty = T::type_object_bound(py);
-        get_mapping_abc(py)?.call_method1("register", (ty,))?;
+        let ty = T::type_object(py);
+        Self::type_object(py).call_method1("register", (ty,))?;
         Ok(())
     }
 }
@@ -109,7 +65,7 @@ impl PyMapping {
 /// syntax these methods are separated into a trait, because stable Rust does not yet support
 /// `arbitrary_self_types`.
 #[doc(alias = "PyMapping")]
-pub trait PyMappingMethods<'py> {
+pub trait PyMappingMethods<'py>: crate::sealed::Sealed {
     /// Returns the number of objects in the mapping.
     ///
     /// This is equivalent to the Python expression `len(self)`.
@@ -123,7 +79,7 @@ pub trait PyMappingMethods<'py> {
     /// This is equivalent to the Python expression `key in self`.
     fn contains<K>(&self, key: K) -> PyResult<bool>
     where
-        K: ToPyObject;
+        K: IntoPyObject<'py>;
 
     /// Gets the item in self with key `key`.
     ///
@@ -132,31 +88,31 @@ pub trait PyMappingMethods<'py> {
     /// This is equivalent to the Python expression `self[key]`.
     fn get_item<K>(&self, key: K) -> PyResult<Bound<'py, PyAny>>
     where
-        K: ToPyObject;
+        K: IntoPyObject<'py>;
 
     /// Sets the item in self with key `key`.
     ///
     /// This is equivalent to the Python expression `self[key] = value`.
     fn set_item<K, V>(&self, key: K, value: V) -> PyResult<()>
     where
-        K: ToPyObject,
-        V: ToPyObject;
+        K: IntoPyObject<'py>,
+        V: IntoPyObject<'py>;
 
     /// Deletes the item with key `key`.
     ///
     /// This is equivalent to the Python statement `del self[key]`.
     fn del_item<K>(&self, key: K) -> PyResult<()>
     where
-        K: ToPyObject;
+        K: IntoPyObject<'py>;
 
-    /// Returns a sequence containing all keys in the mapping.
-    fn keys(&self) -> PyResult<Bound<'py, PySequence>>;
+    /// Returns a list containing all keys in the mapping.
+    fn keys(&self) -> PyResult<Bound<'py, PyList>>;
 
-    /// Returns a sequence containing all values in the mapping.
-    fn values(&self) -> PyResult<Bound<'py, PySequence>>;
+    /// Returns a list containing all values in the mapping.
+    fn values(&self) -> PyResult<Bound<'py, PyList>>;
 
-    /// Returns a sequence of tuples of all (key, value) pairs in the mapping.
-    fn items(&self) -> PyResult<Bound<'py, PySequence>>;
+    /// Returns a list of all (key, value) pairs in the mapping.
+    fn items(&self) -> PyResult<Bound<'py, PyList>>;
 }
 
 impl<'py> PyMappingMethods<'py> for Bound<'py, PyMapping> {
@@ -174,7 +130,7 @@ impl<'py> PyMappingMethods<'py> for Bound<'py, PyMapping> {
 
     fn contains<K>(&self, key: K) -> PyResult<bool>
     where
-        K: ToPyObject,
+        K: IntoPyObject<'py>,
     {
         PyAnyMethods::contains(&**self, key)
     }
@@ -182,7 +138,7 @@ impl<'py> PyMappingMethods<'py> for Bound<'py, PyMapping> {
     #[inline]
     fn get_item<K>(&self, key: K) -> PyResult<Bound<'py, PyAny>>
     where
-        K: ToPyObject,
+        K: IntoPyObject<'py>,
     {
         PyAnyMethods::get_item(&**self, key)
     }
@@ -190,8 +146,8 @@ impl<'py> PyMappingMethods<'py> for Bound<'py, PyMapping> {
     #[inline]
     fn set_item<K, V>(&self, key: K, value: V) -> PyResult<()>
     where
-        K: ToPyObject,
-        V: ToPyObject,
+        K: IntoPyObject<'py>,
+        V: IntoPyObject<'py>,
     {
         PyAnyMethods::set_item(&**self, key, value)
     }
@@ -199,86 +155,36 @@ impl<'py> PyMappingMethods<'py> for Bound<'py, PyMapping> {
     #[inline]
     fn del_item<K>(&self, key: K) -> PyResult<()>
     where
-        K: ToPyObject,
+        K: IntoPyObject<'py>,
     {
         PyAnyMethods::del_item(&**self, key)
     }
 
     #[inline]
-    fn keys(&self) -> PyResult<Bound<'py, PySequence>> {
+    fn keys(&self) -> PyResult<Bound<'py, PyList>> {
         unsafe {
             ffi::PyMapping_Keys(self.as_ptr())
                 .assume_owned_or_err(self.py())
-                .downcast_into_unchecked()
+                .cast_into_unchecked()
         }
     }
 
     #[inline]
-    fn values(&self) -> PyResult<Bound<'py, PySequence>> {
+    fn values(&self) -> PyResult<Bound<'py, PyList>> {
         unsafe {
             ffi::PyMapping_Values(self.as_ptr())
                 .assume_owned_or_err(self.py())
-                .downcast_into_unchecked()
+                .cast_into_unchecked()
         }
     }
 
     #[inline]
-    fn items(&self) -> PyResult<Bound<'py, PySequence>> {
+    fn items(&self) -> PyResult<Bound<'py, PyList>> {
         unsafe {
             ffi::PyMapping_Items(self.as_ptr())
                 .assume_owned_or_err(self.py())
-                .downcast_into_unchecked()
-        }
-    }
-}
-
-fn get_mapping_abc(py: Python<'_>) -> PyResult<&Bound<'_, PyType>> {
-    static MAPPING_ABC: GILOnceCell<Py<PyType>> = GILOnceCell::new();
-
-    MAPPING_ABC.get_or_try_init_type_ref(py, "collections.abc", "Mapping")
-}
-
-impl PyTypeCheck for PyMapping {
-    const NAME: &'static str = "Mapping";
-
-    #[inline]
-    fn type_check(object: &Bound<'_, PyAny>) -> bool {
-        // Using `is_instance` for `collections.abc.Mapping` is slow, so provide
-        // optimized case dict as a well-known mapping
-        PyDict::is_type_of_bound(object)
-            || get_mapping_abc(object.py())
-                .and_then(|abc| object.is_instance(abc))
-                .unwrap_or_else(|err| {
-                    err.write_unraisable_bound(object.py(), Some(&object.as_borrowed()));
-                    false
-                })
-    }
-}
-
-#[allow(deprecated)]
-impl<'v> crate::PyTryFrom<'v> for PyMapping {
-    /// Downcasting to `PyMapping` requires the concrete class to be a subclass (or registered
-    /// subclass) of `collections.abc.Mapping` (from the Python standard library) - i.e.
-    /// `isinstance(<class>, collections.abc.Mapping) == True`.
-    fn try_from<V: Into<&'v PyAny>>(value: V) -> Result<&'v PyMapping, PyDowncastError<'v>> {
-        let value = value.into();
-
-        if PyMapping::type_check(&value.as_borrowed()) {
-            unsafe { return Ok(value.downcast_unchecked()) }
+                .cast_into_unchecked()
         }
-
-        Err(PyDowncastError::new(value, "Mapping"))
-    }
-
-    #[inline]
-    fn try_from_exact<V: Into<&'v PyAny>>(value: V) -> Result<&'v PyMapping, PyDowncastError<'v>> {
-        value.into().downcast()
-    }
-
-    #[inline]
-    unsafe fn try_from_unchecked<V: Into<&'v PyAny>>(value: V) -> &'v PyMapping {
-        let ptr = value.into() as *const _ as *const PyMapping;
-        &*ptr
     }
 }
 
@@ -286,26 +192,23 @@ impl<'v> crate::PyTryFrom<'v> for PyMapping {
 mod tests {
     use std::collections::HashMap;
 
-    use crate::{
-        exceptions::PyKeyError,
-        types::{PyDict, PyTuple},
-        Python,
-    };
+    use crate::{exceptions::PyKeyError, types::PyTuple};
 
     use super::*;
+    use crate::conversion::IntoPyObject;
 
     #[test]
     fn test_len() {
-        Python::with_gil(|py| {
-            let mut v = HashMap::new();
-            let ob = v.to_object(py);
-            let mapping: &PyMapping = ob.downcast(py).unwrap();
+        Python::attach(|py| {
+            let mut v = HashMap::<i32, i32>::new();
+            let ob = (&v).into_pyobject(py).unwrap();
+            let mapping = ob.cast::<PyMapping>().unwrap();
             assert_eq!(0, mapping.len().unwrap());
             assert!(mapping.is_empty().unwrap());
 
             v.insert(7, 32);
-            let ob = v.to_object(py);
-            let mapping2: &PyMapping = ob.downcast(py).unwrap();
+            let ob = v.into_pyobject(py).unwrap();
+            let mapping2 = ob.cast::<PyMapping>().unwrap();
             assert_eq!(1, mapping2.len().unwrap());
             assert!(!mapping2.is_empty().unwrap());
         });
@@ -313,11 +216,11 @@ mod tests {
 
     #[test]
     fn test_contains() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let mut v = HashMap::new();
             v.insert("key0", 1234);
-            let ob = v.to_object(py);
-            let mapping: &PyMapping = ob.downcast(py).unwrap();
+            let ob = v.into_pyobject(py).unwrap();
+            let mapping = ob.cast::<PyMapping>().unwrap();
             mapping.set_item("key1", "foo").unwrap();
 
             assert!(mapping.contains("key0").unwrap());
@@ -328,11 +231,11 @@ mod tests {
 
     #[test]
     fn test_get_item() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let mut v = HashMap::new();
             v.insert(7, 32);
-            let ob = v.to_object(py);
-            let mapping: &PyMapping = ob.downcast(py).unwrap();
+            let ob = v.into_pyobject(py).unwrap();
+            let mapping = ob.cast::<PyMapping>().unwrap();
             assert_eq!(
                 32,
                 mapping.get_item(7i32).unwrap().extract::<i32>().unwrap()
@@ -346,11 +249,11 @@ mod tests {
 
     #[test]
     fn test_set_item() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let mut v = HashMap::new();
             v.insert(7, 32);
-            let ob = v.to_object(py);
-            let mapping: &PyMapping = ob.downcast(py).unwrap();
+            let ob = v.into_pyobject(py).unwrap();
+            let mapping = ob.cast::<PyMapping>().unwrap();
             assert!(mapping.set_item(7i32, 42i32).is_ok()); // change
             assert!(mapping.set_item(8i32, 123i32).is_ok()); // insert
             assert_eq!(
@@ -366,11 +269,11 @@ mod tests {
 
     #[test]
     fn test_del_item() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let mut v = HashMap::new();
             v.insert(7, 32);
-            let ob = v.to_object(py);
-            let mapping: &PyMapping = ob.downcast(py).unwrap();
+            let ob = v.into_pyobject(py).unwrap();
+            let mapping = ob.cast::<PyMapping>().unwrap();
             assert!(mapping.del_item(7i32).is_ok());
             assert_eq!(0, mapping.len().unwrap());
             assert!(mapping
@@ -382,18 +285,18 @@ mod tests {
 
     #[test]
     fn test_items() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let mut v = HashMap::new();
             v.insert(7, 32);
             v.insert(8, 42);
             v.insert(9, 123);
-            let ob = v.to_object(py);
-            let mapping: &PyMapping = ob.downcast(py).unwrap();
+            let ob = v.into_pyobject(py).unwrap();
+            let mapping = ob.cast::<PyMapping>().unwrap();
             // Can't just compare against a vector of tuples since we don't have a guaranteed ordering.
             let mut key_sum = 0;
             let mut value_sum = 0;
-            for el in mapping.items().unwrap().iter().unwrap() {
-                let tuple = el.unwrap().downcast::<PyTuple>().unwrap();
+            for el in mapping.items().unwrap().try_iter().unwrap() {
+                let tuple = el.unwrap().cast_into::<PyTuple>().unwrap();
                 key_sum += tuple.get_item(0).unwrap().extract::<i32>().unwrap();
                 value_sum += tuple.get_item(1).unwrap().extract::<i32>().unwrap();
             }
@@ -404,16 +307,16 @@ mod tests {
 
     #[test]
     fn test_keys() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let mut v = HashMap::new();
             v.insert(7, 32);
             v.insert(8, 42);
             v.insert(9, 123);
-            let ob = v.to_object(py);
-            let mapping: &PyMapping = ob.downcast(py).unwrap();
+            let ob = v.into_pyobject(py).unwrap();
+            let mapping = ob.cast::<PyMapping>().unwrap();
             // Can't just compare against a vector of tuples since we don't have a guaranteed ordering.
             let mut key_sum = 0;
-            for el in mapping.keys().unwrap().iter().unwrap() {
+            for el in mapping.keys().unwrap().try_iter().unwrap() {
                 key_sum += el.unwrap().extract::<i32>().unwrap();
             }
             assert_eq!(7 + 8 + 9, key_sum);
@@ -422,16 +325,16 @@ mod tests {
 
     #[test]
     fn test_values() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let mut v = HashMap::new();
             v.insert(7, 32);
             v.insert(8, 42);
             v.insert(9, 123);
-            let ob = v.to_object(py);
-            let mapping: &PyMapping = ob.downcast(py).unwrap();
+            let ob = v.into_pyobject(py).unwrap();
+            let mapping = ob.cast::<PyMapping>().unwrap();
             // Can't just compare against a vector of tuples since we don't have a guaranteed ordering.
             let mut values_sum = 0;
-            for el in mapping.values().unwrap().iter().unwrap() {
+            for el in mapping.values().unwrap().try_iter().unwrap() {
                 values_sum += el.unwrap().extract::<i32>().unwrap();
             }
             assert_eq!(32 + 42 + 123, values_sum);
@@ -439,13 +342,10 @@ mod tests {
     }
 
     #[test]
-    #[allow(deprecated)]
-    fn test_mapping_try_from() {
-        use crate::PyTryFrom;
-        Python::with_gil(|py| {
-            let dict = PyDict::new(py);
-            let _ = <PyMapping as PyTryFrom>::try_from(dict).unwrap();
-            let _ = PyMapping::try_from_exact(dict).unwrap();
-        });
+    fn test_type_object() {
+        Python::attach(|py| {
+            let abc = PyMapping::type_object(py);
+            assert!(PyDict::new(py).is_instance(&abc).unwrap());
+        })
     }
 }
diff --git a/src/types/mappingproxy.rs b/src/types/mappingproxy.rs
new file mode 100644
index 00000000000..478621a7163
--- /dev/null
+++ b/src/types/mappingproxy.rs
@@ -0,0 +1,547 @@
+// Copyright (c) 2017-present PyO3 Project and Contributors
+
+use super::PyMapping;
+use crate::err::PyResult;
+use crate::ffi_ptr_ext::FfiPtrExt;
+use crate::instance::Bound;
+use crate::types::any::PyAnyMethods;
+use crate::types::{PyAny, PyIterator, PyList};
+use crate::{ffi, Python};
+
+use std::ffi::c_int;
+
+/// Represents a Python `mappingproxy`.
+#[repr(transparent)]
+pub struct PyMappingProxy(PyAny);
+
+#[inline]
+unsafe fn dict_proxy_check(op: *mut ffi::PyObject) -> c_int {
+    unsafe { ffi::Py_IS_TYPE(op, std::ptr::addr_of_mut!(ffi::PyDictProxy_Type)) }
+}
+
+pyobject_native_type_core!(
+    PyMappingProxy,
+    pyobject_native_static_type_object!(ffi::PyDictProxy_Type),
+    #checkfunction=dict_proxy_check
+);
+
+impl PyMappingProxy {
+    /// Creates a mappingproxy from an object.
+    pub fn new<'py>(
+        py: Python<'py>,
+        elements: &Bound<'py, PyMapping>,
+    ) -> Bound<'py, PyMappingProxy> {
+        unsafe {
+            ffi::PyDictProxy_New(elements.as_ptr())
+                .assume_owned(py)
+                .cast_into_unchecked()
+        }
+    }
+}
+
+/// Implementation of functionality for [`PyMappingProxy`].
+///
+/// These methods are defined for the `Bound<'py, PyMappingProxy>` smart pointer, so to use method call
+/// syntax these methods are separated into a trait, because stable Rust does not yet support
+/// `arbitrary_self_types`.
+#[doc(alias = "PyMappingProxy")]
+pub trait PyMappingProxyMethods<'py, 'a>: crate::sealed::Sealed {
+    /// Checks if the mappingproxy is empty, i.e. `len(self) == 0`.
+    fn is_empty(&self) -> PyResult<bool>;
+
+    /// Returns a list containing all keys in the mapping.
+    fn keys(&self) -> PyResult<Bound<'py, PyList>>;
+
+    /// Returns a list containing all values in the mapping.
+    fn values(&self) -> PyResult<Bound<'py, PyList>>;
+
+    /// Returns a list of tuples of all (key, value) pairs in the mapping.
+    fn items(&self) -> PyResult<Bound<'py, PyList>>;
+
+    /// Returns `self` cast as a `PyMapping`.
+    fn as_mapping(&self) -> &Bound<'py, PyMapping>;
+
+    /// Takes an object and returns an iterator for it. Returns an error if the object is not
+    /// iterable.
+    fn try_iter(&'a self) -> PyResult<BoundMappingProxyIterator<'py, 'a>>;
+}
+
+impl<'py, 'a> PyMappingProxyMethods<'py, 'a> for Bound<'py, PyMappingProxy> {
+    fn is_empty(&self) -> PyResult<bool> {
+        Ok(self.len()? == 0)
+    }
+
+    #[inline]
+    fn keys(&self) -> PyResult<Bound<'py, PyList>> {
+        unsafe {
+            Ok(ffi::PyMapping_Keys(self.as_ptr())
+                .assume_owned_or_err(self.py())?
+                .cast_into_unchecked())
+        }
+    }
+
+    #[inline]
+    fn values(&self) -> PyResult<Bound<'py, PyList>> {
+        unsafe {
+            Ok(ffi::PyMapping_Values(self.as_ptr())
+                .assume_owned_or_err(self.py())?
+                .cast_into_unchecked())
+        }
+    }
+
+    #[inline]
+    fn items(&self) -> PyResult<Bound<'py, PyList>> {
+        unsafe {
+            Ok(ffi::PyMapping_Items(self.as_ptr())
+                .assume_owned_or_err(self.py())?
+                .cast_into_unchecked())
+        }
+    }
+
+    fn as_mapping(&self) -> &Bound<'py, PyMapping> {
+        unsafe { self.cast_unchecked() }
+    }
+
+    fn try_iter(&'a self) -> PyResult<BoundMappingProxyIterator<'py, 'a>> {
+        Ok(BoundMappingProxyIterator {
+            iterator: PyIterator::from_object(self)?,
+            mappingproxy: self,
+        })
+    }
+}
+
+pub struct BoundMappingProxyIterator<'py, 'a> {
+    iterator: Bound<'py, PyIterator>,
+    mappingproxy: &'a Bound<'py, PyMappingProxy>,
+}
+
+impl<'py> Iterator for BoundMappingProxyIterator<'py, '_> {
+    type Item = PyResult<(Bound<'py, PyAny>, Bound<'py, PyAny>)>;
+
+    #[inline]
+    fn next(&mut self) -> Option<Self::Item> {
+        self.iterator.next().map(|key| match key {
+            Ok(key) => match self.mappingproxy.get_item(&key) {
+                Ok(value) => Ok((key, value)),
+                Err(e) => Err(e),
+            },
+            Err(e) => Err(e),
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+
+    use super::*;
+    use crate::types::dict::*;
+    use crate::Python;
+    use crate::{
+        exceptions::PyKeyError,
+        types::{PyInt, PyTuple},
+    };
+    use std::collections::{BTreeMap, HashMap};
+
+    #[test]
+    fn test_new() {
+        Python::attach(|py| {
+            let pydict = [(7, 32)].into_py_dict(py).unwrap();
+            let mappingproxy = PyMappingProxy::new(py, pydict.as_mapping());
+            mappingproxy.get_item(7i32).unwrap();
+            assert_eq!(
+                32,
+                mappingproxy
+                    .get_item(7i32)
+                    .unwrap()
+                    .extract::<i32>()
+                    .unwrap()
+            );
+            assert!(mappingproxy
+                .get_item(8i32)
+                .unwrap_err()
+                .is_instance_of::<PyKeyError>(py));
+        });
+    }
+
+    #[test]
+    fn test_len() {
+        Python::attach(|py| {
+            let mut v = HashMap::new();
+            let dict = v.clone().into_py_dict(py).unwrap();
+            let mappingproxy = PyMappingProxy::new(py, dict.as_mapping());
+            assert_eq!(mappingproxy.len().unwrap(), 0);
+            v.insert(7, 32);
+            let dict2 = v.clone().into_py_dict(py).unwrap();
+            let mp2 = PyMappingProxy::new(py, dict2.as_mapping());
+            assert_eq!(mp2.len().unwrap(), 1);
+        });
+    }
+
+    #[test]
+    fn test_contains() {
+        Python::attach(|py| {
+            let mut v = HashMap::new();
+            v.insert(7, 32);
+            let dict = v.clone().into_py_dict(py).unwrap();
+            let mappingproxy = PyMappingProxy::new(py, dict.as_mapping());
+            assert!(mappingproxy.contains(7i32).unwrap());
+            assert!(!mappingproxy.contains(8i32).unwrap());
+        });
+    }
+
+    #[test]
+    fn test_get_item() {
+        Python::attach(|py| {
+            let mut v = HashMap::new();
+            v.insert(7, 32);
+            let dict = v.clone().into_py_dict(py).unwrap();
+            let mappingproxy = PyMappingProxy::new(py, dict.as_mapping());
+            assert_eq!(
+                32,
+                mappingproxy
+                    .get_item(7i32)
+                    .unwrap()
+                    .extract::<i32>()
+                    .unwrap()
+            );
+            assert!(mappingproxy
+                .get_item(8i32)
+                .unwrap_err()
+                .is_instance_of::<PyKeyError>(py));
+        });
+    }
+
+    #[test]
+    fn test_set_item_refcnt() {
+        Python::attach(|py| {
+            let cnt;
+            {
+                let none = py.None();
+                cnt = none.get_refcnt(py);
+                let dict = [(10, none)].into_py_dict(py).unwrap();
+                let _mappingproxy = PyMappingProxy::new(py, dict.as_mapping());
+            }
+            {
+                assert_eq!(cnt, py.None().get_refcnt(py));
+            }
+        });
+    }
+
+    #[test]
+    fn test_isempty() {
+        Python::attach(|py| {
+            let map: HashMap<usize, usize> = HashMap::new();
+            let dict = map.into_py_dict(py).unwrap();
+            let mappingproxy = PyMappingProxy::new(py, dict.as_mapping());
+            assert!(mappingproxy.is_empty().unwrap());
+        });
+    }
+
+    #[test]
+    fn test_keys() {
+        Python::attach(|py| {
+            let mut v = HashMap::new();
+            v.insert(7, 32);
+            v.insert(8, 42);
+            v.insert(9, 123);
+            let dict = v.into_py_dict(py).unwrap();
+            let mappingproxy = PyMappingProxy::new(py, dict.as_mapping());
+            // Can't just compare against a vector of tuples since we don't have a guaranteed ordering.
+            let mut key_sum = 0;
+            for el in mappingproxy.keys().unwrap().try_iter().unwrap() {
+                key_sum += el.unwrap().extract::<i32>().unwrap();
+            }
+            assert_eq!(7 + 8 + 9, key_sum);
+        });
+    }
+
+    #[test]
+    fn test_values() {
+        Python::attach(|py| {
+            let mut v: HashMap<i32, i32> = HashMap::new();
+            v.insert(7, 32);
+            v.insert(8, 42);
+            v.insert(9, 123);
+            let dict = v.into_py_dict(py).unwrap();
+            let mappingproxy = PyMappingProxy::new(py, dict.as_mapping());
+            // Can't just compare against a vector of tuples since we don't have a guaranteed ordering.
+            let mut values_sum = 0;
+            for el in mappingproxy.values().unwrap().try_iter().unwrap() {
+                values_sum += el.unwrap().extract::<i32>().unwrap();
+            }
+            assert_eq!(32 + 42 + 123, values_sum);
+        });
+    }
+
+    #[test]
+    fn test_items() {
+        Python::attach(|py| {
+            let mut v = HashMap::new();
+            v.insert(7, 32);
+            v.insert(8, 42);
+            v.insert(9, 123);
+            let dict = v.into_py_dict(py).unwrap();
+            let mappingproxy = PyMappingProxy::new(py, dict.as_mapping());
+            // Can't just compare against a vector of tuples since we don't have a guaranteed ordering.
+            let mut key_sum = 0;
+            let mut value_sum = 0;
+            for res in mappingproxy.items().unwrap().try_iter().unwrap() {
+                let el = res.unwrap();
+                let tuple = el.cast::<PyTuple>().unwrap();
+                key_sum += tuple.get_item(0).unwrap().extract::<i32>().unwrap();
+                value_sum += tuple.get_item(1).unwrap().extract::<i32>().unwrap();
+            }
+            assert_eq!(7 + 8 + 9, key_sum);
+            assert_eq!(32 + 42 + 123, value_sum);
+        });
+    }
+
+    #[test]
+    fn test_iter() {
+        Python::attach(|py| {
+            let mut v = HashMap::new();
+            v.insert(7, 32);
+            v.insert(8, 42);
+            v.insert(9, 123);
+            let dict = v.into_py_dict(py).unwrap();
+            let mappingproxy = PyMappingProxy::new(py, dict.as_mapping());
+            let mut key_sum = 0;
+            let mut value_sum = 0;
+            for res in mappingproxy.try_iter().unwrap() {
+                let (key, value) = res.unwrap();
+                key_sum += key.extract::<i32>().unwrap();
+                value_sum += value.extract::<i32>().unwrap();
+            }
+            assert_eq!(7 + 8 + 9, key_sum);
+            assert_eq!(32 + 42 + 123, value_sum);
+        });
+    }
+
+    #[test]
+    fn test_hashmap_into_python() {
+        Python::attach(|py| {
+            let mut map = HashMap::<i32, i32>::new();
+            map.insert(1, 1);
+
+            let dict = map.clone().into_py_dict(py).unwrap();
+            let py_map = PyMappingProxy::new(py, dict.as_mapping());
+
+            assert_eq!(py_map.len().unwrap(), 1);
+            assert_eq!(py_map.get_item(1).unwrap().extract::<i32>().unwrap(), 1);
+        });
+    }
+
+    #[test]
+    fn test_hashmap_into_mappingproxy() {
+        Python::attach(|py| {
+            let mut map = HashMap::<i32, i32>::new();
+            map.insert(1, 1);
+
+            let dict = map.clone().into_py_dict(py).unwrap();
+            let py_map = PyMappingProxy::new(py, dict.as_mapping());
+
+            assert_eq!(py_map.len().unwrap(), 1);
+            assert_eq!(py_map.get_item(1).unwrap().extract::<i32>().unwrap(), 1);
+        });
+    }
+
+    #[test]
+    fn test_btreemap_into_py() {
+        Python::attach(|py| {
+            let mut map = BTreeMap::<i32, i32>::new();
+            map.insert(1, 1);
+
+            let dict = map.clone().into_py_dict(py).unwrap();
+            let py_map = PyMappingProxy::new(py, dict.as_mapping());
+
+            assert_eq!(py_map.len().unwrap(), 1);
+            assert_eq!(py_map.get_item(1).unwrap().extract::<i32>().unwrap(), 1);
+        });
+    }
+
+    #[test]
+    fn test_btreemap_into_mappingproxy() {
+        Python::attach(|py| {
+            let mut map = BTreeMap::<i32, i32>::new();
+            map.insert(1, 1);
+
+            let dict = map.clone().into_py_dict(py).unwrap();
+            let py_map = PyMappingProxy::new(py, dict.as_mapping());
+
+            assert_eq!(py_map.len().unwrap(), 1);
+            assert_eq!(py_map.get_item(1).unwrap().extract::<i32>().unwrap(), 1);
+        });
+    }
+
+    #[test]
+    fn test_vec_into_mappingproxy() {
+        Python::attach(|py| {
+            let vec = vec![("a", 1), ("b", 2), ("c", 3)];
+            let dict = vec.clone().into_py_dict(py).unwrap();
+            let py_map = PyMappingProxy::new(py, dict.as_mapping());
+
+            assert_eq!(py_map.len().unwrap(), 3);
+            assert_eq!(py_map.get_item("b").unwrap().extract::<i32>().unwrap(), 2);
+        });
+    }
+
+    #[test]
+    fn test_slice_into_mappingproxy() {
+        Python::attach(|py| {
+            let arr = [("a", 1), ("b", 2), ("c", 3)];
+
+            let dict = arr.into_py_dict(py).unwrap();
+            let py_map = PyMappingProxy::new(py, dict.as_mapping());
+
+            assert_eq!(py_map.len().unwrap(), 3);
+            assert_eq!(py_map.get_item("b").unwrap().extract::<i32>().unwrap(), 2);
+        });
+    }
+
+    #[test]
+    fn mappingproxy_as_mapping() {
+        Python::attach(|py| {
+            let mut map = HashMap::<i32, i32>::new();
+            map.insert(1, 1);
+
+            let dict = map.clone().into_py_dict(py).unwrap();
+            let py_map = PyMappingProxy::new(py, dict.as_mapping());
+
+            assert_eq!(py_map.as_mapping().len().unwrap(), 1);
+            assert_eq!(
+                py_map
+                    .as_mapping()
+                    .get_item(1)
+                    .unwrap()
+                    .extract::<i32>()
+                    .unwrap(),
+                1
+            );
+        });
+    }
+
+    #[cfg(not(any(PyPy, GraalPy)))]
+    fn abc_mappingproxy(py: Python<'_>) -> Bound<'_, PyMappingProxy> {
+        let mut map = HashMap::<&'static str, i32>::new();
+        map.insert("a", 1);
+        map.insert("b", 2);
+        map.insert("c", 3);
+        let dict = map.clone().into_py_dict(py).unwrap();
+        PyMappingProxy::new(py, dict.as_mapping())
+    }
+
+    #[test]
+    #[cfg(not(any(PyPy, GraalPy)))]
+    fn mappingproxy_keys_view() {
+        Python::attach(|py| {
+            let mappingproxy = abc_mappingproxy(py);
+            let keys = mappingproxy.call_method0("keys").unwrap();
+            assert!(keys.is_instance(&py.get_type::<PyDictKeys>()).unwrap());
+        })
+    }
+
+    #[test]
+    #[cfg(not(any(PyPy, GraalPy)))]
+    fn mappingproxy_values_view() {
+        Python::attach(|py| {
+            let mappingproxy = abc_mappingproxy(py);
+            let values = mappingproxy.call_method0("values").unwrap();
+            assert!(values.is_instance(&py.get_type::<PyDictValues>()).unwrap());
+        })
+    }
+
+    #[test]
+    #[cfg(not(any(PyPy, GraalPy)))]
+    fn mappingproxy_items_view() {
+        Python::attach(|py| {
+            let mappingproxy = abc_mappingproxy(py);
+            let items = mappingproxy.call_method0("items").unwrap();
+            assert!(items.is_instance(&py.get_type::<PyDictItems>()).unwrap());
+        })
+    }
+
+    #[test]
+    fn get_value_from_mappingproxy_of_strings() {
+        Python::attach(|py: Python<'_>| {
+            let mut map = HashMap::new();
+            map.insert("first key".to_string(), "first value".to_string());
+            map.insert("second key".to_string(), "second value".to_string());
+            map.insert("third key".to_string(), "third value".to_string());
+
+            let dict = map.clone().into_py_dict(py).unwrap();
+            let mappingproxy = PyMappingProxy::new(py, dict.as_mapping());
+
+            assert_eq!(
+                map.into_iter().collect::<Vec<(String, String)>>(),
+                mappingproxy
+                    .try_iter()
+                    .unwrap()
+                    .map(|object| {
+                        let tuple = object.unwrap();
+                        (
+                            tuple.0.extract::<String>().unwrap(),
+                            tuple.1.extract::<String>().unwrap(),
+                        )
+                    })
+                    .collect::<Vec<(String, String)>>()
+            );
+        })
+    }
+
+    #[test]
+    fn get_value_from_mappingproxy_of_integers() {
+        Python::attach(|py: Python<'_>| {
+            const LEN: usize = 10_000;
+            let items: Vec<(usize, usize)> = (1..LEN).map(|i| (i, i - 1)).collect();
+
+            let dict = items.clone().into_py_dict(py).unwrap();
+            let mappingproxy = PyMappingProxy::new(py, dict.as_mapping());
+
+            assert_eq!(
+                items,
+                mappingproxy
+                    .clone()
+                    .try_iter()
+                    .unwrap()
+                    .map(|object| {
+                        let tuple = object.unwrap();
+                        (
+                            tuple.0.cast::<PyInt>().unwrap().extract::<usize>().unwrap(),
+                            tuple.1.cast::<PyInt>().unwrap().extract::<usize>().unwrap(),
+                        )
+                    })
+                    .collect::<Vec<(usize, usize)>>()
+            );
+            for index in 1..LEN {
+                assert_eq!(
+                    mappingproxy
+                        .clone()
+                        .get_item(index)
+                        .unwrap()
+                        .extract::<usize>()
+                        .unwrap(),
+                    index - 1
+                );
+            }
+        })
+    }
+
+    #[test]
+    fn iter_mappingproxy_nosegv() {
+        Python::attach(|py| {
+            const LEN: usize = 1_000;
+            let items = (0..LEN as u64).map(|i| (i, i * 2));
+
+            let dict = items.clone().into_py_dict(py).unwrap();
+            let mappingproxy = PyMappingProxy::new(py, dict.as_mapping());
+
+            let mut sum = 0;
+            for result in mappingproxy.try_iter().unwrap() {
+                let (k, _v) = result.unwrap();
+                let i: u64 = k.extract().unwrap();
+                sum += i;
+            }
+            assert_eq!(sum, 499_500);
+        })
+    }
+}
diff --git a/src/types/memoryview.rs b/src/types/memoryview.rs
index 414bfc69cfa..cdb252e72d2 100644
--- a/src/types/memoryview.rs
+++ b/src/types/memoryview.rs
@@ -1,57 +1,35 @@
 use crate::err::PyResult;
 use crate::ffi_ptr_ext::FfiPtrExt;
 use crate::py_result_ext::PyResultExt;
-use crate::{ffi, AsPyPointer, Bound, PyAny, PyNativeType};
+use crate::{ffi, Bound, PyAny};
 
 /// Represents a Python `memoryview`.
+///
+/// Values of this type are accessed via PyO3's smart pointers, e.g. as
+/// [`Py<PyMemoryView>`][crate::Py] or [`Bound<'py, PyMemoryView>`][Bound].
 #[repr(transparent)]
 pub struct PyMemoryView(PyAny);
 
 pyobject_native_type_core!(PyMemoryView, pyobject_native_static_type_object!(ffi::PyMemoryView_Type), #checkfunction=ffi::PyMemoryView_Check);
 
 impl PyMemoryView {
-    /// Deprecated form of [`PyMemoryView::from_bound`]
-    #[cfg_attr(
-        not(feature = "gil-refs"),
-        deprecated(
-            since = "0.21.0",
-            note = "`PyMemoryView::from` will be replaced by `PyMemoryView::from_bound` in a future PyO3 version"
-        )
-    )]
-    pub fn from(src: &PyAny) -> PyResult<&PyMemoryView> {
-        unsafe {
-            src.py()
-                .from_owned_ptr_or_err(ffi::PyMemoryView_FromObject(src.as_ptr()))
-        }
-    }
-
     /// Creates a new Python `memoryview` object from another Python object that
     /// implements the buffer protocol.
-    pub fn from_bound<'py>(src: &Bound<'py, PyAny>) -> PyResult<Bound<'py, Self>> {
+    pub fn from<'py>(src: &Bound<'py, PyAny>) -> PyResult<Bound<'py, Self>> {
         unsafe {
             ffi::PyMemoryView_FromObject(src.as_ptr())
                 .assume_owned_or_err(src.py())
-                .downcast_into_unchecked()
+                .cast_into_unchecked()
         }
     }
 }
 
-impl<'py> TryFrom<&'py PyAny> for &'py PyMemoryView {
-    type Error = crate::PyErr;
-
-    /// Creates a new Python `memoryview` object from another Python object that
-    /// implements the buffer protocol.
-    fn try_from(value: &'py PyAny) -> Result<Self, Self::Error> {
-        PyMemoryView::from_bound(&value.as_borrowed()).map(Bound::into_gil_ref)
-    }
-}
-
 impl<'py> TryFrom<&Bound<'py, PyAny>> for Bound<'py, PyMemoryView> {
     type Error = crate::PyErr;
 
     /// Creates a new Python `memoryview` object from another Python object that
     /// implements the buffer protocol.
     fn try_from(value: &Bound<'py, PyAny>) -> Result<Self, Self::Error> {
-        PyMemoryView::from_bound(value)
+        PyMemoryView::from(value)
     }
 }
diff --git a/src/types/mod.rs b/src/types/mod.rs
index da22b30729f..beff336d4db 100644
--- a/src/types/mod.rs
+++ b/src/types/mod.rs
@@ -1,52 +1,57 @@
 //! Various types defined by the Python interpreter such as `int`, `str` and `tuple`.
 
-pub use self::any::PyAny;
-pub use self::boolobject::PyBool;
-pub use self::bytearray::PyByteArray;
-pub use self::bytes::PyBytes;
-pub use self::capsule::PyCapsule;
-#[cfg(not(Py_LIMITED_API))]
-pub use self::code::PyCode;
-pub use self::complex::PyComplex;
+pub use self::any::{PyAny, PyAnyMethods};
+pub use self::boolobject::{PyBool, PyBoolMethods};
+pub use self::bytearray::{PyByteArray, PyByteArrayMethods};
+pub use self::bytes::{PyBytes, PyBytesMethods};
+pub use self::capsule::{CapsuleName, PyCapsule, PyCapsuleMethods};
+pub use self::code::{PyCode, PyCodeInput, PyCodeMethods};
+pub use self::complex::{PyComplex, PyComplexMethods};
 #[allow(deprecated)]
-#[cfg(not(Py_LIMITED_API))]
-pub use self::datetime::timezone_utc;
-#[cfg(not(Py_LIMITED_API))]
 pub use self::datetime::{
-    timezone_utc_bound, PyDate, PyDateAccess, PyDateTime, PyDelta, PyDeltaAccess, PyTime,
-    PyTimeAccess, PyTzInfo, PyTzInfoAccess,
+    timezone_utc, PyDate, PyDateTime, PyDelta, PyTime, PyTzInfo, PyTzInfoAccess,
 };
-pub use self::dict::{IntoPyDict, PyDict};
-#[cfg(not(PyPy))]
+#[cfg(not(Py_LIMITED_API))]
+pub use self::datetime::{PyDateAccess, PyDeltaAccess, PyTimeAccess};
+pub use self::dict::{IntoPyDict, PyDict, PyDictMethods};
+#[cfg(not(any(PyPy, GraalPy)))]
 pub use self::dict::{PyDictItems, PyDictKeys, PyDictValues};
 pub use self::ellipsis::PyEllipsis;
-pub use self::float::PyFloat;
-#[cfg(all(not(Py_LIMITED_API), not(PyPy)))]
+pub use self::float::{PyFloat, PyFloatMethods};
+#[cfg(all(not(Py_LIMITED_API), not(PyPy), not(GraalPy)))]
 pub use self::frame::PyFrame;
-pub use self::frozenset::{PyFrozenSet, PyFrozenSetBuilder};
+pub use self::frozenset::{PyFrozenSet, PyFrozenSetBuilder, PyFrozenSetMethods};
 pub use self::function::PyCFunction;
-#[cfg(all(not(Py_LIMITED_API), not(PyPy)))]
+#[cfg(not(Py_LIMITED_API))]
 pub use self::function::PyFunction;
+#[cfg(Py_3_9)]
+pub use self::genericalias::PyGenericAlias;
 pub use self::iterator::PyIterator;
-pub use self::list::PyList;
-pub use self::mapping::PyMapping;
+#[cfg(all(not(PyPy), Py_3_10))]
+pub use self::iterator::PySendResult;
+pub use self::list::{PyList, PyListMethods};
+pub use self::mapping::{PyMapping, PyMappingMethods};
+pub use self::mappingproxy::PyMappingProxy;
 pub use self::memoryview::PyMemoryView;
-pub use self::module::PyModule;
+pub use self::module::{PyModule, PyModuleMethods};
+#[cfg(all(not(Py_LIMITED_API), Py_3_13))]
+pub use self::mutex::{PyMutex, PyMutexGuard};
 pub use self::none::PyNone;
 pub use self::notimplemented::PyNotImplemented;
-pub use self::num::PyLong;
-pub use self::num::PyLong as PyInt;
-#[cfg(not(PyPy))]
+pub use self::num::PyInt;
+#[cfg(not(any(PyPy, GraalPy)))]
 pub use self::pysuper::PySuper;
-pub use self::sequence::PySequence;
-pub use self::set::PySet;
-pub use self::slice::{PySlice, PySliceIndices};
+pub use self::range::{PyRange, PyRangeMethods};
+pub use self::sequence::{PySequence, PySequenceMethods};
+pub use self::set::{PySet, PySetMethods};
+pub use self::slice::{PySlice, PySliceIndices, PySliceMethods};
 #[cfg(not(Py_LIMITED_API))]
 pub use self::string::PyStringData;
-pub use self::string::{PyString, PyString as PyUnicode};
-pub use self::traceback::PyTraceback;
-pub use self::tuple::PyTuple;
-pub use self::typeobject::PyType;
+pub use self::string::{PyString, PyStringMethods};
+pub use self::traceback::{PyTraceback, PyTracebackMethods};
+pub use self::tuple::{PyTuple, PyTupleMethods};
+pub use self::typeobject::{PyType, PyTypeMethods};
+pub use self::weakref::{PyWeakref, PyWeakrefMethods, PyWeakrefProxy, PyWeakrefReference};
 
 /// Iteration over Python collections.
 ///
@@ -59,12 +64,13 @@ pub use self::typeobject::PyType;
 /// ```rust
 /// use pyo3::prelude::*;
 /// use pyo3::types::PyDict;
+/// use pyo3::ffi::c_str;
 ///
 /// # pub fn main() -> PyResult<()> {
-/// Python::with_gil(|py| {
-///     let dict = py.eval_bound("{'a':'b', 'c':'d'}", None, None)?.downcast_into::<PyDict>()?;
+/// Python::attach(|py| {
+///     let dict = py.eval(c"{'a':'b', 'c':'d'}", None, None)?.cast_into::<PyDict>()?;
 ///
-///     for (key, value) in dict.iter() {
+///     for (key, value) in &dict {
 ///         println!("key: {}, value: {}", key, value);
 ///     }
 ///
@@ -79,57 +85,37 @@ pub use self::typeobject::PyType;
 /// the Limited API and PyPy, the underlying structures are opaque and that may not be possible.
 /// In these cases the iterators are implemented by forwarding to [`PyIterator`].
 pub mod iter {
-    pub use super::dict::{BoundDictIterator, PyDictIterator};
-    pub use super::frozenset::{BoundFrozenSetIterator, PyFrozenSetIterator};
-    pub use super::list::{BoundListIterator, PyListIterator};
-    pub use super::set::{BoundSetIterator, PySetIterator};
-    pub use super::tuple::{BorrowedTupleIterator, BoundTupleIterator, PyTupleIterator};
+    pub use super::dict::BoundDictIterator;
+    pub use super::frozenset::BoundFrozenSetIterator;
+    pub use super::list::BoundListIterator;
+    pub use super::set::BoundSetIterator;
+    pub use super::tuple::{BorrowedTupleIterator, BoundTupleIterator};
 }
 
-// Implementations core to all native types
-#[doc(hidden)]
-#[macro_export]
-macro_rules! pyobject_native_type_base(
-    ($name:ty $(;$generics:ident)* ) => {
-        unsafe impl<$($generics,)*> $crate::PyNativeType for $name {
-            type AsRefSource = Self;
-        }
-
-        impl<$($generics,)*> ::std::fmt::Debug for $name {
-            fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>)
-                   -> ::std::result::Result<(), ::std::fmt::Error>
-            {
-                let s = self.repr().or(::std::result::Result::Err(::std::fmt::Error))?;
-                f.write_str(&s.to_string_lossy())
-            }
-        }
-
-        impl<$($generics,)*> ::std::fmt::Display for $name {
-            fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>)
-                   -> ::std::result::Result<(), ::std::fmt::Error>
-            {
-                use $crate::PyNativeType;
-                match self.str() {
-                    ::std::result::Result::Ok(s) => return f.write_str(&s.to_string_lossy()),
-                    ::std::result::Result::Err(err) => err.write_unraisable_bound(self.py(), ::std::option::Option::Some(&self.as_borrowed())),
-                }
-
-                match self.get_type().name() {
-                    ::std::result::Result::Ok(name) => ::std::write!(f, "<unprintable {} object>", name),
-                    ::std::result::Result::Err(_err) => f.write_str("<unprintable object>"),
-                }
-            }
-        }
-
-        impl<$($generics,)*> $crate::ToPyObject for $name
-        {
-            #[inline]
-            fn to_object(&self, py: $crate::Python<'_>) -> $crate::PyObject {
-                unsafe { $crate::PyObject::from_borrowed_ptr(py, self.as_ptr()) }
-            }
-        }
-    };
-);
+/// Python objects that have a base type.
+///
+/// This marks types that can be upcast into a [`PyAny`] and used in its place.
+/// This essentially includes every Python object except [`PyAny`] itself.
+///
+/// This is used to provide the [`Deref<Target = Bound<'_, PyAny>>`](std::ops::Deref)
+/// implementations for [`Bound<'_, T>`](crate::Bound).
+///
+/// Users should not need to implement this trait directly. It's implementation
+/// is provided by the [`#[pyclass]`](macro@crate::pyclass) attribute.
+///
+/// ## Note
+/// This is needed because the compiler currently tries to figure out all the
+/// types in a deref-chain before starting to look for applicable method calls.
+/// So we need to prevent [`Bound<'_, PyAny`](crate::Bound) dereferencing to
+/// itself in order to avoid running into the recursion limit. This trait is
+/// used to exclude this from our blanket implementation. See [this Rust
+/// issue][1] for more details. If the compiler limitation gets resolved, this
+/// trait will be removed.
+///
+/// [1]: https://github.com/rust-lang/rust/issues/19509
+pub trait DerefToPyAny {
+    // Empty.
+}
 
 // Implementations core to all native types except for PyAny (because they don't
 // make sense on PyAny / have different implementations).
@@ -137,67 +123,35 @@ macro_rules! pyobject_native_type_base(
 #[macro_export]
 macro_rules! pyobject_native_type_named (
     ($name:ty $(;$generics:ident)*) => {
-        $crate::pyobject_native_type_base!($name $(;$generics)*);
-
-        impl<$($generics,)*> ::std::convert::AsRef<$crate::PyAny> for $name {
-            #[inline]
-            fn as_ref(&self) -> &$crate::PyAny {
-                &self.0
-            }
-        }
-
-        impl<$($generics,)*> ::std::ops::Deref for $name {
-            type Target = $crate::PyAny;
-
-            #[inline]
-            fn deref(&self) -> &$crate::PyAny {
-                &self.0
-            }
-        }
-
-        unsafe impl<$($generics,)*> $crate::AsPyPointer for $name {
-            /// Gets the underlying FFI pointer, returns a borrowed pointer.
-            #[inline]
-            fn as_ptr(&self) -> *mut $crate::ffi::PyObject {
-                self.0.as_ptr()
-            }
-        }
-
-        impl<$($generics,)*> $crate::IntoPy<$crate::Py<$name>> for &'_ $name {
-            #[inline]
-            fn into_py(self, py: $crate::Python<'_>) -> $crate::Py<$name> {
-                unsafe { $crate::Py::from_borrowed_ptr(py, self.as_ptr()) }
-            }
-        }
-
-        impl<$($generics,)*> ::std::convert::From<&'_ $name> for $crate::Py<$name> {
-            #[inline]
-            fn from(other: &$name) -> Self {
-                use $crate::PyNativeType;
-                unsafe { $crate::Py::from_borrowed_ptr(other.py(), other.as_ptr()) }
-            }
-        }
-
-        impl<'a, $($generics,)*> ::std::convert::From<&'a $name> for &'a $crate::PyAny {
-            fn from(ob: &'a $name) -> Self {
-                unsafe{&*(ob as *const $name as *const $crate::PyAny)}
-            }
-        }
+        impl $crate::types::DerefToPyAny for $name {}
     };
 );
 
+/// Helper for defining the `$typeobject` argument for other macros in this module.
+///
+/// # Safety
+///
+/// - `$typeobject` must be a known `static mut PyTypeObject`
 #[doc(hidden)]
 #[macro_export]
 macro_rules! pyobject_native_static_type_object(
     ($typeobject:expr) => {
-        |_py| unsafe { ::std::ptr::addr_of_mut!($typeobject) }
+        |_py| ::std::ptr::addr_of_mut!($typeobject)
     };
 );
 
+/// Implements the `PyTypeInfo` trait for a native Python type.
+///
+/// # Safety
+///
+/// - `$typeobject` must be a function that produces a valid `*mut PyTypeObject`
+/// - `$checkfunction` must be a function that accepts arbitrary `*mut PyObject` and returns true /
+///   false according to whether the object is an instance of the type from `$typeobject`
 #[doc(hidden)]
 #[macro_export]
 macro_rules! pyobject_native_type_info(
     ($name:ty, $typeobject:expr, $module:expr $(, #checkfunction=$checkfunction:path)? $(;$generics:ident)*) => {
+        // SAFETY: macro caller has upheld the safety contracts
         unsafe impl<$($generics,)*> $crate::type_object::PyTypeInfo for $name {
             const NAME: &'static str = stringify!($name);
             const MODULE: ::std::option::Option<&'static str> = $module;
@@ -210,29 +164,24 @@ macro_rules! pyobject_native_type_info(
 
             $(
                 #[inline]
-                fn is_type_of_bound(obj: &$crate::Bound<'_, $crate::PyAny>) -> bool {
-                    #[allow(unused_unsafe)]
+                fn is_type_of(obj: &$crate::Bound<'_, $crate::PyAny>) -> bool {
+                    #[allow(unused_unsafe)] // not all `$checkfunction` are unsafe extern "C" fn
+                    // SAFETY: `$checkfunction` is being called with a valid `PyObject` pointer
                     unsafe { $checkfunction(obj.as_ptr()) > 0 }
                 }
             )?
         }
-    };
-);
 
-// NOTE: This macro is not included in pyobject_native_type_base!
-// because rust-numpy has a special implementation.
-#[doc(hidden)]
-#[macro_export]
-macro_rules! pyobject_native_type_extract {
-    ($name:ty $(;$generics:ident)*) => {
-        impl<'py, $($generics,)*> $crate::FromPyObject<'py> for &'py $name {
-            #[inline]
-            fn extract_bound(obj: &$crate::Bound<'py, $crate::PyAny>) -> $crate::PyResult<Self> {
-                ::std::clone::Clone::clone(obj).into_gil_ref().downcast().map_err(::std::convert::Into::into)
-            }
+        impl $name {
+            #[doc(hidden)]
+            pub const _PYO3_DEF: $crate::impl_::pymodule::AddTypeToModule<Self> = $crate::impl_::pymodule::AddTypeToModule::new();
+
+            #[allow(dead_code)]
+            #[doc(hidden)]
+            pub const _PYO3_INTROSPECTION_ID: &'static str = concat!(stringify!($module), stringify!($name));
         }
-    }
-}
+    };
+);
 
 /// Declares all of the boilerplate for Python types.
 #[doc(hidden)]
@@ -241,7 +190,6 @@ macro_rules! pyobject_native_type_core {
     ($name:ty, $typeobject:expr, #module=$module:expr $(, #checkfunction=$checkfunction:path)? $(;$generics:ident)*) => {
         $crate::pyobject_native_type_named!($name $(;$generics)*);
         $crate::pyobject_native_type_info!($name, $typeobject, $module $(, #checkfunction=$checkfunction)? $(;$generics)*);
-        $crate::pyobject_native_type_extract!($name $(;$generics)*);
     };
     ($name:ty, $typeobject:expr $(, #checkfunction=$checkfunction:path)? $(;$generics:ident)*) => {
         $crate::pyobject_native_type_core!($name, $typeobject, #module=::std::option::Option::Some("builtins") $(, #checkfunction=$checkfunction)? $(;$generics)*);
@@ -250,19 +198,27 @@ macro_rules! pyobject_native_type_core {
 
 #[doc(hidden)]
 #[macro_export]
-macro_rules! pyobject_native_type_sized {
+macro_rules! pyobject_subclassable_native_type {
     ($name:ty, $layout:path $(;$generics:ident)*) => {
-        unsafe impl $crate::type_object::PyLayout<$name> for $layout {}
-        impl $crate::type_object::PySizedLayout<$name> for $layout {}
+        #[cfg(not(Py_LIMITED_API))]
         impl<$($generics,)*> $crate::impl_::pyclass::PyClassBaseType for $name {
-            type LayoutAsBase = $crate::pycell::PyCellBase<$layout>;
+            type LayoutAsBase = $crate::impl_::pycell::PyClassObjectBase<$layout>;
             type BaseNativeType = $name;
-            type Initializer = $crate::pyclass_init::PyNativeTypeInitializer<Self>;
+            type Initializer = $crate::impl_::pyclass_init::PyNativeTypeInitializer<Self>;
             type PyClassMutability = $crate::pycell::impl_::ImmutableClass;
         }
     }
 }
 
+#[doc(hidden)]
+#[macro_export]
+macro_rules! pyobject_native_type_sized {
+    ($name:ty, $layout:path $(;$generics:ident)*) => {
+        unsafe impl $crate::type_object::PyLayout<$name> for $layout {}
+        impl $crate::type_object::PySizedLayout<$name> for $layout {}
+    };
+}
+
 /// Declares all of the boilerplate for Python types which can be inherited from (because the exact
 /// Python layout is known).
 #[doc(hidden)]
@@ -281,32 +237,37 @@ pub(crate) mod boolobject;
 pub(crate) mod bytearray;
 pub(crate) mod bytes;
 pub(crate) mod capsule;
-#[cfg(not(Py_LIMITED_API))]
 mod code;
-mod complex;
-#[cfg(not(Py_LIMITED_API))]
+pub(crate) mod complex;
 pub(crate) mod datetime;
 pub(crate) mod dict;
 mod ellipsis;
 pub(crate) mod float;
-#[cfg(all(not(Py_LIMITED_API), not(PyPy)))]
+#[cfg(all(not(Py_LIMITED_API), not(PyPy), not(GraalPy)))]
 mod frame;
 pub(crate) mod frozenset;
 mod function;
+#[cfg(Py_3_9)]
+pub(crate) mod genericalias;
 pub(crate) mod iterator;
 pub(crate) mod list;
 pub(crate) mod mapping;
+pub(crate) mod mappingproxy;
 mod memoryview;
 pub(crate) mod module;
+#[cfg(all(not(Py_LIMITED_API), Py_3_13))]
+mod mutex;
 mod none;
 mod notimplemented;
 mod num;
-#[cfg(not(PyPy))]
+#[cfg(not(any(PyPy, GraalPy)))]
 mod pysuper;
+pub(crate) mod range;
 pub(crate) mod sequence;
 pub(crate) mod set;
-mod slice;
+pub(crate) mod slice;
 pub(crate) mod string;
 pub(crate) mod traceback;
 pub(crate) mod tuple;
-mod typeobject;
+pub(crate) mod typeobject;
+pub(crate) mod weakref;
diff --git a/src/types/module.rs b/src/types/module.rs
index 8824dfcf030..82f3f176180 100644
--- a/src/types/module.rs
+++ b/src/types/module.rs
@@ -1,16 +1,27 @@
-use crate::callback::IntoPyCallbackOutput;
 use crate::err::{PyErr, PyResult};
 use crate::ffi_ptr_ext::FfiPtrExt;
+use crate::impl_::callback::IntoPyCallbackOutput;
+use crate::py_result_ext::PyResultExt;
 use crate::pyclass::PyClass;
 use crate::types::{
     any::PyAnyMethods, list::PyListMethods, PyAny, PyCFunction, PyDict, PyList, PyString,
 };
-use crate::{exceptions, ffi, Bound, FromPyObject, IntoPy, Py, PyNativeType, PyObject, Python};
-use std::ffi::CString;
+use crate::{
+    exceptions, ffi, Borrowed, Bound, BoundObject, IntoPyObject, IntoPyObjectExt, Py, Python,
+};
+#[cfg(all(not(Py_LIMITED_API), Py_GIL_DISABLED))]
+use std::ffi::c_int;
+use std::ffi::CStr;
 use std::str;
 
 /// Represents a Python [`module`][1] object.
 ///
+/// Values of this type are accessed via PyO3's smart pointers, e.g. as
+/// [`Py<PyModule>`][crate::Py] or [`Bound<'py, PyModule>`][Bound].
+///
+/// For APIs available on `module` objects, see the [`PyModuleMethods`] trait which is implemented for
+/// [`Bound<'py, PyModule>`][Bound].
+///
 /// As with all other Python objects, modules are first class citizens.
 /// This means they can be passed to or returned from functions,
 /// created dynamically, assigned to variables and so forth.
@@ -30,7 +41,7 @@ impl PyModule {
     /// use pyo3::prelude::*;
     ///
     /// # fn main() -> PyResult<()> {
-    /// Python::with_gil(|py| -> PyResult<()> {
+    /// Python::attach(|py| -> PyResult<()> {
     ///     let module = PyModule::new(py, "my_module")?;
     ///
     ///     assert_eq!(module.name()?, "my_module");
@@ -38,10 +49,13 @@ impl PyModule {
     /// })?;
     /// # Ok(())}
     ///  ```
-    pub fn new<'p>(py: Python<'p>, name: &str) -> PyResult<&'p PyModule> {
-        // Could use PyModule_NewObject, but it doesn't exist on PyPy.
-        let name = CString::new(name)?;
-        unsafe { py.from_owned_ptr_or_err(ffi::PyModule_New(name.as_ptr())) }
+    pub fn new<'py>(py: Python<'py>, name: &str) -> PyResult<Bound<'py, PyModule>> {
+        let name = PyString::new(py, name);
+        unsafe {
+            ffi::PyModule_NewObject(name.as_ptr())
+                .assume_owned_or_err(py)
+                .cast_into_unchecked()
+        }
     }
 
     /// Imports the Python module with the specified name.
@@ -52,7 +66,7 @@ impl PyModule {
     /// # fn main() {
     /// use pyo3::prelude::*;
     ///
-    /// Python::with_gil(|py| {
+    /// Python::attach(|py| {
     ///     let module = PyModule::import(py, "antigravity").expect("No flying for you.");
     /// });
     /// # }
@@ -62,18 +76,27 @@ impl PyModule {
     /// ```python
     /// import antigravity
     /// ```
-    pub fn import<N>(py: Python<'_>, name: N) -> PyResult<&PyModule>
+    ///
+    /// If you want to import a class, you can store a reference to it with
+    /// [`PyOnceLock::import`][crate::sync::PyOnceLock::import].
+    pub fn import<'py, N>(py: Python<'py>, name: N) -> PyResult<Bound<'py, PyModule>>
     where
-        N: IntoPy<Py<PyString>>,
+        N: IntoPyObject<'py, Target = PyString>,
     {
-        let name: Py<PyString> = name.into_py(py);
-        unsafe { py.from_owned_ptr_or_err(ffi::PyImport_Import(name.as_ptr())) }
+        let name = name.into_pyobject_or_pyerr(py)?;
+        unsafe {
+            ffi::PyImport_Import(name.as_ptr())
+                .assume_owned_or_err(py)
+                .cast_into_unchecked()
+        }
     }
 
     /// Creates and loads a module named `module_name`,
     /// containing the Python code passed to `code`
     /// and pretending to live at `file_name`.
     ///
+    /// If `file_name` is empty, it will be set to `<string>`.
+    ///
     /// <div class="information">
     ///     <div class="tooltip compile_fail" style="">&#x26a0; &#xfe0f;</div>
     /// </div><div class="example-wrap" style="display:inline-block"><pre class="compile_fail" style="white-space:normal;font:inherit;">
@@ -87,19 +110,20 @@ impl PyModule {
     /// Returns `PyErr` if:
     /// - `code` is not syntactically correct Python.
     /// - Any Python exceptions are raised while initializing the module.
-    /// - Any of the arguments cannot be converted to [`CString`]s.
+    /// - Any of the arguments cannot be converted to [`CString`][std::ffi::CString]s.
     ///
     /// # Example: bundle in a file at compile time with [`include_str!`][std::include_str]:
     ///
     /// ```rust
     /// use pyo3::prelude::*;
+    /// use pyo3::ffi::c_str;
     ///
     /// # fn main() -> PyResult<()> {
     /// // This path is resolved relative to this file.
-    /// let code = include_str!("../../assets/script.py");
+    /// let code = c_str!(include_str!("../../assets/script.py"));
     ///
-    /// Python::with_gil(|py| -> PyResult<()> {
-    ///     PyModule::from_code(py, code, "example.py", "example")?;
+    /// Python::attach(|py| -> PyResult<()> {
+    ///     PyModule::from_code(py, code, c"example.py", c"example")?;
     ///     Ok(())
     /// })?;
     /// # Ok(())
@@ -110,247 +134,45 @@ impl PyModule {
     ///
     /// ```rust
     /// use pyo3::prelude::*;
+    /// use pyo3::ffi::c_str;
+    /// use std::ffi::CString;
     ///
     /// # fn main() -> PyResult<()> {
+    /// # #[cfg(not(target_arch = "wasm32"))]  // node fs doesn't see this file, maybe cwd wrong?
+    /// # {
     /// // This path is resolved by however the platform resolves paths,
     /// // which also makes this less portable. Consider using `include_str`
     /// // if you just want to bundle a script with your module.
     /// let code = std::fs::read_to_string("assets/script.py")?;
     ///
-    /// Python::with_gil(|py| -> PyResult<()> {
-    ///     PyModule::from_code(py, &code, "example.py", "example")?;
+    /// Python::attach(|py| -> PyResult<()> {
+    ///     PyModule::from_code(py, CString::new(code)?.as_c_str(), c"example.py", c"example")?;
     ///     Ok(())
     /// })?;
-    /// Ok(())
+    /// # }
+    /// # Ok(())
     /// # }
     /// ```
-    pub fn from_code<'p>(
-        py: Python<'p>,
-        code: &str,
-        file_name: &str,
-        module_name: &str,
-    ) -> PyResult<&'p PyModule> {
-        let data = CString::new(code)?;
-        let filename = CString::new(file_name)?;
-        let module = CString::new(module_name)?;
-
+    pub fn from_code<'py>(
+        py: Python<'py>,
+        code: &CStr,
+        file_name: &CStr,
+        module_name: &CStr,
+    ) -> PyResult<Bound<'py, PyModule>> {
+        let file_name = if file_name.is_empty() {
+            c"<string>"
+        } else {
+            file_name
+        };
         unsafe {
-            let cptr = ffi::Py_CompileString(data.as_ptr(), filename.as_ptr(), ffi::Py_file_input);
-            if cptr.is_null() {
-                return Err(PyErr::fetch(py));
-            }
-
-            let mptr = ffi::PyImport_ExecCodeModuleEx(module.as_ptr(), cptr, filename.as_ptr());
-            ffi::Py_DECREF(cptr);
-            if mptr.is_null() {
-                return Err(PyErr::fetch(py));
-            }
+            let code = ffi::Py_CompileString(code.as_ptr(), file_name.as_ptr(), ffi::Py_file_input)
+                .assume_owned_or_err(py)?;
 
-            <&PyModule as FromPyObject>::extract(py.from_owned_ptr_or_err(mptr)?)
+            ffi::PyImport_ExecCodeModuleEx(module_name.as_ptr(), code.as_ptr(), file_name.as_ptr())
+                .assume_owned_or_err(py)
+                .cast_into()
         }
     }
-
-    /// Returns the module's `__dict__` attribute, which contains the module's symbol table.
-    pub fn dict(&self) -> &PyDict {
-        self.as_borrowed().dict().into_gil_ref()
-    }
-
-    /// Returns the index (the `__all__` attribute) of the module,
-    /// creating one if needed.
-    ///
-    /// `__all__` declares the items that will be imported with `from my_module import *`.
-    pub fn index(&self) -> PyResult<&PyList> {
-        self.as_borrowed().index().map(Bound::into_gil_ref)
-    }
-
-    /// Returns the name (the `__name__` attribute) of the module.
-    ///
-    /// May fail if the module does not have a `__name__` attribute.
-    pub fn name(&self) -> PyResult<&str> {
-        self.as_borrowed().name()?.into_gil_ref().to_str()
-    }
-
-    /// Returns the filename (the `__file__` attribute) of the module.
-    ///
-    /// May fail if the module does not have a `__file__` attribute.
-    #[cfg(not(PyPy))]
-    pub fn filename(&self) -> PyResult<&str> {
-        self.as_borrowed().filename()?.into_gil_ref().to_str()
-    }
-
-    /// Adds an attribute to the module.
-    ///
-    /// For adding classes, functions or modules, prefer to use [`PyModule::add_class`],
-    /// [`PyModule::add_function`] or [`PyModule::add_submodule`] instead, respectively.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// use pyo3::prelude::*;
-    ///
-    /// #[pymodule]
-    /// fn my_module(_py: Python<'_>, module: &PyModule) -> PyResult<()> {
-    ///     module.add("c", 299_792_458)?;
-    ///     Ok(())
-    /// }
-    /// ```
-    ///
-    /// Python code can then do the following:
-    ///
-    /// ```python
-    /// from my_module import c
-    ///
-    /// print("c is", c)
-    /// ```
-    ///
-    /// This will result in the following output:
-    ///
-    /// ```text
-    /// c is 299792458
-    /// ```
-    pub fn add<V>(&self, name: &str, value: V) -> PyResult<()>
-    where
-        V: IntoPy<PyObject>,
-    {
-        self.as_borrowed().add(name, value)
-    }
-
-    /// Adds a new class to the module.
-    ///
-    /// Notice that this method does not take an argument.
-    /// Instead, this method is *generic*, and requires us to use the
-    /// "turbofish" syntax to specify the class we want to add.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// use pyo3::prelude::*;
-    ///
-    /// #[pyclass]
-    /// struct Foo { /* fields omitted */ }
-    ///
-    /// #[pymodule]
-    /// fn my_module(_py: Python<'_>, module: &PyModule) -> PyResult<()> {
-    ///     module.add_class::<Foo>()?;
-    ///     Ok(())
-    /// }
-    ///  ```
-    ///
-    /// Python code can see this class as such:
-    /// ```python
-    /// from my_module import Foo
-    ///
-    /// print("Foo is", Foo)
-    /// ```
-    ///
-    /// This will result in the following output:
-    /// ```text
-    /// Foo is <class 'builtins.Foo'>
-    /// ```
-    ///
-    /// Note that as we haven't defined a [constructor][1], Python code can't actually
-    /// make an *instance* of `Foo` (or *get* one for that matter, as we haven't exported
-    /// anything that can return instances of `Foo`).
-    ///
-    /// [1]: https://pyo3.rs/latest/class.html#constructor
-    pub fn add_class<T>(&self) -> PyResult<()>
-    where
-        T: PyClass,
-    {
-        self.as_borrowed().add_class::<T>()
-    }
-
-    /// Adds a function or a (sub)module to a module, using the functions name as name.
-    ///
-    /// Prefer to use [`PyModule::add_function`] and/or [`PyModule::add_submodule`] instead.
-    pub fn add_wrapped<'a, T>(&'a self, wrapper: &impl Fn(Python<'a>) -> T) -> PyResult<()>
-    where
-        T: IntoPyCallbackOutput<PyObject>,
-    {
-        self.as_borrowed().add_wrapped(wrapper)
-    }
-
-    /// Adds a submodule to a module.
-    ///
-    /// This is especially useful for creating module hierarchies.
-    ///
-    /// Note that this doesn't define a *package*, so this won't allow Python code
-    /// to directly import submodules by using
-    /// <span style="white-space: pre">`from my_module import submodule`</span>.
-    /// For more information, see [#759][1] and [#1517][2].
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// use pyo3::prelude::*;
-    ///
-    /// #[pymodule]
-    /// fn my_module(py: Python<'_>, module: &PyModule) -> PyResult<()> {
-    ///     let submodule = PyModule::new(py, "submodule")?;
-    ///     submodule.add("super_useful_constant", "important")?;
-    ///
-    ///     module.add_submodule(submodule)?;
-    ///     Ok(())
-    /// }
-    /// ```
-    ///
-    /// Python code can then do the following:
-    ///
-    /// ```python
-    /// import my_module
-    ///
-    /// print("super_useful_constant is", my_module.submodule.super_useful_constant)
-    /// ```
-    ///
-    /// This will result in the following output:
-    ///
-    /// ```text
-    /// super_useful_constant is important
-    /// ```
-    ///
-    /// [1]: https://github.com/PyO3/pyo3/issues/759
-    /// [2]: https://github.com/PyO3/pyo3/issues/1517#issuecomment-808664021
-    pub fn add_submodule(&self, module: &PyModule) -> PyResult<()> {
-        self.as_borrowed().add_submodule(&module.as_borrowed())
-    }
-
-    /// Add a function to a module.
-    ///
-    /// Note that this also requires the [`wrap_pyfunction!`][2] macro
-    /// to wrap a function annotated with [`#[pyfunction]`][1].
-    ///
-    /// ```rust
-    /// use pyo3::prelude::*;
-    ///
-    /// #[pyfunction]
-    /// fn say_hello() {
-    ///     println!("Hello world!")
-    /// }
-    /// #[pymodule]
-    /// fn my_module(_py: Python<'_>, module: &PyModule) -> PyResult<()> {
-    ///     module.add_function(wrap_pyfunction!(say_hello, module)?)
-    /// }
-    /// ```
-    ///
-    /// Python code can then do the following:
-    ///
-    /// ```python
-    /// from my_module import say_hello
-    ///
-    /// say_hello()
-    /// ```
-    ///
-    /// This will result in the following output:
-    ///
-    /// ```text
-    /// Hello world!
-    /// ```
-    ///
-    /// [1]: crate::prelude::pyfunction
-    /// [2]: crate::wrap_pyfunction
-    pub fn add_function<'a>(&'a self, fun: &'a PyCFunction) -> PyResult<()> {
-        self.as_borrowed().add_function(&fun.as_borrowed())
-    }
 }
 
 /// Implementation of functionality for [`PyModule`].
@@ -359,7 +181,7 @@ impl PyModule {
 /// syntax these methods are separated into a trait, because stable Rust does not yet support
 /// `arbitrary_self_types`.
 #[doc(alias = "PyModule")]
-pub trait PyModuleMethods<'py> {
+pub trait PyModuleMethods<'py>: crate::sealed::Sealed {
     /// Returns the module's `__dict__` attribute, which contains the module's symbol table.
     fn dict(&self) -> Bound<'py, PyDict>;
 
@@ -377,21 +199,21 @@ pub trait PyModuleMethods<'py> {
     /// Returns the filename (the `__file__` attribute) of the module.
     ///
     /// May fail if the module does not have a `__file__` attribute.
-    #[cfg(not(PyPy))]
     fn filename(&self) -> PyResult<Bound<'py, PyString>>;
 
     /// Adds an attribute to the module.
     ///
-    /// For adding classes, functions or modules, prefer to use [`PyModule::add_class`],
-    /// [`PyModule::add_function`] or [`PyModule::add_submodule`] instead, respectively.
+    /// For adding classes, functions or modules, prefer to use [`PyModuleMethods::add_class`],
+    /// [`PyModuleMethods::add_function`] or [`PyModuleMethods::add_submodule`] instead,
+    /// respectively.
     ///
     /// # Examples
     ///
-    /// ```rust
+    /// ```rust,no_run
     /// use pyo3::prelude::*;
     ///
     /// #[pymodule]
-    /// fn my_module(_py: Python<'_>, module: &PyModule) -> PyResult<()> {
+    /// fn my_module(module: &Bound<'_, PyModule>) -> PyResult<()> {
     ///     module.add("c", 299_792_458)?;
     ///     Ok(())
     /// }
@@ -412,8 +234,8 @@ pub trait PyModuleMethods<'py> {
     /// ```
     fn add<N, V>(&self, name: N, value: V) -> PyResult<()>
     where
-        N: IntoPy<Py<PyString>>,
-        V: IntoPy<PyObject>;
+        N: IntoPyObject<'py, Target = PyString>,
+        V: IntoPyObject<'py>;
 
     /// Adds a new class to the module.
     ///
@@ -423,14 +245,14 @@ pub trait PyModuleMethods<'py> {
     ///
     /// # Examples
     ///
-    /// ```rust
+    /// ```rust,no_run
     /// use pyo3::prelude::*;
     ///
     /// #[pyclass]
     /// struct Foo { /* fields omitted */ }
     ///
     /// #[pymodule]
-    /// fn my_module(_py: Python<'_>, module: &PyModule) -> PyResult<()> {
+    /// fn my_module(module: &Bound<'_, PyModule>) -> PyResult<()> {
     ///     module.add_class::<Foo>()?;
     ///     Ok(())
     /// }
@@ -452,17 +274,18 @@ pub trait PyModuleMethods<'py> {
     /// make an *instance* of `Foo` (or *get* one for that matter, as we haven't exported
     /// anything that can return instances of `Foo`).
     ///
-    /// [1]: https://pyo3.rs/latest/class.html#constructor
+    #[doc = concat!("[1]: https://pyo3.rs/v", env!("CARGO_PKG_VERSION"), "/class.html#constructor")]
     fn add_class<T>(&self) -> PyResult<()>
     where
         T: PyClass;
 
     /// Adds a function or a (sub)module to a module, using the functions name as name.
     ///
-    /// Prefer to use [`PyModule::add_function`] and/or [`PyModule::add_submodule`] instead.
+    /// Prefer to use [`PyModuleMethods::add_function`] and/or [`PyModuleMethods::add_submodule`]
+    /// instead.
     fn add_wrapped<T>(&self, wrapper: &impl Fn(Python<'py>) -> T) -> PyResult<()>
     where
-        T: IntoPyCallbackOutput<PyObject>;
+        T: IntoPyCallbackOutput<'py, Py<PyAny>>;
 
     /// Adds a submodule to a module.
     ///
@@ -475,15 +298,15 @@ pub trait PyModuleMethods<'py> {
     ///
     /// # Examples
     ///
-    /// ```rust
+    /// ```rust,no_run
     /// use pyo3::prelude::*;
     ///
     /// #[pymodule]
-    /// fn my_module(py: Python<'_>, module: &PyModule) -> PyResult<()> {
+    /// fn my_module(py: Python<'_>, module: &Bound<'_, PyModule>) -> PyResult<()> {
     ///     let submodule = PyModule::new(py, "submodule")?;
     ///     submodule.add("super_useful_constant", "important")?;
     ///
-    ///     module.add_submodule(submodule)?;
+    ///     module.add_submodule(&submodule)?;
     ///     Ok(())
     /// }
     /// ```
@@ -511,7 +334,7 @@ pub trait PyModuleMethods<'py> {
     /// Note that this also requires the [`wrap_pyfunction!`][2] macro
     /// to wrap a function annotated with [`#[pyfunction]`][1].
     ///
-    /// ```rust
+    /// ```rust,no_run
     /// use pyo3::prelude::*;
     ///
     /// #[pyfunction]
@@ -519,7 +342,7 @@ pub trait PyModuleMethods<'py> {
     ///     println!("Hello world!")
     /// }
     /// #[pymodule]
-    /// fn my_module(_py: Python<'_>, module: &PyModule) -> PyResult<()> {
+    /// fn my_module(module: &Bound<'_, PyModule>) -> PyResult<()> {
     ///     module.add_function(wrap_pyfunction!(say_hello, module)?)
     /// }
     /// ```
@@ -540,7 +363,41 @@ pub trait PyModuleMethods<'py> {
     ///
     /// [1]: crate::prelude::pyfunction
     /// [2]: crate::wrap_pyfunction
-    fn add_function(&self, fun: &Bound<'_, PyCFunction>) -> PyResult<()>;
+    fn add_function(&self, fun: Bound<'_, PyCFunction>) -> PyResult<()>;
+
+    /// Declare whether or not this module supports running with the GIL disabled
+    ///
+    /// If the module does not rely on the GIL for thread safety, you can pass
+    /// `false` to this function to indicate the module does not rely on the GIL
+    /// for thread-safety.
+    ///
+    /// This function sets the [`Py_MOD_GIL`
+    /// slot](https://docs.python.org/3/c-api/module.html#c.Py_mod_gil) on the
+    /// module object. The default is `Py_MOD_GIL_USED`, so passing `true` to
+    /// this function is a no-op unless you have already set `Py_MOD_GIL` to
+    /// `Py_MOD_GIL_NOT_USED` elsewhere.
+    ///
+    /// # Examples
+    ///
+    /// ```rust,no_run
+    /// use pyo3::prelude::*;
+    ///
+    /// #[pymodule(gil_used = false)]
+    /// fn my_module(py: Python<'_>, module: &Bound<'_, PyModule>) -> PyResult<()> {
+    ///     let submodule = PyModule::new(py, "submodule")?;
+    ///     submodule.gil_used(false)?;
+    ///     module.add_submodule(&submodule)?;
+    ///     Ok(())
+    /// }
+    /// ```
+    ///
+    /// The resulting module will not print a `RuntimeWarning` and re-enable the
+    /// GIL when Python imports it on the free-threaded build, since all module
+    /// objects defined in the extension have `Py_MOD_GIL` set to
+    /// `Py_MOD_GIL_NOT_USED`.
+    ///
+    /// This is a no-op on the GIL-enabled build.
+    fn gil_used(&self, gil_used: bool) -> PyResult<()>;
 }
 
 impl<'py> PyModuleMethods<'py> for Bound<'py, PyModule> {
@@ -550,18 +407,18 @@ impl<'py> PyModuleMethods<'py> for Bound<'py, PyModule> {
             ffi::PyModule_GetDict(self.as_ptr())
                 .assume_borrowed(self.py())
                 .to_owned()
-                .downcast_into_unchecked()
+                .cast_into_unchecked()
         }
     }
 
     fn index(&self) -> PyResult<Bound<'py, PyList>> {
         let __all__ = __all__(self.py());
         match self.getattr(__all__) {
-            Ok(idx) => idx.downcast_into().map_err(PyErr::from),
+            Ok(idx) => idx.cast_into().map_err(PyErr::from),
             Err(err) => {
                 if err.is_instance_of::<exceptions::PyAttributeError>(self.py()) {
-                    let l = PyList::empty_bound(self.py());
-                    self.setattr(__all__, &l).map_err(PyErr::from)?;
+                    let l = PyList::empty(self.py());
+                    self.setattr(__all__, &l)?;
                     Ok(l)
                 } else {
                     Err(err)
@@ -573,12 +430,10 @@ impl<'py> PyModuleMethods<'py> for Bound<'py, PyModule> {
     fn name(&self) -> PyResult<Bound<'py, PyString>> {
         #[cfg(not(PyPy))]
         {
-            use crate::py_result_ext::PyResultExt;
-
             unsafe {
                 ffi::PyModule_GetNameObject(self.as_ptr())
                     .assume_owned_or_err(self.py())
-                    .downcast_into_unchecked()
+                    .cast_into_unchecked()
             }
         }
 
@@ -587,44 +442,51 @@ impl<'py> PyModuleMethods<'py> for Bound<'py, PyModule> {
             self.dict()
                 .get_item("__name__")
                 .map_err(|_| exceptions::PyAttributeError::new_err("__name__"))?
-                .downcast_into()
+                .cast_into()
                 .map_err(PyErr::from)
         }
     }
 
-    #[cfg(not(PyPy))]
     fn filename(&self) -> PyResult<Bound<'py, PyString>> {
-        use crate::py_result_ext::PyResultExt;
-
+        #[cfg(not(PyPy))]
         unsafe {
             ffi::PyModule_GetFilenameObject(self.as_ptr())
                 .assume_owned_or_err(self.py())
-                .downcast_into_unchecked()
+                .cast_into_unchecked()
+        }
+
+        #[cfg(PyPy)]
+        {
+            self.dict()
+                .get_item("__file__")
+                .map_err(|_| exceptions::PyAttributeError::new_err("__file__"))?
+                .cast_into()
+                .map_err(PyErr::from)
         }
     }
 
     fn add<N, V>(&self, name: N, value: V) -> PyResult<()>
     where
-        N: IntoPy<Py<PyString>>,
-        V: IntoPy<PyObject>,
+        N: IntoPyObject<'py, Target = PyString>,
+        V: IntoPyObject<'py>,
     {
         fn inner(
             module: &Bound<'_, PyModule>,
-            name: Bound<'_, PyString>,
-            value: Bound<'_, PyAny>,
+            name: Borrowed<'_, '_, PyString>,
+            value: Borrowed<'_, '_, PyAny>,
         ) -> PyResult<()> {
             module
                 .index()?
-                .append(&name)
+                .append(name)
                 .expect("could not append __name__ to __all__");
-            module.setattr(name, value.into_py(module.py()))
+            module.setattr(name, value)
         }
 
         let py = self.py();
         inner(
             self,
-            name.into_py(py).into_bound(py),
-            value.into_py(py).into_bound(py),
+            name.into_pyobject_or_pyerr(py)?.as_borrowed(),
+            value.into_pyobject_or_pyerr(py)?.into_any().as_borrowed(),
         )
     }
 
@@ -638,11 +500,11 @@ impl<'py> PyModuleMethods<'py> for Bound<'py, PyModule> {
 
     fn add_wrapped<T>(&self, wrapper: &impl Fn(Python<'py>) -> T) -> PyResult<()>
     where
-        T: IntoPyCallbackOutput<PyObject>,
+        T: IntoPyCallbackOutput<'py, Py<PyAny>>,
     {
         fn inner(module: &Bound<'_, PyModule>, object: Bound<'_, PyAny>) -> PyResult<()> {
             let name = object.getattr(__name__(module.py()))?;
-            module.add(name.downcast_into::<PyString>()?, object)
+            module.add(name.cast_into::<PyString>()?, object)
         }
 
         let py = self.py();
@@ -654,9 +516,26 @@ impl<'py> PyModuleMethods<'py> for Bound<'py, PyModule> {
         self.add(name, module)
     }
 
-    fn add_function(&self, fun: &Bound<'_, PyCFunction>) -> PyResult<()> {
+    fn add_function(&self, fun: Bound<'_, PyCFunction>) -> PyResult<()> {
         let name = fun.getattr(__name__(self.py()))?;
-        self.add(name.downcast_into::<PyString>()?, fun)
+        self.add(name.cast_into::<PyString>()?, fun)
+    }
+
+    #[cfg_attr(any(Py_LIMITED_API, not(Py_GIL_DISABLED)), allow(unused_variables))]
+    fn gil_used(&self, gil_used: bool) -> PyResult<()> {
+        #[cfg(all(not(Py_LIMITED_API), Py_GIL_DISABLED))]
+        {
+            let gil_used = match gil_used {
+                true => ffi::Py_MOD_GIL_USED,
+                false => ffi::Py_MOD_GIL_NOT_USED,
+            };
+            match unsafe { ffi::PyUnstable_Module_SetGIL(self.as_ptr(), gil_used) } {
+                c_int::MIN..=-1 => Err(PyErr::fetch(self.py())),
+                0..=c_int::MAX => Ok(()),
+            }
+        }
+        #[cfg(any(Py_LIMITED_API, not(Py_GIL_DISABLED)))]
+        Ok(())
     }
 }
 
@@ -670,22 +549,38 @@ fn __name__(py: Python<'_>) -> &Bound<'_, PyString> {
 
 #[cfg(test)]
 mod tests {
-    use crate::{types::PyModule, Python};
+    use crate::{
+        types::{module::PyModuleMethods, PyModule},
+        Python,
+    };
 
     #[test]
     fn module_import_and_name() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let builtins = PyModule::import(py, "builtins").unwrap();
             assert_eq!(builtins.name().unwrap(), "builtins");
         })
     }
 
     #[test]
-    #[cfg(not(PyPy))]
     fn module_filename() {
-        Python::with_gil(|py| {
+        use crate::types::string::PyStringMethods;
+        Python::attach(|py| {
             let site = PyModule::import(py, "site").unwrap();
-            assert!(site.filename().unwrap().ends_with("site.py"));
+            assert!(site
+                .filename()
+                .unwrap()
+                .to_cow()
+                .unwrap()
+                .ends_with("site.py"));
+        })
+    }
+
+    #[test]
+    fn module_from_code_empty_file() {
+        Python::attach(|py| {
+            let builtins = PyModule::from_code(py, c"", c"", c"").unwrap();
+            assert_eq!(builtins.filename().unwrap(), "<string>");
         })
     }
 }
diff --git a/src/types/mutex.rs b/src/types/mutex.rs
new file mode 100644
index 00000000000..fe9f9e436f3
--- /dev/null
+++ b/src/types/mutex.rs
@@ -0,0 +1,468 @@
+use std::cell::UnsafeCell;
+use std::marker::PhantomData;
+use std::ops::{Deref, DerefMut};
+#[cfg(panic = "unwind")]
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::{LockResult, PoisonError};
+#[cfg(panic = "unwind")]
+use std::thread;
+
+// See std::sync::poison in the rust standard library.
+// This is more-or-less copied from there since it is not public.
+// this type detects a panic and poisons the wrapping mutex
+struct Flag {
+    #[cfg(panic = "unwind")]
+    failed: AtomicBool,
+}
+
+impl Flag {
+    #[inline]
+    const fn new() -> Flag {
+        Flag {
+            #[cfg(panic = "unwind")]
+            failed: AtomicBool::new(false),
+        }
+    }
+
+    /// Checks the flag for an unguarded borrow, where we only care about existing poison.
+    #[inline]
+    fn borrow(&self) -> LockResult<()> {
+        if self.get() {
+            Err(PoisonError::new(()))
+        } else {
+            Ok(())
+        }
+    }
+
+    /// Checks the flag for a guarded borrow, where we may also set poison when `done`.
+    #[inline]
+    fn guard(&self) -> LockResult<Guard> {
+        let ret = Guard {
+            #[cfg(panic = "unwind")]
+            panicking: thread::panicking(),
+        };
+        if self.get() {
+            Err(PoisonError::new(ret))
+        } else {
+            Ok(ret)
+        }
+    }
+
+    #[inline]
+    #[cfg(panic = "unwind")]
+    fn done(&self, guard: &Guard) {
+        if !guard.panicking && thread::panicking() {
+            self.failed.store(true, Ordering::Relaxed);
+        }
+    }
+
+    #[inline]
+    #[cfg(not(panic = "unwind"))]
+    fn done(&self, _guard: &Guard) {}
+
+    #[inline]
+    #[cfg(panic = "unwind")]
+    fn get(&self) -> bool {
+        self.failed.load(Ordering::Relaxed)
+    }
+
+    #[inline(always)]
+    #[cfg(not(panic = "unwind"))]
+    fn get(&self) -> bool {
+        false
+    }
+
+    #[inline]
+    fn clear(&self) {
+        #[cfg(panic = "unwind")]
+        self.failed.store(false, Ordering::Relaxed)
+    }
+}
+
+#[derive(Clone)]
+pub(crate) struct Guard {
+    #[cfg(panic = "unwind")]
+    panicking: bool,
+}
+
+/// Wrapper for [`PyMutex`](https://docs.python.org/3/c-api/init.html#c.PyMutex), exposing an RAII guard interface.
+///
+/// Compared with `std::sync::Mutex` or `parking_lot::Mutex`, this is a very
+/// stripped-down locking primitive that only supports blocking lock and unlock
+/// operations and does not support `try_lock` or APIs that depend on
+/// `try_lock`.  For this reason, it is not possible to avoid the possibility of
+/// possibly blocking when calling `lock` and extreme care must be taken to avoid
+/// introducing a deadlock.
+///
+/// This type is most useful when arbitrary Python code might execute while the
+/// lock is held. On the GIL-enabled build, PyMutex will release the GIL if the
+/// thread is blocked on acquiring the lock. On the free-threaded build, threads
+/// blocked on acquiring a PyMutex will not prevent the garbage collector from
+/// running.
+///
+/// ## Poisoning
+///
+/// Like `std::sync::Mutex`, `PyMutex` implements poisoning. A mutex
+/// is considered poisoned whenever a thread panics while holding the mutex. Once
+/// a mutex is poisoned, all other threads are unable to access the data by
+/// default as it is likely to be tainted (some invariant is not being held).
+///
+/// This means that the `lock` method returns a `Result` which indicated whether
+/// the mutex has been poisoned or not. Must usage will simple `unwrap()` these
+/// results, propagating panics among threads to ensure a possible invalid
+/// invariant is not being observed.
+///
+/// A poisoned mutex, however, does not prevent all access to the underlying
+/// data. The `PoisonError` type has an `into_inner` method which will return
+/// the guard that would have otherwise been returned on a successful lock. This
+/// allows access to the data, despite the lock being poisoned.
+pub struct PyMutex<T: ?Sized> {
+    mutex: UnsafeCell<crate::ffi::PyMutex>,
+    poison: Flag,
+    data: UnsafeCell<T>,
+}
+
+/// RAII guard to handle releasing a PyMutex lock.
+///
+/// The lock is released when `PyMutexGuard` is dropped.
+pub struct PyMutexGuard<'a, T: ?Sized> {
+    inner: &'a PyMutex<T>,
+    poison: Guard,
+    // this is equivalent to impl !Send, which we can't do
+    // because negative trait bounds aren't supported yet
+    _phantom: PhantomData<*const ()>,
+}
+
+/// `T` must be `Sync` for a [`PyMutexGuard<T>`] to be `Sync`
+/// because it is possible to get a `&T` from `&MutexGuard` (via `Deref`).
+unsafe impl<T: ?Sized + Sync> Sync for PyMutexGuard<'_, T> {}
+
+/// `T` must be `Send` for a [`PyMutex`] to be `Send` because it is possible to acquire
+/// the owned `T` from the `PyMutex` via [`into_inner`].
+///
+/// [`into_inner`]: PyMutex::into_inner
+unsafe impl<T: ?Sized + Send> Send for PyMutex<T> {}
+
+/// `T` must be `Send` for [`PyMutex`] to be `Sync`.
+/// This ensures that the protected data can be accessed safely from multiple threads
+/// without causing data races or other unsafe behavior.
+///
+/// [`PyMutex<T>`] provides mutable access to `T` to one thread at a time. However, it's essential
+/// for `T` to be `Send` because it's not safe for non-`Send` structures to be accessed in
+/// this manner. For instance, consider [`Rc`], a non-atomic reference counted smart pointer,
+/// which is not `Send`. With `Rc`, we can have multiple copies pointing to the same heap
+/// allocation with a non-atomic reference count. If we were to use `Mutex<Rc<_>>`, it would
+/// only protect one instance of `Rc` from shared access, leaving other copies vulnerable
+/// to potential data races.
+///
+/// Also note that it is not necessary for `T` to be `Sync` as `&T` is only made available
+/// to one thread at a time if `T` is not `Sync`.
+///
+/// [`Rc`]: std::rc::Rc
+unsafe impl<T: ?Sized + Send> Sync for PyMutex<T> {}
+
+impl<T> PyMutex<T> {
+    /// Acquire the mutex, blocking the current thread until it is able to do so.
+    pub fn lock(&self) -> LockResult<PyMutexGuard<'_, T>> {
+        unsafe { crate::ffi::PyMutex_Lock(UnsafeCell::raw_get(&self.mutex)) };
+        PyMutexGuard::new(self)
+    }
+
+    /// Create a new mutex in an unlocked state ready for use.
+    pub const fn new(value: T) -> Self {
+        Self {
+            mutex: UnsafeCell::new(crate::ffi::PyMutex::new()),
+            data: UnsafeCell::new(value),
+            poison: Flag::new(),
+        }
+    }
+
+    /// Check if the mutex is locked.
+    ///
+    /// Note that this is only useful for debugging or test purposes and should
+    /// not be used to make concurrency control decisions, as the lock state may
+    /// change immediately after the check.
+    #[cfg(Py_3_14)]
+    pub fn is_locked(&self) -> bool {
+        let ret = unsafe { crate::ffi::PyMutex_IsLocked(UnsafeCell::raw_get(&self.mutex)) };
+        ret != 0
+    }
+
+    /// Consumes this mutex, returning the underlying data.
+    ///
+    /// # Errors
+    ///
+    /// If another user of this mutex panicked while holding the mutex, then
+    /// this call will return an error containing the underlying data
+    /// instead.
+    pub fn into_inner(self) -> LockResult<T>
+    where
+        T: Sized,
+    {
+        let data = self.data.into_inner();
+        map_result(self.poison.borrow(), |()| data)
+    }
+
+    /// Clear the poisoned state from a mutex.
+    ///
+    /// If the mutex is poisoned, it will remain poisoned until this function is called. This
+    /// allows recovering from a poisoned state and marking that it has recovered. For example, if
+    /// the value is overwritten by a known-good value, then the mutex can be marked as
+    /// un-poisoned. Or possibly, the value could be inspected to determine if it is in a
+    /// consistent state, and if so the poison is removed.
+    pub fn clear_poison(&self) {
+        self.poison.clear();
+    }
+}
+
+#[cfg_attr(not(panic = "unwind"), allow(clippy::unnecessary_wraps))]
+fn map_result<T, U, F>(result: LockResult<T>, f: F) -> LockResult<U>
+where
+    F: FnOnce(T) -> U,
+{
+    match result {
+        Ok(t) => Ok(f(t)),
+        #[cfg(panic = "unwind")]
+        Err(e) => Err(PoisonError::new(f(e.into_inner()))),
+        #[cfg(not(panic = "unwind"))]
+        Err(_) => {
+            unreachable!();
+        }
+    }
+}
+
+impl<'mutex, T: ?Sized> PyMutexGuard<'mutex, T> {
+    fn new(lock: &'mutex PyMutex<T>) -> LockResult<PyMutexGuard<'mutex, T>> {
+        map_result(lock.poison.guard(), |guard| PyMutexGuard {
+            inner: lock,
+            poison: guard,
+            _phantom: PhantomData,
+        })
+    }
+}
+
+impl<'a, T: ?Sized> Drop for PyMutexGuard<'a, T> {
+    fn drop(&mut self) {
+        unsafe {
+            self.inner.poison.done(&self.poison);
+            crate::ffi::PyMutex_Unlock(UnsafeCell::raw_get(&self.inner.mutex))
+        };
+    }
+}
+
+impl<'a, T> Deref for PyMutexGuard<'a, T> {
+    type Target = T;
+
+    fn deref(&self) -> &T {
+        // safety: cannot be null pointer because PyMutex::new always
+        // creates a valid PyMutex pointer
+        unsafe { &*self.inner.data.get() }
+    }
+}
+
+impl<'a, T> DerefMut for PyMutexGuard<'a, T> {
+    fn deref_mut(&mut self) -> &mut T {
+        // safety: cannot be null pointer because PyMutex::new always
+        // creates a valid PyMutex pointer
+        unsafe { &mut *self.inner.data.get() }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    #[cfg(not(target_arch = "wasm32"))]
+    use std::sync::{
+        atomic::{AtomicBool, Ordering},
+        Arc, Barrier,
+    };
+
+    use super::*;
+    #[cfg(not(target_arch = "wasm32"))]
+    use crate::types::{PyAnyMethods, PyDict, PyDictMethods, PyNone};
+    #[cfg(not(target_arch = "wasm32"))]
+    use crate::Py;
+    #[cfg(not(target_arch = "wasm32"))]
+    use crate::Python;
+
+    #[cfg(not(target_arch = "wasm32"))]
+    #[test]
+    fn test_pymutex() {
+        let mutex = Python::attach(|py| -> PyMutex<Py<PyDict>> {
+            let d = PyDict::new(py);
+            PyMutex::new(d.unbind())
+        });
+        #[cfg_attr(not(Py_3_14), allow(unused_variables))]
+        let mutex = Python::attach(|py| {
+            let mutex = py.detach(|| -> PyMutex<Py<PyDict>> {
+                std::thread::spawn(|| {
+                    let dict_guard = mutex.lock().unwrap();
+                    Python::attach(|py| {
+                        let dict = dict_guard.bind(py);
+                        dict.set_item(PyNone::get(py), PyNone::get(py)).unwrap();
+                    });
+                    #[cfg(Py_3_14)]
+                    assert!(mutex.is_locked());
+                    drop(dict_guard);
+                    #[cfg(Py_3_14)]
+                    assert!(!mutex.is_locked());
+                    mutex
+                })
+                .join()
+                .unwrap()
+            });
+
+            let dict_guard = mutex.lock().unwrap();
+            #[cfg(Py_3_14)]
+            assert!(mutex.is_locked());
+            let d = dict_guard.bind(py);
+
+            assert!(d
+                .get_item(PyNone::get(py))
+                .unwrap()
+                .unwrap()
+                .eq(PyNone::get(py))
+                .unwrap());
+            #[cfg(Py_3_14)]
+            assert!(mutex.is_locked());
+            drop(dict_guard);
+            #[cfg(Py_3_14)]
+            assert!(!mutex.is_locked());
+            mutex
+        });
+        #[cfg(Py_3_14)]
+        assert!(!mutex.is_locked());
+    }
+
+    #[cfg(not(target_arch = "wasm32"))]
+    #[test]
+    fn test_pymutex_blocks() {
+        let mutex = PyMutex::new(());
+        let first_thread_locked_once = AtomicBool::new(false);
+        let second_thread_locked_once = AtomicBool::new(false);
+        let finished = AtomicBool::new(false);
+        let barrier = Barrier::new(2);
+
+        std::thread::scope(|s| {
+            s.spawn(|| {
+                let guard = mutex.lock();
+                first_thread_locked_once.store(true, Ordering::SeqCst);
+                while !finished.load(Ordering::SeqCst) {
+                    if second_thread_locked_once.load(Ordering::SeqCst) {
+                        // Wait a little to guard against the unlikely event that
+                        // the other thread isn't blocked on acquiring the mutex yet.
+                        // If PyMutex had a try_lock implementation this would be
+                        // unnecessary
+                        std::thread::sleep(std::time::Duration::from_millis(10));
+                        // block (and hold the mutex) until the receiver actually receives something
+                        barrier.wait();
+                        finished.store(true, Ordering::SeqCst);
+                    }
+                }
+                drop(guard);
+            });
+
+            s.spawn(|| {
+                while !first_thread_locked_once.load(Ordering::SeqCst) {
+                    std::hint::spin_loop();
+                }
+                second_thread_locked_once.store(true, Ordering::SeqCst);
+                let guard = mutex.lock();
+                assert!(finished.load(Ordering::SeqCst));
+                drop(guard);
+            });
+
+            barrier.wait();
+        });
+    }
+
+    #[cfg(not(target_arch = "wasm32"))]
+    #[test]
+    fn test_recover_poison() {
+        let mutex = Python::attach(|py| -> PyMutex<Py<PyDict>> {
+            let d = PyDict::new(py);
+            d.set_item("hello", "world").unwrap();
+            PyMutex::new(d.unbind())
+        });
+
+        let lock = Arc::new(mutex);
+        let lock2 = Arc::clone(&lock);
+
+        let _ = thread::spawn(move || {
+            let _guard = lock2.lock().unwrap();
+
+            // poison the mutex
+            panic!();
+        })
+        .join();
+
+        // by now the lock is poisoned, use into_inner to recover the value despite that
+        let guard = match lock.lock() {
+            Ok(_) => {
+                unreachable!();
+            }
+            Err(poisoned) => poisoned.into_inner(),
+        };
+
+        Python::attach(|py| {
+            assert!(
+                (*guard)
+                    .bind(py)
+                    .get_item("hello")
+                    .unwrap()
+                    .unwrap()
+                    .extract::<&str>()
+                    .unwrap()
+                    == "world"
+            );
+        });
+
+        // now test recovering via PyMutex::into_inner
+        let mutex = PyMutex::new(0);
+        assert_eq!(mutex.into_inner().unwrap(), 0);
+
+        let mutex = PyMutex::new(0);
+        let _ = std::thread::scope(|s| {
+            s.spawn(|| {
+                let _guard = mutex.lock().unwrap();
+
+                // poison the mutex
+                panic!();
+            })
+            .join()
+        });
+
+        match mutex.into_inner() {
+            Ok(_) => {
+                unreachable!()
+            }
+            Err(e) => {
+                assert!(e.into_inner() == 0)
+            }
+        }
+
+        // now test recovering via PyMutex::clear_poison
+        let mutex = PyMutex::new(0);
+        let _ = std::thread::scope(|s| {
+            s.spawn(|| {
+                let _guard = mutex.lock().unwrap();
+
+                // poison the mutex
+                panic!();
+            })
+            .join()
+        });
+        mutex.clear_poison();
+        assert_eq!(*mutex.lock().unwrap(), 0);
+    }
+
+    #[test]
+    fn test_send_not_send() {
+        use crate::impl_::pyclass::{value_of, IsSend, IsSync};
+
+        assert!(!value_of!(IsSend, PyMutexGuard<'_, i32>));
+        assert!(value_of!(IsSync, PyMutexGuard<'_, i32>));
+
+        assert!(value_of!(IsSend, PyMutex<i32>));
+        assert!(value_of!(IsSync, PyMutex<i32>));
+    }
+}
diff --git a/src/types/none.rs b/src/types/none.rs
index 6460482e5ff..dc2a6b0123b 100644
--- a/src/types/none.rs
+++ b/src/types/none.rs
@@ -1,35 +1,25 @@
 use crate::ffi_ptr_ext::FfiPtrExt;
-use crate::{
-    ffi, types::any::PyAnyMethods, Borrowed, Bound, IntoPy, PyAny, PyObject, PyTypeInfo, Python,
-    ToPyObject,
-};
+use crate::{ffi, types::any::PyAnyMethods, Borrowed, Bound, PyAny, PyTypeInfo, Python};
 
 /// Represents the Python `None` object.
+///
+/// Values of this type are accessed via PyO3's smart pointers, e.g. as
+/// [`Py<PyNone>`][crate::Py] or [`Bound<'py, PyNone>`][Bound].
 #[repr(transparent)]
 pub struct PyNone(PyAny);
 
 pyobject_native_type_named!(PyNone);
-pyobject_native_type_extract!(PyNone);
 
 impl PyNone {
     /// Returns the `None` object.
-    /// Deprecated form of [`PyNone::get_bound`]
-    #[cfg_attr(
-        not(feature = "gil-refs"),
-        deprecated(
-            since = "0.21.0",
-            note = "`PyNone::get` will be replaced by `PyNone::get_bound` in a future PyO3 version"
-        )
-    )]
     #[inline]
-    pub fn get(py: Python<'_>) -> &PyNone {
-        Self::get_bound(py).into_gil_ref()
-    }
-
-    /// Returns the `None` object.
-    #[inline]
-    pub fn get_bound(py: Python<'_>) -> Borrowed<'_, '_, PyNone> {
-        unsafe { ffi::Py_None().assume_borrowed(py).downcast_unchecked() }
+    pub fn get(py: Python<'_>) -> Borrowed<'_, '_, PyNone> {
+        // SAFETY: `Py_None` is a global singleton which is known to be the None object
+        unsafe {
+            ffi::Py_None()
+                .assume_borrowed_unchecked(py)
+                .cast_unchecked()
+        }
     }
 }
 
@@ -43,28 +33,14 @@ unsafe impl PyTypeInfo for PyNone {
     }
 
     #[inline]
-    fn is_type_of_bound(object: &Bound<'_, PyAny>) -> bool {
+    fn is_type_of(object: &Bound<'_, PyAny>) -> bool {
         // NoneType is not usable as a base type
-        Self::is_exact_type_of_bound(object)
-    }
-
-    #[inline]
-    fn is_exact_type_of_bound(object: &Bound<'_, PyAny>) -> bool {
-        object.is(&**Self::get_bound(object.py()))
-    }
-}
-
-/// `()` is converted to Python `None`.
-impl ToPyObject for () {
-    fn to_object(&self, py: Python<'_>) -> PyObject {
-        PyNone::get_bound(py).into_py(py)
+        Self::is_exact_type_of(object)
     }
-}
 
-impl IntoPy<PyObject> for () {
     #[inline]
-    fn into_py(self, py: Python<'_>) -> PyObject {
-        PyNone::get_bound(py).into_py(py)
+    fn is_exact_type_of(object: &Bound<'_, PyAny>) -> bool {
+        object.is(&**Self::get(object.py()))
     }
 }
 
@@ -72,53 +48,34 @@ impl IntoPy<PyObject> for () {
 mod tests {
     use crate::types::any::PyAnyMethods;
     use crate::types::{PyDict, PyNone};
-    use crate::{IntoPy, PyObject, PyTypeInfo, Python, ToPyObject};
+    use crate::{PyTypeInfo, Python};
+
     #[test]
     fn test_none_is_itself() {
-        Python::with_gil(|py| {
-            assert!(PyNone::get_bound(py).is_instance_of::<PyNone>());
-            assert!(PyNone::get_bound(py).is_exact_instance_of::<PyNone>());
+        Python::attach(|py| {
+            assert!(PyNone::get(py).is_instance_of::<PyNone>());
+            assert!(PyNone::get(py).is_exact_instance_of::<PyNone>());
         })
     }
 
     #[test]
     fn test_none_type_object_consistent() {
-        Python::with_gil(|py| {
-            assert!(PyNone::get_bound(py)
-                .get_type()
-                .is(&PyNone::type_object_bound(py)));
+        Python::attach(|py| {
+            assert!(PyNone::get(py).get_type().is(PyNone::type_object(py)));
         })
     }
 
     #[test]
     fn test_none_is_none() {
-        Python::with_gil(|py| {
-            assert!(PyNone::get_bound(py)
-                .downcast::<PyNone>()
-                .unwrap()
-                .is_none());
-        })
-    }
-
-    #[test]
-    fn test_unit_to_object_is_none() {
-        Python::with_gil(|py| {
-            assert!(().to_object(py).downcast::<PyNone>(py).is_ok());
-        })
-    }
-
-    #[test]
-    fn test_unit_into_py_is_none() {
-        Python::with_gil(|py| {
-            let obj: PyObject = ().into_py(py);
-            assert!(obj.downcast::<PyNone>(py).is_ok());
+        Python::attach(|py| {
+            assert!(PyNone::get(py).cast::<PyNone>().unwrap().is_none());
         })
     }
 
     #[test]
     fn test_dict_is_not_none() {
-        Python::with_gil(|py| {
-            assert!(PyDict::new_bound(py).downcast::<PyNone>().is_err());
+        Python::attach(|py| {
+            assert!(PyDict::new(py).cast::<PyNone>().is_err());
         })
     }
 }
diff --git a/src/types/notimplemented.rs b/src/types/notimplemented.rs
index 9d31e670e2b..d89b2fa64a6 100644
--- a/src/types/notimplemented.rs
+++ b/src/types/notimplemented.rs
@@ -4,33 +4,23 @@ use crate::{
 };
 
 /// Represents the Python `NotImplemented` object.
+///
+/// Values of this type are accessed via PyO3's smart pointers, e.g. as
+/// [`Py<PyNotImplemented>`][crate::Py] or [`Bound<'py, PyNotImplemented>`][Bound].
 #[repr(transparent)]
 pub struct PyNotImplemented(PyAny);
 
 pyobject_native_type_named!(PyNotImplemented);
-pyobject_native_type_extract!(PyNotImplemented);
 
 impl PyNotImplemented {
     /// Returns the `NotImplemented` object.
-    #[cfg_attr(
-        not(feature = "gil-refs"),
-        deprecated(
-            since = "0.21.0",
-            note = "`PyNotImplemented::get` will be replaced by `PyNotImplemented::get_bound` in a future PyO3 version"
-        )
-    )]
     #[inline]
-    pub fn get(py: Python<'_>) -> &PyNotImplemented {
-        Self::get_bound(py).into_gil_ref()
-    }
-
-    /// Returns the `NotImplemented` object.
-    #[inline]
-    pub fn get_bound(py: Python<'_>) -> Borrowed<'_, '_, PyNotImplemented> {
+    pub fn get(py: Python<'_>) -> Borrowed<'_, '_, PyNotImplemented> {
+        // SAFETY: `Py_NotImplemented` is a global singleton which is known to be the NotImplemented object
         unsafe {
             ffi::Py_NotImplemented()
-                .assume_borrowed(py)
-                .downcast_unchecked()
+                .assume_borrowed_unchecked(py)
+                .cast_unchecked()
         }
     }
 }
@@ -44,14 +34,14 @@ unsafe impl PyTypeInfo for PyNotImplemented {
     }
 
     #[inline]
-    fn is_type_of_bound(object: &Bound<'_, PyAny>) -> bool {
+    fn is_type_of(object: &Bound<'_, PyAny>) -> bool {
         // NotImplementedType is not usable as a base type
-        Self::is_exact_type_of_bound(object)
+        Self::is_exact_type_of(object)
     }
 
     #[inline]
-    fn is_exact_type_of_bound(object: &Bound<'_, PyAny>) -> bool {
-        object.is(&**Self::get_bound(object.py()))
+    fn is_exact_type_of(object: &Bound<'_, PyAny>) -> bool {
+        object.is(&**Self::get(object.py()))
     }
 }
 
@@ -63,27 +53,25 @@ mod tests {
 
     #[test]
     fn test_notimplemented_is_itself() {
-        Python::with_gil(|py| {
-            assert!(PyNotImplemented::get_bound(py).is_instance_of::<PyNotImplemented>());
-            assert!(PyNotImplemented::get_bound(py).is_exact_instance_of::<PyNotImplemented>());
+        Python::attach(|py| {
+            assert!(PyNotImplemented::get(py).is_instance_of::<PyNotImplemented>());
+            assert!(PyNotImplemented::get(py).is_exact_instance_of::<PyNotImplemented>());
         })
     }
 
     #[test]
     fn test_notimplemented_type_object_consistent() {
-        Python::with_gil(|py| {
-            assert!(PyNotImplemented::get_bound(py)
+        Python::attach(|py| {
+            assert!(PyNotImplemented::get(py)
                 .get_type()
-                .is(&PyNotImplemented::type_object_bound(py)));
+                .is(PyNotImplemented::type_object(py)));
         })
     }
 
     #[test]
     fn test_dict_is_not_notimplemented() {
-        Python::with_gil(|py| {
-            assert!(PyDict::new_bound(py)
-                .downcast::<PyNotImplemented>()
-                .is_err());
+        Python::attach(|py| {
+            assert!(PyDict::new(py).cast::<PyNotImplemented>().is_err());
         })
     }
 }
diff --git a/src/types/num.rs b/src/types/num.rs
index 26748f7d1c7..41ecb5ea527 100644
--- a/src/types/num.rs
+++ b/src/types/num.rs
@@ -1,12 +1,151 @@
-use crate::{ffi, PyAny};
+use super::any::PyAnyMethods;
+use crate::{ffi, instance::Bound, IntoPyObject, PyAny, Python};
+use std::convert::Infallible;
 
 /// Represents a Python `int` object.
 ///
-/// You can usually avoid directly working with this type
-/// by using [`ToPyObject`](crate::conversion::ToPyObject)
-/// and [`extract`](PyAny::extract)
+/// Values of this type are accessed via PyO3's smart pointers, e.g. as
+/// [`Py<PyInt>`][crate::Py] or [`Bound<'py, PyInt>`][crate::Bound].
+///
+/// You can usually avoid directly working with this type by using
+/// [`IntoPyObject`] and [`extract`](super::PyAnyMethods::extract)
 /// with the primitive Rust integer types.
 #[repr(transparent)]
-pub struct PyLong(PyAny);
+pub struct PyInt(PyAny);
+
+pyobject_native_type_core!(PyInt, pyobject_native_static_type_object!(ffi::PyLong_Type), #checkfunction=ffi::PyLong_Check);
+
+impl PyInt {
+    /// Creates a new Python int object.
+    ///
+    /// Panics if out of memory.
+    pub fn new<'a, T>(py: Python<'a>, i: T) -> Bound<'a, PyInt>
+    where
+        T: IntoPyObject<'a, Target = PyInt, Output = Bound<'a, PyInt>, Error = Infallible>,
+    {
+        match T::into_pyobject(i, py) {
+            Ok(v) => v,
+            Err(never) => match never {},
+        }
+    }
+}
+
+macro_rules! int_compare {
+    ($rust_type: ty) => {
+        impl PartialEq<$rust_type> for Bound<'_, PyInt> {
+            #[inline]
+            fn eq(&self, other: &$rust_type) -> bool {
+                if let Ok(value) = self.extract::<$rust_type>() {
+                    value == *other
+                } else {
+                    false
+                }
+            }
+        }
+        impl PartialEq<Bound<'_, PyInt>> for $rust_type {
+            #[inline]
+            fn eq(&self, other: &Bound<'_, PyInt>) -> bool {
+                if let Ok(value) = other.extract::<$rust_type>() {
+                    value == *self
+                } else {
+                    false
+                }
+            }
+        }
+    };
+}
+
+int_compare!(i8);
+int_compare!(u8);
+int_compare!(i16);
+int_compare!(u16);
+int_compare!(i32);
+int_compare!(u32);
+int_compare!(i64);
+int_compare!(u64);
+int_compare!(i128);
+int_compare!(u128);
+int_compare!(isize);
+int_compare!(usize);
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{IntoPyObject, Python};
+
+    #[test]
+    fn test_partial_eq() {
+        Python::attach(|py| {
+            let v_i8 = 123i8;
+            let v_u8 = 123i8;
+            let v_i16 = 123i16;
+            let v_u16 = 123u16;
+            let v_i32 = 123i32;
+            let v_u32 = 123u32;
+            let v_i64 = 123i64;
+            let v_u64 = 123u64;
+            let v_i128 = 123i128;
+            let v_u128 = 123u128;
+            let v_isize = 123isize;
+            let v_usize = 123usize;
+            let obj = 123_i64.into_pyobject(py).unwrap();
+            assert_eq!(v_i8, obj);
+            assert_eq!(obj, v_i8);
+
+            assert_eq!(v_u8, obj);
+            assert_eq!(obj, v_u8);
+
+            assert_eq!(v_i16, obj);
+            assert_eq!(obj, v_i16);
+
+            assert_eq!(v_u16, obj);
+            assert_eq!(obj, v_u16);
+
+            assert_eq!(v_i32, obj);
+            assert_eq!(obj, v_i32);
+
+            assert_eq!(v_u32, obj);
+            assert_eq!(obj, v_u32);
+
+            assert_eq!(v_i64, obj);
+            assert_eq!(obj, v_i64);
+
+            assert_eq!(v_u64, obj);
+            assert_eq!(obj, v_u64);
+
+            assert_eq!(v_i128, obj);
+            assert_eq!(obj, v_i128);
+
+            assert_eq!(v_u128, obj);
+            assert_eq!(obj, v_u128);
+
+            assert_eq!(v_isize, obj);
+            assert_eq!(obj, v_isize);
+
+            assert_eq!(v_usize, obj);
+            assert_eq!(obj, v_usize);
+
+            let big_num = (u8::MAX as u16) + 1;
+            let big_obj = big_num.into_pyobject(py).unwrap();
+
+            for x in 0u8..=u8::MAX {
+                assert_ne!(x, big_obj);
+                assert_ne!(big_obj, x);
+            }
+        });
+    }
+
+    #[test]
+    fn test_display_int() {
+        Python::attach(|py| {
+            let s = PyInt::new(py, 42u8);
+            assert_eq!(format!("{s}"), "42");
+
+            let s = PyInt::new(py, 43i32);
+            assert_eq!(format!("{s}"), "43");
 
-pyobject_native_type_core!(PyLong, pyobject_native_static_type_object!(ffi::PyLong_Type), #checkfunction=ffi::PyLong_Check);
+            let s = PyInt::new(py, 44usize);
+            assert_eq!(format!("{s}"), "44");
+        })
+    }
+}
diff --git a/src/types/pysuper.rs b/src/types/pysuper.rs
index 261a91f289b..b8f3cef2d06 100644
--- a/src/types/pysuper.rs
+++ b/src/types/pysuper.rs
@@ -1,12 +1,13 @@
 use crate::instance::Bound;
 use crate::types::any::PyAnyMethods;
 use crate::types::PyType;
-use crate::{ffi, PyNativeType, PyTypeInfo};
+use crate::{ffi, PyTypeInfo};
 use crate::{PyAny, PyResult};
 
 /// Represents a Python `super` object.
 ///
-/// This type is immutable.
+/// Values of this type are accessed via PyO3's smart pointers, e.g. as
+/// [`Py<PySuper>`][crate::Py] or [`Bound<'py, PySuper>`][Bound].
 #[repr(transparent)]
 pub struct PySuper(PyAny);
 
@@ -16,23 +17,11 @@ pyobject_native_type_core!(
 );
 
 impl PySuper {
-    /// Deprecated form of `PySuper::new_bound`.
-    #[cfg_attr(
-        not(feature = "gil-refs"),
-        deprecated(
-            since = "0.21.0",
-            note = "`PySuper::new` will be replaced by `PySuper::new_bound` in a future PyO3 version"
-        )
-    )]
-    pub fn new<'py>(ty: &'py PyType, obj: &'py PyAny) -> PyResult<&'py PySuper> {
-        Self::new_bound(&ty.as_borrowed(), &obj.as_borrowed()).map(Bound::into_gil_ref)
-    }
-
     /// Constructs a new super object. More read about super object: [docs](https://docs.python.org/3/library/functions.html#super)
     ///
     /// # Examples
     ///
-    /// ```rust
+    /// ```rust,no_run
     /// use pyo3::prelude::*;
     ///
     /// #[pyclass(subclass)]
@@ -62,21 +51,19 @@ impl PySuper {
     ///         (SubClass {}, BaseClass::new())
     ///     }
     ///
-    ///     fn method(self_: &PyCell<Self>) -> PyResult<&PyAny> {
+    ///     fn method<'py>(self_: &Bound<'py, Self>) -> PyResult<Bound<'py, PyAny>> {
     ///         let super_ = self_.py_super()?;
     ///         super_.call_method("method", (), None)
     ///     }
     /// }
     /// ```
-    pub fn new_bound<'py>(
+    pub fn new<'py>(
         ty: &Bound<'py, PyType>,
         obj: &Bound<'py, PyAny>,
     ) -> PyResult<Bound<'py, PySuper>> {
-        PySuper::type_object_bound(ty.py())
-            .call1((ty, obj))
-            .map(|any| {
-                // Safety: super() always returns instance of super
-                unsafe { any.downcast_into_unchecked() }
-            })
+        PySuper::type_object(ty.py()).call1((ty, obj)).map(|any| {
+            // Safety: super() always returns instance of super
+            unsafe { any.cast_into_unchecked() }
+        })
     }
 }
diff --git a/src/types/range.rs b/src/types/range.rs
new file mode 100644
index 00000000000..00c7ce2a325
--- /dev/null
+++ b/src/types/range.rs
@@ -0,0 +1,92 @@
+use crate::sealed::Sealed;
+use crate::types::PyAnyMethods;
+use crate::{ffi, Bound, PyAny, PyResult, PyTypeInfo, Python};
+
+/// Represents a Python `range`.
+///
+/// Values of this type are accessed via PyO3's smart pointers, e.g. as
+/// [`Py<PyRange>`][crate::Py] or [`Bound<'py, PyRange>`][Bound].
+///
+/// For APIs available on `range` objects, see the [`PyRangeMethods`] trait which is implemented for
+/// [`Bound<'py, PyRange>`][Bound].
+#[repr(transparent)]
+pub struct PyRange(PyAny);
+
+pyobject_native_type_core!(PyRange, pyobject_native_static_type_object!(ffi::PyRange_Type), #checkfunction=ffi::PyRange_Check);
+
+impl<'py> PyRange {
+    /// Creates a new Python `range` object with a default step of 1.
+    pub fn new(py: Python<'py>, start: isize, stop: isize) -> PyResult<Bound<'py, Self>> {
+        Self::new_with_step(py, start, stop, 1)
+    }
+
+    /// Creates a new Python `range` object with a specified step.
+    pub fn new_with_step(
+        py: Python<'py>,
+        start: isize,
+        stop: isize,
+        step: isize,
+    ) -> PyResult<Bound<'py, Self>> {
+        unsafe {
+            Ok(Self::type_object(py)
+                .call1((start, stop, step))?
+                .cast_into_unchecked())
+        }
+    }
+}
+
+/// Implementation of functionality for [`PyRange`].
+///
+/// These methods are defined for the `Bound<'py, PyRange>` smart pointer, so to use method call
+/// syntax these methods are separated into a trait, because stable Rust does not yet support
+/// `arbitrary_self_types`.
+#[doc(alias = "PyRange")]
+pub trait PyRangeMethods<'py>: Sealed {
+    /// Returns the start of the range.
+    fn start(&self) -> PyResult<isize>;
+
+    /// Returns the exclusive end of the range.
+    fn stop(&self) -> PyResult<isize>;
+
+    /// Returns the step of the range.
+    fn step(&self) -> PyResult<isize>;
+}
+
+impl<'py> PyRangeMethods<'py> for Bound<'py, PyRange> {
+    fn start(&self) -> PyResult<isize> {
+        self.getattr(intern!(self.py(), "start"))?.extract()
+    }
+
+    fn stop(&self) -> PyResult<isize> {
+        self.getattr(intern!(self.py(), "stop"))?.extract()
+    }
+
+    fn step(&self) -> PyResult<isize> {
+        self.getattr(intern!(self.py(), "step"))?.extract()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_py_range_new() {
+        Python::attach(|py| {
+            let range = PyRange::new(py, isize::MIN, isize::MAX).unwrap();
+            assert_eq!(range.start().unwrap(), isize::MIN);
+            assert_eq!(range.stop().unwrap(), isize::MAX);
+            assert_eq!(range.step().unwrap(), 1);
+        });
+    }
+
+    #[test]
+    fn test_py_range_new_with_step() {
+        Python::attach(|py| {
+            let range = PyRange::new_with_step(py, 1, 10, 2).unwrap();
+            assert_eq!(range.start().unwrap(), 1);
+            assert_eq!(range.stop().unwrap(), 10);
+            assert_eq!(range.step().unwrap(), 2);
+        });
+    }
+}
diff --git a/src/types/sequence.rs b/src/types/sequence.rs
index 80306cbf44b..6cb6a921495 100644
--- a/src/types/sequence.rs
+++ b/src/types/sequence.rs
@@ -1,187 +1,60 @@
-use crate::err::{self, DowncastError, PyDowncastError, PyErr, PyResult};
-use crate::exceptions::PyTypeError;
+use crate::err::{self, PyErr, PyResult};
 use crate::ffi_ptr_ext::FfiPtrExt;
-#[cfg(feature = "experimental-inspect")]
-use crate::inspect::types::TypeInfo;
 use crate::instance::Bound;
 use crate::internal_tricks::get_ssize_index;
 use crate::py_result_ext::PyResultExt;
-use crate::sync::GILOnceCell;
+use crate::sync::PyOnceLock;
 use crate::type_object::PyTypeInfo;
-use crate::types::{any::PyAnyMethods, PyAny, PyList, PyString, PyTuple, PyType};
-use crate::{ffi, FromPyObject, Py, PyNativeType, PyTypeCheck, Python, ToPyObject};
+use crate::types::{any::PyAnyMethods, PyAny, PyList, PyTuple, PyType, PyTypeMethods};
+use crate::{ffi, Borrowed, BoundObject, IntoPyObject, IntoPyObjectExt, Py, Python};
 
 /// Represents a reference to a Python object supporting the sequence protocol.
+///
+/// Values of this type are accessed via PyO3's smart pointers, e.g. as
+/// [`Py<PySequence>`][crate::Py] or [`Bound<'py, PySequence>`][Bound].
+///
+/// For APIs available on sequence objects, see the [`PySequenceMethods`] trait which is implemented for
+/// [`Bound<'py, PySequence>`][Bound].
 #[repr(transparent)]
 pub struct PySequence(PyAny);
-pyobject_native_type_named!(PySequence);
-pyobject_native_type_extract!(PySequence);
-
-impl PySequence {
-    /// Returns the number of objects in sequence.
-    ///
-    /// This is equivalent to the Python expression `len(self)`.
-    #[inline]
-    pub fn len(&self) -> PyResult<usize> {
-        self.as_borrowed().len()
-    }
-
-    /// Returns whether the sequence is empty.
-    #[inline]
-    pub fn is_empty(&self) -> PyResult<bool> {
-        self.as_borrowed().is_empty()
-    }
-
-    /// Returns the concatenation of `self` and `other`.
-    ///
-    /// This is equivalent to the Python expression `self + other`.
-    #[inline]
-    pub fn concat(&self, other: &PySequence) -> PyResult<&PySequence> {
-        self.as_borrowed()
-            .concat(&other.as_borrowed())
-            .map(Bound::into_gil_ref)
-    }
-
-    /// Returns the result of repeating a sequence object `count` times.
-    ///
-    /// This is equivalent to the Python expression `self * count`.
-    #[inline]
-    pub fn repeat(&self, count: usize) -> PyResult<&PySequence> {
-        self.as_borrowed().repeat(count).map(Bound::into_gil_ref)
-    }
-
-    /// Concatenates `self` and `other`, in place if possible.
-    ///
-    /// This is equivalent to the Python expression `self.__iadd__(other)`.
-    ///
-    /// The Python statement `self += other` is syntactic sugar for `self =
-    /// self.__iadd__(other)`.  `__iadd__` should modify and return `self` if
-    /// possible, but create and return a new object if not.
-    #[inline]
-    pub fn in_place_concat(&self, other: &PySequence) -> PyResult<&PySequence> {
-        self.as_borrowed()
-            .in_place_concat(&other.as_borrowed())
-            .map(Bound::into_gil_ref)
-    }
-
-    /// Repeats the sequence object `count` times and updates `self`, if possible.
-    ///
-    /// This is equivalent to the Python expression `self.__imul__(other)`.
-    ///
-    /// The Python statement `self *= other` is syntactic sugar for `self =
-    /// self.__imul__(other)`.  `__imul__` should modify and return `self` if
-    /// possible, but create and return a new object if not.
-    #[inline]
-    pub fn in_place_repeat(&self, count: usize) -> PyResult<&PySequence> {
-        self.as_borrowed()
-            .in_place_repeat(count)
-            .map(Bound::into_gil_ref)
-    }
-
-    /// Returns the `index`th element of the Sequence.
-    ///
-    /// This is equivalent to the Python expression `self[index]` without support of negative indices.
-    #[inline]
-    pub fn get_item(&self, index: usize) -> PyResult<&PyAny> {
-        self.as_borrowed().get_item(index).map(Bound::into_gil_ref)
-    }
-
-    /// Returns the slice of sequence object between `begin` and `end`.
-    ///
-    /// This is equivalent to the Python expression `self[begin:end]`.
-    #[inline]
-    pub fn get_slice(&self, begin: usize, end: usize) -> PyResult<&PySequence> {
-        self.as_borrowed()
-            .get_slice(begin, end)
-            .map(Bound::into_gil_ref)
-    }
-
-    /// Assigns object `item` to the `i`th element of self.
-    ///
-    /// This is equivalent to the Python statement `self[i] = v`.
-    #[inline]
-    pub fn set_item<I>(&self, i: usize, item: I) -> PyResult<()>
-    where
-        I: ToPyObject,
-    {
-        self.as_borrowed().set_item(i, item)
-    }
-
-    /// Deletes the `i`th element of self.
-    ///
-    /// This is equivalent to the Python statement `del self[i]`.
-    #[inline]
-    pub fn del_item(&self, i: usize) -> PyResult<()> {
-        self.as_borrowed().del_item(i)
-    }
-
-    /// Assigns the sequence `v` to the slice of `self` from `i1` to `i2`.
-    ///
-    /// This is equivalent to the Python statement `self[i1:i2] = v`.
-    #[inline]
-    pub fn set_slice(&self, i1: usize, i2: usize, v: &PyAny) -> PyResult<()> {
-        self.as_borrowed().set_slice(i1, i2, &v.as_borrowed())
-    }
-
-    /// Deletes the slice from `i1` to `i2` from `self`.
-    ///
-    /// This is equivalent to the Python statement `del self[i1:i2]`.
-    #[inline]
-    pub fn del_slice(&self, i1: usize, i2: usize) -> PyResult<()> {
-        self.as_borrowed().del_slice(i1, i2)
-    }
 
-    /// Returns the number of occurrences of `value` in self, that is, return the
-    /// number of keys for which `self[key] == value`.
-    #[inline]
-    #[cfg(not(PyPy))]
-    pub fn count<V>(&self, value: V) -> PyResult<usize>
-    where
-        V: ToPyObject,
-    {
-        self.as_borrowed().count(value)
-    }
+pyobject_native_type_named!(PySequence);
 
-    /// Determines if self contains `value`.
-    ///
-    /// This is equivalent to the Python expression `value in self`.
-    #[inline]
-    pub fn contains<V>(&self, value: V) -> PyResult<bool>
-    where
-        V: ToPyObject,
-    {
-        self.as_borrowed().contains(value)
-    }
+unsafe impl PyTypeInfo for PySequence {
+    const NAME: &'static str = "Sequence";
+    const MODULE: Option<&'static str> = Some("collections.abc");
 
-    /// Returns the first index `i` for which `self[i] == value`.
-    ///
-    /// This is equivalent to the Python expression `self.index(value)`.
     #[inline]
-    pub fn index<V>(&self, value: V) -> PyResult<usize>
-    where
-        V: ToPyObject,
-    {
-        self.as_borrowed().index(value)
+    #[allow(clippy::redundant_closure_call)]
+    fn type_object_raw(py: Python<'_>) -> *mut ffi::PyTypeObject {
+        static TYPE: PyOnceLock<Py<PyType>> = PyOnceLock::new();
+        TYPE.import(py, "collections.abc", "Sequence")
+            .unwrap()
+            .as_type_ptr()
     }
 
-    /// Returns a fresh list based on the Sequence.
     #[inline]
-    pub fn to_list(&self) -> PyResult<&PyList> {
-        self.as_borrowed().to_list().map(Bound::into_gil_ref)
-    }
-
-    /// Returns a fresh tuple based on the Sequence.
-    #[inline]
-    pub fn to_tuple(&self) -> PyResult<&PyTuple> {
-        self.as_borrowed().to_tuple().map(Bound::into_gil_ref)
+    fn is_type_of(object: &Bound<'_, PyAny>) -> bool {
+        // Using `is_instance` for `collections.abc.Sequence` is slow, so provide
+        // optimized cases for list and tuples as common well-known sequences
+        PyList::is_type_of(object)
+            || PyTuple::is_type_of(object)
+            || object
+                .is_instance(&Self::type_object(object.py()).into_any())
+                .unwrap_or_else(|err| {
+                    err.write_unraisable(object.py(), Some(object));
+                    false
+                })
     }
+}
 
+impl PySequence {
     /// Register a pyclass as a subclass of `collections.abc.Sequence` (from the Python standard
-    /// library). This is equvalent to `collections.abc.Sequence.register(T)` in Python.
-    /// This registration is required for a pyclass to be downcastable from `PyAny` to `PySequence`.
+    /// library). This is equivalent to `collections.abc.Sequence.register(T)` in Python.
+    /// This registration is required for a pyclass to be castable from `PyAny` to `PySequence`.
     pub fn register<T: PyTypeInfo>(py: Python<'_>) -> PyResult<()> {
-        let ty = T::type_object_bound(py);
-        get_sequence_abc(py)?.call_method1("register", (ty,))?;
+        let ty = T::type_object(py);
+        Self::type_object(py).call_method1("register", (ty,))?;
         Ok(())
     }
 }
@@ -192,7 +65,7 @@ impl PySequence {
 /// syntax these methods are separated into a trait, because stable Rust does not yet support
 /// `arbitrary_self_types`.
 #[doc(alias = "PySequence")]
-pub trait PySequenceMethods<'py> {
+pub trait PySequenceMethods<'py>: crate::sealed::Sealed {
     /// Returns the number of objects in sequence.
     ///
     /// This is equivalent to the Python expression `len(self)`.
@@ -244,7 +117,7 @@ pub trait PySequenceMethods<'py> {
     /// This is equivalent to the Python statement `self[i] = v`.
     fn set_item<I>(&self, i: usize, item: I) -> PyResult<()>
     where
-        I: ToPyObject;
+        I: IntoPyObject<'py>;
 
     /// Deletes the `i`th element of self.
     ///
@@ -266,21 +139,21 @@ pub trait PySequenceMethods<'py> {
     #[cfg(not(PyPy))]
     fn count<V>(&self, value: V) -> PyResult<usize>
     where
-        V: ToPyObject;
+        V: IntoPyObject<'py>;
 
     /// Determines if self contains `value`.
     ///
     /// This is equivalent to the Python expression `value in self`.
     fn contains<V>(&self, value: V) -> PyResult<bool>
     where
-        V: ToPyObject;
+        V: IntoPyObject<'py>;
 
     /// Returns the first index `i` for which `self[i] == value`.
     ///
     /// This is equivalent to the Python expression `self.index(value)`.
     fn index<V>(&self, value: V) -> PyResult<usize>
     where
-        V: ToPyObject;
+        V: IntoPyObject<'py>;
 
     /// Returns a fresh list based on the Sequence.
     fn to_list(&self) -> PyResult<Bound<'py, PyList>>;
@@ -307,7 +180,7 @@ impl<'py> PySequenceMethods<'py> for Bound<'py, PySequence> {
         unsafe {
             ffi::PySequence_Concat(self.as_ptr(), other.as_ptr())
                 .assume_owned_or_err(self.py())
-                .downcast_into_unchecked()
+                .cast_into_unchecked()
         }
     }
 
@@ -316,7 +189,7 @@ impl<'py> PySequenceMethods<'py> for Bound<'py, PySequence> {
         unsafe {
             ffi::PySequence_Repeat(self.as_ptr(), get_ssize_index(count))
                 .assume_owned_or_err(self.py())
-                .downcast_into_unchecked()
+                .cast_into_unchecked()
         }
     }
 
@@ -325,7 +198,7 @@ impl<'py> PySequenceMethods<'py> for Bound<'py, PySequence> {
         unsafe {
             ffi::PySequence_InPlaceConcat(self.as_ptr(), other.as_ptr())
                 .assume_owned_or_err(self.py())
-                .downcast_into_unchecked()
+                .cast_into_unchecked()
         }
     }
 
@@ -334,7 +207,7 @@ impl<'py> PySequenceMethods<'py> for Bound<'py, PySequence> {
         unsafe {
             ffi::PySequence_InPlaceRepeat(self.as_ptr(), get_ssize_index(count))
                 .assume_owned_or_err(self.py())
-                .downcast_into_unchecked()
+                .cast_into_unchecked()
         }
     }
 
@@ -351,23 +224,31 @@ impl<'py> PySequenceMethods<'py> for Bound<'py, PySequence> {
         unsafe {
             ffi::PySequence_GetSlice(self.as_ptr(), get_ssize_index(begin), get_ssize_index(end))
                 .assume_owned_or_err(self.py())
-                .downcast_into_unchecked()
+                .cast_into_unchecked()
         }
     }
 
     #[inline]
     fn set_item<I>(&self, i: usize, item: I) -> PyResult<()>
     where
-        I: ToPyObject,
+        I: IntoPyObject<'py>,
     {
-        fn inner(seq: &Bound<'_, PySequence>, i: usize, item: Bound<'_, PyAny>) -> PyResult<()> {
+        fn inner(
+            seq: &Bound<'_, PySequence>,
+            i: usize,
+            item: Borrowed<'_, '_, PyAny>,
+        ) -> PyResult<()> {
             err::error_on_minusone(seq.py(), unsafe {
                 ffi::PySequence_SetItem(seq.as_ptr(), get_ssize_index(i), item.as_ptr())
             })
         }
 
         let py = self.py();
-        inner(self, i, item.to_object(py).into_bound(py))
+        inner(
+            self,
+            i,
+            item.into_pyobject_or_pyerr(py)?.into_any().as_borrowed(),
+        )
     }
 
     #[inline]
@@ -400,24 +281,27 @@ impl<'py> PySequenceMethods<'py> for Bound<'py, PySequence> {
     #[cfg(not(PyPy))]
     fn count<V>(&self, value: V) -> PyResult<usize>
     where
-        V: ToPyObject,
+        V: IntoPyObject<'py>,
     {
-        fn inner(seq: &Bound<'_, PySequence>, value: Bound<'_, PyAny>) -> PyResult<usize> {
+        fn inner(seq: &Bound<'_, PySequence>, value: Borrowed<'_, '_, PyAny>) -> PyResult<usize> {
             let r = unsafe { ffi::PySequence_Count(seq.as_ptr(), value.as_ptr()) };
             crate::err::error_on_minusone(seq.py(), r)?;
             Ok(r as usize)
         }
 
         let py = self.py();
-        inner(self, value.to_object(py).into_bound(py))
+        inner(
+            self,
+            value.into_pyobject_or_pyerr(py)?.into_any().as_borrowed(),
+        )
     }
 
     #[inline]
     fn contains<V>(&self, value: V) -> PyResult<bool>
     where
-        V: ToPyObject,
+        V: IntoPyObject<'py>,
     {
-        fn inner(seq: &Bound<'_, PySequence>, value: Bound<'_, PyAny>) -> PyResult<bool> {
+        fn inner(seq: &Bound<'_, PySequence>, value: Borrowed<'_, '_, PyAny>) -> PyResult<bool> {
             let r = unsafe { ffi::PySequence_Contains(seq.as_ptr(), value.as_ptr()) };
             match r {
                 0 => Ok(false),
@@ -427,22 +311,28 @@ impl<'py> PySequenceMethods<'py> for Bound<'py, PySequence> {
         }
 
         let py = self.py();
-        inner(self, value.to_object(py).into_bound(py))
+        inner(
+            self,
+            value.into_pyobject_or_pyerr(py)?.into_any().as_borrowed(),
+        )
     }
 
     #[inline]
     fn index<V>(&self, value: V) -> PyResult<usize>
     where
-        V: ToPyObject,
+        V: IntoPyObject<'py>,
     {
-        fn inner(seq: &Bound<'_, PySequence>, value: Bound<'_, PyAny>) -> PyResult<usize> {
+        fn inner(seq: &Bound<'_, PySequence>, value: Borrowed<'_, '_, PyAny>) -> PyResult<usize> {
             let r = unsafe { ffi::PySequence_Index(seq.as_ptr(), value.as_ptr()) };
             crate::err::error_on_minusone(seq.py(), r)?;
             Ok(r as usize)
         }
 
         let py = self.py();
-        inner(self, value.to_object(self.py()).into_bound(py))
+        inner(
+            self,
+            value.into_pyobject_or_pyerr(py)?.into_any().as_borrowed(),
+        )
     }
 
     #[inline]
@@ -450,7 +340,7 @@ impl<'py> PySequenceMethods<'py> for Bound<'py, PySequence> {
         unsafe {
             ffi::PySequence_List(self.as_ptr())
                 .assume_owned_or_err(self.py())
-                .downcast_into_unchecked()
+                .cast_into_unchecked()
         }
     }
 
@@ -459,205 +349,93 @@ impl<'py> PySequenceMethods<'py> for Bound<'py, PySequence> {
         unsafe {
             ffi::PySequence_Tuple(self.as_ptr())
                 .assume_owned_or_err(self.py())
-                .downcast_into_unchecked()
-        }
-    }
-}
-
-#[inline]
-fn sequence_len(seq: &PySequence) -> usize {
-    seq.len().expect("failed to get sequence length")
-}
-
-#[inline]
-fn sequence_slice(seq: &PySequence, start: usize, end: usize) -> &PySequence {
-    seq.get_slice(start, end)
-        .expect("sequence slice operation failed")
-}
-
-index_impls!(PySequence, "sequence", sequence_len, sequence_slice);
-
-impl<'py, T> FromPyObject<'py> for Vec<T>
-where
-    T: FromPyObject<'py>,
-{
-    fn extract_bound(obj: &Bound<'py, PyAny>) -> PyResult<Self> {
-        if obj.is_instance_of::<PyString>() {
-            return Err(PyTypeError::new_err("Can't extract `str` to `Vec`"));
-        }
-        extract_sequence(obj)
-    }
-
-    #[cfg(feature = "experimental-inspect")]
-    fn type_input() -> TypeInfo {
-        TypeInfo::sequence_of(T::type_input())
-    }
-}
-
-fn extract_sequence<'py, T>(obj: &Bound<'py, PyAny>) -> PyResult<Vec<T>>
-where
-    T: FromPyObject<'py>,
-{
-    // Types that pass `PySequence_Check` usually implement enough of the sequence protocol
-    // to support this function and if not, we will only fail extraction safely.
-    let seq = unsafe {
-        if ffi::PySequence_Check(obj.as_ptr()) != 0 {
-            obj.downcast_unchecked::<PySequence>()
-        } else {
-            return Err(DowncastError::new(obj, "Sequence").into());
-        }
-    };
-
-    let mut v = Vec::with_capacity(seq.len().unwrap_or(0));
-    for item in seq.iter()? {
-        v.push(item?.extract::<T>()?);
-    }
-    Ok(v)
-}
-
-fn get_sequence_abc(py: Python<'_>) -> PyResult<&Bound<'_, PyType>> {
-    static SEQUENCE_ABC: GILOnceCell<Py<PyType>> = GILOnceCell::new();
-
-    SEQUENCE_ABC.get_or_try_init_type_ref(py, "collections.abc", "Sequence")
-}
-
-impl PyTypeCheck for PySequence {
-    const NAME: &'static str = "Sequence";
-
-    #[inline]
-    fn type_check(object: &Bound<'_, PyAny>) -> bool {
-        // Using `is_instance` for `collections.abc.Sequence` is slow, so provide
-        // optimized cases for list and tuples as common well-known sequences
-        PyList::is_type_of_bound(object)
-            || PyTuple::is_type_of_bound(object)
-            || get_sequence_abc(object.py())
-                .and_then(|abc| object.is_instance(abc))
-                .unwrap_or_else(|err| {
-                    err.write_unraisable_bound(object.py(), Some(&object.as_borrowed()));
-                    false
-                })
-    }
-}
-
-#[allow(deprecated)]
-impl<'v> crate::PyTryFrom<'v> for PySequence {
-    /// Downcasting to `PySequence` requires the concrete class to be a subclass (or registered
-    /// subclass) of `collections.abc.Sequence` (from the Python standard library) - i.e.
-    /// `isinstance(<class>, collections.abc.Sequence) == True`.
-    fn try_from<V: Into<&'v PyAny>>(value: V) -> Result<&'v PySequence, PyDowncastError<'v>> {
-        let value = value.into();
-
-        if PySequence::type_check(&value.as_borrowed()) {
-            unsafe { return Ok(value.downcast_unchecked::<PySequence>()) }
+                .cast_into_unchecked()
         }
-
-        Err(PyDowncastError::new(value, "Sequence"))
-    }
-
-    fn try_from_exact<V: Into<&'v PyAny>>(value: V) -> Result<&'v PySequence, PyDowncastError<'v>> {
-        value.into().downcast()
-    }
-
-    #[inline]
-    unsafe fn try_from_unchecked<V: Into<&'v PyAny>>(value: V) -> &'v PySequence {
-        let ptr = value.into() as *const _ as *const PySequence;
-        &*ptr
     }
 }
 
 #[cfg(test)]
-#[cfg_attr(not(feature = "gil-refs"), allow(deprecated))]
 mod tests {
-    use crate::types::{PyList, PySequence, PyTuple};
-    use crate::{PyObject, Python, ToPyObject};
+    use crate::types::{PyAnyMethods, PyList, PySequence, PySequenceMethods, PyTuple};
+    use crate::{IntoPyObject, Py, PyAny, PyTypeInfo, Python};
+    use std::ptr;
 
-    fn get_object() -> PyObject {
+    fn get_object() -> Py<PyAny> {
         // Convenience function for getting a single unique object
-        Python::with_gil(|py| {
-            let obj = py.eval("object()", None, None).unwrap();
+        Python::attach(|py| {
+            let obj = py.eval(c"object()", None, None).unwrap();
 
-            obj.to_object(py)
+            obj.into_pyobject(py).unwrap().unbind()
         })
     }
 
     #[test]
     fn test_numbers_are_not_sequences() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let v = 42i32;
-            assert!(v.to_object(py).downcast::<PySequence>(py).is_err());
+            assert!(v.into_pyobject(py).unwrap().cast::<PySequence>().is_err());
         });
     }
 
     #[test]
     fn test_strings_are_sequences() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let v = "London Calling";
-            assert!(v.to_object(py).downcast::<PySequence>(py).is_ok());
-        });
-    }
-
-    #[test]
-    fn test_strings_cannot_be_extracted_to_vec() {
-        Python::with_gil(|py| {
-            let v = "London Calling";
-            let ob = v.to_object(py);
-
-            assert!(ob.extract::<Vec<String>>(py).is_err());
-            assert!(ob.extract::<Vec<char>>(py).is_err());
+            assert!(v.into_pyobject(py).unwrap().cast::<PySequence>().is_ok());
         });
     }
 
     #[test]
     fn test_seq_empty() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let v: Vec<i32> = vec![];
-            let ob = v.to_object(py);
-            let seq = ob.downcast::<PySequence>(py).unwrap();
+            let ob = v.into_pyobject(py).unwrap();
+            let seq = ob.cast::<PySequence>().unwrap();
             assert_eq!(0, seq.len().unwrap());
 
-            let needle = 7i32.to_object(py);
+            let needle = 7i32.into_pyobject(py).unwrap();
             assert!(!seq.contains(&needle).unwrap());
         });
     }
 
     #[test]
     fn test_seq_is_empty() {
-        Python::with_gil(|py| {
-            let list = vec![1].to_object(py);
-            let seq = list.downcast::<PySequence>(py).unwrap();
+        Python::attach(|py| {
+            let list = vec![1].into_pyobject(py).unwrap();
+            let seq = list.cast::<PySequence>().unwrap();
             assert!(!seq.is_empty().unwrap());
             let vec: Vec<u32> = Vec::new();
-            let empty_list = vec.to_object(py);
-            let empty_seq = empty_list.downcast::<PySequence>(py).unwrap();
+            let empty_list = vec.into_pyobject(py).unwrap();
+            let empty_seq = empty_list.cast::<PySequence>().unwrap();
             assert!(empty_seq.is_empty().unwrap());
         });
     }
 
     #[test]
     fn test_seq_contains() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let v: Vec<i32> = vec![1, 1, 2, 3, 5, 8];
-            let ob = v.to_object(py);
-            let seq = ob.downcast::<PySequence>(py).unwrap();
+            let ob = v.into_pyobject(py).unwrap();
+            let seq = ob.cast::<PySequence>().unwrap();
             assert_eq!(6, seq.len().unwrap());
 
-            let bad_needle = 7i32.to_object(py);
+            let bad_needle = 7i32.into_pyobject(py).unwrap();
             assert!(!seq.contains(&bad_needle).unwrap());
 
-            let good_needle = 8i32.to_object(py);
+            let good_needle = 8i32.into_pyobject(py).unwrap();
             assert!(seq.contains(&good_needle).unwrap());
 
-            let type_coerced_needle = 8f32.to_object(py);
+            let type_coerced_needle = 8f32.into_pyobject(py).unwrap();
             assert!(seq.contains(&type_coerced_needle).unwrap());
         });
     }
 
     #[test]
     fn test_seq_get_item() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let v: Vec<i32> = vec![1, 1, 2, 3, 5, 8];
-            let ob = v.to_object(py);
-            let seq = ob.downcast::<PySequence>(py).unwrap();
+            let ob = v.into_pyobject(py).unwrap();
+            let seq = ob.cast::<PySequence>().unwrap();
             assert_eq!(1, seq.get_item(0).unwrap().extract::<i32>().unwrap());
             assert_eq!(1, seq.get_item(1).unwrap().extract::<i32>().unwrap());
             assert_eq!(2, seq.get_item(2).unwrap().extract::<i32>().unwrap());
@@ -668,109 +446,24 @@ mod tests {
         });
     }
 
-    #[test]
-    fn test_seq_index_trait() {
-        Python::with_gil(|py| {
-            let v: Vec<i32> = vec![1, 1, 2];
-            let ob = v.to_object(py);
-            let seq = ob.downcast::<PySequence>(py).unwrap();
-            assert_eq!(1, seq[0].extract::<i32>().unwrap());
-            assert_eq!(1, seq[1].extract::<i32>().unwrap());
-            assert_eq!(2, seq[2].extract::<i32>().unwrap());
-        });
-    }
-
-    #[test]
-    #[should_panic = "index 7 out of range for sequence"]
-    fn test_seq_index_trait_panic() {
-        Python::with_gil(|py| {
-            let v: Vec<i32> = vec![1, 1, 2];
-            let ob = v.to_object(py);
-            let seq = ob.downcast::<PySequence>(py).unwrap();
-            let _ = &seq[7];
-        });
-    }
-
-    #[test]
-    fn test_seq_index_trait_ranges() {
-        Python::with_gil(|py| {
-            let v: Vec<i32> = vec![1, 1, 2];
-            let ob = v.to_object(py);
-            let seq = ob.downcast::<PySequence>(py).unwrap();
-            assert_eq!(vec![1, 2], seq[1..3].extract::<Vec<i32>>().unwrap());
-            assert_eq!(Vec::<i32>::new(), seq[3..3].extract::<Vec<i32>>().unwrap());
-            assert_eq!(vec![1, 2], seq[1..].extract::<Vec<i32>>().unwrap());
-            assert_eq!(Vec::<i32>::new(), seq[3..].extract::<Vec<i32>>().unwrap());
-            assert_eq!(vec![1, 1, 2], seq[..].extract::<Vec<i32>>().unwrap());
-            assert_eq!(vec![1, 2], seq[1..=2].extract::<Vec<i32>>().unwrap());
-            assert_eq!(vec![1, 1], seq[..2].extract::<Vec<i32>>().unwrap());
-            assert_eq!(vec![1, 1], seq[..=1].extract::<Vec<i32>>().unwrap());
-        })
-    }
-
-    #[test]
-    #[should_panic = "range start index 5 out of range for sequence of length 3"]
-    fn test_seq_index_trait_range_panic_start() {
-        Python::with_gil(|py| {
-            let v: Vec<i32> = vec![1, 1, 2];
-            let ob = v.to_object(py);
-            let seq = ob.downcast::<PySequence>(py).unwrap();
-            seq[5..10].extract::<Vec<i32>>().unwrap();
-        })
-    }
-
-    #[test]
-    #[should_panic = "range end index 10 out of range for sequence of length 3"]
-    fn test_seq_index_trait_range_panic_end() {
-        Python::with_gil(|py| {
-            let v: Vec<i32> = vec![1, 1, 2];
-            let ob = v.to_object(py);
-            let seq = ob.downcast::<PySequence>(py).unwrap();
-            seq[1..10].extract::<Vec<i32>>().unwrap();
-        })
-    }
-
-    #[test]
-    #[should_panic = "slice index starts at 2 but ends at 1"]
-    fn test_seq_index_trait_range_panic_wrong_order() {
-        Python::with_gil(|py| {
-            let v: Vec<i32> = vec![1, 1, 2];
-            let ob = v.to_object(py);
-            let seq = ob.downcast::<PySequence>(py).unwrap();
-            #[allow(clippy::reversed_empty_ranges)]
-            seq[2..1].extract::<Vec<i32>>().unwrap();
-        })
-    }
-
-    #[test]
-    #[should_panic = "range start index 8 out of range for sequence of length 3"]
-    fn test_seq_index_trait_range_from_panic() {
-        Python::with_gil(|py| {
-            let v: Vec<i32> = vec![1, 1, 2];
-            let ob = v.to_object(py);
-            let seq = ob.downcast::<PySequence>(py).unwrap();
-            seq[8..].extract::<Vec<i32>>().unwrap();
-        })
-    }
-
     #[test]
     fn test_seq_del_item() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let v: Vec<i32> = vec![1, 1, 2, 3, 5, 8];
-            let ob = v.to_object(py);
-            let seq = ob.downcast::<PySequence>(py).unwrap();
+            let ob = v.into_pyobject(py).unwrap();
+            let seq = ob.cast::<PySequence>().unwrap();
             assert!(seq.del_item(10).is_err());
-            assert_eq!(1, seq[0].extract::<i32>().unwrap());
+            assert_eq!(1, seq.get_item(0).unwrap().extract::<i32>().unwrap());
             assert!(seq.del_item(0).is_ok());
-            assert_eq!(1, seq[0].extract::<i32>().unwrap());
+            assert_eq!(1, seq.get_item(0).unwrap().extract::<i32>().unwrap());
             assert!(seq.del_item(0).is_ok());
-            assert_eq!(2, seq[0].extract::<i32>().unwrap());
+            assert_eq!(2, seq.get_item(0).unwrap().extract::<i32>().unwrap());
             assert!(seq.del_item(0).is_ok());
-            assert_eq!(3, seq[0].extract::<i32>().unwrap());
+            assert_eq!(3, seq.get_item(0).unwrap().extract::<i32>().unwrap());
             assert!(seq.del_item(0).is_ok());
-            assert_eq!(5, seq[0].extract::<i32>().unwrap());
+            assert_eq!(5, seq.get_item(0).unwrap().extract::<i32>().unwrap());
             assert!(seq.del_item(0).is_ok());
-            assert_eq!(8, seq[0].extract::<i32>().unwrap());
+            assert_eq!(8, seq.get_item(0).unwrap().extract::<i32>().unwrap());
             assert!(seq.del_item(0).is_ok());
             assert_eq!(0, seq.len().unwrap());
             assert!(seq.del_item(0).is_err());
@@ -779,13 +472,13 @@ mod tests {
 
     #[test]
     fn test_seq_set_item() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let v: Vec<i32> = vec![1, 2];
-            let ob = v.to_object(py);
-            let seq = ob.downcast::<PySequence>(py).unwrap();
-            assert_eq!(2, seq[1].extract::<i32>().unwrap());
+            let ob = v.into_pyobject(py).unwrap();
+            let seq = ob.cast::<PySequence>().unwrap();
+            assert_eq!(2, seq.get_item(1).unwrap().extract::<i32>().unwrap());
             assert!(seq.set_item(1, 10).is_ok());
-            assert_eq!(10, seq[1].extract::<i32>().unwrap());
+            assert_eq!(10, seq.get_item(1).unwrap().extract::<i32>().unwrap());
         });
     }
 
@@ -793,25 +486,25 @@ mod tests {
     fn test_seq_set_item_refcnt() {
         let obj = get_object();
 
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let v: Vec<i32> = vec![1, 2];
-            let ob = v.to_object(py);
-            let seq = ob.downcast::<PySequence>(py).unwrap();
+            let ob = v.into_pyobject(py).unwrap();
+            let seq = ob.cast::<PySequence>().unwrap();
             assert!(seq.set_item(1, &obj).is_ok());
-            assert!(seq[1].as_ptr() == obj.as_ptr());
+            assert!(ptr::eq(seq.get_item(1).unwrap().as_ptr(), obj.as_ptr()));
         });
 
-        Python::with_gil(|py| {
+        Python::attach(move |py| {
             assert_eq!(1, obj.get_refcnt(py));
         });
     }
 
     #[test]
     fn test_seq_get_slice() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let v: Vec<i32> = vec![1, 1, 2, 3, 5, 8];
-            let ob = v.to_object(py);
-            let seq = ob.downcast::<PySequence>(py).unwrap();
+            let ob = v.into_pyobject(py).unwrap();
+            let seq = ob.cast::<PySequence>().unwrap();
             assert_eq!(
                 [1, 2, 3],
                 seq.get_slice(1, 4).unwrap().extract::<[i32; 3]>().unwrap()
@@ -828,25 +521,25 @@ mod tests {
 
     #[test]
     fn test_set_slice() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let v: Vec<i32> = vec![1, 1, 2, 3, 5, 8];
             let w: Vec<i32> = vec![7, 4];
-            let ob = v.to_object(py);
-            let seq = ob.downcast::<PySequence>(py).unwrap();
-            let ins = w.to_object(py);
-            seq.set_slice(1, 4, ins.as_ref(py)).unwrap();
+            let ob = v.into_pyobject(py).unwrap();
+            let seq = ob.cast::<PySequence>().unwrap();
+            let ins = w.into_pyobject(py).unwrap();
+            seq.set_slice(1, 4, &ins).unwrap();
             assert_eq!([1, 7, 4, 5, 8], seq.extract::<[i32; 5]>().unwrap());
-            seq.set_slice(3, 100, PyList::empty(py)).unwrap();
+            seq.set_slice(3, 100, &PyList::empty(py)).unwrap();
             assert_eq!([1, 7, 4], seq.extract::<[i32; 3]>().unwrap());
         });
     }
 
     #[test]
     fn test_del_slice() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let v: Vec<i32> = vec![1, 1, 2, 3, 5, 8];
-            let ob = v.to_object(py);
-            let seq = ob.downcast::<PySequence>(py).unwrap();
+            let ob = v.into_pyobject(py).unwrap();
+            let seq = ob.cast::<PySequence>().unwrap();
             seq.del_slice(1, 4).unwrap();
             assert_eq!([1, 5, 8], seq.extract::<[i32; 3]>().unwrap());
             seq.del_slice(1, 100).unwrap();
@@ -856,10 +549,10 @@ mod tests {
 
     #[test]
     fn test_seq_index() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let v: Vec<i32> = vec![1, 1, 2, 3, 5, 8];
-            let ob = v.to_object(py);
-            let seq = ob.downcast::<PySequence>(py).unwrap();
+            let ob = v.into_pyobject(py).unwrap();
+            let seq = ob.cast::<PySequence>().unwrap();
             assert_eq!(0, seq.index(1i32).unwrap());
             assert_eq!(2, seq.index(2i32).unwrap());
             assert_eq!(3, seq.index(3i32).unwrap());
@@ -870,12 +563,12 @@ mod tests {
     }
 
     #[test]
-    #[cfg(not(PyPy))]
+    #[cfg(not(any(PyPy, GraalPy)))]
     fn test_seq_count() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let v: Vec<i32> = vec![1, 1, 2, 3, 5, 8];
-            let ob = v.to_object(py);
-            let seq = ob.downcast::<PySequence>(py).unwrap();
+            let ob = v.into_pyobject(py).unwrap();
+            let seq = ob.cast::<PySequence>().unwrap();
             assert_eq!(2, seq.count(1i32).unwrap());
             assert_eq!(1, seq.count(2i32).unwrap());
             assert_eq!(1, seq.count(3i32).unwrap());
@@ -887,12 +580,12 @@ mod tests {
 
     #[test]
     fn test_seq_iter() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let v: Vec<i32> = vec![1, 1, 2, 3, 5, 8];
-            let ob = v.to_object(py);
-            let seq = ob.downcast::<PySequence>(py).unwrap();
+            let ob = (&v).into_pyobject(py).unwrap();
+            let seq = ob.cast::<PySequence>().unwrap();
             let mut idx = 0;
-            for el in seq.iter().unwrap() {
+            for el in seq.try_iter().unwrap() {
                 assert_eq!(v[idx], el.unwrap().extract::<i32>().unwrap());
                 idx += 1;
             }
@@ -902,29 +595,29 @@ mod tests {
 
     #[test]
     fn test_seq_strings() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let v = vec!["It", "was", "the", "worst", "of", "times"];
-            let ob = v.to_object(py);
-            let seq = ob.downcast::<PySequence>(py).unwrap();
+            let ob = v.into_pyobject(py).unwrap();
+            let seq = ob.cast::<PySequence>().unwrap();
 
-            let bad_needle = "blurst".to_object(py);
+            let bad_needle = "blurst".into_pyobject(py).unwrap();
             assert!(!seq.contains(bad_needle).unwrap());
 
-            let good_needle = "worst".to_object(py);
+            let good_needle = "worst".into_pyobject(py).unwrap();
             assert!(seq.contains(good_needle).unwrap());
         });
     }
 
     #[test]
     fn test_seq_concat() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let v: Vec<i32> = vec![1, 2, 3];
-            let ob = v.to_object(py);
-            let seq = ob.downcast::<PySequence>(py).unwrap();
+            let ob = v.into_pyobject(py).unwrap();
+            let seq = ob.cast::<PySequence>().unwrap();
             let concat_seq = seq.concat(seq).unwrap();
             assert_eq!(6, concat_seq.len().unwrap());
             let concat_v: Vec<i32> = vec![1, 2, 3, 1, 2, 3];
-            for (el, cc) in concat_seq.iter().unwrap().zip(concat_v) {
+            for (el, cc) in concat_seq.try_iter().unwrap().zip(concat_v) {
                 assert_eq!(cc, el.unwrap().extract::<i32>().unwrap());
             }
         });
@@ -932,14 +625,14 @@ mod tests {
 
     #[test]
     fn test_seq_concat_string() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let v = "string";
-            let ob = v.to_object(py);
-            let seq = ob.downcast::<PySequence>(py).unwrap();
+            let ob = v.into_pyobject(py).unwrap();
+            let seq = ob.cast::<PySequence>().unwrap();
             let concat_seq = seq.concat(seq).unwrap();
             assert_eq!(12, concat_seq.len().unwrap());
             let concat_v = "stringstring".to_owned();
-            for (el, cc) in seq.iter().unwrap().zip(concat_v.chars()) {
+            for (el, cc) in seq.try_iter().unwrap().zip(concat_v.chars()) {
                 assert_eq!(cc, el.unwrap().extract::<char>().unwrap());
             }
         });
@@ -947,14 +640,14 @@ mod tests {
 
     #[test]
     fn test_seq_repeat() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let v = vec!["foo", "bar"];
-            let ob = v.to_object(py);
-            let seq = ob.downcast::<PySequence>(py).unwrap();
+            let ob = v.into_pyobject(py).unwrap();
+            let seq = ob.cast::<PySequence>().unwrap();
             let repeat_seq = seq.repeat(3).unwrap();
             assert_eq!(6, repeat_seq.len().unwrap());
             let repeated = ["foo", "bar", "foo", "bar", "foo", "bar"];
-            for (el, rpt) in repeat_seq.iter().unwrap().zip(repeated.iter()) {
+            for (el, rpt) in repeat_seq.try_iter().unwrap().zip(repeated.iter()) {
                 assert_eq!(*rpt, el.unwrap().extract::<String>().unwrap());
             }
         });
@@ -962,124 +655,94 @@ mod tests {
 
     #[test]
     fn test_seq_inplace() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let v = vec!["foo", "bar"];
-            let ob = v.to_object(py);
-            let seq = ob.downcast::<PySequence>(py).unwrap();
+            let ob = v.into_pyobject(py).unwrap();
+            let seq = ob.cast::<PySequence>().unwrap();
             let rep_seq = seq.in_place_repeat(3).unwrap();
             assert_eq!(6, seq.len().unwrap());
-            assert!(seq.is(rep_seq));
+            assert!(seq.is(&rep_seq));
 
             let conc_seq = seq.in_place_concat(seq).unwrap();
             assert_eq!(12, seq.len().unwrap());
-            assert!(seq.is(conc_seq));
+            assert!(seq.is(&conc_seq));
         });
     }
 
     #[test]
     fn test_list_coercion() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let v = vec!["foo", "bar"];
-            let ob = v.to_object(py);
-            let seq = ob.downcast::<PySequence>(py).unwrap();
-            assert!(seq.to_list().unwrap().eq(PyList::new(py, &v)).unwrap());
+            let ob = (&v).into_pyobject(py).unwrap();
+            let seq = ob.cast::<PySequence>().unwrap();
+            assert!(seq
+                .to_list()
+                .unwrap()
+                .eq(PyList::new(py, &v).unwrap())
+                .unwrap());
         });
     }
 
     #[test]
     fn test_strings_coerce_to_lists() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let v = "foo";
-            let ob = v.to_object(py);
-            let seq: &PySequence = ob.downcast(py).unwrap();
+            let ob = v.into_pyobject(py).unwrap();
+            let seq = ob.cast::<PySequence>().unwrap();
             assert!(seq
                 .to_list()
                 .unwrap()
-                .eq(PyList::new(py, ["f", "o", "o"]))
+                .eq(PyList::new(py, ["f", "o", "o"]).unwrap())
                 .unwrap());
         });
     }
 
     #[test]
     fn test_tuple_coercion() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let v = ("foo", "bar");
-            let ob = v.to_object(py);
-            let seq = ob.downcast::<PySequence>(py).unwrap();
+            let ob = v.into_pyobject(py).unwrap();
+            let seq = ob.cast::<PySequence>().unwrap();
             assert!(seq
                 .to_tuple()
                 .unwrap()
-                .eq(PyTuple::new_bound(py, ["foo", "bar"]))
+                .eq(PyTuple::new(py, ["foo", "bar"]).unwrap())
                 .unwrap());
         });
     }
 
     #[test]
     fn test_lists_coerce_to_tuples() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let v = vec!["foo", "bar"];
-            let ob = v.to_object(py);
-            let seq = ob.downcast::<PySequence>(py).unwrap();
+            let ob = (&v).into_pyobject(py).unwrap();
+            let seq = ob.cast::<PySequence>().unwrap();
             assert!(seq
                 .to_tuple()
                 .unwrap()
-                .eq(PyTuple::new_bound(py, &v))
+                .eq(PyTuple::new(py, &v).unwrap())
                 .unwrap());
         });
     }
 
     #[test]
-    fn test_extract_tuple_to_vec() {
-        Python::with_gil(|py| {
-            let v: Vec<i32> = py.eval("(1, 2)", None, None).unwrap().extract().unwrap();
-            assert!(v == [1, 2]);
-        });
-    }
-
-    #[test]
-    fn test_extract_range_to_vec() {
-        Python::with_gil(|py| {
-            let v: Vec<i32> = py
-                .eval("range(1, 5)", None, None)
-                .unwrap()
-                .extract()
-                .unwrap();
-            assert!(v == [1, 2, 3, 4]);
-        });
-    }
-
-    #[test]
-    fn test_extract_bytearray_to_vec() {
-        Python::with_gil(|py| {
-            let v: Vec<u8> = py
-                .eval("bytearray(b'abc')", None, None)
-                .unwrap()
-                .extract()
-                .unwrap();
-            assert!(v == b"abc");
-        });
-    }
-
-    #[test]
-    fn test_seq_downcast_unchecked() {
-        Python::with_gil(|py| {
+    fn test_seq_cast_unchecked() {
+        Python::attach(|py| {
             let v = vec!["foo", "bar"];
-            let ob = v.to_object(py);
-            let seq = ob.downcast::<PySequence>(py).unwrap();
-            let type_ptr = seq.as_ref();
-            let seq_from = unsafe { type_ptr.downcast_unchecked::<PySequence>() };
+            let ob = v.into_pyobject(py).unwrap();
+            let seq = ob.cast::<PySequence>().unwrap();
+            let type_ptr = seq.as_any();
+            let seq_from = unsafe { type_ptr.cast_unchecked::<PySequence>() };
             assert!(seq_from.to_list().is_ok());
         });
     }
 
     #[test]
-    #[allow(deprecated)]
-    fn test_seq_try_from() {
-        use crate::PyTryFrom;
-        Python::with_gil(|py| {
-            let list = PyList::empty(py);
-            let _ = <PySequence as PyTryFrom>::try_from(list).unwrap();
-            let _ = PySequence::try_from_exact(list).unwrap();
-        });
+    fn test_type_object() {
+        Python::attach(|py| {
+            let abc = PySequence::type_object(py);
+            assert!(PyList::empty(py).is_instance(&abc).unwrap());
+            assert!(PyTuple::empty(py).is_instance(&abc).unwrap());
+        })
     }
 }
diff --git a/src/types/set.rs b/src/types/set.rs
index 3204e71f3e5..2f22b2f9ba2 100644
--- a/src/types/set.rs
+++ b/src/types/set.rs
@@ -1,21 +1,27 @@
-#[cfg(Py_LIMITED_API)]
 use crate::types::PyIterator;
 use crate::{
     err::{self, PyErr, PyResult},
     ffi_ptr_ext::FfiPtrExt,
     instance::Bound,
     py_result_ext::PyResultExt,
-    types::any::PyAnyMethods,
-    PyNativeType,
 };
-use crate::{ffi, PyAny, PyObject, Python, ToPyObject};
+use crate::{ffi, Borrowed, BoundObject, IntoPyObject, IntoPyObjectExt, PyAny, Python};
 use std::ptr;
 
-/// Represents a Python `set`
+/// Represents a Python `set`.
+///
+/// Values of this type are accessed via PyO3's smart pointers, e.g. as
+/// [`Py<PySet>`][crate::Py] or [`Bound<'py, PySet>`][Bound].
+///
+/// For APIs available on `set` objects, see the [`PySetMethods`] trait which is implemented for
+/// [`Bound<'py, PySet>`][Bound].
 #[repr(transparent)]
 pub struct PySet(PyAny);
 
-#[cfg(not(PyPy))]
+#[cfg(not(any(PyPy, GraalPy)))]
+pyobject_subclassable_native_type!(PySet, crate::ffi::PySetObject);
+
+#[cfg(not(any(PyPy, GraalPy)))]
 pyobject_native_type!(
     PySet,
     ffi::PySetObject,
@@ -23,7 +29,7 @@ pyobject_native_type!(
     #checkfunction=ffi::PySet_Check
 );
 
-#[cfg(PyPy)]
+#[cfg(any(PyPy, GraalPy))]
 pyobject_native_type_core!(
     PySet,
     pyobject_native_static_type_object!(ffi::PySet_Type),
@@ -31,107 +37,28 @@ pyobject_native_type_core!(
 );
 
 impl PySet {
-    /// Deprecated form of [`PySet::new_bound`].
-    #[cfg_attr(
-        not(feature = "gil-refs"),
-        deprecated(
-            since = "0.21.0",
-            note = "`PySet::new` will be replaced by `PySet::new_bound` in a future PyO3 version"
-        )
-    )]
-    #[inline]
-    pub fn new<'a, 'p, T: ToPyObject + 'a>(
-        py: Python<'p>,
-        elements: impl IntoIterator<Item = &'a T>,
-    ) -> PyResult<&'p PySet> {
-        Self::new_bound(py, elements).map(Bound::into_gil_ref)
-    }
-
     /// Creates a new set with elements from the given slice.
     ///
     /// Returns an error if some element is not hashable.
     #[inline]
-    pub fn new_bound<'a, 'p, T: ToPyObject + 'a>(
-        py: Python<'p>,
-        elements: impl IntoIterator<Item = &'a T>,
-    ) -> PyResult<Bound<'p, PySet>> {
-        new_from_iter(py, elements)
-    }
-
-    /// Deprecated form of [`PySet::empty_bound`].
-    pub fn empty(py: Python<'_>) -> PyResult<&'_ PySet> {
-        Self::empty_bound(py).map(Bound::into_gil_ref)
+    pub fn new<'py, T>(
+        py: Python<'py>,
+        elements: impl IntoIterator<Item = T>,
+    ) -> PyResult<Bound<'py, PySet>>
+    where
+        T: IntoPyObject<'py>,
+    {
+        try_new_from_iter(py, elements)
     }
 
     /// Creates a new empty set.
-    pub fn empty_bound(py: Python<'_>) -> PyResult<Bound<'_, PySet>> {
+    pub fn empty(py: Python<'_>) -> PyResult<Bound<'_, PySet>> {
         unsafe {
             ffi::PySet_New(ptr::null_mut())
                 .assume_owned_or_err(py)
-                .downcast_into_unchecked()
+                .cast_into_unchecked()
         }
     }
-
-    /// Removes all elements from the set.
-    #[inline]
-    pub fn clear(&self) {
-        self.as_borrowed().clear()
-    }
-
-    /// Returns the number of items in the set.
-    ///
-    /// This is equivalent to the Python expression `len(self)`.
-    #[inline]
-    pub fn len(&self) -> usize {
-        self.as_borrowed().len()
-    }
-
-    /// Checks if set is empty.
-    pub fn is_empty(&self) -> bool {
-        self.as_borrowed().is_empty()
-    }
-
-    /// Determines if the set contains the specified key.
-    ///
-    /// This is equivalent to the Python expression `key in self`.
-    pub fn contains<K>(&self, key: K) -> PyResult<bool>
-    where
-        K: ToPyObject,
-    {
-        self.as_borrowed().contains(key)
-    }
-
-    /// Removes the element from the set if it is present.
-    ///
-    /// Returns `true` if the element was present in the set.
-    pub fn discard<K>(&self, key: K) -> PyResult<bool>
-    where
-        K: ToPyObject,
-    {
-        self.as_borrowed().discard(key)
-    }
-
-    /// Adds an element to the set.
-    pub fn add<K>(&self, key: K) -> PyResult<()>
-    where
-        K: ToPyObject,
-    {
-        self.as_borrowed().add(key)
-    }
-
-    /// Removes and returns an arbitrary element from the set.
-    pub fn pop(&self) -> Option<PyObject> {
-        self.as_borrowed().pop().map(Bound::unbind)
-    }
-
-    /// Returns an iterator of values in this set.
-    ///
-    /// # Panics
-    ///
-    /// If PyO3 detects that the set is mutated during iteration, it will panic.
-    pub fn iter(&self) -> PySetIterator<'_> {
-        PySetIterator(BoundSetIterator::new(self.as_borrowed().to_owned()))
-    }
 }
 
 /// Implementation of functionality for [`PySet`].
@@ -140,7 +67,7 @@ impl PySet {
 /// syntax these methods are separated into a trait, because stable Rust does not yet support
 /// `arbitrary_self_types`.
 #[doc(alias = "PySet")]
-pub trait PySetMethods<'py> {
+pub trait PySetMethods<'py>: crate::sealed::Sealed {
     /// Removes all elements from the set.
     fn clear(&self);
 
@@ -159,19 +86,19 @@ pub trait PySetMethods<'py> {
     /// This is equivalent to the Python expression `key in self`.
     fn contains<K>(&self, key: K) -> PyResult<bool>
     where
-        K: ToPyObject;
+        K: IntoPyObject<'py>;
 
     /// Removes the element from the set if it is present.
     ///
     /// Returns `true` if the element was present in the set.
     fn discard<K>(&self, key: K) -> PyResult<bool>
     where
-        K: ToPyObject;
+        K: IntoPyObject<'py>;
 
     /// Adds an element to the set.
     fn add<K>(&self, key: K) -> PyResult<()>
     where
-        K: ToPyObject;
+        K: IntoPyObject<'py>;
 
     /// Removes and returns an arbitrary element from the set.
     fn pop(&self) -> Option<Bound<'py, PyAny>>;
@@ -199,9 +126,9 @@ impl<'py> PySetMethods<'py> for Bound<'py, PySet> {
 
     fn contains<K>(&self, key: K) -> PyResult<bool>
     where
-        K: ToPyObject,
+        K: IntoPyObject<'py>,
     {
-        fn inner(set: &Bound<'_, PySet>, key: Bound<'_, PyAny>) -> PyResult<bool> {
+        fn inner(set: &Bound<'_, PySet>, key: Borrowed<'_, '_, PyAny>) -> PyResult<bool> {
             match unsafe { ffi::PySet_Contains(set.as_ptr(), key.as_ptr()) } {
                 1 => Ok(true),
                 0 => Ok(false),
@@ -210,14 +137,17 @@ impl<'py> PySetMethods<'py> for Bound<'py, PySet> {
         }
 
         let py = self.py();
-        inner(self, key.to_object(py).into_bound(py))
+        inner(
+            self,
+            key.into_pyobject_or_pyerr(py)?.into_any().as_borrowed(),
+        )
     }
 
     fn discard<K>(&self, key: K) -> PyResult<bool>
     where
-        K: ToPyObject,
+        K: IntoPyObject<'py>,
     {
-        fn inner(set: &Bound<'_, PySet>, key: Bound<'_, PyAny>) -> PyResult<bool> {
+        fn inner(set: &Bound<'_, PySet>, key: Borrowed<'_, '_, PyAny>) -> PyResult<bool> {
             match unsafe { ffi::PySet_Discard(set.as_ptr(), key.as_ptr()) } {
                 1 => Ok(true),
                 0 => Ok(false),
@@ -226,29 +156,32 @@ impl<'py> PySetMethods<'py> for Bound<'py, PySet> {
         }
 
         let py = self.py();
-        inner(self, key.to_object(py).into_bound(py))
+        inner(
+            self,
+            key.into_pyobject_or_pyerr(py)?.into_any().as_borrowed(),
+        )
     }
 
     fn add<K>(&self, key: K) -> PyResult<()>
     where
-        K: ToPyObject,
+        K: IntoPyObject<'py>,
     {
-        fn inner(set: &Bound<'_, PySet>, key: Bound<'_, PyAny>) -> PyResult<()> {
+        fn inner(set: &Bound<'_, PySet>, key: Borrowed<'_, '_, PyAny>) -> PyResult<()> {
             err::error_on_minusone(set.py(), unsafe {
                 ffi::PySet_Add(set.as_ptr(), key.as_ptr())
             })
         }
 
         let py = self.py();
-        inner(self, key.to_object(py).into_bound(py))
+        inner(
+            self,
+            key.into_pyobject_or_pyerr(py)?.into_any().as_borrowed(),
+        )
     }
 
     fn pop(&self) -> Option<Bound<'py, PyAny>> {
         let element = unsafe { ffi::PySet_Pop(self.as_ptr()).assume_owned_or_err(self.py()) };
-        match element {
-            Ok(e) => Some(e),
-            Err(_) => None,
-        }
+        element.ok()
     }
 
     fn iter(&self) -> BoundSetIterator<'py> {
@@ -256,41 +189,21 @@ impl<'py> PySetMethods<'py> for Bound<'py, PySet> {
     }
 }
 
-/// PyO3 implementation of an iterator for a Python `set` object.
-pub struct PySetIterator<'py>(BoundSetIterator<'py>);
-
-impl<'py> Iterator for PySetIterator<'py> {
-    type Item = &'py super::PyAny;
-
-    /// Advances the iterator and returns the next value.
-    ///
-    /// # Panics
-    ///
-    /// If PyO3 detects that the set is mutated during iteration, it will panic.
-    #[inline]
-    fn next(&mut self) -> Option<Self::Item> {
-        self.0.next().map(Bound::into_gil_ref)
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        self.0.size_hint()
-    }
-}
+impl<'py> IntoIterator for Bound<'py, PySet> {
+    type Item = Bound<'py, PyAny>;
+    type IntoIter = BoundSetIterator<'py>;
 
-impl<'py> IntoIterator for &'py PySet {
-    type Item = &'py PyAny;
-    type IntoIter = PySetIterator<'py>;
     /// Returns an iterator of values in this set.
     ///
     /// # Panics
     ///
     /// If PyO3 detects that the set is mutated during iteration, it will panic.
     fn into_iter(self) -> Self::IntoIter {
-        PySetIterator(BoundSetIterator::new(self.as_borrowed().to_owned()))
+        BoundSetIterator::new(self)
     }
 }
 
-impl<'py> IntoIterator for Bound<'py, PySet> {
+impl<'py> IntoIterator for &Bound<'py, PySet> {
     type Item = Bound<'py, PyAny>;
     type IntoIter = BoundSetIterator<'py>;
 
@@ -300,147 +213,94 @@ impl<'py> IntoIterator for Bound<'py, PySet> {
     ///
     /// If PyO3 detects that the set is mutated during iteration, it will panic.
     fn into_iter(self) -> Self::IntoIter {
-        BoundSetIterator::new(self)
+        self.iter()
     }
 }
 
-#[cfg(Py_LIMITED_API)]
-mod impl_ {
-    use super::*;
-
-    /// PyO3 implementation of an iterator for a Python `set` object.
-    pub struct BoundSetIterator<'p> {
-        it: Bound<'p, PyIterator>,
-    }
-
-    impl<'py> BoundSetIterator<'py> {
-        pub(super) fn new(set: Bound<'py, PySet>) -> Self {
-            Self {
-                it: PyIterator::from_bound_object(&set).unwrap(),
-            }
-        }
-    }
+/// PyO3 implementation of an iterator for a Python `set` object.
+pub struct BoundSetIterator<'p> {
+    it: Bound<'p, PyIterator>,
+    // Remaining elements in the set. This is fine to store because
+    // Python will error if the set changes size during iteration.
+    remaining: usize,
+}
 
-    impl<'py> Iterator for BoundSetIterator<'py> {
-        type Item = Bound<'py, super::PyAny>;
-
-        /// Advances the iterator and returns the next value.
-        ///
-        /// # Panics
-        ///
-        /// If PyO3 detects that the set is mutated during iteration, it will panic.
-        #[inline]
-        fn next(&mut self) -> Option<Self::Item> {
-            self.it.next().map(Result::unwrap)
+impl<'py> BoundSetIterator<'py> {
+    pub(super) fn new(set: Bound<'py, PySet>) -> Self {
+        Self {
+            it: PyIterator::from_object(&set).unwrap(),
+            remaining: set.len(),
         }
     }
 }
 
-#[cfg(not(Py_LIMITED_API))]
-mod impl_ {
-    use super::*;
+impl<'py> Iterator for BoundSetIterator<'py> {
+    type Item = Bound<'py, super::PyAny>;
 
-    /// PyO3 implementation of an iterator for a Python `set` object.
-    pub struct BoundSetIterator<'py> {
-        set: Bound<'py, super::PySet>,
-        pos: ffi::Py_ssize_t,
-        used: ffi::Py_ssize_t,
-    }
-
-    impl<'py> BoundSetIterator<'py> {
-        pub(super) fn new(set: Bound<'py, PySet>) -> Self {
-            let used = unsafe { ffi::PySet_Size(set.as_ptr()) };
-            BoundSetIterator { set, pos: 0, used }
-        }
+    /// Advances the iterator and returns the next value.
+    fn next(&mut self) -> Option<Self::Item> {
+        self.remaining = self.remaining.saturating_sub(1);
+        self.it.next().map(Result::unwrap)
     }
 
-    impl<'py> Iterator for BoundSetIterator<'py> {
-        type Item = Bound<'py, super::PyAny>;
-
-        /// Advances the iterator and returns the next value.
-        ///
-        /// # Panics
-        ///
-        /// If PyO3 detects that the set is mutated during iteration, it will panic.
-        #[inline]
-        fn next(&mut self) -> Option<Self::Item> {
-            unsafe {
-                let len = ffi::PySet_Size(self.set.as_ptr());
-                assert_eq!(self.used, len, "Set changed size during iteration");
-
-                let mut key: *mut ffi::PyObject = std::ptr::null_mut();
-                let mut hash: ffi::Py_hash_t = 0;
-                if ffi::_PySet_NextEntry(self.set.as_ptr(), &mut self.pos, &mut key, &mut hash) != 0
-                {
-                    // _PySet_NextEntry returns borrowed object; for safety must make owned (see #890)
-                    Some(key.assume_borrowed(self.set.py()).to_owned())
-                } else {
-                    None
-                }
-            }
-        }
-
-        #[inline]
-        fn size_hint(&self) -> (usize, Option<usize>) {
-            let len = self.len();
-            (len, Some(len))
-        }
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        (self.remaining, Some(self.remaining))
     }
 
-    impl<'py> ExactSizeIterator for BoundSetIterator<'py> {
-        fn len(&self) -> usize {
-            self.set.len().saturating_sub(self.pos as usize)
-        }
+    #[inline]
+    fn count(self) -> usize
+    where
+        Self: Sized,
+    {
+        self.len()
     }
+}
 
-    impl<'py> ExactSizeIterator for PySetIterator<'py> {
-        fn len(&self) -> usize {
-            self.0.len()
-        }
+impl ExactSizeIterator for BoundSetIterator<'_> {
+    fn len(&self) -> usize {
+        self.remaining
     }
 }
 
-pub use impl_::*;
-
 #[inline]
-pub(crate) fn new_from_iter<T: ToPyObject>(
-    py: Python<'_>,
+pub(crate) fn try_new_from_iter<'py, T>(
+    py: Python<'py>,
     elements: impl IntoIterator<Item = T>,
-) -> PyResult<Bound<'_, PySet>> {
-    fn inner<'py>(
-        py: Python<'py>,
-        elements: &mut dyn Iterator<Item = PyObject>,
-    ) -> PyResult<Bound<'py, PySet>> {
-        let set = unsafe {
-            // We create the  `Py` pointer because its Drop cleans up the set if user code panics.
-            ffi::PySet_New(std::ptr::null_mut())
-                .assume_owned_or_err(py)?
-                .downcast_into_unchecked()
-        };
-        let ptr = set.as_ptr();
-
-        for obj in elements {
-            err::error_on_minusone(py, unsafe { ffi::PySet_Add(ptr, obj.as_ptr()) })?;
-        }
-
-        Ok(set)
-    }
-
-    let mut iter = elements.into_iter().map(|e| e.to_object(py));
-    inner(py, &mut iter)
+) -> PyResult<Bound<'py, PySet>>
+where
+    T: IntoPyObject<'py>,
+{
+    let set = unsafe {
+        // We create the `Bound` pointer because its Drop cleans up the set if
+        // user code errors or panics.
+        ffi::PySet_New(std::ptr::null_mut())
+            .assume_owned_or_err(py)?
+            .cast_into_unchecked()
+    };
+    let ptr = set.as_ptr();
+
+    elements.into_iter().try_for_each(|element| {
+        let obj = element.into_pyobject_or_pyerr(py)?;
+        err::error_on_minusone(py, unsafe { ffi::PySet_Add(ptr, obj.as_ptr()) })
+    })?;
+
+    Ok(set)
 }
 
 #[cfg(test)]
-#[cfg_attr(not(feature = "gil-refs"), allow(deprecated))]
 mod tests {
     use super::PySet;
-    use crate::{Python, ToPyObject};
+    use crate::{
+        conversion::IntoPyObject,
+        types::{PyAnyMethods, PySetMethods},
+        Python,
+    };
     use std::collections::HashSet;
 
     #[test]
     fn test_set_new() {
-        Python::with_gil(|py| {
-            let set = PySet::new(py, &[1]).unwrap();
+        Python::attach(|py| {
+            let set = PySet::new(py, [1]).unwrap();
             assert_eq!(1, set.len());
 
             let v = vec![1];
@@ -450,7 +310,7 @@ mod tests {
 
     #[test]
     fn test_set_empty() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let set = PySet::empty(py).unwrap();
             assert_eq!(0, set.len());
             assert!(set.is_empty());
@@ -459,22 +319,22 @@ mod tests {
 
     #[test]
     fn test_set_len() {
-        Python::with_gil(|py| {
-            let mut v = HashSet::new();
-            let ob = v.to_object(py);
-            let set: &PySet = ob.downcast(py).unwrap();
+        Python::attach(|py| {
+            let mut v = HashSet::<i32>::new();
+            let ob = (&v).into_pyobject(py).unwrap();
+            let set = ob.cast::<PySet>().unwrap();
             assert_eq!(0, set.len());
             v.insert(7);
-            let ob = v.to_object(py);
-            let set2: &PySet = ob.downcast(py).unwrap();
+            let ob = v.into_pyobject(py).unwrap();
+            let set2 = ob.cast::<PySet>().unwrap();
             assert_eq!(1, set2.len());
         });
     }
 
     #[test]
     fn test_set_clear() {
-        Python::with_gil(|py| {
-            let set = PySet::new(py, &[1]).unwrap();
+        Python::attach(|py| {
+            let set = PySet::new(py, [1]).unwrap();
             assert_eq!(1, set.len());
             set.clear();
             assert_eq!(0, set.len());
@@ -483,16 +343,16 @@ mod tests {
 
     #[test]
     fn test_set_contains() {
-        Python::with_gil(|py| {
-            let set = PySet::new(py, &[1]).unwrap();
+        Python::attach(|py| {
+            let set = PySet::new(py, [1]).unwrap();
             assert!(set.contains(1).unwrap());
         });
     }
 
     #[test]
     fn test_set_discard() {
-        Python::with_gil(|py| {
-            let set = PySet::new(py, &[1]).unwrap();
+        Python::attach(|py| {
+            let set = PySet::new(py, [1]).unwrap();
             assert!(!set.discard(2).unwrap());
             assert_eq!(1, set.len());
 
@@ -506,40 +366,47 @@ mod tests {
 
     #[test]
     fn test_set_add() {
-        Python::with_gil(|py| {
-            let set = PySet::new(py, &[1, 2]).unwrap();
-            set.add(1).unwrap(); // Add a dupliated element
+        Python::attach(|py| {
+            let set = PySet::new(py, [1, 2]).unwrap();
+            set.add(1).unwrap(); // Add a duplicated element
             assert!(set.contains(1).unwrap());
         });
     }
 
     #[test]
     fn test_set_pop() {
-        Python::with_gil(|py| {
-            let set = PySet::new(py, &[1]).unwrap();
+        Python::attach(|py| {
+            let set = PySet::new(py, [1]).unwrap();
             let val = set.pop();
             assert!(val.is_some());
             let val2 = set.pop();
             assert!(val2.is_none());
             assert!(py
-                .eval("print('Exception state should not be set.')", None, None)
+                .eval(c"print('Exception state should not be set.')", None, None)
                 .is_ok());
         });
     }
 
     #[test]
     fn test_set_iter() {
-        Python::with_gil(|py| {
-            let set = PySet::new(py, &[1]).unwrap();
+        Python::attach(|py| {
+            let set = PySet::new(py, [1]).unwrap();
 
-            // iter method
             for el in set {
                 assert_eq!(1i32, el.extract::<'_, i32>().unwrap());
             }
+        });
+    }
 
-            // intoiterator iteration
-            for el in set {
-                assert_eq!(1i32, el.extract::<'_, i32>().unwrap());
+    #[test]
+    fn test_set_iter_bound() {
+        use crate::types::any::PyAnyMethods;
+
+        Python::attach(|py| {
+            let set = PySet::new(py, [1]).unwrap();
+
+            for el in &set {
+                assert_eq!(1i32, el.extract::<i32>().unwrap());
             }
         });
     }
@@ -547,10 +414,10 @@ mod tests {
     #[test]
     #[should_panic]
     fn test_set_iter_mutation() {
-        Python::with_gil(|py| {
-            let set = PySet::new(py, &[1, 2, 3, 4, 5]).unwrap();
+        Python::attach(|py| {
+            let set = PySet::new(py, [1, 2, 3, 4, 5]).unwrap();
 
-            for _ in set {
+            for _ in &set {
                 let _ = set.add(42);
             }
         });
@@ -559,10 +426,10 @@ mod tests {
     #[test]
     #[should_panic]
     fn test_set_iter_mutation_same_len() {
-        Python::with_gil(|py| {
-            let set = PySet::new(py, &[1, 2, 3, 4, 5]).unwrap();
+        Python::attach(|py| {
+            let set = PySet::new(py, [1, 2, 3, 4, 5]).unwrap();
 
-            for item in set {
+            for item in &set {
                 let item: i32 = item.extract().unwrap();
                 let _ = set.del_item(item);
                 let _ = set.add(item + 10);
@@ -571,10 +438,9 @@ mod tests {
     }
 
     #[test]
-    #[cfg(not(Py_LIMITED_API))]
     fn test_set_iter_size_hint() {
-        Python::with_gil(|py| {
-            let set = PySet::new(py, &[1]).unwrap();
+        Python::attach(|py| {
+            let set = PySet::new(py, [1]).unwrap();
             let mut iter = set.iter();
 
             // Exact size
@@ -587,14 +453,10 @@ mod tests {
     }
 
     #[test]
-    #[cfg(Py_LIMITED_API)]
-    fn test_set_iter_size_hint() {
-        Python::with_gil(|py| {
-            let set = PySet::new(py, &[1]).unwrap();
-            let iter = set.iter();
-
-            // No known bounds
-            assert_eq!(iter.size_hint(), (0, None));
-        });
+    fn test_iter_count() {
+        Python::attach(|py| {
+            let set = PySet::new(py, vec![1, 2, 3]).unwrap();
+            assert_eq!(set.iter().count(), 3);
+        })
     }
 }
diff --git a/src/types/slice.rs b/src/types/slice.rs
index 8e86ff7ceee..78248d54c40 100644
--- a/src/types/slice.rs
+++ b/src/types/slice.rs
@@ -1,13 +1,19 @@
 use crate::err::{PyErr, PyResult};
-use crate::ffi::{self, Py_ssize_t};
+use crate::ffi;
 use crate::ffi_ptr_ext::FfiPtrExt;
-use crate::types::any::PyAnyMethods;
-use crate::{Bound, PyAny, PyNativeType, PyObject, Python, ToPyObject};
-use std::os::raw::c_long;
+use crate::types::{PyRange, PyRangeMethods};
+use crate::{Bound, IntoPyObject, PyAny, Python};
+use std::convert::Infallible;
 
 /// Represents a Python `slice`.
 ///
-/// Only `c_long` indices supported at the moment by the `PySlice` object.
+/// Values of this type are accessed via PyO3's smart pointers, e.g. as
+/// [`Py<PySlice>`][crate::Py] or [`Bound<'py, PySlice>`][Bound].
+///
+/// For APIs available on `slice` objects, see the [`PySliceMethods`] trait which is implemented for
+/// [`Bound<'py, PySlice>`][Bound].
+///
+/// Only `isize` indices supported at the moment by the `PySlice` object.
 #[repr(transparent)]
 pub struct PySlice(PyAny);
 
@@ -18,17 +24,21 @@ pyobject_native_type!(
     #checkfunction=ffi::PySlice_Check
 );
 
-/// Return value from [`PySlice::indices`].
+/// Return value from [`PySliceMethods::indices`].
 #[derive(Debug, Eq, PartialEq)]
 pub struct PySliceIndices {
     /// Start of the slice
+    ///
+    /// It can be -1 when the step is negative, otherwise it's non-negative.
     pub start: isize,
     /// End of the slice
+    ///
+    /// It can be -1 when the step is negative, otherwise it's non-negative.
     pub stop: isize,
     /// Increment to use when iterating the slice from `start` to `stop`.
     pub step: isize,
     /// The length of the slice calculated from the original input sequence.
-    pub slicelength: isize,
+    pub slicelength: usize,
 }
 
 impl PySliceIndices {
@@ -44,20 +54,8 @@ impl PySliceIndices {
 }
 
 impl PySlice {
-    /// Deprecated form of `PySlice::new_bound`.
-    #[cfg_attr(
-        not(feature = "gil-refs"),
-        deprecated(
-            since = "0.21.0",
-            note = "`PySlice::new` will be replaced by `PySlice::new_bound` in a future PyO3 version"
-        )
-    )]
-    pub fn new(py: Python<'_>, start: isize, stop: isize, step: isize) -> &PySlice {
-        Self::new_bound(py, start, stop, step).into_gil_ref()
-    }
-
     /// Constructs a new slice with the given elements.
-    pub fn new_bound(py: Python<'_>, start: isize, stop: isize, step: isize) -> Bound<'_, PySlice> {
+    pub fn new(py: Python<'_>, start: isize, stop: isize, step: isize) -> Bound<'_, PySlice> {
         unsafe {
             ffi::PySlice_New(
                 ffi::PyLong_FromSsize_t(start),
@@ -65,41 +63,18 @@ impl PySlice {
                 ffi::PyLong_FromSsize_t(step),
             )
             .assume_owned(py)
-            .downcast_into_unchecked()
-        }
-    }
-
-    /// Deprecated form of `PySlice::full_bound`.
-    #[cfg_attr(
-        not(feature = "gil-refs"),
-        deprecated(
-            since = "0.21.0",
-            note = "`PySlice::full` will be replaced by `PySlice::full_bound` in a future PyO3 version"
-        )
-    )]
-    pub fn full(py: Python<'_>) -> &PySlice {
-        unsafe {
-            let ptr = ffi::PySlice_New(ffi::Py_None(), ffi::Py_None(), ffi::Py_None());
-            py.from_owned_ptr(ptr)
+            .cast_into_unchecked()
         }
     }
 
     /// Constructs a new full slice that is equivalent to `::`.
-    pub fn full_bound(py: Python<'_>) -> Bound<'_, PySlice> {
+    pub fn full(py: Python<'_>) -> Bound<'_, PySlice> {
         unsafe {
             ffi::PySlice_New(ffi::Py_None(), ffi::Py_None(), ffi::Py_None())
                 .assume_owned(py)
-                .downcast_into_unchecked()
+                .cast_into_unchecked()
         }
     }
-
-    /// Retrieves the start, stop, and step indices from the slice object,
-    /// assuming a sequence of length `length`, and stores the length of the
-    /// slice in its `slicelength` member.
-    #[inline]
-    pub fn indices(&self, length: c_long) -> PyResult<PySliceIndices> {
-        self.as_borrowed().indices(length)
-    }
 }
 
 /// Implementation of functionality for [`PySlice`].
@@ -108,16 +83,15 @@ impl PySlice {
 /// syntax these methods are separated into a trait, because stable Rust does not yet support
 /// `arbitrary_self_types`.
 #[doc(alias = "PySlice")]
-pub trait PySliceMethods<'py> {
+pub trait PySliceMethods<'py>: crate::sealed::Sealed {
     /// Retrieves the start, stop, and step indices from the slice object,
     /// assuming a sequence of length `length`, and stores the length of the
     /// slice in its `slicelength` member.
-    fn indices(&self, length: c_long) -> PyResult<PySliceIndices>;
+    fn indices(&self, length: isize) -> PyResult<PySliceIndices>;
 }
 
 impl<'py> PySliceMethods<'py> for Bound<'py, PySlice> {
-    fn indices(&self, length: c_long) -> PyResult<PySliceIndices> {
-        // non-negative Py_ssize_t should always fit into Rust usize
+    fn indices(&self, length: isize) -> PyResult<PySliceIndices> {
         unsafe {
             let mut slicelength: isize = 0;
             let mut start: isize = 0;
@@ -125,7 +99,7 @@ impl<'py> PySliceMethods<'py> for Bound<'py, PySlice> {
             let mut step: isize = 0;
             let r = ffi::PySlice_GetIndicesEx(
                 self.as_ptr(),
-                length as Py_ssize_t,
+                length,
                 &mut start,
                 &mut stop,
                 &mut step,
@@ -136,7 +110,8 @@ impl<'py> PySliceMethods<'py> for Bound<'py, PySlice> {
                     start,
                     stop,
                     step,
-                    slicelength,
+                    // non-negative isize should always fit into usize
+                    slicelength: slicelength as _,
                 })
             } else {
                 Err(PyErr::fetch(self.py()))
@@ -145,20 +120,48 @@ impl<'py> PySliceMethods<'py> for Bound<'py, PySlice> {
     }
 }
 
-impl ToPyObject for PySliceIndices {
-    fn to_object(&self, py: Python<'_>) -> PyObject {
-        PySlice::new_bound(py, self.start, self.stop, self.step).into()
+impl<'py> IntoPyObject<'py> for PySliceIndices {
+    type Target = PySlice;
+    type Output = Bound<'py, Self::Target>;
+    type Error = Infallible;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        Ok(PySlice::new(py, self.start, self.stop, self.step))
+    }
+}
+
+impl<'py> IntoPyObject<'py> for &PySliceIndices {
+    type Target = PySlice;
+    type Output = Bound<'py, Self::Target>;
+    type Error = Infallible;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        Ok(PySlice::new(py, self.start, self.stop, self.step))
+    }
+}
+
+impl<'py> TryFrom<Bound<'py, PyRange>> for Bound<'py, PySlice> {
+    type Error = PyErr;
+
+    fn try_from(range: Bound<'py, PyRange>) -> Result<Self, Self::Error> {
+        Ok(PySlice::new(
+            range.py(),
+            range.start()?,
+            range.stop()?,
+            range.step()?,
+        ))
     }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::types::PyAnyMethods as _;
 
     #[test]
     fn test_py_slice_new() {
-        Python::with_gil(|py| {
-            let slice = PySlice::new_bound(py, isize::MIN, isize::MAX, 1);
+        Python::attach(|py| {
+            let slice = PySlice::new(py, isize::MIN, isize::MAX, 1);
             assert_eq!(
                 slice.getattr("start").unwrap().extract::<isize>().unwrap(),
                 isize::MIN
@@ -176,8 +179,8 @@ mod tests {
 
     #[test]
     fn test_py_slice_full() {
-        Python::with_gil(|py| {
-            let slice = PySlice::full_bound(py);
+        Python::attach(|py| {
+            let slice = PySlice::full(py);
             assert!(slice.getattr("start").unwrap().is_none(),);
             assert!(slice.getattr("stop").unwrap().is_none(),);
             assert!(slice.getattr("step").unwrap().is_none(),);
diff --git a/src/types/string.rs b/src/types/string.rs
index 2b2635715d3..ff1875a6c62 100644
--- a/src/types/string.rs
+++ b/src/types/string.rs
@@ -3,12 +3,11 @@ use crate::exceptions::PyUnicodeDecodeError;
 use crate::ffi_ptr_ext::FfiPtrExt;
 use crate::instance::Borrowed;
 use crate::py_result_ext::PyResultExt;
-use crate::types::any::PyAnyMethods;
 use crate::types::bytes::PyBytesMethods;
 use crate::types::PyBytes;
-use crate::{ffi, Bound, IntoPy, Py, PyAny, PyNativeType, PyResult, Python};
+use crate::{ffi, Bound, Py, PyAny, PyResult, Python};
 use std::borrow::Cow;
-use std::os::raw::c_char;
+use std::ffi::{CStr, CString};
 use std::str;
 
 /// Represents raw data backing a Python `str`.
@@ -35,16 +34,10 @@ impl<'a> PyStringData<'a> {
         match self {
             Self::Ucs1(s) => s,
             Self::Ucs2(s) => unsafe {
-                std::slice::from_raw_parts(
-                    s.as_ptr() as *const u8,
-                    s.len() * self.value_width_bytes(),
-                )
+                std::slice::from_raw_parts(s.as_ptr().cast(), s.len() * self.value_width_bytes())
             },
             Self::Ucs4(s) => unsafe {
-                std::slice::from_raw_parts(
-                    s.as_ptr() as *const u8,
-                    s.len() * self.value_width_bytes(),
-                )
+                std::slice::from_raw_parts(s.as_ptr().cast(), s.len() * self.value_width_bytes())
             },
         }
     }
@@ -69,13 +62,10 @@ impl<'a> PyStringData<'a> {
     /// C APIs that skip input validation (like `PyUnicode_FromKindAndData`) and should
     /// never occur for strings that were created from Python code.
     pub fn to_string(self, py: Python<'_>) -> PyResult<Cow<'a, str>> {
-        use std::ffi::CStr;
         match self {
             Self::Ucs1(data) => match str::from_utf8(data) {
                 Ok(s) => Ok(Cow::Borrowed(s)),
-                Err(e) => Err(crate::PyErr::from_value(PyUnicodeDecodeError::new_utf8(
-                    py, data, e,
-                )?)),
+                Err(e) => Err(PyUnicodeDecodeError::new_utf8(py, data, e)?.into()),
             },
             Self::Ucs2(data) => match String::from_utf16(data) {
                 Ok(s) => Ok(Cow::Owned(s)),
@@ -83,24 +73,26 @@ impl<'a> PyStringData<'a> {
                     let mut message = e.to_string().as_bytes().to_vec();
                     message.push(0);
 
-                    Err(crate::PyErr::from_value(PyUnicodeDecodeError::new(
+                    Err(PyUnicodeDecodeError::new(
                         py,
-                        CStr::from_bytes_with_nul(b"utf-16\0").unwrap(),
+                        c"utf-16",
                         self.as_bytes(),
                         0..self.as_bytes().len(),
                         CStr::from_bytes_with_nul(&message).unwrap(),
-                    )?))
+                    )?
+                    .into())
                 }
             },
             Self::Ucs4(data) => match data.iter().map(|&c| std::char::from_u32(c)).collect() {
                 Some(s) => Ok(Cow::Owned(s)),
-                None => Err(crate::PyErr::from_value(PyUnicodeDecodeError::new(
+                None => Err(PyUnicodeDecodeError::new(
                     py,
-                    CStr::from_bytes_with_nul(b"utf-32\0").unwrap(),
+                    c"utf-32",
                     self.as_bytes(),
                     0..self.as_bytes().len(),
-                    CStr::from_bytes_with_nul(b"error converting utf-32\0").unwrap(),
-                )?)),
+                    c"error converting utf-32",
+                )?
+                .into()),
             },
         }
     }
@@ -128,48 +120,66 @@ impl<'a> PyStringData<'a> {
 
 /// Represents a Python `string` (a Unicode string object).
 ///
-/// This type is immutable.
+/// Values of this type are accessed via PyO3's smart pointers, e.g. as
+/// [`Py<PyString>`][crate::Py] or [`Bound<'py, PyString>`][Bound].
+///
+/// For APIs available on `str` objects, see the [`PyStringMethods`] trait which is implemented for
+/// [`Bound<'py, PyString>`][Bound].
+///
+/// # Equality
+///
+/// For convenience, [`Bound<'py, PyString>`] implements [`PartialEq<str>`] to allow comparing the
+/// data in the Python string to a Rust UTF-8 string slice.
+///
+/// This is not always the most appropriate way to compare Python strings, as Python string
+/// subclasses may have different equality semantics. In situations where subclasses overriding
+/// equality might be relevant, use [`PyAnyMethods::eq`](crate::types::any::PyAnyMethods::eq), at
+/// cost of the additional overhead of a Python method call.
+///
+/// ```rust
+/// # use pyo3::prelude::*;
+/// use pyo3::types::PyString;
+///
+/// # Python::attach(|py| {
+/// let py_string = PyString::new(py, "foo");
+/// // via PartialEq<str>
+/// assert_eq!(py_string, "foo");
+///
+/// // via Python equality
+/// assert!(py_string.as_any().eq("foo").unwrap());
+/// # });
+/// ```
 #[repr(transparent)]
 pub struct PyString(PyAny);
 
 pyobject_native_type_core!(PyString, pyobject_native_static_type_object!(ffi::PyUnicode_Type), #checkfunction=ffi::PyUnicode_Check);
 
 impl PyString {
-    /// Deprecated form of [`PyString::new_bound`].
-    #[cfg_attr(
-        not(feature = "gil-refs"),
-        deprecated(
-            since = "0.21.0",
-            note = "`PyString::new` will be replaced by `PyString::new_bound` in a future PyO3 version"
-        )
-    )]
-    pub fn new<'py>(py: Python<'py>, s: &str) -> &'py Self {
-        Self::new_bound(py, s).into_gil_ref()
-    }
-
     /// Creates a new Python string object.
     ///
     /// Panics if out of memory.
-    pub fn new_bound<'py>(py: Python<'py>, s: &str) -> Bound<'py, PyString> {
-        let ptr = s.as_ptr() as *const c_char;
+    pub fn new<'py>(py: Python<'py>, s: &str) -> Bound<'py, PyString> {
+        let ptr = s.as_ptr().cast();
         let len = s.len() as ffi::Py_ssize_t;
         unsafe {
             ffi::PyUnicode_FromStringAndSize(ptr, len)
                 .assume_owned(py)
-                .downcast_into_unchecked()
+                .cast_into_unchecked()
         }
     }
 
-    /// Deprecated form of [`PyString::intern_bound`].
-    #[cfg_attr(
-        not(feature = "gil-refs"),
-        deprecated(
-            since = "0.21.0",
-            note = "`PyString::intern` will be replaced by `PyString::intern_bound` in a future PyO3 version"
-        )
-    )]
-    pub fn intern<'py>(py: Python<'py>, s: &str) -> &'py Self {
-        Self::intern_bound(py, s).into_gil_ref()
+    /// Creates a new Python string object from bytes.
+    ///
+    /// Returns PyMemoryError if out of memory.
+    /// Returns [PyUnicodeDecodeError] if the slice is not a valid UTF-8 string.
+    pub fn from_bytes<'py>(py: Python<'py>, s: &[u8]) -> PyResult<Bound<'py, PyString>> {
+        let ptr = s.as_ptr().cast();
+        let len = s.len() as ffi::Py_ssize_t;
+        unsafe {
+            ffi::PyUnicode_FromStringAndSize(ptr, len)
+                .assume_owned_or_err(py)
+                .cast_into_unchecked()
+        }
     }
 
     /// Intern the given string
@@ -180,102 +190,63 @@ impl PyString {
     /// temporary Python string object and is thereby slower than [`PyString::new`].
     ///
     /// Panics if out of memory.
-    pub fn intern_bound<'py>(py: Python<'py>, s: &str) -> Bound<'py, PyString> {
-        let ptr = s.as_ptr() as *const c_char;
+    pub fn intern<'py>(py: Python<'py>, s: &str) -> Bound<'py, PyString> {
+        let ptr = s.as_ptr().cast();
         let len = s.len() as ffi::Py_ssize_t;
         unsafe {
             let mut ob = ffi::PyUnicode_FromStringAndSize(ptr, len);
             if !ob.is_null() {
                 ffi::PyUnicode_InternInPlace(&mut ob);
             }
-            ob.assume_owned(py).downcast_into_unchecked()
+            ob.assume_owned(py).cast_into_unchecked()
         }
     }
 
-    /// Deprecated form of [`PyString::from_object_bound`].
-    #[cfg_attr(
-        not(feature = "gil-refs"),
-        deprecated(
-            since = "0.21.0",
-            note = "`PyString::from_object` will be replaced by `PyString::from_object_bound` in a future PyO3 version"
-        )
-    )]
-    pub fn from_object<'py>(src: &'py PyAny, encoding: &str, errors: &str) -> PyResult<&'py Self> {
-        Self::from_object_bound(&src.as_borrowed(), encoding, errors).map(Bound::into_gil_ref)
-    }
-
     /// Attempts to create a Python string from a Python [bytes-like object].
     ///
+    /// The `encoding` and `errors` parameters are optional:
+    /// - If `encoding` is `None`, the default encoding is used (UTF-8).
+    /// - If `errors` is `None`, the default error handling is used ("strict").
+    ///
+    /// See the [Python documentation on codecs] for more information.
+    ///
     /// [bytes-like object]: (https://docs.python.org/3/glossary.html#term-bytes-like-object).
-    pub fn from_object_bound<'py>(
+    /// [Python documentation on codecs]: https://docs.python.org/3/library/codecs.html#standard-encodings
+    pub fn from_encoded_object<'py>(
         src: &Bound<'py, PyAny>,
-        encoding: &str,
-        errors: &str,
+        encoding: Option<&CStr>,
+        errors: Option<&CStr>,
     ) -> PyResult<Bound<'py, PyString>> {
+        let encoding = encoding.map_or(std::ptr::null(), CStr::as_ptr);
+        let errors = errors.map_or(std::ptr::null(), CStr::as_ptr);
+        // Safety:
+        // - `src` is a valid Python object
+        // - `encoding` and `errors` are either null or valid C strings. `encoding` and `errors` are
+        //   documented as allowing null.
+        // - `ffi::PyUnicode_FromEncodedObject` returns a new `str` object, or sets an error.
         unsafe {
-            ffi::PyUnicode_FromEncodedObject(
-                src.as_ptr(),
-                encoding.as_ptr() as *const c_char,
-                errors.as_ptr() as *const c_char,
-            )
-            .assume_owned_or_err(src.py())
-            .downcast_into_unchecked()
+            ffi::PyUnicode_FromEncodedObject(src.as_ptr(), encoding, errors)
+                .assume_owned_or_err(src.py())
+                .cast_into_unchecked()
         }
     }
 
-    /// Gets the Python string as a Rust UTF-8 string slice.
+    /// Deprecated form of `PyString::from_encoded_object`.
     ///
-    /// Returns a `UnicodeEncodeError` if the input is not valid unicode
-    /// (containing unpaired surrogates).
-    pub fn to_str(&self) -> PyResult<&str> {
-        #[cfg(any(Py_3_10, not(Py_LIMITED_API)))]
-        {
-            self.as_borrowed().to_str()
-        }
-
-        #[cfg(not(any(Py_3_10, not(Py_LIMITED_API))))]
-        {
-            let bytes = unsafe {
-                self.py()
-                    .from_owned_ptr_or_err::<PyBytes>(ffi::PyUnicode_AsUTF8String(self.as_ptr()))
-            }?;
-            Ok(unsafe { std::str::from_utf8_unchecked(bytes.as_bytes()) })
-        }
-    }
-
-    /// Converts the `PyString` into a Rust string, avoiding copying when possible.
-    ///
-    /// Returns a `UnicodeEncodeError` if the input is not valid unicode
-    /// (containing unpaired surrogates).
-    pub fn to_cow(&self) -> PyResult<Cow<'_, str>> {
-        self.as_borrowed().to_cow()
-    }
-
-    /// Converts the `PyString` into a Rust string.
-    ///
-    /// Unpaired surrogates invalid UTF-8 sequences are
-    /// replaced with `U+FFFD REPLACEMENT CHARACTER`.
-    pub fn to_string_lossy(&self) -> Cow<'_, str> {
-        self.as_borrowed().to_string_lossy()
-    }
-
-    /// Obtains the raw data backing the Python string.
-    ///
-    /// If the Python string object was created through legacy APIs, its internal storage format
-    /// will be canonicalized before data is returned.
-    ///
-    /// # Safety
-    ///
-    /// This function implementation relies on manually decoding a C bitfield. In practice, this
-    /// works well on common little-endian architectures such as x86_64, where the bitfield has a
-    /// common representation (even if it is not part of the C spec). The PyO3 CI tests this API on
-    /// x86_64 platforms.
-    ///
-    /// By using this API, you accept responsibility for testing that PyStringData behaves as
-    /// expected on the targets where you plan to distribute your software.
-    #[cfg(not(Py_LIMITED_API))]
-    pub unsafe fn data(&self) -> PyResult<PyStringData<'_>> {
-        self.as_borrowed().data()
+    /// This version took `&str` arguments for `encoding` and `errors`, which required a runtime
+    /// conversion to `CString` internally.
+    #[deprecated(
+        since = "0.25.0",
+        note = "replaced with to `PyString::from_encoded_object`"
+    )]
+    pub fn from_object<'py>(
+        src: &Bound<'py, PyAny>,
+        encoding: &str,
+        errors: &str,
+    ) -> PyResult<Bound<'py, PyString>> {
+        let encoding = CString::new(encoding)?;
+        let errors = CString::new(errors)?;
+        PyString::from_encoded_object(src, Some(&encoding), Some(&errors))
     }
 }
 
@@ -285,7 +256,7 @@ impl PyString {
 /// syntax these methods are separated into a trait, because stable Rust does not yet support
 /// `arbitrary_self_types`.
 #[doc(alias = "PyString")]
-pub trait PyStringMethods<'py> {
+pub trait PyStringMethods<'py>: crate::sealed::Sealed {
     /// Gets the Python string as a Rust UTF-8 string slice.
     ///
     /// Returns a `UnicodeEncodeError` if the input is not valid unicode
@@ -322,7 +293,7 @@ pub trait PyStringMethods<'py> {
     ///
     /// By using this API, you accept responsibility for testing that PyStringData behaves as
     /// expected on the targets where you plan to distribute your software.
-    #[cfg(not(Py_LIMITED_API))]
+    #[cfg(not(any(Py_LIMITED_API, GraalPy, PyPy)))]
     unsafe fn data(&self) -> PyResult<PyStringData<'_>>;
 }
 
@@ -344,20 +315,20 @@ impl<'py> PyStringMethods<'py> for Bound<'py, PyString> {
         unsafe {
             ffi::PyUnicode_AsUTF8String(self.as_ptr())
                 .assume_owned_or_err(self.py())
-                .downcast_into_unchecked::<PyBytes>()
+                .cast_into_unchecked::<PyBytes>()
         }
     }
 
-    #[cfg(not(Py_LIMITED_API))]
+    #[cfg(not(any(Py_LIMITED_API, GraalPy, PyPy)))]
     unsafe fn data(&self) -> PyResult<PyStringData<'_>> {
-        self.as_borrowed().data()
+        unsafe { self.as_borrowed().data() }
     }
 }
 
 impl<'a> Borrowed<'a, '_, PyString> {
     #[cfg(any(Py_3_10, not(Py_LIMITED_API)))]
     #[allow(clippy::wrong_self_convention)]
-    fn to_str(self) -> PyResult<&'a str> {
+    pub(crate) fn to_str(self) -> PyResult<&'a str> {
         // PyUnicode_AsUTF8AndSize only available on limited API starting with 3.10.
         let mut size: ffi::Py_ssize_t = 0;
         let data: *const u8 =
@@ -372,7 +343,7 @@ impl<'a> Borrowed<'a, '_, PyString> {
     }
 
     #[allow(clippy::wrong_self_convention)]
-    fn to_cow(self) -> PyResult<Cow<'a, str>> {
+    pub(crate) fn to_cow(self) -> PyResult<Cow<'a, str>> {
         // TODO: this method can probably be deprecated once Python 3.9 support is dropped,
         // because all versions then support the more efficient `to_str`.
         #[cfg(any(Py_3_10, not(Py_LIMITED_API)))]
@@ -400,52 +371,50 @@ impl<'a> Borrowed<'a, '_, PyString> {
         }
 
         let bytes = unsafe {
-            ffi::PyUnicode_AsEncodedString(
-                ptr,
-                b"utf-8\0".as_ptr().cast(),
-                b"surrogatepass\0".as_ptr().cast(),
-            )
-            .assume_owned(py)
-            .downcast_into_unchecked::<PyBytes>()
+            ffi::PyUnicode_AsEncodedString(ptr, c"utf-8".as_ptr(), c"surrogatepass".as_ptr())
+                .assume_owned(py)
+                .cast_into_unchecked::<PyBytes>()
         };
         Cow::Owned(String::from_utf8_lossy(bytes.as_bytes()).into_owned())
     }
 
-    #[cfg(not(Py_LIMITED_API))]
+    #[cfg(not(any(Py_LIMITED_API, GraalPy, PyPy)))]
     unsafe fn data(self) -> PyResult<PyStringData<'a>> {
-        let ptr = self.as_ptr();
-
-        #[cfg(not(Py_3_12))]
-        #[allow(deprecated)]
-        {
-            let ready = ffi::PyUnicode_READY(ptr);
-            if ready != 0 {
-                // Exception was created on failure.
-                return Err(crate::PyErr::fetch(self.py()));
+        unsafe {
+            let ptr = self.as_ptr();
+
+            #[cfg(not(Py_3_12))]
+            #[allow(deprecated)]
+            {
+                let ready = ffi::PyUnicode_READY(ptr);
+                if ready != 0 {
+                    // Exception was created on failure.
+                    return Err(crate::PyErr::fetch(self.py()));
+                }
             }
-        }
 
-        // The string should be in its canonical form after calling `PyUnicode_READY()`.
-        // And non-canonical form not possible after Python 3.12. So it should be safe
-        // to call these APIs.
-        let length = ffi::PyUnicode_GET_LENGTH(ptr) as usize;
-        let raw_data = ffi::PyUnicode_DATA(ptr);
-        let kind = ffi::PyUnicode_KIND(ptr);
-
-        match kind {
-            ffi::PyUnicode_1BYTE_KIND => Ok(PyStringData::Ucs1(std::slice::from_raw_parts(
-                raw_data as *const u8,
-                length,
-            ))),
-            ffi::PyUnicode_2BYTE_KIND => Ok(PyStringData::Ucs2(std::slice::from_raw_parts(
-                raw_data as *const u16,
-                length,
-            ))),
-            ffi::PyUnicode_4BYTE_KIND => Ok(PyStringData::Ucs4(std::slice::from_raw_parts(
-                raw_data as *const u32,
-                length,
-            ))),
-            _ => unreachable!(),
+            // The string should be in its canonical form after calling `PyUnicode_READY()`.
+            // And non-canonical form not possible after Python 3.12. So it should be safe
+            // to call these APIs.
+            let length = ffi::PyUnicode_GET_LENGTH(ptr) as usize;
+            let raw_data = ffi::PyUnicode_DATA(ptr);
+            let kind = ffi::PyUnicode_KIND(ptr);
+
+            match kind {
+                ffi::PyUnicode_1BYTE_KIND => Ok(PyStringData::Ucs1(std::slice::from_raw_parts(
+                    raw_data as *const u8,
+                    length,
+                ))),
+                ffi::PyUnicode_2BYTE_KIND => Ok(PyStringData::Ucs2(std::slice::from_raw_parts(
+                    raw_data as *const u16,
+                    length,
+                ))),
+                ffi::PyUnicode_4BYTE_KIND => Ok(PyStringData::Ucs4(std::slice::from_raw_parts(
+                    raw_data as *const u32,
+                    length,
+                ))),
+                _ => unreachable!(),
+            }
         }
     }
 }
@@ -486,78 +455,169 @@ impl Py<PyString> {
     }
 }
 
-impl IntoPy<Py<PyString>> for Bound<'_, PyString> {
-    fn into_py(self, _py: Python<'_>) -> Py<PyString> {
-        self.unbind()
+/// Compares whether the data in the Python string is equal to the given UTF8.
+///
+/// In some cases Python equality might be more appropriate; see the note on [`PyString`].
+impl PartialEq<str> for Bound<'_, PyString> {
+    #[inline]
+    fn eq(&self, other: &str) -> bool {
+        self.as_borrowed() == *other
+    }
+}
+
+/// Compares whether the data in the Python string is equal to the given UTF8.
+///
+/// In some cases Python equality might be more appropriate; see the note on [`PyString`].
+impl PartialEq<&'_ str> for Bound<'_, PyString> {
+    #[inline]
+    fn eq(&self, other: &&str) -> bool {
+        self.as_borrowed() == **other
+    }
+}
+
+/// Compares whether the data in the Python string is equal to the given UTF8.
+///
+/// In some cases Python equality might be more appropriate; see the note on [`PyString`].
+impl PartialEq<Bound<'_, PyString>> for str {
+    #[inline]
+    fn eq(&self, other: &Bound<'_, PyString>) -> bool {
+        *self == other.as_borrowed()
+    }
+}
+
+/// Compares whether the data in the Python string is equal to the given UTF8.
+///
+/// In some cases Python equality might be more appropriate; see the note on [`PyString`].
+impl PartialEq<&'_ Bound<'_, PyString>> for str {
+    #[inline]
+    fn eq(&self, other: &&Bound<'_, PyString>) -> bool {
+        *self == other.as_borrowed()
+    }
+}
+
+/// Compares whether the data in the Python string is equal to the given UTF8.
+///
+/// In some cases Python equality might be more appropriate; see the note on [`PyString`].
+impl PartialEq<Bound<'_, PyString>> for &'_ str {
+    #[inline]
+    fn eq(&self, other: &Bound<'_, PyString>) -> bool {
+        **self == other.as_borrowed()
+    }
+}
+
+/// Compares whether the data in the Python string is equal to the given UTF8.
+///
+/// In some cases Python equality might be more appropriate; see the note on [`PyString`].
+impl PartialEq<str> for &'_ Bound<'_, PyString> {
+    #[inline]
+    fn eq(&self, other: &str) -> bool {
+        self.as_borrowed() == other
     }
 }
 
-impl IntoPy<Py<PyString>> for &Bound<'_, PyString> {
-    fn into_py(self, _py: Python<'_>) -> Py<PyString> {
-        self.clone().unbind()
+/// Compares whether the data in the Python string is equal to the given UTF8.
+///
+/// In some cases Python equality might be more appropriate; see the note on [`PyString`].
+impl PartialEq<str> for Borrowed<'_, '_, PyString> {
+    #[inline]
+    fn eq(&self, other: &str) -> bool {
+        #[cfg(not(Py_3_13))]
+        {
+            self.to_cow().is_ok_and(|s| s == other)
+        }
+
+        #[cfg(Py_3_13)]
+        unsafe {
+            ffi::PyUnicode_EqualToUTF8AndSize(
+                self.as_ptr(),
+                other.as_ptr().cast(),
+                other.len() as _,
+            ) == 1
+        }
     }
 }
 
-impl IntoPy<Py<PyString>> for &'_ Py<PyString> {
-    fn into_py(self, py: Python<'_>) -> Py<PyString> {
-        self.clone_ref(py)
+/// Compares whether the data in the Python string is equal to the given UTF8.
+///
+/// In some cases Python equality might be more appropriate; see the note on [`PyString`].
+impl PartialEq<&str> for Borrowed<'_, '_, PyString> {
+    #[inline]
+    fn eq(&self, other: &&str) -> bool {
+        *self == **other
+    }
+}
+
+/// Compares whether the data in the Python string is equal to the given UTF8.
+///
+/// In some cases Python equality might be more appropriate; see the note on [`PyString`].
+impl PartialEq<Borrowed<'_, '_, PyString>> for str {
+    #[inline]
+    fn eq(&self, other: &Borrowed<'_, '_, PyString>) -> bool {
+        other == self
+    }
+}
+
+/// Compares whether the data in the Python string is equal to the given UTF8.
+///
+/// In some cases Python equality might be more appropriate; see the note on [`PyString`].
+impl PartialEq<Borrowed<'_, '_, PyString>> for &'_ str {
+    #[inline]
+    fn eq(&self, other: &Borrowed<'_, '_, PyString>) -> bool {
+        other == self
     }
 }
 
 #[cfg(test)]
-#[cfg_attr(not(feature = "gil-refs"), allow(deprecated))]
 mod tests {
     use super::*;
-    use crate::Python;
-    use crate::{PyObject, ToPyObject};
-    #[cfg(not(Py_LIMITED_API))]
-    use std::borrow::Cow;
+    use crate::{exceptions::PyLookupError, types::PyAnyMethods as _, IntoPyObject};
 
     #[test]
-    fn test_to_str_utf8() {
-        Python::with_gil(|py| {
+    fn test_to_cow_utf8() {
+        Python::attach(|py| {
             let s = "ascii 🐈";
-            let obj: PyObject = PyString::new(py, s).into();
-            let py_string: &PyString = obj.downcast(py).unwrap();
-            assert_eq!(s, py_string.to_str().unwrap());
+            let py_string = PyString::new(py, s);
+            assert_eq!(s, py_string.to_cow().unwrap());
         })
     }
 
     #[test]
-    fn test_to_str_surrogate() {
-        Python::with_gil(|py| {
-            let obj: PyObject = py.eval(r"'\ud800'", None, None).unwrap().into();
-            let py_string: &PyString = obj.downcast(py).unwrap();
-            assert!(py_string.to_str().is_err());
+    fn test_to_cow_surrogate() {
+        Python::attach(|py| {
+            let py_string = py
+                .eval(cr"'\ud800'", None, None)
+                .unwrap()
+                .cast_into::<PyString>()
+                .unwrap();
+            assert!(py_string.to_cow().is_err());
         })
     }
 
     #[test]
-    fn test_to_str_unicode() {
-        Python::with_gil(|py| {
+    fn test_to_cow_unicode() {
+        Python::attach(|py| {
             let s = "哈哈🐈";
-            let obj: PyObject = PyString::new(py, s).into();
-            let py_string: &PyString = obj.downcast(py).unwrap();
-            assert_eq!(s, py_string.to_str().unwrap());
+            let py_string = PyString::new(py, s);
+            assert_eq!(s, py_string.to_cow().unwrap());
         })
     }
 
     #[test]
     fn test_encode_utf8_unicode() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let s = "哈哈🐈";
-            let obj = PyString::new_bound(py, s);
+            let obj = PyString::new(py, s);
             assert_eq!(s.as_bytes(), obj.encode_utf8().unwrap().as_bytes());
         })
     }
 
     #[test]
     fn test_encode_utf8_surrogate() {
-        Python::with_gil(|py| {
-            let obj: PyObject = py.eval(r"'\ud800'", None, None).unwrap().into();
+        Python::attach(|py| {
+            let obj: Py<PyAny> = py.eval(cr"'\ud800'", None, None).unwrap().into();
             assert!(obj
                 .bind(py)
-                .downcast::<PyString>()
+                .cast::<PyString>()
                 .unwrap()
                 .encode_utf8()
                 .is_err());
@@ -566,38 +626,93 @@ mod tests {
 
     #[test]
     fn test_to_string_lossy() {
-        Python::with_gil(|py| {
-            let obj: PyObject = py
-                .eval(r"'🐈 Hello \ud800World'", None, None)
+        Python::attach(|py| {
+            let py_string = py
+                .eval(cr"'🐈 Hello \ud800World'", None, None)
                 .unwrap()
-                .into();
-            let py_string: &PyString = obj.downcast(py).unwrap();
+                .cast_into::<PyString>()
+                .unwrap();
+
             assert_eq!(py_string.to_string_lossy(), "🐈 Hello ���World");
         })
     }
 
     #[test]
     fn test_debug_string() {
-        Python::with_gil(|py| {
-            let v = "Hello\n".to_object(py);
-            let s: &PyString = v.downcast(py).unwrap();
-            assert_eq!(format!("{:?}", s), "'Hello\\n'");
+        Python::attach(|py| {
+            let s = "Hello\n".into_pyobject(py).unwrap();
+            assert_eq!(format!("{s:?}"), "'Hello\\n'");
         })
     }
 
     #[test]
     fn test_display_string() {
-        Python::with_gil(|py| {
-            let v = "Hello\n".to_object(py);
-            let s: &PyString = v.downcast(py).unwrap();
-            assert_eq!(format!("{}", s), "Hello\n");
+        Python::attach(|py| {
+            let s = "Hello\n".into_pyobject(py).unwrap();
+            assert_eq!(format!("{s}"), "Hello\n");
         })
     }
 
     #[test]
-    #[cfg(not(Py_LIMITED_API))]
+    fn test_string_from_encoded_object() {
+        Python::attach(|py| {
+            let py_bytes = PyBytes::new(py, b"ab\xFFcd");
+
+            // default encoding is utf-8, default error handler is strict
+            let py_string = PyString::from_encoded_object(&py_bytes, None, None).unwrap_err();
+            assert!(py_string
+                .get_type(py)
+                .is(py.get_type::<crate::exceptions::PyUnicodeDecodeError>()));
+
+            // with `ignore` error handler, the invalid byte is dropped
+            let py_string =
+                PyString::from_encoded_object(&py_bytes, None, Some(c"ignore")).unwrap();
+
+            let result = py_string.to_cow().unwrap();
+            assert_eq!(result, "abcd");
+
+            #[allow(deprecated)]
+            let py_string = PyString::from_object(&py_bytes, "utf-8", "ignore").unwrap();
+
+            let result = py_string.to_cow().unwrap();
+            assert_eq!(result, "abcd");
+        });
+    }
+
+    #[test]
+    fn test_string_from_encoded_object_with_invalid_encoding_errors() {
+        Python::attach(|py| {
+            let py_bytes = PyBytes::new(py, b"abcd");
+
+            // invalid encoding
+            let err = PyString::from_encoded_object(&py_bytes, Some(c"wat"), None).unwrap_err();
+            assert!(err.is_instance(py, &py.get_type::<PyLookupError>()));
+            assert_eq!(err.to_string(), "LookupError: unknown encoding: wat");
+
+            // invalid error handler
+            let err =
+                PyString::from_encoded_object(&PyBytes::new(py, b"ab\xFFcd"), None, Some(c"wat"))
+                    .unwrap_err();
+            assert!(err.is_instance(py, &py.get_type::<PyLookupError>()));
+            assert_eq!(
+                err.to_string(),
+                "LookupError: unknown error handler name 'wat'"
+            );
+
+            #[allow(deprecated)]
+            let result = PyString::from_object(&py_bytes, "utf\0-8", "ignore");
+            assert!(result.is_err());
+
+            #[allow(deprecated)]
+            let result = PyString::from_object(&py_bytes, "utf-8", "ign\0ore");
+            assert!(result.is_err());
+        });
+    }
+
+    #[test]
+    #[cfg(not(any(Py_LIMITED_API, PyPy, GraalPy)))]
     fn test_string_data_ucs1() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let s = PyString::new(py, "hello, world");
             let data = unsafe { s.data().unwrap() };
 
@@ -608,20 +723,20 @@ mod tests {
     }
 
     #[test]
-    #[cfg(not(Py_LIMITED_API))]
+    #[cfg(not(any(Py_LIMITED_API, PyPy, GraalPy)))]
     fn test_string_data_ucs1_invalid() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             // 0xfe is not allowed in UTF-8.
             let buffer = b"f\xfe\0";
             let ptr = unsafe {
                 crate::ffi::PyUnicode_FromKindAndData(
                     crate::ffi::PyUnicode_1BYTE_KIND as _,
-                    buffer.as_ptr() as *const _,
+                    buffer.as_ptr().cast(),
                     2,
                 )
             };
             assert!(!ptr.is_null());
-            let s: &PyString = unsafe { py.from_owned_ptr(ptr) };
+            let s = unsafe { ptr.assume_owned(py).cast_into_unchecked::<PyString>() };
             let data = unsafe { s.data().unwrap() };
             assert_eq!(data, PyStringData::Ucs1(b"f\xfe"));
             let err = data.to_string(py).unwrap_err();
@@ -634,11 +749,11 @@ mod tests {
     }
 
     #[test]
-    #[cfg(not(Py_LIMITED_API))]
+    #[cfg(not(any(Py_LIMITED_API, PyPy, GraalPy)))]
     fn test_string_data_ucs2() {
-        Python::with_gil(|py| {
-            let s = py.eval("'foo\\ud800'", None, None).unwrap();
-            let py_string = s.downcast::<PyString>().unwrap();
+        Python::attach(|py| {
+            let s = py.eval(c"'foo\\ud800'", None, None).unwrap();
+            let py_string = s.cast::<PyString>().unwrap();
             let data = unsafe { py_string.data().unwrap() };
 
             assert_eq!(data, PyStringData::Ucs2(&[102, 111, 111, 0xd800]));
@@ -650,20 +765,20 @@ mod tests {
     }
 
     #[test]
-    #[cfg(all(not(Py_LIMITED_API), target_endian = "little"))]
+    #[cfg(all(not(any(Py_LIMITED_API, PyPy, GraalPy)), target_endian = "little"))]
     fn test_string_data_ucs2_invalid() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             // U+FF22 (valid) & U+d800 (never valid)
             let buffer = b"\x22\xff\x00\xd8\x00\x00";
             let ptr = unsafe {
                 crate::ffi::PyUnicode_FromKindAndData(
                     crate::ffi::PyUnicode_2BYTE_KIND as _,
-                    buffer.as_ptr() as *const _,
+                    buffer.as_ptr().cast(),
                     2,
                 )
             };
             assert!(!ptr.is_null());
-            let s: &PyString = unsafe { py.from_owned_ptr(ptr) };
+            let s = unsafe { ptr.assume_owned(py).cast_into_unchecked::<PyString>() };
             let data = unsafe { s.data().unwrap() };
             assert_eq!(data, PyStringData::Ucs2(&[0xff22, 0xd800]));
             let err = data.to_string(py).unwrap_err();
@@ -676,9 +791,9 @@ mod tests {
     }
 
     #[test]
-    #[cfg(not(Py_LIMITED_API))]
+    #[cfg(not(any(Py_LIMITED_API, PyPy, GraalPy)))]
     fn test_string_data_ucs4() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let s = "哈哈🐈";
             let py_string = PyString::new(py, s);
             let data = unsafe { py_string.data().unwrap() };
@@ -689,20 +804,20 @@ mod tests {
     }
 
     #[test]
-    #[cfg(all(not(Py_LIMITED_API), target_endian = "little"))]
+    #[cfg(all(not(any(Py_LIMITED_API, PyPy, GraalPy)), target_endian = "little"))]
     fn test_string_data_ucs4_invalid() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             // U+20000 (valid) & U+d800 (never valid)
             let buffer = b"\x00\x00\x02\x00\x00\xd8\x00\x00\x00\x00\x00\x00";
             let ptr = unsafe {
                 crate::ffi::PyUnicode_FromKindAndData(
                     crate::ffi::PyUnicode_4BYTE_KIND as _,
-                    buffer.as_ptr() as *const _,
+                    buffer.as_ptr().cast(),
                     2,
                 )
             };
             assert!(!ptr.is_null());
-            let s: &PyString = unsafe { py.from_owned_ptr(ptr) };
+            let s = unsafe { ptr.assume_owned(py).cast_into_unchecked::<PyString>() };
             let data = unsafe { s.data().unwrap() };
             assert_eq!(data, PyStringData::Ucs4(&[0x20000, 0xd800]));
             let err = data.to_string(py).unwrap_err();
@@ -714,19 +829,33 @@ mod tests {
         });
     }
 
+    #[test]
+    #[cfg(not(any(Py_LIMITED_API, PyPy, GraalPy)))]
+    fn test_pystring_from_bytes() {
+        Python::attach(|py| {
+            let result = PyString::from_bytes(py, "\u{2122}".as_bytes());
+            assert!(result.is_ok());
+            let result = PyString::from_bytes(py, b"\x80");
+            assert!(result
+                .unwrap_err()
+                .get_type(py)
+                .is(py.get_type::<PyUnicodeDecodeError>()));
+        });
+    }
+
     #[test]
     fn test_intern_string() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let py_string1 = PyString::intern(py, "foo");
-            assert_eq!(py_string1.to_str().unwrap(), "foo");
+            assert_eq!(py_string1, "foo");
 
             let py_string2 = PyString::intern(py, "foo");
-            assert_eq!(py_string2.to_str().unwrap(), "foo");
+            assert_eq!(py_string2, "foo");
 
             assert_eq!(py_string1.as_ptr(), py_string2.as_ptr());
 
             let py_string3 = PyString::intern(py, "bar");
-            assert_eq!(py_string3.to_str().unwrap(), "bar");
+            assert_eq!(py_string3, "bar");
 
             assert_ne!(py_string1.as_ptr(), py_string3.as_ptr());
         });
@@ -734,9 +863,9 @@ mod tests {
 
     #[test]
     fn test_py_to_str_utf8() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let s = "ascii 🐈";
-            let py_string: Py<PyString> = PyString::new(py, s).into_py(py);
+            let py_string = PyString::new(py, s).unbind();
 
             #[cfg(any(Py_3_10, not(Py_LIMITED_API)))]
             assert_eq!(s, py_string.to_str(py).unwrap());
@@ -747,9 +876,12 @@ mod tests {
 
     #[test]
     fn test_py_to_str_surrogate() {
-        Python::with_gil(|py| {
-            let py_string: Py<PyString> =
-                py.eval(r"'\ud800'", None, None).unwrap().extract().unwrap();
+        Python::attach(|py| {
+            let py_string: Py<PyString> = py
+                .eval(cr"'\ud800'", None, None)
+                .unwrap()
+                .extract()
+                .unwrap();
 
             #[cfg(any(Py_3_10, not(Py_LIMITED_API)))]
             assert!(py_string.to_str(py).is_err());
@@ -760,13 +892,43 @@ mod tests {
 
     #[test]
     fn test_py_to_string_lossy() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let py_string: Py<PyString> = py
-                .eval(r"'🐈 Hello \ud800World'", None, None)
+                .eval(cr"'🐈 Hello \ud800World'", None, None)
                 .unwrap()
                 .extract()
                 .unwrap();
             assert_eq!(py_string.to_string_lossy(py), "🐈 Hello ���World");
         })
     }
+
+    #[test]
+    fn test_comparisons() {
+        Python::attach(|py| {
+            let s = "hello, world";
+            let py_string = PyString::new(py, s);
+
+            assert_eq!(py_string, "hello, world");
+
+            assert_eq!(py_string, s);
+            assert_eq!(&py_string, s);
+            assert_eq!(s, py_string);
+            assert_eq!(s, &py_string);
+
+            assert_eq!(py_string, *s);
+            assert_eq!(&py_string, *s);
+            assert_eq!(*s, py_string);
+            assert_eq!(*s, &py_string);
+
+            let py_string = py_string.as_borrowed();
+
+            assert_eq!(py_string, s);
+            assert_eq!(&py_string, s);
+            assert_eq!(s, py_string);
+            assert_eq!(s, &py_string);
+
+            assert_eq!(py_string, *s);
+            assert_eq!(*s, py_string);
+        })
+    }
 }
diff --git a/src/types/traceback.rs b/src/types/traceback.rs
index b97e2ed0093..2dfdc3121ba 100644
--- a/src/types/traceback.rs
+++ b/src/types/traceback.rs
@@ -1,12 +1,14 @@
 use crate::err::{error_on_minusone, PyResult};
-use crate::types::PyString;
-use crate::{ffi, Bound};
-use crate::{PyAny, PyNativeType};
-
-use super::any::PyAnyMethods;
-use super::string::PyStringMethods;
+use crate::types::{any::PyAnyMethods, string::PyStringMethods, PyString};
+use crate::{ffi, Bound, PyAny};
 
 /// Represents a Python traceback.
+///
+/// Values of this type are accessed via PyO3's smart pointers, e.g. as
+/// [`Py<PyTraceback>`][crate::Py] or [`Bound<'py, PyTraceback>`][Bound].
+///
+/// For APIs available on traceback objects, see the [`PyTracebackMethods`] trait which is implemented for
+/// [`Bound<'py, PyTraceback>`][Bound].
 #[repr(transparent)]
 pub struct PyTraceback(PyAny);
 
@@ -16,50 +18,13 @@ pyobject_native_type_core!(
     #checkfunction=ffi::PyTraceBack_Check
 );
 
-impl PyTraceback {
-    /// Formats the traceback as a string.
-    ///
-    /// This does not include the exception type and value. The exception type and value can be
-    /// formatted using the `Display` implementation for `PyErr`.
-    ///
-    /// # Example
-    ///
-    /// The following code formats a Python traceback and exception pair from Rust:
-    ///
-    /// ```rust
-    /// # use pyo3::{Python, PyResult, prelude::PyTracebackMethods};
-    /// # let result: PyResult<()> =
-    /// Python::with_gil(|py| {
-    ///     let err = py
-    ///         .run_bound("raise Exception('banana')", None, None)
-    ///         .expect_err("raise will create a Python error");
-    ///
-    ///     let traceback = err.traceback_bound(py).expect("raised exception will have a traceback");
-    ///     assert_eq!(
-    ///         format!("{}{}", traceback.format()?, err),
-    ///         "\
-    /// Traceback (most recent call last):
-    ///   File \"<string>\", line 1, in <module>
-    /// Exception: banana\
-    /// "
-    ///     );
-    ///     Ok(())
-    /// })
-    /// # ;
-    /// # result.expect("example failed");
-    /// ```
-    pub fn format(&self) -> PyResult<String> {
-        self.as_borrowed().format()
-    }
-}
-
 /// Implementation of functionality for [`PyTraceback`].
 ///
 /// These methods are defined for the `Bound<'py, PyTraceback>` smart pointer, so to use method call
 /// syntax these methods are separated into a trait, because stable Rust does not yet support
 /// `arbitrary_self_types`.
 #[doc(alias = "PyTraceback")]
-pub trait PyTracebackMethods<'py> {
+pub trait PyTracebackMethods<'py>: crate::sealed::Sealed {
     /// Formats the traceback as a string.
     ///
     /// This does not include the exception type and value. The exception type and value can be
@@ -70,14 +35,14 @@ pub trait PyTracebackMethods<'py> {
     /// The following code formats a Python traceback and exception pair from Rust:
     ///
     /// ```rust
-    /// # use pyo3::{Python, PyResult, prelude::PyTracebackMethods};
+    /// # use pyo3::{Python, PyResult, prelude::PyTracebackMethods, ffi::c_str};
     /// # let result: PyResult<()> =
-    /// Python::with_gil(|py| {
+    /// Python::attach(|py| {
     ///     let err = py
-    ///         .run_bound("raise Exception('banana')", None, None)
+    ///         .run(c"raise Exception('banana')", None, None)
     ///         .expect_err("raise will create a Python error");
     ///
-    ///     let traceback = err.traceback_bound(py).expect("raised exception will have a traceback");
+    ///     let traceback = err.traceback(py).expect("raised exception will have a traceback");
     ///     assert_eq!(
     ///         format!("{}{}", traceback.format()?, err),
     ///         "\
@@ -98,7 +63,7 @@ impl<'py> PyTracebackMethods<'py> for Bound<'py, PyTraceback> {
     fn format(&self) -> PyResult<String> {
         let py = self.py();
         let string_io = py
-            .import_bound(intern!(py, "io"))?
+            .import(intern!(py, "io"))?
             .getattr(intern!(py, "StringIO"))?
             .call0()?;
         let result = unsafe { ffi::PyTraceBack_Print(self.as_ptr(), string_io.as_ptr()) };
@@ -106,7 +71,7 @@ impl<'py> PyTracebackMethods<'py> for Bound<'py, PyTraceback> {
         let formatted = string_io
             .getattr(intern!(py, "getvalue"))?
             .call0()?
-            .downcast::<PyString>()?
+            .cast::<PyString>()?
             .to_cow()?
             .into_owned();
         Ok(formatted)
@@ -115,20 +80,21 @@ impl<'py> PyTracebackMethods<'py> for Bound<'py, PyTraceback> {
 
 #[cfg(test)]
 mod tests {
+    use crate::IntoPyObject;
     use crate::{
-        prelude::*,
-        types::{traceback::PyTracebackMethods, PyDict},
+        types::{any::PyAnyMethods, dict::PyDictMethods, traceback::PyTracebackMethods, PyDict},
+        PyErr, Python,
     };
 
     #[test]
     fn format_traceback() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let err = py
-                .run_bound("raise Exception('banana')", None, None)
+                .run(c"raise Exception('banana')", None, None)
                 .expect_err("raising should have given us an error");
 
             assert_eq!(
-                err.traceback_bound(py).unwrap().format().unwrap(),
+                err.traceback(py).unwrap().format().unwrap(),
                 "Traceback (most recent call last):\n  File \"<string>\", line 1, in <module>\n"
             );
         })
@@ -136,11 +102,11 @@ mod tests {
 
     #[test]
     fn test_err_from_value() {
-        Python::with_gil(|py| {
-            let locals = PyDict::new_bound(py);
+        Python::attach(|py| {
+            let locals = PyDict::new(py);
             // Produce an error from python so that it has a traceback
-            py.run_bound(
-                r"
+            py.run(
+                cr"
 try:
     raise ValueError('raised exception')
 except Exception as e:
@@ -150,19 +116,19 @@ except Exception as e:
                 Some(&locals),
             )
             .unwrap();
-            let err = PyErr::from_value(locals.get_item("err").unwrap().unwrap().into_gil_ref());
+            let err = PyErr::from_value(locals.get_item("err").unwrap().unwrap());
             let traceback = err.value(py).getattr("__traceback__").unwrap();
-            assert!(err.traceback_bound(py).unwrap().is(traceback));
+            assert!(err.traceback(py).unwrap().is(&traceback));
         })
     }
 
     #[test]
     fn test_err_into_py() {
-        Python::with_gil(|py| {
-            let locals = PyDict::new_bound(py);
+        Python::attach(|py| {
+            let locals = PyDict::new(py);
             // Produce an error from python so that it has a traceback
-            py.run_bound(
-                r"
+            py.run(
+                cr"
 def f():
     raise ValueError('raised exception')
 ",
@@ -172,8 +138,8 @@ def f():
             .unwrap();
             let f = locals.get_item("f").unwrap().unwrap();
             let err = f.call0().unwrap_err();
-            let traceback = err.traceback_bound(py).unwrap();
-            let err_object = err.clone_ref(py).into_py(py).into_ref(py);
+            let traceback = err.traceback(py).unwrap();
+            let err_object = err.clone_ref(py).into_pyobject(py).unwrap();
 
             assert!(err_object.getattr("__traceback__").unwrap().is(&traceback));
         })
diff --git a/src/types/tuple.rs b/src/types/tuple.rs
index a8737c256c4..719cca50c40 100644
--- a/src/types/tuple.rs
+++ b/src/types/tuple.rs
@@ -1,24 +1,23 @@
-use std::convert::TryInto;
-use std::iter::FusedIterator;
-
 use crate::ffi::{self, Py_ssize_t};
 use crate::ffi_ptr_ext::FfiPtrExt;
 #[cfg(feature = "experimental-inspect")]
 use crate::inspect::types::TypeInfo;
 use crate::instance::Borrowed;
 use crate::internal_tricks::get_ssize_index;
-use crate::types::{any::PyAnyMethods, sequence::PySequenceMethods, PyList, PySequence};
+use crate::types::{sequence::PySequenceMethods, PyList, PySequence};
 use crate::{
-    exceptions, Bound, FromPyObject, IntoPy, Py, PyAny, PyErr, PyNativeType, PyObject, PyResult,
-    Python, ToPyObject,
+    exceptions, Bound, FromPyObject, IntoPyObject, IntoPyObjectExt, PyAny, PyErr, PyResult, Python,
 };
+use std::iter::FusedIterator;
+#[cfg(feature = "nightly")]
+use std::num::NonZero;
 
 #[inline]
 #[track_caller]
-fn new_from_iter<'py>(
+fn try_new_from_iter<'py>(
     py: Python<'py>,
-    elements: &mut dyn ExactSizeIterator<Item = PyObject>,
-) -> Bound<'py, PyTuple> {
+    mut elements: impl ExactSizeIterator<Item = PyResult<Bound<'py, PyAny>>>,
+) -> PyResult<Bound<'py, PyTuple>> {
     unsafe {
         // PyTuple_New checks for overflow but has a bad error message, so we check ourselves
         let len: Py_ssize_t = elements
@@ -30,59 +29,46 @@ fn new_from_iter<'py>(
 
         // - Panics if the ptr is null
         // - Cleans up the tuple if `convert` or the asserts panic
-        let tup = ptr.assume_owned(py).downcast_into_unchecked();
+        let tup = ptr.assume_owned(py).cast_into_unchecked();
 
         let mut counter: Py_ssize_t = 0;
 
-        for obj in elements.take(len as usize) {
-            #[cfg(not(any(Py_LIMITED_API, PyPy)))]
-            ffi::PyTuple_SET_ITEM(ptr, counter, obj.into_ptr());
-            #[cfg(any(Py_LIMITED_API, PyPy))]
-            ffi::PyTuple_SetItem(ptr, counter, obj.into_ptr());
+        for obj in (&mut elements).take(len as usize) {
+            #[cfg(not(any(Py_LIMITED_API, PyPy, GraalPy)))]
+            ffi::PyTuple_SET_ITEM(ptr, counter, obj?.into_ptr());
+            #[cfg(any(Py_LIMITED_API, PyPy, GraalPy))]
+            ffi::PyTuple_SetItem(ptr, counter, obj?.into_ptr());
             counter += 1;
         }
 
         assert!(elements.next().is_none(), "Attempted to create PyTuple but `elements` was larger than reported by its `ExactSizeIterator` implementation.");
         assert_eq!(len, counter, "Attempted to create PyTuple but `elements` was smaller than reported by its `ExactSizeIterator` implementation.");
 
-        tup
+        Ok(tup)
     }
 }
 
 /// Represents a Python `tuple` object.
 ///
-/// This type is immutable.
+/// Values of this type are accessed via PyO3's smart pointers, e.g. as
+/// [`Py<PyTuple>`][crate::Py] or [`Bound<'py, PyTuple>`][Bound].
+///
+/// For APIs available on `tuple` objects, see the [`PyTupleMethods`] trait which is implemented for
+/// [`Bound<'py, PyTuple>`][Bound].
 #[repr(transparent)]
 pub struct PyTuple(PyAny);
 
 pyobject_native_type_core!(PyTuple, pyobject_native_static_type_object!(ffi::PyTuple_Type), #checkfunction=ffi::PyTuple_Check);
 
 impl PyTuple {
-    /// Deprecated form of `PyTuple::new_bound`.
-    #[track_caller]
-    #[cfg_attr(
-        not(feature = "gil-refs"),
-        deprecated(
-            since = "0.21.0",
-            note = "`PyTuple::new` will be replaced by `PyTuple::new_bound` in a future PyO3 version"
-        )
-    )]
-    pub fn new<T, U>(
-        py: Python<'_>,
-        elements: impl IntoIterator<Item = T, IntoIter = U>,
-    ) -> &PyTuple
-    where
-        T: ToPyObject,
-        U: ExactSizeIterator<Item = T>,
-    {
-        Self::new_bound(py, elements).into_gil_ref()
-    }
-
     /// Constructs a new tuple with the given elements.
     ///
-    /// If you want to create a [`PyTuple`] with elements of different or unknown types, or from an
-    /// iterable that doesn't implement [`ExactSizeIterator`], create a Rust tuple with the given
-    /// elements and convert it at once using `into_py`.
+    /// If you want to create a [`PyTuple`] with elements of different or unknown types, create a Rust
+    /// tuple with the given elements and convert it at once using [`into_pyobject()`][crate::IntoPyObject].
+    /// (`IntoPyObject` is implemented for tuples of up to 12 elements.)
+    ///
+    /// To create a [`PyTuple`] from an iterable that doesn't implement [`ExactSizeIterator`],
+    /// collect the elements into a `Vec` first.
     ///
     /// # Examples
     ///
@@ -90,12 +76,17 @@ impl PyTuple {
     /// use pyo3::prelude::*;
     /// use pyo3::types::PyTuple;
     ///
-    /// # fn main() {
-    /// Python::with_gil(|py| {
+    /// # fn main() -> PyResult<()> {
+    /// Python::attach(|py| {
     ///     let elements: Vec<i32> = vec![0, 1, 2, 3, 4, 5];
-    ///     let tuple = PyTuple::new_bound(py, elements);
+    ///     let tuple = PyTuple::new(py, elements)?;
     ///     assert_eq!(format!("{:?}", tuple), "(0, 1, 2, 3, 4, 5)");
-    /// });
+    ///
+    ///     // alternative using `into_pyobject()`
+    ///     let tuple = (0, "hello", true).into_pyobject(py)?;
+    ///     assert_eq!(format!("{:?}", tuple), "(0, 'hello', True)");
+    /// # Ok(())
+    /// })
     /// # }
     /// ```
     ///
@@ -105,151 +96,31 @@ impl PyTuple {
     /// All standard library structures implement this trait correctly, if they do, so calling this
     /// function using [`Vec`]`<T>` or `&[T]` will always succeed.
     #[track_caller]
-    pub fn new_bound<T, U>(
-        py: Python<'_>,
+    pub fn new<'py, T, U>(
+        py: Python<'py>,
         elements: impl IntoIterator<Item = T, IntoIter = U>,
-    ) -> Bound<'_, PyTuple>
+    ) -> PyResult<Bound<'py, PyTuple>>
     where
-        T: ToPyObject,
+        T: IntoPyObject<'py>,
         U: ExactSizeIterator<Item = T>,
     {
-        let mut elements = elements.into_iter().map(|e| e.to_object(py));
-        new_from_iter(py, &mut elements)
-    }
-
-    /// Deprecated form of `PyTuple::empty_bound`.
-    #[cfg_attr(
-        not(feature = "gil-refs"),
-        deprecated(
-            since = "0.21.0",
-            note = "`PyTuple::empty` will be replaced by `PyTuple::empty_bound` in a future PyO3 version"
-        )
-    )]
-    pub fn empty(py: Python<'_>) -> &PyTuple {
-        Self::empty_bound(py).into_gil_ref()
+        let elements = elements.into_iter().map(|e| e.into_bound_py_any(py));
+        try_new_from_iter(py, elements)
     }
 
     /// Constructs an empty tuple (on the Python side, a singleton object).
-    pub fn empty_bound(py: Python<'_>) -> Bound<'_, PyTuple> {
-        unsafe {
-            ffi::PyTuple_New(0)
-                .assume_owned(py)
-                .downcast_into_unchecked()
-        }
-    }
-
-    /// Gets the length of the tuple.
-    pub fn len(&self) -> usize {
-        self.as_borrowed().len()
-    }
-
-    /// Checks if the tuple is empty.
-    pub fn is_empty(&self) -> bool {
-        self.as_borrowed().is_empty()
-    }
-
-    /// Returns `self` cast as a `PySequence`.
-    pub fn as_sequence(&self) -> &PySequence {
-        unsafe { self.downcast_unchecked() }
-    }
-
-    /// Takes the slice `self[low:high]` and returns it as a new tuple.
-    ///
-    /// Indices must be nonnegative, and out-of-range indices are clipped to
-    /// `self.len()`.
-    pub fn get_slice(&self, low: usize, high: usize) -> &PyTuple {
-        self.as_borrowed().get_slice(low, high).into_gil_ref()
-    }
-
-    /// Gets the tuple item at the specified index.
-    /// # Example
-    /// ```
-    /// use pyo3::{prelude::*, types::PyTuple};
-    ///
-    /// # fn main() -> PyResult<()> {
-    /// Python::with_gil(|py| -> PyResult<()> {
-    ///     let ob = (1, 2, 3).to_object(py);
-    ///     let tuple: &PyTuple = ob.downcast(py).unwrap();
-    ///     let obj = tuple.get_item(0);
-    ///     assert_eq!(obj.unwrap().extract::<i32>().unwrap(), 1);
-    ///     Ok(())
-    /// })
-    /// # }
-    /// ```
-    pub fn get_item(&self, index: usize) -> PyResult<&PyAny> {
-        self.as_borrowed()
-            .get_borrowed_item(index)
-            .map(Borrowed::into_gil_ref)
-    }
-
-    /// Gets the tuple item at the specified index. Undefined behavior on bad index. Use with caution.
-    ///
-    /// # Safety
-    ///
-    /// Caller must verify that the index is within the bounds of the tuple.
-    #[cfg(not(any(Py_LIMITED_API, PyPy)))]
-    pub unsafe fn get_item_unchecked(&self, index: usize) -> &PyAny {
-        self.as_borrowed()
-            .get_borrowed_item_unchecked(index)
-            .into_gil_ref()
-    }
-
-    /// Returns `self` as a slice of objects.
-    #[cfg(not(Py_LIMITED_API))]
-    pub fn as_slice(&self) -> &[&PyAny] {
-        // This is safe because &PyAny has the same memory layout as *mut ffi::PyObject,
-        // and because tuples are immutable.
-        unsafe {
-            let ptr = self.as_ptr() as *mut ffi::PyTupleObject;
-            let slice = std::slice::from_raw_parts((*ptr).ob_item.as_ptr(), self.len());
-            &*(slice as *const [*mut ffi::PyObject] as *const [&PyAny])
-        }
-    }
-
-    /// Determines if self contains `value`.
-    ///
-    /// This is equivalent to the Python expression `value in self`.
-    #[inline]
-    pub fn contains<V>(&self, value: V) -> PyResult<bool>
-    where
-        V: ToPyObject,
-    {
-        self.as_borrowed().contains(value)
-    }
-
-    /// Returns the first index `i` for which `self[i] == value`.
-    ///
-    /// This is equivalent to the Python expression `self.index(value)`.
-    #[inline]
-    pub fn index<V>(&self, value: V) -> PyResult<usize>
-    where
-        V: ToPyObject,
-    {
-        self.as_borrowed().index(value)
-    }
-
-    /// Returns an iterator over the tuple items.
-    pub fn iter(&self) -> PyTupleIterator<'_> {
-        PyTupleIterator(BorrowedTupleIterator::new(self.as_borrowed()))
-    }
-
-    /// Return a new list containing the contents of this tuple; equivalent to the Python expression `list(tuple)`.
-    ///
-    /// This method is equivalent to `self.as_sequence().to_list()` and faster than `PyList::new(py, self)`.
-    pub fn to_list(&self) -> &PyList {
-        self.as_borrowed().to_list().into_gil_ref()
+    pub fn empty(py: Python<'_>) -> Bound<'_, PyTuple> {
+        unsafe { ffi::PyTuple_New(0).assume_owned(py).cast_into_unchecked() }
     }
 }
 
-index_impls!(PyTuple, "tuple", PyTuple::len, PyTuple::get_slice);
-
 /// Implementation of functionality for [`PyTuple`].
 ///
 /// These methods are defined for the `Bound<'py, PyTuple>` smart pointer, so to use method call
 /// syntax these methods are separated into a trait, because stable Rust does not yet support
 /// `arbitrary_self_types`.
 #[doc(alias = "PyTuple")]
-pub trait PyTupleMethods<'py> {
+pub trait PyTupleMethods<'py>: crate::sealed::Sealed {
     /// Gets the length of the tuple.
     fn len(&self) -> usize;
 
@@ -259,6 +130,9 @@ pub trait PyTupleMethods<'py> {
     /// Returns `self` cast as a `PySequence`.
     fn as_sequence(&self) -> &Bound<'py, PySequence>;
 
+    /// Returns `self` cast as a `PySequence`.
+    fn into_sequence(self) -> Bound<'py, PySequence>;
+
     /// Takes the slice `self[low:high]` and returns it as a new tuple.
     ///
     /// Indices must be nonnegative, and out-of-range indices are clipped to
@@ -268,14 +142,13 @@ pub trait PyTupleMethods<'py> {
     /// Gets the tuple item at the specified index.
     /// # Example
     /// ```
-    /// use pyo3::{prelude::*, types::PyTuple};
+    /// use pyo3::prelude::*;
     ///
     /// # fn main() -> PyResult<()> {
-    /// Python::with_gil(|py| -> PyResult<()> {
-    ///     let ob = (1, 2, 3).to_object(py);
-    ///     let tuple: &PyTuple = ob.downcast(py).unwrap();
+    /// Python::attach(|py| -> PyResult<()> {
+    ///     let tuple = (1, 2, 3).into_pyobject(py)?;
     ///     let obj = tuple.get_item(0);
-    ///     assert_eq!(obj.unwrap().extract::<i32>().unwrap(), 1);
+    ///     assert_eq!(obj?.extract::<i32>()?, 1);
     ///     Ok(())
     /// })
     /// # }
@@ -286,12 +159,17 @@ pub trait PyTupleMethods<'py> {
     /// by avoiding a reference count change.
     fn get_borrowed_item<'a>(&'a self, index: usize) -> PyResult<Borrowed<'a, 'py, PyAny>>;
 
-    /// Gets the tuple item at the specified index. Undefined behavior on bad index. Use with caution.
+    /// Gets the tuple item at the specified index. Undefined behavior on bad index, or if the tuple
+    /// contains a null pointer at the specified index. Use with caution.
     ///
     /// # Safety
     ///
-    /// Caller must verify that the index is within the bounds of the tuple.
-    #[cfg(not(any(Py_LIMITED_API, PyPy)))]
+    /// - Caller must verify that the index is within the bounds of the tuple.
+    /// - A null pointer is only legal in a tuple which is in the process of being initialized, callers
+    ///   can typically assume the tuple item is non-null unless they are knowingly filling an
+    ///   uninitialized tuple. (If a tuple were to contain a null pointer element, accessing it from Python
+    ///   typically causes a segfault.)
+    #[cfg(not(any(Py_LIMITED_API, PyPy, GraalPy)))]
     unsafe fn get_item_unchecked(&self, index: usize) -> Bound<'py, PyAny>;
 
     /// Like [`get_item_unchecked`][PyTupleMethods::get_item_unchecked], but returns a borrowed object,
@@ -299,12 +177,12 @@ pub trait PyTupleMethods<'py> {
     ///
     /// # Safety
     ///
-    /// Caller must verify that the index is within the bounds of the tuple.
-    #[cfg(not(any(Py_LIMITED_API, PyPy)))]
+    /// See [`get_item_unchecked`][PyTupleMethods::get_item_unchecked].
+    #[cfg(not(any(Py_LIMITED_API, PyPy, GraalPy)))]
     unsafe fn get_borrowed_item_unchecked<'a>(&'a self, index: usize) -> Borrowed<'a, 'py, PyAny>;
 
     /// Returns `self` as a slice of objects.
-    #[cfg(not(Py_LIMITED_API))]
+    #[cfg(not(any(Py_LIMITED_API, GraalPy)))]
     fn as_slice(&self) -> &[Bound<'py, PyAny>];
 
     /// Determines if self contains `value`.
@@ -312,14 +190,14 @@ pub trait PyTupleMethods<'py> {
     /// This is equivalent to the Python expression `value in self`.
     fn contains<V>(&self, value: V) -> PyResult<bool>
     where
-        V: ToPyObject;
+        V: IntoPyObject<'py>;
 
     /// Returns the first index `i` for which `self[i] == value`.
     ///
     /// This is equivalent to the Python expression `self.index(value)`.
     fn index<V>(&self, value: V) -> PyResult<usize>
     where
-        V: ToPyObject;
+        V: IntoPyObject<'py>;
 
     /// Returns an iterator over the tuple items.
     fn iter(&self) -> BoundTupleIterator<'py>;
@@ -337,9 +215,9 @@ pub trait PyTupleMethods<'py> {
 impl<'py> PyTupleMethods<'py> for Bound<'py, PyTuple> {
     fn len(&self) -> usize {
         unsafe {
-            #[cfg(not(any(Py_LIMITED_API, PyPy)))]
+            #[cfg(not(any(Py_LIMITED_API, PyPy, GraalPy)))]
             let size = ffi::PyTuple_GET_SIZE(self.as_ptr());
-            #[cfg(any(Py_LIMITED_API, PyPy))]
+            #[cfg(any(Py_LIMITED_API, PyPy, GraalPy))]
             let size = ffi::PyTuple_Size(self.as_ptr());
             // non-negative Py_ssize_t should always fit into Rust uint
             size as usize
@@ -351,14 +229,18 @@ impl<'py> PyTupleMethods<'py> for Bound<'py, PyTuple> {
     }
 
     fn as_sequence(&self) -> &Bound<'py, PySequence> {
-        unsafe { self.downcast_unchecked() }
+        unsafe { self.cast_unchecked() }
+    }
+
+    fn into_sequence(self) -> Bound<'py, PySequence> {
+        unsafe { self.cast_into_unchecked() }
     }
 
     fn get_slice(&self, low: usize, high: usize) -> Bound<'py, PyTuple> {
         unsafe {
             ffi::PyTuple_GetSlice(self.as_ptr(), get_ssize_index(low), get_ssize_index(high))
                 .assume_owned(self.py())
-                .downcast_into_unchecked()
+                .cast_into_unchecked()
         }
     }
 
@@ -370,31 +252,28 @@ impl<'py> PyTupleMethods<'py> for Bound<'py, PyTuple> {
         self.as_borrowed().get_borrowed_item(index)
     }
 
-    #[cfg(not(any(Py_LIMITED_API, PyPy)))]
+    #[cfg(not(any(Py_LIMITED_API, PyPy, GraalPy)))]
     unsafe fn get_item_unchecked(&self, index: usize) -> Bound<'py, PyAny> {
-        self.get_borrowed_item_unchecked(index).to_owned()
+        unsafe { self.get_borrowed_item_unchecked(index).to_owned() }
     }
 
-    #[cfg(not(any(Py_LIMITED_API, PyPy)))]
+    #[cfg(not(any(Py_LIMITED_API, PyPy, GraalPy)))]
     unsafe fn get_borrowed_item_unchecked<'a>(&'a self, index: usize) -> Borrowed<'a, 'py, PyAny> {
-        self.as_borrowed().get_borrowed_item_unchecked(index)
+        unsafe { self.as_borrowed().get_borrowed_item_unchecked(index) }
     }
 
-    #[cfg(not(Py_LIMITED_API))]
+    #[cfg(not(any(Py_LIMITED_API, GraalPy)))]
     fn as_slice(&self) -> &[Bound<'py, PyAny>] {
-        // This is safe because Bound<'py, PyAny> has the same memory layout as *mut ffi::PyObject,
-        // and because tuples are immutable.
-        unsafe {
-            let ptr = self.as_ptr() as *mut ffi::PyTupleObject;
-            let slice = std::slice::from_raw_parts((*ptr).ob_item.as_ptr(), self.len());
-            &*(slice as *const [*mut ffi::PyObject] as *const [Bound<'py, PyAny>])
-        }
+        // SAFETY: self is known to be a tuple object, and tuples are immutable
+        let items = unsafe { &(*self.as_ptr().cast::<ffi::PyTupleObject>()).ob_item };
+        // SAFETY: Bound<'py, PyAny> has the same memory layout as *mut ffi::PyObject
+        unsafe { std::slice::from_raw_parts(items.as_ptr().cast(), self.len()) }
     }
 
     #[inline]
     fn contains<V>(&self, value: V) -> PyResult<bool>
     where
-        V: ToPyObject,
+        V: IntoPyObject<'py>,
     {
         self.as_sequence().contains(value)
     }
@@ -402,7 +281,7 @@ impl<'py> PyTupleMethods<'py> for Bound<'py, PyTuple> {
     #[inline]
     fn index<V>(&self, value: V) -> PyResult<usize>
     where
-        V: ToPyObject,
+        V: IntoPyObject<'py>,
     {
         self.as_sequence().index(value)
     }
@@ -412,7 +291,7 @@ impl<'py> PyTupleMethods<'py> for Bound<'py, PyTuple> {
     }
 
     fn iter_borrowed<'a>(&'a self) -> BorrowedTupleIterator<'a, 'py> {
-        BorrowedTupleIterator::new(self.as_borrowed())
+        self.as_borrowed().iter_borrowed()
     }
 
     fn to_list(&self) -> Bound<'py, PyList> {
@@ -430,50 +309,20 @@ impl<'a, 'py> Borrowed<'a, 'py, PyTuple> {
         }
     }
 
-    #[cfg(not(any(Py_LIMITED_API, PyPy)))]
+    /// # Safety
+    ///
+    /// See `get_item_unchecked` in `PyTupleMethods`.
+    #[cfg(not(any(Py_LIMITED_API, PyPy, GraalPy)))]
     unsafe fn get_borrowed_item_unchecked(self, index: usize) -> Borrowed<'a, 'py, PyAny> {
-        ffi::PyTuple_GET_ITEM(self.as_ptr(), index as Py_ssize_t).assume_borrowed(self.py())
-    }
-}
-
-/// Used by `PyTuple::iter()`.
-pub struct PyTupleIterator<'a>(BorrowedTupleIterator<'a, 'a>);
-
-impl<'a> Iterator for PyTupleIterator<'a> {
-    type Item = &'a PyAny;
-
-    #[inline]
-    fn next(&mut self) -> Option<Self::Item> {
-        self.0.next().map(Borrowed::into_gil_ref)
-    }
-
-    #[inline]
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        self.0.size_hint()
-    }
-}
-
-impl<'a> DoubleEndedIterator for PyTupleIterator<'a> {
-    #[inline]
-    fn next_back(&mut self) -> Option<Self::Item> {
-        self.0.next_back().map(Borrowed::into_gil_ref)
-    }
-}
-
-impl<'a> ExactSizeIterator for PyTupleIterator<'a> {
-    fn len(&self) -> usize {
-        self.0.len()
+        // SAFETY: caller has upheld the safety contract
+        unsafe {
+            ffi::PyTuple_GET_ITEM(self.as_ptr(), index as Py_ssize_t)
+                .assume_borrowed_unchecked(self.py())
+        }
     }
-}
 
-impl FusedIterator for PyTupleIterator<'_> {}
-
-impl<'a> IntoIterator for &'a PyTuple {
-    type Item = &'a PyAny;
-    type IntoIter = PyTupleIterator<'a>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        PyTupleIterator(BorrowedTupleIterator::new(self.as_borrowed()))
+    pub(crate) fn iter_borrowed(self) -> BorrowedTupleIterator<'a, 'py> {
+        BorrowedTupleIterator::new(self)
     }
 }
 
@@ -516,9 +365,65 @@ impl<'py> Iterator for BoundTupleIterator<'py> {
         let len = self.len();
         (len, Some(len))
     }
+
+    #[inline]
+    fn count(self) -> usize
+    where
+        Self: Sized,
+    {
+        self.len()
+    }
+
+    #[inline]
+    fn last(mut self) -> Option<Self::Item>
+    where
+        Self: Sized,
+    {
+        self.next_back()
+    }
+
+    #[inline]
+    #[cfg(not(feature = "nightly"))]
+    fn nth(&mut self, n: usize) -> Option<Self::Item> {
+        let length = self.length.min(self.tuple.len());
+        let target_index = self.index + n;
+        if target_index < length {
+            let item = unsafe {
+                BorrowedTupleIterator::get_item(self.tuple.as_borrowed(), target_index).to_owned()
+            };
+            self.index = target_index + 1;
+            Some(item)
+        } else {
+            None
+        }
+    }
+
+    #[inline]
+    #[cfg(feature = "nightly")]
+    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>> {
+        let max_len = self.length.min(self.tuple.len());
+        let currently_at = self.index;
+        if currently_at >= max_len {
+            if n == 0 {
+                return Ok(());
+            } else {
+                return Err(unsafe { NonZero::new_unchecked(n) });
+            }
+        }
+
+        let items_left = max_len - currently_at;
+        if n <= items_left {
+            self.index += n;
+            Ok(())
+        } else {
+            self.index = max_len;
+            let remainder = n - items_left;
+            Err(unsafe { NonZero::new_unchecked(remainder) })
+        }
+    }
 }
 
-impl<'py> DoubleEndedIterator for BoundTupleIterator<'py> {
+impl DoubleEndedIterator for BoundTupleIterator<'_> {
     #[inline]
     fn next_back(&mut self) -> Option<Self::Item> {
         if self.index < self.length {
@@ -532,9 +437,49 @@ impl<'py> DoubleEndedIterator for BoundTupleIterator<'py> {
             None
         }
     }
+
+    #[inline]
+    #[cfg(not(feature = "nightly"))]
+    fn nth_back(&mut self, n: usize) -> Option<Self::Item> {
+        let length_size = self.length.min(self.tuple.len());
+        if self.index + n < length_size {
+            let target_index = length_size - n - 1;
+            let item = unsafe {
+                BorrowedTupleIterator::get_item(self.tuple.as_borrowed(), target_index).to_owned()
+            };
+            self.length = target_index;
+            Some(item)
+        } else {
+            None
+        }
+    }
+
+    #[inline]
+    #[cfg(feature = "nightly")]
+    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>> {
+        let max_len = self.length.min(self.tuple.len());
+        let currently_at = self.index;
+        if currently_at >= max_len {
+            if n == 0 {
+                return Ok(());
+            } else {
+                return Err(unsafe { NonZero::new_unchecked(n) });
+            }
+        }
+
+        let items_left = max_len - currently_at;
+        if n <= items_left {
+            self.length = max_len - n;
+            Ok(())
+        } else {
+            self.length = currently_at;
+            let remainder = n - items_left;
+            Err(unsafe { NonZero::new_unchecked(remainder) })
+        }
+    }
 }
 
-impl<'py> ExactSizeIterator for BoundTupleIterator<'py> {
+impl ExactSizeIterator for BoundTupleIterator<'_> {
     fn len(&self) -> usize {
         self.length.saturating_sub(self.index)
     }
@@ -551,6 +496,15 @@ impl<'py> IntoIterator for Bound<'py, PyTuple> {
     }
 }
 
+impl<'py> IntoIterator for &Bound<'py, PyTuple> {
+    type Item = Bound<'py, PyAny>;
+    type IntoIter = BoundTupleIterator<'py>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.iter()
+    }
+}
+
 /// Used by `PyTuple::iter_borrowed()`.
 pub struct BorrowedTupleIterator<'a, 'py> {
     tuple: Borrowed<'a, 'py, PyTuple>,
@@ -572,10 +526,10 @@ impl<'a, 'py> BorrowedTupleIterator<'a, 'py> {
         tuple: Borrowed<'a, 'py, PyTuple>,
         index: usize,
     ) -> Borrowed<'a, 'py, PyAny> {
-        #[cfg(any(Py_LIMITED_API, PyPy))]
+        #[cfg(any(Py_LIMITED_API, PyPy, GraalPy))]
         let item = tuple.get_borrowed_item(index).expect("tuple.get failed");
-        #[cfg(not(any(Py_LIMITED_API, PyPy)))]
-        let item = tuple.get_borrowed_item_unchecked(index);
+        #[cfg(not(any(Py_LIMITED_API, PyPy, GraalPy)))]
+        let item = unsafe { tuple.get_borrowed_item_unchecked(index) };
         item
     }
 }
@@ -599,9 +553,25 @@ impl<'a, 'py> Iterator for BorrowedTupleIterator<'a, 'py> {
         let len = self.len();
         (len, Some(len))
     }
+
+    #[inline]
+    fn count(self) -> usize
+    where
+        Self: Sized,
+    {
+        self.len()
+    }
+
+    #[inline]
+    fn last(mut self) -> Option<Self::Item>
+    where
+        Self: Sized,
+    {
+        self.next_back()
+    }
 }
 
-impl<'a, 'py> DoubleEndedIterator for BorrowedTupleIterator<'a, 'py> {
+impl DoubleEndedIterator for BorrowedTupleIterator<'_, '_> {
     #[inline]
     fn next_back(&mut self) -> Option<Self::Item> {
         if self.index < self.length {
@@ -614,7 +584,7 @@ impl<'a, 'py> DoubleEndedIterator for BorrowedTupleIterator<'a, 'py> {
     }
 }
 
-impl<'a, 'py> ExactSizeIterator for BorrowedTupleIterator<'a, 'py> {
+impl ExactSizeIterator for BorrowedTupleIterator<'_, '_> {
     fn len(&self) -> usize {
         self.length.saturating_sub(self.index)
     }
@@ -622,14 +592,8 @@ impl<'a, 'py> ExactSizeIterator for BorrowedTupleIterator<'a, 'py> {
 
 impl FusedIterator for BorrowedTupleIterator<'_, '_> {}
 
-impl IntoPy<Py<PyTuple>> for Bound<'_, PyTuple> {
-    fn into_py(self, _: Python<'_>) -> Py<PyTuple> {
-        self.unbind()
-    }
-}
-
 #[cold]
-fn wrong_tuple_length(t: &Bound<'_, PyTuple>, expected_length: usize) -> PyErr {
+fn wrong_tuple_length(t: Borrowed<'_, '_, PyTuple>, expected_length: usize) -> PyErr {
     let msg = format!(
         "expected tuple of length {}, but got tuple of length {}",
         expected_length,
@@ -639,63 +603,334 @@ fn wrong_tuple_length(t: &Bound<'_, PyTuple>, expected_length: usize) -> PyErr {
 }
 
 macro_rules! tuple_conversion ({$length:expr,$(($refN:ident, $n:tt, $T:ident)),+} => {
-    impl <$($T: ToPyObject),+> ToPyObject for ($($T,)+) {
-        fn to_object(&self, py: Python<'_>) -> PyObject {
-            array_into_tuple(py, [$(self.$n.to_object(py)),+]).into()
-        }
-    }
-    impl <$($T: IntoPy<PyObject>),+> IntoPy<PyObject> for ($($T,)+) {
-        fn into_py(self, py: Python<'_>) -> PyObject {
-            array_into_tuple(py, [$(self.$n.into_py(py)),+]).into()
+    impl <'py, $($T),+> IntoPyObject<'py> for ($($T,)+)
+    where
+        $($T: IntoPyObject<'py>,)+
+    {
+        type Target = PyTuple;
+        type Output = Bound<'py, Self::Target>;
+        type Error = PyErr;
+
+        fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+            Ok(array_into_tuple(py, [$(self.$n.into_bound_py_any(py)?),+]))
         }
 
         #[cfg(feature = "experimental-inspect")]
-fn type_output() -> TypeInfo {
+        fn type_output() -> TypeInfo {
             TypeInfo::Tuple(Some(vec![$( $T::type_output() ),+]))
         }
     }
 
-    impl <$($T: IntoPy<PyObject>),+> IntoPy<Py<PyTuple>> for ($($T,)+) {
-        fn into_py(self, py: Python<'_>) -> Py<PyTuple> {
-            array_into_tuple(py, [$(self.$n.into_py(py)),+])
+    impl <'a, 'py, $($T),+> IntoPyObject<'py> for &'a ($($T,)+)
+    where
+        $(&'a $T: IntoPyObject<'py>,)+
+    {
+        type Target = PyTuple;
+        type Output = Bound<'py, Self::Target>;
+        type Error = PyErr;
+
+        fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+            Ok(array_into_tuple(py, [$(self.$n.into_bound_py_any(py)?),+]))
         }
 
         #[cfg(feature = "experimental-inspect")]
         fn type_output() -> TypeInfo {
-            TypeInfo::Tuple(Some(vec![$( $T::type_output() ),+]))
+            TypeInfo::Tuple(Some(vec![$( <&$T>::type_output() ),+]))
+        }
+    }
+
+    impl<'py, $($T),+> crate::call::private::Sealed for ($($T,)+) where $($T: IntoPyObject<'py>,)+ {}
+    impl<'py, $($T),+> crate::call::PyCallArgs<'py> for ($($T,)+)
+    where
+        $($T: IntoPyObject<'py>,)+
+    {
+        #[cfg(all(Py_3_9, not(any(PyPy, GraalPy, Py_LIMITED_API))))]
+        fn call(
+            self,
+            function: Borrowed<'_, 'py, PyAny>,
+            kwargs: Borrowed<'_, '_, crate::types::PyDict>,
+            _: crate::call::private::Token,
+        ) -> PyResult<Bound<'py, PyAny>> {
+            let py = function.py();
+            // We need this to drop the arguments correctly.
+            let args_bound = [$(self.$n.into_bound_py_any(py)?,)*];
+            // Prepend one null argument for `PY_VECTORCALL_ARGUMENTS_OFFSET`.
+            let mut args = [std::ptr::null_mut(), $(args_bound[$n].as_ptr()),*];
+            unsafe {
+                ffi::PyObject_VectorcallDict(
+                    function.as_ptr(),
+                    args.as_mut_ptr().add(1),
+                    $length + ffi::PY_VECTORCALL_ARGUMENTS_OFFSET,
+                    kwargs.as_ptr(),
+                )
+                .assume_owned_or_err(py)
+            }
+        }
+
+        #[cfg(all(not(any(PyPy, GraalPy)), any(all(Py_3_9, not(Py_LIMITED_API)), Py_3_12)))]
+        fn call_positional(
+            self,
+            function: Borrowed<'_, 'py, PyAny>,
+            _: crate::call::private::Token,
+        ) -> PyResult<Bound<'py, PyAny>> {
+            let py = function.py();
+            // We need this to drop the arguments correctly.
+            let args_bound = [$(self.$n.into_bound_py_any(py)?,)*];
+
+            #[cfg(not(Py_LIMITED_API))]
+            if $length == 1 {
+                return unsafe {
+                    ffi::PyObject_CallOneArg(
+                       function.as_ptr(),
+                       args_bound[0].as_ptr()
+                    )
+                    .assume_owned_or_err(py)
+                };
+            }
+
+            // Prepend one null argument for `PY_VECTORCALL_ARGUMENTS_OFFSET`.
+            let mut args = [std::ptr::null_mut(), $(args_bound[$n].as_ptr()),*];
+            unsafe {
+                ffi::PyObject_Vectorcall(
+                    function.as_ptr(),
+                    args.as_mut_ptr().add(1),
+                    $length + ffi::PY_VECTORCALL_ARGUMENTS_OFFSET,
+                    std::ptr::null_mut(),
+                )
+                .assume_owned_or_err(py)
+            }
+        }
+
+        #[cfg(all(not(any(PyPy, GraalPy)), any(all(Py_3_9, not(Py_LIMITED_API)), Py_3_12)))]
+        fn call_method_positional(
+            self,
+            object: Borrowed<'_, 'py, PyAny>,
+            method_name: Borrowed<'_, 'py, crate::types::PyString>,
+            _: crate::call::private::Token,
+        ) -> PyResult<Bound<'py, PyAny>> {
+            let py = object.py();
+            // We need this to drop the arguments correctly.
+            let args_bound = [$(self.$n.into_bound_py_any(py)?,)*];
+
+            #[cfg(not(Py_LIMITED_API))]
+            if $length == 1 {
+                return unsafe {
+                    ffi::PyObject_CallMethodOneArg(
+                            object.as_ptr(),
+                            method_name.as_ptr(),
+                            args_bound[0].as_ptr(),
+                    )
+                    .assume_owned_or_err(py)
+                };
+            }
+
+            let mut args = [object.as_ptr(), $(args_bound[$n].as_ptr()),*];
+            unsafe {
+                ffi::PyObject_VectorcallMethod(
+                    method_name.as_ptr(),
+                    args.as_mut_ptr(),
+                    // +1 for the receiver.
+                    1 + $length + ffi::PY_VECTORCALL_ARGUMENTS_OFFSET,
+                    std::ptr::null_mut(),
+                )
+                .assume_owned_or_err(py)
+            }
+
+        }
+
+        #[cfg(not(all(Py_3_9, not(any(PyPy, GraalPy, Py_LIMITED_API)))))]
+        fn call(
+            self,
+            function: Borrowed<'_, 'py, PyAny>,
+            kwargs: Borrowed<'_, 'py, crate::types::PyDict>,
+            token: crate::call::private::Token,
+        ) -> PyResult<Bound<'py, PyAny>> {
+            self.into_pyobject_or_pyerr(function.py())?.call(function, kwargs, token)
+        }
+
+        #[cfg(not(all(not(any(PyPy, GraalPy)), any(all(Py_3_9, not(Py_LIMITED_API)), Py_3_12))))]
+        fn call_positional(
+            self,
+            function: Borrowed<'_, 'py, PyAny>,
+            token: crate::call::private::Token,
+        ) -> PyResult<Bound<'py, PyAny>> {
+            self.into_pyobject_or_pyerr(function.py())?.call_positional(function, token)
+        }
+
+        #[cfg(not(all(not(any(PyPy, GraalPy)), any(all(Py_3_9, not(Py_LIMITED_API)), Py_3_12))))]
+        fn call_method_positional(
+            self,
+            object: Borrowed<'_, 'py, PyAny>,
+            method_name: Borrowed<'_, 'py, crate::types::PyString>,
+            token: crate::call::private::Token,
+        ) -> PyResult<Bound<'py, PyAny>> {
+            self.into_pyobject_or_pyerr(object.py())?.call_method_positional(object, method_name, token)
         }
     }
 
-    impl<'py, $($T: FromPyObject<'py>),+> FromPyObject<'py> for ($($T,)+) {
-        fn extract_bound(obj: &Bound<'py, PyAny>) -> PyResult<Self>
+    impl<'a, 'py, $($T),+> crate::call::private::Sealed for &'a ($($T,)+) where $(&'a $T: IntoPyObject<'py>,)+ {}
+    impl<'a, 'py, $($T),+> crate::call::PyCallArgs<'py> for &'a ($($T,)+)
+    where
+        $(&'a $T: IntoPyObject<'py>,)+
+    {
+        #[cfg(all(Py_3_9, not(any(PyPy, GraalPy, Py_LIMITED_API))))]
+        fn call(
+            self,
+            function: Borrowed<'_, 'py, PyAny>,
+            kwargs: Borrowed<'_, '_, crate::types::PyDict>,
+            _: crate::call::private::Token,
+        ) -> PyResult<Bound<'py, PyAny>> {
+            let py = function.py();
+            // We need this to drop the arguments correctly.
+            let args_bound = [$(self.$n.into_bound_py_any(py)?,)*];
+            // Prepend one null argument for `PY_VECTORCALL_ARGUMENTS_OFFSET`.
+            let mut args = [std::ptr::null_mut(), $(args_bound[$n].as_ptr()),*];
+            unsafe {
+                ffi::PyObject_VectorcallDict(
+                    function.as_ptr(),
+                    args.as_mut_ptr().add(1),
+                    $length + ffi::PY_VECTORCALL_ARGUMENTS_OFFSET,
+                    kwargs.as_ptr(),
+                )
+                .assume_owned_or_err(py)
+            }
+        }
+
+        #[cfg(all(not(any(PyPy, GraalPy)), any(all(Py_3_9, not(Py_LIMITED_API)), Py_3_12)))]
+        fn call_positional(
+            self,
+            function: Borrowed<'_, 'py, PyAny>,
+            _: crate::call::private::Token,
+        ) -> PyResult<Bound<'py, PyAny>> {
+            let py = function.py();
+            // We need this to drop the arguments correctly.
+            let args_bound = [$(self.$n.into_bound_py_any(py)?,)*];
+
+            #[cfg(not(Py_LIMITED_API))]
+            if $length == 1 {
+                return unsafe {
+                    ffi::PyObject_CallOneArg(
+                       function.as_ptr(),
+                       args_bound[0].as_ptr()
+                    )
+                    .assume_owned_or_err(py)
+                };
+            }
+
+            // Prepend one null argument for `PY_VECTORCALL_ARGUMENTS_OFFSET`.
+            let mut args = [std::ptr::null_mut(), $(args_bound[$n].as_ptr()),*];
+            unsafe {
+                ffi::PyObject_Vectorcall(
+                    function.as_ptr(),
+                    args.as_mut_ptr().add(1),
+                    $length + ffi::PY_VECTORCALL_ARGUMENTS_OFFSET,
+                    std::ptr::null_mut(),
+                )
+                .assume_owned_or_err(py)
+            }
+        }
+
+        #[cfg(all(not(any(PyPy, GraalPy)), any(all(Py_3_9, not(Py_LIMITED_API)), Py_3_12)))]
+        fn call_method_positional(
+            self,
+            object: Borrowed<'_, 'py, PyAny>,
+            method_name: Borrowed<'_, 'py, crate::types::PyString>,
+            _: crate::call::private::Token,
+        ) -> PyResult<Bound<'py, PyAny>> {
+            let py = object.py();
+            // We need this to drop the arguments correctly.
+            let args_bound = [$(self.$n.into_bound_py_any(py)?,)*];
+
+            #[cfg(not(Py_LIMITED_API))]
+            if $length == 1 {
+                return unsafe {
+                    ffi::PyObject_CallMethodOneArg(
+                            object.as_ptr(),
+                            method_name.as_ptr(),
+                            args_bound[0].as_ptr(),
+                    )
+                    .assume_owned_or_err(py)
+                };
+            }
+
+            let mut args = [object.as_ptr(), $(args_bound[$n].as_ptr()),*];
+            unsafe {
+                ffi::PyObject_VectorcallMethod(
+                    method_name.as_ptr(),
+                    args.as_mut_ptr(),
+                    // +1 for the receiver.
+                    1 + $length + ffi::PY_VECTORCALL_ARGUMENTS_OFFSET,
+                    std::ptr::null_mut(),
+                )
+                .assume_owned_or_err(py)
+            }
+        }
+
+        #[cfg(not(all(Py_3_9, not(any(PyPy, GraalPy, Py_LIMITED_API)))))]
+        fn call(
+            self,
+            function: Borrowed<'_, 'py, PyAny>,
+            kwargs: Borrowed<'_, 'py, crate::types::PyDict>,
+            token: crate::call::private::Token,
+        ) -> PyResult<Bound<'py, PyAny>> {
+            self.into_pyobject_or_pyerr(function.py())?.call(function, kwargs, token)
+        }
+
+        #[cfg(not(all(not(any(PyPy, GraalPy)), any(all(Py_3_9, not(Py_LIMITED_API)), Py_3_12))))]
+        fn call_positional(
+            self,
+            function: Borrowed<'_, 'py, PyAny>,
+            token: crate::call::private::Token,
+        ) -> PyResult<Bound<'py, PyAny>> {
+            self.into_pyobject_or_pyerr(function.py())?.call_positional(function, token)
+        }
+
+        #[cfg(not(all(not(any(PyPy, GraalPy)), any(all(Py_3_9, not(Py_LIMITED_API)), Py_3_12))))]
+        fn call_method_positional(
+            self,
+            object: Borrowed<'_, 'py, PyAny>,
+            method_name: Borrowed<'_, 'py, crate::types::PyString>,
+            token: crate::call::private::Token,
+        ) -> PyResult<Bound<'py, PyAny>> {
+            self.into_pyobject_or_pyerr(object.py())?.call_method_positional(object, method_name, token)
+        }
+    }
+
+    impl<'a, 'py, $($T: FromPyObject<'a, 'py>),+> FromPyObject<'a, 'py> for ($($T,)+) {
+        type Error = PyErr;
+
+        fn extract(obj: Borrowed<'a, 'py, PyAny>) -> Result<Self, Self::Error>
         {
-            let t = obj.downcast::<PyTuple>()?;
+            let t = obj.cast::<PyTuple>()?;
             if t.len() == $length {
-                #[cfg(any(Py_LIMITED_API, PyPy))]
-                return Ok(($(t.get_item($n)?.extract::<$T>()?,)+));
+                #[cfg(any(Py_LIMITED_API, PyPy, GraalPy))]
+                return Ok(($(t.get_borrowed_item($n)?.extract::<$T>().map_err(Into::into)?,)+));
 
-                #[cfg(not(any(Py_LIMITED_API, PyPy)))]
-                unsafe {return Ok(($(t.get_item_unchecked($n).extract::<$T>()?,)+));}
+                #[cfg(not(any(Py_LIMITED_API, PyPy, GraalPy)))]
+                unsafe {return Ok(($(t.get_borrowed_item_unchecked($n).extract::<$T>().map_err(Into::into)?,)+));}
             } else {
                 Err(wrong_tuple_length(t, $length))
             }
         }
 
         #[cfg(feature = "experimental-inspect")]
-fn type_input() -> TypeInfo {
+        fn type_input() -> TypeInfo {
             TypeInfo::Tuple(Some(vec![$( $T::type_input() ),+]))
         }
     }
 });
 
-fn array_into_tuple<const N: usize>(py: Python<'_>, array: [PyObject; N]) -> Py<PyTuple> {
+fn array_into_tuple<'py, const N: usize>(
+    py: Python<'py>,
+    array: [Bound<'py, PyAny>; N],
+) -> Bound<'py, PyTuple> {
     unsafe {
         let ptr = ffi::PyTuple_New(N.try_into().expect("0 < N <= 12"));
-        let tup = Py::from_owned_ptr(py, ptr);
+        let tup = ptr.assume_owned(py).cast_into_unchecked();
         for (index, obj) in array.into_iter().enumerate() {
-            #[cfg(not(any(Py_LIMITED_API, PyPy)))]
+            #[cfg(not(any(Py_LIMITED_API, PyPy, GraalPy)))]
             ffi::PyTuple_SET_ITEM(ptr, index as ffi::Py_ssize_t, obj.into_ptr());
-            #[cfg(any(Py_LIMITED_API, PyPy))]
+            #[cfg(any(Py_LIMITED_API, PyPy, GraalPy))]
             ffi::PyTuple_SetItem(ptr, index as ffi::Py_ssize_t, obj.into_ptr());
         }
         tup
@@ -807,42 +1042,43 @@ tuple_conversion!(
 );
 
 #[cfg(test)]
-#[allow(deprecated)] // TODO: remove allow when GIL Pool is removed
 mod tests {
-    use crate::types::{any::PyAnyMethods, tuple::PyTupleMethods, PyAny, PyList, PyTuple};
-    use crate::{Python, ToPyObject};
+    use crate::types::{any::PyAnyMethods, tuple::PyTupleMethods, PyList, PyTuple};
+    use crate::{IntoPyObject, Python};
     use std::collections::HashSet;
-
+    #[cfg(feature = "nightly")]
+    use std::num::NonZero;
+    use std::ops::Range;
     #[test]
     fn test_new() {
-        Python::with_gil(|py| {
-            let ob = PyTuple::new(py, [1, 2, 3]);
+        Python::attach(|py| {
+            let ob = PyTuple::new(py, [1, 2, 3]).unwrap();
             assert_eq!(3, ob.len());
-            let ob: &PyAny = ob.into();
+            let ob = ob.as_any();
             assert_eq!((1, 2, 3), ob.extract().unwrap());
 
             let mut map = HashSet::new();
             map.insert(1);
             map.insert(2);
-            PyTuple::new(py, map);
+            PyTuple::new(py, map).unwrap();
         });
     }
 
     #[test]
     fn test_len() {
-        Python::with_gil(|py| {
-            let ob = (1, 2, 3).to_object(py);
-            let tuple: &PyTuple = ob.downcast(py).unwrap();
+        Python::attach(|py| {
+            let ob = (1, 2, 3).into_pyobject(py).unwrap();
+            let tuple = ob.cast::<PyTuple>().unwrap();
             assert_eq!(3, tuple.len());
             assert!(!tuple.is_empty());
-            let ob: &PyAny = tuple.into();
+            let ob = tuple.as_any();
             assert_eq!((1, 2, 3), ob.extract().unwrap());
         });
     }
 
     #[test]
     fn test_empty() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let tuple = PyTuple::empty(py);
             assert!(tuple.is_empty());
             assert_eq!(0, tuple.len());
@@ -851,8 +1087,8 @@ mod tests {
 
     #[test]
     fn test_slice() {
-        Python::with_gil(|py| {
-            let tup = PyTuple::new(py, [2, 3, 5, 7]);
+        Python::attach(|py| {
+            let tup = PyTuple::new(py, [2, 3, 5, 7]).unwrap();
             let slice = tup.get_slice(1, 3);
             assert_eq!(2, slice.len());
             let slice = tup.get_slice(1, 7);
@@ -862,9 +1098,9 @@ mod tests {
 
     #[test]
     fn test_iter() {
-        Python::with_gil(|py| {
-            let ob = (1, 2, 3).to_object(py);
-            let tuple: &PyTuple = ob.downcast(py).unwrap();
+        Python::attach(|py| {
+            let ob = (1, 2, 3).into_pyobject(py).unwrap();
+            let tuple = ob.cast::<PyTuple>().unwrap();
             assert_eq!(3, tuple.len());
             let mut iter = tuple.iter();
 
@@ -886,9 +1122,9 @@ mod tests {
 
     #[test]
     fn test_iter_rev() {
-        Python::with_gil(|py| {
-            let ob = (1, 2, 3).to_object(py);
-            let tuple: &PyTuple = ob.downcast(py).unwrap();
+        Python::attach(|py| {
+            let ob = (1, 2, 3).into_pyobject(py).unwrap();
+            let tuple = ob.cast::<PyTuple>().unwrap();
             assert_eq!(3, tuple.len());
             let mut iter = tuple.iter().rev();
 
@@ -910,8 +1146,8 @@ mod tests {
 
     #[test]
     fn test_bound_iter() {
-        Python::with_gil(|py| {
-            let tuple = PyTuple::new_bound(py, [1, 2, 3]);
+        Python::attach(|py| {
+            let tuple = PyTuple::new(py, [1, 2, 3]).unwrap();
             assert_eq!(3, tuple.len());
             let mut iter = tuple.iter();
 
@@ -933,8 +1169,8 @@ mod tests {
 
     #[test]
     fn test_bound_iter_rev() {
-        Python::with_gil(|py| {
-            let tuple = PyTuple::new_bound(py, [1, 2, 3]);
+        Python::attach(|py| {
+            let tuple = PyTuple::new(py, [1, 2, 3]).unwrap();
             assert_eq!(3, tuple.len());
             let mut iter = tuple.iter().rev();
 
@@ -956,9 +1192,9 @@ mod tests {
 
     #[test]
     fn test_into_iter() {
-        Python::with_gil(|py| {
-            let ob = (1, 2, 3).to_object(py);
-            let tuple: &PyTuple = ob.downcast(py).unwrap();
+        Python::attach(|py| {
+            let ob = (1, 2, 3).into_pyobject(py).unwrap();
+            let tuple = ob.cast::<PyTuple>().unwrap();
             assert_eq!(3, tuple.len());
 
             for (i, item) in tuple.iter().enumerate() {
@@ -968,11 +1204,25 @@ mod tests {
     }
 
     #[test]
-    #[cfg(not(Py_LIMITED_API))]
+    fn test_into_iter_bound() {
+        Python::attach(|py| {
+            let tuple = (1, 2, 3).into_pyobject(py).unwrap();
+            assert_eq!(3, tuple.len());
+
+            let mut items = vec![];
+            for item in tuple {
+                items.push(item.extract::<usize>().unwrap());
+            }
+            assert_eq!(items, vec![1, 2, 3]);
+        });
+    }
+
+    #[test]
+    #[cfg(not(any(Py_LIMITED_API, GraalPy)))]
     fn test_as_slice() {
-        Python::with_gil(|py| {
-            let ob = (1, 2, 3).to_object(py);
-            let tuple: &PyTuple = ob.downcast(py).unwrap();
+        Python::attach(|py| {
+            let ob = (1, 2, 3).into_pyobject(py).unwrap();
+            let tuple = ob.cast::<PyTuple>().unwrap();
 
             let slice = tuple.as_slice();
             assert_eq!(3, slice.len());
@@ -984,62 +1234,66 @@ mod tests {
 
     #[test]
     fn test_tuple_lengths_up_to_12() {
-        Python::with_gil(|py| {
-            let t0 = (0,).to_object(py);
-            let t1 = (0, 1).to_object(py);
-            let t2 = (0, 1, 2).to_object(py);
-            let t3 = (0, 1, 2, 3).to_object(py);
-            let t4 = (0, 1, 2, 3, 4).to_object(py);
-            let t5 = (0, 1, 2, 3, 4, 5).to_object(py);
-            let t6 = (0, 1, 2, 3, 4, 5, 6).to_object(py);
-            let t7 = (0, 1, 2, 3, 4, 5, 6, 7).to_object(py);
-            let t8 = (0, 1, 2, 3, 4, 5, 6, 7, 8).to_object(py);
-            let t9 = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9).to_object(py);
-            let t10 = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10).to_object(py);
-            let t11 = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11).to_object(py);
-
-            assert_eq!(t0.extract::<(i32,)>(py).unwrap(), (0,));
-            assert_eq!(t1.extract::<(i32, i32)>(py).unwrap(), (0, 1,));
-            assert_eq!(t2.extract::<(i32, i32, i32)>(py).unwrap(), (0, 1, 2,));
+        Python::attach(|py| {
+            let t0 = (0,).into_pyobject(py).unwrap();
+            let t1 = (0, 1).into_pyobject(py).unwrap();
+            let t2 = (0, 1, 2).into_pyobject(py).unwrap();
+            let t3 = (0, 1, 2, 3).into_pyobject(py).unwrap();
+            let t4 = (0, 1, 2, 3, 4).into_pyobject(py).unwrap();
+            let t5 = (0, 1, 2, 3, 4, 5).into_pyobject(py).unwrap();
+            let t6 = (0, 1, 2, 3, 4, 5, 6).into_pyobject(py).unwrap();
+            let t7 = (0, 1, 2, 3, 4, 5, 6, 7).into_pyobject(py).unwrap();
+            let t8 = (0, 1, 2, 3, 4, 5, 6, 7, 8).into_pyobject(py).unwrap();
+            let t9 = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9).into_pyobject(py).unwrap();
+            let t10 = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
+                .into_pyobject(py)
+                .unwrap();
+            let t11 = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11)
+                .into_pyobject(py)
+                .unwrap();
+
+            assert_eq!(t0.extract::<(i32,)>().unwrap(), (0,));
+            assert_eq!(t1.extract::<(i32, i32)>().unwrap(), (0, 1,));
+            assert_eq!(t2.extract::<(i32, i32, i32)>().unwrap(), (0, 1, 2,));
             assert_eq!(
-                t3.extract::<(i32, i32, i32, i32,)>(py).unwrap(),
+                t3.extract::<(i32, i32, i32, i32,)>().unwrap(),
                 (0, 1, 2, 3,)
             );
             assert_eq!(
-                t4.extract::<(i32, i32, i32, i32, i32,)>(py).unwrap(),
+                t4.extract::<(i32, i32, i32, i32, i32,)>().unwrap(),
                 (0, 1, 2, 3, 4,)
             );
             assert_eq!(
-                t5.extract::<(i32, i32, i32, i32, i32, i32,)>(py).unwrap(),
+                t5.extract::<(i32, i32, i32, i32, i32, i32,)>().unwrap(),
                 (0, 1, 2, 3, 4, 5,)
             );
             assert_eq!(
-                t6.extract::<(i32, i32, i32, i32, i32, i32, i32,)>(py)
+                t6.extract::<(i32, i32, i32, i32, i32, i32, i32,)>()
                     .unwrap(),
                 (0, 1, 2, 3, 4, 5, 6,)
             );
             assert_eq!(
-                t7.extract::<(i32, i32, i32, i32, i32, i32, i32, i32,)>(py)
+                t7.extract::<(i32, i32, i32, i32, i32, i32, i32, i32,)>()
                     .unwrap(),
                 (0, 1, 2, 3, 4, 5, 6, 7,)
             );
             assert_eq!(
-                t8.extract::<(i32, i32, i32, i32, i32, i32, i32, i32, i32,)>(py)
+                t8.extract::<(i32, i32, i32, i32, i32, i32, i32, i32, i32,)>()
                     .unwrap(),
                 (0, 1, 2, 3, 4, 5, 6, 7, 8,)
             );
             assert_eq!(
-                t9.extract::<(i32, i32, i32, i32, i32, i32, i32, i32, i32, i32,)>(py)
+                t9.extract::<(i32, i32, i32, i32, i32, i32, i32, i32, i32, i32,)>()
                     .unwrap(),
                 (0, 1, 2, 3, 4, 5, 6, 7, 8, 9,)
             );
             assert_eq!(
-                t10.extract::<(i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32,)>(py)
+                t10.extract::<(i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32,)>()
                     .unwrap(),
                 (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,)
             );
             assert_eq!(
-                t11.extract::<(i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32,)>(py)
+                t11.extract::<(i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32,)>()
                     .unwrap(),
                 (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,)
             );
@@ -1048,9 +1302,9 @@ mod tests {
 
     #[test]
     fn test_tuple_get_item_invalid_index() {
-        Python::with_gil(|py| {
-            let ob = (1, 2, 3).to_object(py);
-            let tuple: &PyTuple = ob.downcast(py).unwrap();
+        Python::attach(|py| {
+            let ob = (1, 2, 3).into_pyobject(py).unwrap();
+            let tuple = ob.cast::<PyTuple>().unwrap();
             let obj = tuple.get_item(5);
             assert!(obj.is_err());
             assert_eq!(
@@ -1062,129 +1316,48 @@ mod tests {
 
     #[test]
     fn test_tuple_get_item_sanity() {
-        Python::with_gil(|py| {
-            let ob = (1, 2, 3).to_object(py);
-            let tuple: &PyTuple = ob.downcast(py).unwrap();
+        Python::attach(|py| {
+            let ob = (1, 2, 3).into_pyobject(py).unwrap();
+            let tuple = ob.cast::<PyTuple>().unwrap();
             let obj = tuple.get_item(0);
             assert_eq!(obj.unwrap().extract::<i32>().unwrap(), 1);
         });
     }
 
-    #[cfg(not(any(Py_LIMITED_API, PyPy)))]
+    #[cfg(not(any(Py_LIMITED_API, PyPy, GraalPy)))]
     #[test]
     fn test_tuple_get_item_unchecked_sanity() {
-        Python::with_gil(|py| {
-            let ob = (1, 2, 3).to_object(py);
-            let tuple: &PyTuple = ob.downcast(py).unwrap();
+        Python::attach(|py| {
+            let ob = (1, 2, 3).into_pyobject(py).unwrap();
+            let tuple = ob.cast::<PyTuple>().unwrap();
             let obj = unsafe { tuple.get_item_unchecked(0) };
             assert_eq!(obj.extract::<i32>().unwrap(), 1);
         });
     }
 
-    #[test]
-    fn test_tuple_index_trait() {
-        Python::with_gil(|py| {
-            let ob = (1, 2, 3).to_object(py);
-            let tuple: &PyTuple = ob.downcast(py).unwrap();
-            assert_eq!(1, tuple[0].extract::<i32>().unwrap());
-            assert_eq!(2, tuple[1].extract::<i32>().unwrap());
-            assert_eq!(3, tuple[2].extract::<i32>().unwrap());
-        });
-    }
-
-    #[test]
-    #[should_panic]
-    fn test_tuple_index_trait_panic() {
-        Python::with_gil(|py| {
-            let ob = (1, 2, 3).to_object(py);
-            let tuple: &PyTuple = ob.downcast(py).unwrap();
-            let _ = &tuple[7];
-        });
-    }
-
-    #[test]
-    fn test_tuple_index_trait_ranges() {
-        Python::with_gil(|py| {
-            let ob = (1, 2, 3).to_object(py);
-            let tuple: &PyTuple = ob.downcast(py).unwrap();
-            assert_eq!(vec![2, 3], tuple[1..3].extract::<Vec<i32>>().unwrap());
-            assert_eq!(
-                Vec::<i32>::new(),
-                tuple[3..3].extract::<Vec<i32>>().unwrap()
-            );
-            assert_eq!(vec![2, 3], tuple[1..].extract::<Vec<i32>>().unwrap());
-            assert_eq!(Vec::<i32>::new(), tuple[3..].extract::<Vec<i32>>().unwrap());
-            assert_eq!(vec![1, 2, 3], tuple[..].extract::<Vec<i32>>().unwrap());
-            assert_eq!(vec![2, 3], tuple[1..=2].extract::<Vec<i32>>().unwrap());
-            assert_eq!(vec![1, 2], tuple[..2].extract::<Vec<i32>>().unwrap());
-            assert_eq!(vec![1, 2], tuple[..=1].extract::<Vec<i32>>().unwrap());
-        })
-    }
-
-    #[test]
-    #[should_panic = "range start index 5 out of range for tuple of length 3"]
-    fn test_tuple_index_trait_range_panic_start() {
-        Python::with_gil(|py| {
-            let ob = (1, 2, 3).to_object(py);
-            let tuple: &PyTuple = ob.downcast(py).unwrap();
-            tuple[5..10].extract::<Vec<i32>>().unwrap();
-        })
-    }
-
-    #[test]
-    #[should_panic = "range end index 10 out of range for tuple of length 3"]
-    fn test_tuple_index_trait_range_panic_end() {
-        Python::with_gil(|py| {
-            let ob = (1, 2, 3).to_object(py);
-            let tuple: &PyTuple = ob.downcast(py).unwrap();
-            tuple[1..10].extract::<Vec<i32>>().unwrap();
-        })
-    }
-
-    #[test]
-    #[should_panic = "slice index starts at 2 but ends at 1"]
-    fn test_tuple_index_trait_range_panic_wrong_order() {
-        Python::with_gil(|py| {
-            let ob = (1, 2, 3).to_object(py);
-            let tuple: &PyTuple = ob.downcast(py).unwrap();
-            #[allow(clippy::reversed_empty_ranges)]
-            tuple[2..1].extract::<Vec<i32>>().unwrap();
-        })
-    }
-
-    #[test]
-    #[should_panic = "range start index 8 out of range for tuple of length 3"]
-    fn test_tuple_index_trait_range_from_panic() {
-        Python::with_gil(|py| {
-            let ob = (1, 2, 3).to_object(py);
-            let tuple: &PyTuple = ob.downcast(py).unwrap();
-            tuple[8..].extract::<Vec<i32>>().unwrap();
-        })
-    }
-
     #[test]
     fn test_tuple_contains() {
-        Python::with_gil(|py| {
-            let ob = (1, 1, 2, 3, 5, 8).to_object(py);
-            let tuple: &PyTuple = ob.downcast(py).unwrap();
+        Python::attach(|py| {
+            let ob = (1, 1, 2, 3, 5, 8).into_pyobject(py).unwrap();
+            let tuple = ob.cast::<PyTuple>().unwrap();
             assert_eq!(6, tuple.len());
 
-            let bad_needle = 7i32.to_object(py);
+            let bad_needle = 7i32.into_pyobject(py).unwrap();
             assert!(!tuple.contains(&bad_needle).unwrap());
 
-            let good_needle = 8i32.to_object(py);
+            let good_needle = 8i32.into_pyobject(py).unwrap();
             assert!(tuple.contains(&good_needle).unwrap());
 
-            let type_coerced_needle = 8f32.to_object(py);
+            let type_coerced_needle = 8f32.into_pyobject(py).unwrap();
             assert!(tuple.contains(&type_coerced_needle).unwrap());
         });
     }
 
     #[test]
     fn test_tuple_index() {
-        Python::with_gil(|py| {
-            let ob = (1, 1, 2, 3, 5, 8).to_object(py);
-            let tuple: &PyTuple = ob.downcast(py).unwrap();
+        Python::attach(|py| {
+            let ob = (1, 1, 2, 3, 5, 8).into_pyobject(py).unwrap();
+            let tuple = ob.cast::<PyTuple>().unwrap();
             assert_eq!(0, tuple.index(1i32).unwrap());
             assert_eq!(2, tuple.index(2i32).unwrap());
             assert_eq!(3, tuple.index(3i32).unwrap());
@@ -1194,8 +1367,6 @@ mod tests {
         });
     }
 
-    use std::ops::Range;
-
     // An iterator that lies about its `ExactSizeIterator` implementation.
     // See https://github.com/PyO3/pyo3/issues/2118
     struct FaultyIter(Range<usize>, usize);
@@ -1219,7 +1390,7 @@ mod tests {
         expected = "Attempted to create PyTuple but `elements` was larger than reported by its `ExactSizeIterator` implementation."
     )]
     fn too_long_iterator() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let iter = FaultyIter(0..usize::MAX, 73);
             let _tuple = PyTuple::new(py, iter);
         })
@@ -1230,7 +1401,7 @@ mod tests {
         expected = "Attempted to create PyTuple but `elements` was smaller than reported by its `ExactSizeIterator` implementation."
     )]
     fn too_short_iterator() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let iter = FaultyIter(0..35, 73);
             let _tuple = PyTuple::new(py, iter);
         })
@@ -1241,44 +1412,38 @@ mod tests {
         expected = "out of range integral type conversion attempted on `elements.len()`"
     )]
     fn overflowing_size() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let iter = FaultyIter(0..0, usize::MAX);
 
             let _tuple = PyTuple::new(py, iter);
         })
     }
 
-    #[cfg(feature = "macros")]
     #[test]
-    fn bad_clone_mem_leaks() {
-        use crate::{IntoPy, Py};
+    fn bad_intopyobject_doesnt_cause_leaks() {
+        use crate::types::PyInt;
+        use std::convert::Infallible;
         use std::sync::atomic::{AtomicUsize, Ordering::SeqCst};
 
         static NEEDS_DESTRUCTING_COUNT: AtomicUsize = AtomicUsize::new(0);
 
-        #[crate::pyclass]
-        #[pyo3(crate = "crate")]
         struct Bad(usize);
 
-        impl Clone for Bad {
-            fn clone(&self) -> Self {
-                // This panic should not lead to a memory leak
-                assert_ne!(self.0, 42);
-                NEEDS_DESTRUCTING_COUNT.fetch_add(1, SeqCst);
-
-                Bad(self.0)
-            }
-        }
-
         impl Drop for Bad {
             fn drop(&mut self) {
                 NEEDS_DESTRUCTING_COUNT.fetch_sub(1, SeqCst);
             }
         }
 
-        impl ToPyObject for Bad {
-            fn to_object(&self, py: Python<'_>) -> Py<PyAny> {
-                self.to_owned().into_py(py)
+        impl<'py> IntoPyObject<'py> for Bad {
+            type Target = PyInt;
+            type Output = crate::Bound<'py, Self::Target>;
+            type Error = Infallible;
+
+            fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+                // This panic should not lead to a memory leak
+                assert_ne!(self.0, 42);
+                self.0.into_pyobject(py)
             }
         }
 
@@ -1301,7 +1466,7 @@ mod tests {
             }
         }
 
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             std::panic::catch_unwind(|| {
                 let iter = FaultyIter(0..50, 50);
                 let _tuple = PyTuple::new(py, iter);
@@ -1316,45 +1481,39 @@ mod tests {
         );
     }
 
-    #[cfg(feature = "macros")]
     #[test]
-    fn bad_clone_mem_leaks_2() {
-        use crate::{IntoPy, Py};
+    fn bad_intopyobject_doesnt_cause_leaks_2() {
+        use crate::types::PyInt;
+        use std::convert::Infallible;
         use std::sync::atomic::{AtomicUsize, Ordering::SeqCst};
 
         static NEEDS_DESTRUCTING_COUNT: AtomicUsize = AtomicUsize::new(0);
 
-        #[crate::pyclass]
-        #[pyo3(crate = "crate")]
         struct Bad(usize);
 
-        impl Clone for Bad {
-            fn clone(&self) -> Self {
-                // This panic should not lead to a memory leak
-                assert_ne!(self.0, 3);
-                NEEDS_DESTRUCTING_COUNT.fetch_add(1, SeqCst);
-
-                Bad(self.0)
-            }
-        }
-
         impl Drop for Bad {
             fn drop(&mut self) {
                 NEEDS_DESTRUCTING_COUNT.fetch_sub(1, SeqCst);
             }
         }
 
-        impl ToPyObject for Bad {
-            fn to_object(&self, py: Python<'_>) -> Py<PyAny> {
-                self.to_owned().into_py(py)
+        impl<'py> IntoPyObject<'py> for &Bad {
+            type Target = PyInt;
+            type Output = crate::Bound<'py, Self::Target>;
+            type Error = Infallible;
+
+            fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+                // This panic should not lead to a memory leak
+                assert_ne!(self.0, 3);
+                self.0.into_pyobject(py)
             }
         }
 
         let s = (Bad(1), Bad(2), Bad(3), Bad(4));
         NEEDS_DESTRUCTING_COUNT.store(4, SeqCst);
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             std::panic::catch_unwind(|| {
-                let _tuple: Py<PyAny> = s.to_object(py);
+                let _tuple = (&s).into_pyobject(py).unwrap();
             })
             .unwrap_err();
         });
@@ -1369,18 +1528,18 @@ mod tests {
 
     #[test]
     fn test_tuple_to_list() {
-        Python::with_gil(|py| {
-            let tuple = PyTuple::new(py, vec![1, 2, 3]);
+        Python::attach(|py| {
+            let tuple = PyTuple::new(py, vec![1, 2, 3]).unwrap();
             let list = tuple.to_list();
-            let list_expected = PyList::new(py, vec![1, 2, 3]);
+            let list_expected = PyList::new(py, vec![1, 2, 3]).unwrap();
             assert!(list.eq(list_expected).unwrap());
         })
     }
 
     #[test]
     fn test_tuple_as_sequence() {
-        Python::with_gil(|py| {
-            let tuple = PyTuple::new(py, vec![1, 2, 3]);
+        Python::attach(|py| {
+            let tuple = PyTuple::new(py, vec![1, 2, 3]).unwrap();
             let sequence = tuple.as_sequence();
             assert!(tuple.get_item(0).unwrap().eq(1).unwrap());
             assert!(sequence.get_item(0).unwrap().eq(1).unwrap());
@@ -1390,10 +1549,20 @@ mod tests {
         })
     }
 
+    #[test]
+    fn test_tuple_into_sequence() {
+        Python::attach(|py| {
+            let tuple = PyTuple::new(py, vec![1, 2, 3]).unwrap();
+            let sequence = tuple.into_sequence();
+            assert!(sequence.get_item(0).unwrap().eq(1).unwrap());
+            assert_eq!(sequence.len().unwrap(), 3);
+        })
+    }
+
     #[test]
     fn test_bound_tuple_get_item() {
-        Python::with_gil(|py| {
-            let tuple = PyTuple::new_bound(py, vec![1, 2, 3, 4]);
+        Python::attach(|py| {
+            let tuple = PyTuple::new(py, vec![1, 2, 3, 4]).unwrap();
 
             assert_eq!(tuple.len(), 4);
             assert_eq!(tuple.get_item(0).unwrap().extract::<i32>().unwrap(), 1);
@@ -1405,7 +1574,7 @@ mod tests {
                     .unwrap(),
                 2
             );
-            #[cfg(not(any(Py_LIMITED_API, PyPy)))]
+            #[cfg(not(any(Py_LIMITED_API, PyPy, GraalPy)))]
             {
                 assert_eq!(
                     unsafe { tuple.get_item_unchecked(2) }
@@ -1422,4 +1591,144 @@ mod tests {
             }
         })
     }
+
+    #[test]
+    fn test_bound_tuple_nth() {
+        Python::attach(|py| {
+            let tuple = PyTuple::new(py, vec![1, 2, 3, 4]).unwrap();
+            let mut iter = tuple.iter();
+            assert_eq!(iter.nth(1).unwrap().extract::<i32>().unwrap(), 2);
+            assert_eq!(iter.nth(1).unwrap().extract::<i32>().unwrap(), 4);
+            assert!(iter.nth(1).is_none());
+
+            let tuple = PyTuple::new(py, Vec::<i32>::new()).unwrap();
+            let mut iter = tuple.iter();
+            iter.next();
+            assert!(iter.nth(1).is_none());
+
+            let tuple = PyTuple::new(py, vec![1, 2, 3]).unwrap();
+            let mut iter = tuple.iter();
+            assert!(iter.nth(10).is_none());
+
+            let tuple = PyTuple::new(py, vec![6, 7, 8, 9, 10]).unwrap();
+            let mut iter = tuple.iter();
+            assert_eq!(iter.next().unwrap().extract::<i32>().unwrap(), 6);
+            assert_eq!(iter.nth(2).unwrap().extract::<i32>().unwrap(), 9);
+            assert_eq!(iter.next().unwrap().extract::<i32>().unwrap(), 10);
+
+            let mut iter = tuple.iter();
+            assert_eq!(iter.nth_back(1).unwrap().extract::<i32>().unwrap(), 9);
+            assert_eq!(iter.nth(2).unwrap().extract::<i32>().unwrap(), 8);
+            assert!(iter.next().is_none());
+        });
+    }
+
+    #[test]
+    fn test_bound_tuple_nth_back() {
+        Python::attach(|py| {
+            let tuple = PyTuple::new(py, vec![1, 2, 3, 4, 5]).unwrap();
+            let mut iter = tuple.iter();
+            assert_eq!(iter.nth_back(0).unwrap().extract::<i32>().unwrap(), 5);
+            assert_eq!(iter.nth_back(1).unwrap().extract::<i32>().unwrap(), 3);
+            assert!(iter.nth_back(2).is_none());
+
+            let tuple = PyTuple::new(py, Vec::<i32>::new()).unwrap();
+            let mut iter = tuple.iter();
+            assert!(iter.nth_back(0).is_none());
+            assert!(iter.nth_back(1).is_none());
+
+            let tuple = PyTuple::new(py, vec![1, 2, 3]).unwrap();
+            let mut iter = tuple.iter();
+            assert!(iter.nth_back(5).is_none());
+
+            let tuple = PyTuple::new(py, vec![1, 2, 3, 4, 5]).unwrap();
+            let mut iter = tuple.iter();
+            iter.next_back(); // Consume the last element
+            assert_eq!(iter.nth_back(1).unwrap().extract::<i32>().unwrap(), 3);
+            assert_eq!(iter.next_back().unwrap().extract::<i32>().unwrap(), 2);
+            assert_eq!(iter.nth_back(0).unwrap().extract::<i32>().unwrap(), 1);
+
+            let tuple = PyTuple::new(py, vec![1, 2, 3, 4, 5]).unwrap();
+            let mut iter = tuple.iter();
+            assert_eq!(iter.nth_back(1).unwrap().extract::<i32>().unwrap(), 4);
+            assert_eq!(iter.nth_back(2).unwrap().extract::<i32>().unwrap(), 1);
+
+            let mut iter2 = tuple.iter();
+            iter2.next_back();
+            assert_eq!(iter2.nth_back(1).unwrap().extract::<i32>().unwrap(), 3);
+            assert_eq!(iter2.next_back().unwrap().extract::<i32>().unwrap(), 2);
+
+            let mut iter3 = tuple.iter();
+            iter3.nth(1);
+            assert_eq!(iter3.nth_back(2).unwrap().extract::<i32>().unwrap(), 3);
+            assert!(iter3.nth_back(0).is_none());
+        });
+    }
+
+    #[cfg(feature = "nightly")]
+    #[test]
+    fn test_bound_tuple_advance_by() {
+        Python::attach(|py| {
+            let tuple = PyTuple::new(py, vec![1, 2, 3, 4, 5]).unwrap();
+            let mut iter = tuple.iter();
+
+            assert_eq!(iter.advance_by(2), Ok(()));
+            assert_eq!(iter.next().unwrap().extract::<i32>().unwrap(), 3);
+            assert_eq!(iter.advance_by(0), Ok(()));
+            assert_eq!(iter.advance_by(100), Err(NonZero::new(98).unwrap()));
+            assert!(iter.next().is_none());
+
+            let mut iter2 = tuple.iter();
+            assert_eq!(iter2.advance_by(6), Err(NonZero::new(1).unwrap()));
+
+            let mut iter3 = tuple.iter();
+            assert_eq!(iter3.advance_by(5), Ok(()));
+
+            let mut iter4 = tuple.iter();
+            assert_eq!(iter4.advance_by(0), Ok(()));
+            assert_eq!(iter4.next().unwrap().extract::<i32>().unwrap(), 1);
+        })
+    }
+
+    #[cfg(feature = "nightly")]
+    #[test]
+    fn test_bound_tuple_advance_back_by() {
+        Python::attach(|py| {
+            let tuple = PyTuple::new(py, vec![1, 2, 3, 4, 5]).unwrap();
+            let mut iter = tuple.iter();
+
+            assert_eq!(iter.advance_back_by(2), Ok(()));
+            assert_eq!(iter.next_back().unwrap().extract::<i32>().unwrap(), 3);
+            assert_eq!(iter.advance_back_by(0), Ok(()));
+            assert_eq!(iter.advance_back_by(100), Err(NonZero::new(98).unwrap()));
+            assert!(iter.next_back().is_none());
+
+            let mut iter2 = tuple.iter();
+            assert_eq!(iter2.advance_back_by(6), Err(NonZero::new(1).unwrap()));
+
+            let mut iter3 = tuple.iter();
+            assert_eq!(iter3.advance_back_by(5), Ok(()));
+
+            let mut iter4 = tuple.iter();
+            assert_eq!(iter4.advance_back_by(0), Ok(()));
+            assert_eq!(iter4.next_back().unwrap().extract::<i32>().unwrap(), 5);
+        })
+    }
+
+    #[test]
+    fn test_iter_last() {
+        Python::attach(|py| {
+            let tuple = PyTuple::new(py, vec![1, 2, 3]).unwrap();
+            let last = tuple.iter().last();
+            assert_eq!(last.unwrap().extract::<i32>().unwrap(), 3);
+        })
+    }
+
+    #[test]
+    fn test_iter_count() {
+        Python::attach(|py| {
+            let tuple = PyTuple::new(py, vec![1, 2, 3]).unwrap();
+            assert_eq!(tuple.iter().count(), 3);
+        })
+    }
 }
diff --git a/src/types/typeobject.rs b/src/types/typeobject.rs
index 50eeaa7153d..f04cc2ada7f 100644
--- a/src/types/typeobject.rs
+++ b/src/types/typeobject.rs
@@ -1,10 +1,21 @@
 use crate::err::{self, PyResult};
-use crate::{ffi, PyAny, PyTypeInfo, Python};
-use std::borrow::Cow;
-#[cfg(not(any(Py_LIMITED_API, PyPy)))]
-use std::ffi::CStr;
+use crate::instance::Borrowed;
+#[cfg(not(Py_3_13))]
+use crate::pybacked::PyBackedStr;
+#[cfg(any(Py_LIMITED_API, PyPy, not(Py_3_13)))]
+use crate::types::any::PyAnyMethods;
+use crate::types::PyTuple;
+use crate::{ffi, Bound, PyAny, PyTypeInfo, Python};
 
-/// Represents a reference to a Python `type object`.
+use super::PyString;
+
+/// Represents a reference to a Python `type` object.
+///
+/// Values of this type are accessed via PyO3's smart pointers, e.g. as
+/// [`Py<PyType>`][crate::Py] or [`Bound<'py, PyType>`][Bound].
+///
+/// For APIs available on `type` objects, see the [`PyTypeMethods`] trait which is implemented for
+/// [`Bound<'py, PyType>`][Bound].
 #[repr(transparent)]
 pub struct PyType(PyAny);
 
@@ -13,84 +24,165 @@ pyobject_native_type_core!(PyType, pyobject_native_static_type_object!(ffi::PyTy
 impl PyType {
     /// Creates a new type object.
     #[inline]
-    pub fn new<T: PyTypeInfo>(py: Python<'_>) -> &PyType {
-        T::type_object_bound(py).into_gil_ref()
+    pub fn new<T: PyTypeInfo>(py: Python<'_>) -> Bound<'_, PyType> {
+        T::type_object(py)
     }
 
-    /// Retrieves the underlying FFI pointer associated with this Python object.
+    /// Converts the given FFI pointer into `Bound<PyType>`, to use in safe code.
+    ///
+    /// The function creates a new reference from the given pointer, and returns
+    /// it as a `Bound<PyType>`.
+    ///
+    /// # Safety
+    /// - The pointer must be a valid non-null reference to a `PyTypeObject`
     #[inline]
-    pub fn as_type_ptr(&self) -> *mut ffi::PyTypeObject {
-        self.as_ptr() as *mut ffi::PyTypeObject
+    pub unsafe fn from_borrowed_type_ptr(
+        py: Python<'_>,
+        p: *mut ffi::PyTypeObject,
+    ) -> Bound<'_, PyType> {
+        unsafe {
+            Borrowed::from_ptr_unchecked(py, p.cast())
+                .cast_unchecked()
+                .to_owned()
+        }
     }
+}
+
+/// Implementation of functionality for [`PyType`].
+///
+/// These methods are defined for the `Bound<'py, PyType>` smart pointer, so to use method call
+/// syntax these methods are separated into a trait, because stable Rust does not yet support
+/// `arbitrary_self_types`.
+#[doc(alias = "PyType")]
+pub trait PyTypeMethods<'py>: crate::sealed::Sealed {
+    /// Retrieves the underlying FFI pointer associated with this Python object.
+    fn as_type_ptr(&self) -> *mut ffi::PyTypeObject;
+
+    /// Gets the name of the `PyType`. Equivalent to `self.__name__` in Python.
+    fn name(&self) -> PyResult<Bound<'py, PyString>>;
+
+    /// Gets the [qualified name](https://docs.python.org/3/glossary.html#term-qualified-name) of the `PyType`.
+    /// Equivalent to `self.__qualname__` in Python.
+    fn qualname(&self) -> PyResult<Bound<'py, PyString>>;
 
-    /// Retrieves the `PyType` instance for the given FFI pointer.
+    /// Gets the name of the module defining the `PyType`.
+    fn module(&self) -> PyResult<Bound<'py, PyString>>;
+
+    /// Gets the [fully qualified name](https://peps.python.org/pep-0737/#add-pytype-getfullyqualifiedname-function) of the `PyType`.
+    fn fully_qualified_name(&self) -> PyResult<Bound<'py, PyString>>;
+
+    /// Checks whether `self` is a subclass of `other`.
     ///
-    /// # Safety
-    /// - The pointer must be non-null.
-    /// - The pointer must be valid for the entire of the lifetime for which the reference is used.
+    /// Equivalent to the Python expression `issubclass(self, other)`.
+    fn is_subclass(&self, other: &Bound<'_, PyAny>) -> PyResult<bool>;
+
+    /// Checks whether `self` is a subclass of type `T`.
+    ///
+    /// Equivalent to the Python expression `issubclass(self, T)`, if the type
+    /// `T` is known at compile time.
+    fn is_subclass_of<T>(&self) -> PyResult<bool>
+    where
+        T: PyTypeInfo;
+
+    /// Return the method resolution order for this type.
+    ///
+    /// Equivalent to the Python expression `self.__mro__`.
+    fn mro(&self) -> Bound<'py, PyTuple>;
+
+    /// Return Python bases
+    ///
+    /// Equivalent to the Python expression `self.__bases__`.
+    fn bases(&self) -> Bound<'py, PyTuple>;
+}
+
+impl<'py> PyTypeMethods<'py> for Bound<'py, PyType> {
+    /// Retrieves the underlying FFI pointer associated with this Python object.
     #[inline]
-    pub unsafe fn from_type_ptr(py: Python<'_>, p: *mut ffi::PyTypeObject) -> &PyType {
-        py.from_borrowed_ptr(p as *mut ffi::PyObject)
+    fn as_type_ptr(&self) -> *mut ffi::PyTypeObject {
+        self.as_ptr() as *mut ffi::PyTypeObject
     }
 
-    /// Gets the [qualified name](https://docs.python.org/3/glossary.html#term-qualified-name) of the `PyType`.
-    pub fn qualname(&self) -> PyResult<String> {
-        #[cfg(any(Py_LIMITED_API, PyPy, not(Py_3_11)))]
-        let name = self.getattr(intern!(self.py(), "__qualname__"))?.extract();
+    /// Gets the name of the `PyType`.
+    fn name(&self) -> PyResult<Bound<'py, PyString>> {
+        #[cfg(not(Py_3_11))]
+        let name = self.getattr(intern!(self.py(), "__name__"))?.cast_into()?;
 
-        #[cfg(not(any(Py_LIMITED_API, PyPy, not(Py_3_11))))]
-        let name = {
+        #[cfg(Py_3_11)]
+        let name = unsafe {
             use crate::ffi_ptr_ext::FfiPtrExt;
-            use crate::types::any::PyAnyMethods;
+            ffi::PyType_GetName(self.as_type_ptr())
+                .assume_owned_or_err(self.py())?
+                // SAFETY: setting `__name__` from Python is required to be a `str`
+                .cast_into_unchecked()
+        };
+
+        Ok(name)
+    }
 
-            let obj = unsafe {
-                ffi::PyType_GetQualName(self.as_type_ptr()).assume_owned_or_err(self.py())?
-            };
+    /// Gets the [qualified name](https://docs.python.org/3/glossary.html#term-qualified-name) of the `PyType`.
+    fn qualname(&self) -> PyResult<Bound<'py, PyString>> {
+        #[cfg(not(Py_3_11))]
+        let name = self
+            .getattr(intern!(self.py(), "__qualname__"))?
+            .cast_into()?;
 
-            obj.extract()
+        #[cfg(Py_3_11)]
+        let name = unsafe {
+            use crate::ffi_ptr_ext::FfiPtrExt;
+            ffi::PyType_GetQualName(self.as_type_ptr())
+                .assume_owned_or_err(self.py())?
+                // SAFETY: setting `__qualname__` from Python is required to be a `str`
+                .cast_into_unchecked()
         };
 
-        name
+        Ok(name)
     }
 
-    /// Gets the full name, which includes the module, of the `PyType`.
-    pub fn name(&self) -> PyResult<Cow<'_, str>> {
-        #[cfg(not(any(Py_LIMITED_API, PyPy)))]
-        {
-            let ptr = self.as_type_ptr();
-
-            let name = unsafe { CStr::from_ptr((*ptr).tp_name) }.to_str()?;
+    /// Gets the name of the module defining the `PyType`.
+    fn module(&self) -> PyResult<Bound<'py, PyString>> {
+        #[cfg(not(Py_3_13))]
+        let name = self.getattr(intern!(self.py(), "__module__"))?;
 
-            #[cfg(Py_3_10)]
-            if unsafe { ffi::PyType_HasFeature(ptr, ffi::Py_TPFLAGS_IMMUTABLETYPE) } != 0 {
-                return Ok(Cow::Borrowed(name));
-            }
+        #[cfg(Py_3_13)]
+        let name = unsafe {
+            use crate::ffi_ptr_ext::FfiPtrExt;
+            ffi::PyType_GetModuleName(self.as_type_ptr()).assume_owned_or_err(self.py())?
+        };
 
-            Ok(Cow::Owned(name.to_owned()))
-        }
+        // `__module__` is never guaranteed to be a `str`
+        name.cast_into().map_err(Into::into)
+    }
 
-        #[cfg(any(Py_LIMITED_API, PyPy))]
-        {
+    /// Gets the [fully qualified name](https://docs.python.org/3/glossary.html#term-qualified-name) of the `PyType`.
+    fn fully_qualified_name(&self) -> PyResult<Bound<'py, PyString>> {
+        #[cfg(not(Py_3_13))]
+        let name = {
             let module = self.getattr(intern!(self.py(), "__module__"))?;
+            let qualname = self.getattr(intern!(self.py(), "__qualname__"))?;
 
-            #[cfg(not(Py_3_11))]
-            let name = self.getattr(intern!(self.py(), "__name__"))?;
-
-            #[cfg(Py_3_11)]
-            let name = {
-                use crate::ffi_ptr_ext::FfiPtrExt;
+            let module_str = module.extract::<PyBackedStr>()?;
+            if module_str == "builtins" || module_str == "__main__" {
+                qualname.cast_into()?
+            } else {
+                PyString::new(self.py(), &format!("{module}.{qualname}"))
+            }
+        };
 
-                unsafe { ffi::PyType_GetName(self.as_type_ptr()).assume_owned_or_err(self.py())? }
-            };
+        #[cfg(Py_3_13)]
+        let name = unsafe {
+            use crate::ffi_ptr_ext::FfiPtrExt;
+            ffi::PyType_GetFullyQualifiedName(self.as_type_ptr())
+                .assume_owned_or_err(self.py())?
+                .cast_into_unchecked()
+        };
 
-            Ok(Cow::Owned(format!("{}.{}", module, name)))
-        }
+        Ok(name)
     }
 
     /// Checks whether `self` is a subclass of `other`.
     ///
     /// Equivalent to the Python expression `issubclass(self, other)`.
-    pub fn is_subclass(&self, other: &PyAny) -> PyResult<bool> {
+    fn is_subclass(&self, other: &Bound<'_, PyAny>) -> PyResult<bool> {
         let result = unsafe { ffi::PyObject_IsSubclass(self.as_ptr(), other.as_ptr()) };
         err::error_on_minusone(self.py(), result)?;
         Ok(result == 1)
@@ -100,32 +192,192 @@ impl PyType {
     ///
     /// Equivalent to the Python expression `issubclass(self, T)`, if the type
     /// `T` is known at compile time.
-    pub fn is_subclass_of<T>(&self) -> PyResult<bool>
+    fn is_subclass_of<T>(&self) -> PyResult<bool>
     where
         T: PyTypeInfo,
     {
-        self.is_subclass(T::type_object_bound(self.py()).as_gil_ref())
+        self.is_subclass(&T::type_object(self.py()))
+    }
+
+    fn mro(&self) -> Bound<'py, PyTuple> {
+        #[cfg(any(Py_LIMITED_API, PyPy))]
+        let mro = self
+            .getattr(intern!(self.py(), "__mro__"))
+            .expect("Cannot get `__mro__` from object.")
+            .extract()
+            .expect("Unexpected type in `__mro__` attribute.");
+
+        #[cfg(not(any(Py_LIMITED_API, PyPy)))]
+        let mro = unsafe {
+            use crate::ffi_ptr_ext::FfiPtrExt;
+            (*self.as_type_ptr())
+                .tp_mro
+                .assume_borrowed(self.py())
+                .to_owned()
+                .cast_into_unchecked()
+        };
+
+        mro
+    }
+
+    fn bases(&self) -> Bound<'py, PyTuple> {
+        #[cfg(any(Py_LIMITED_API, PyPy))]
+        let bases = self
+            .getattr(intern!(self.py(), "__bases__"))
+            .expect("Cannot get `__bases__` from object.")
+            .extract()
+            .expect("Unexpected type in `__bases__` attribute.");
+
+        #[cfg(not(any(Py_LIMITED_API, PyPy)))]
+        let bases = unsafe {
+            use crate::ffi_ptr_ext::FfiPtrExt;
+            (*self.as_type_ptr())
+                .tp_bases
+                .assume_borrowed(self.py())
+                .to_owned()
+                .cast_into_unchecked()
+        };
+
+        bases
     }
 }
 
 #[cfg(test)]
 mod tests {
-    use crate::types::{PyBool, PyLong};
+    use crate::test_utils::generate_unique_module_name;
+    use crate::types::{PyAnyMethods, PyBool, PyInt, PyModule, PyTuple, PyType, PyTypeMethods};
+    use crate::PyAny;
     use crate::Python;
+    use pyo3_ffi::c_str;
 
     #[test]
     fn test_type_is_subclass() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let bool_type = py.get_type::<PyBool>();
-            let long_type = py.get_type::<PyLong>();
-            assert!(bool_type.is_subclass(long_type).unwrap());
+            let long_type = py.get_type::<PyInt>();
+            assert!(bool_type.is_subclass(&long_type).unwrap());
         });
     }
 
     #[test]
     fn test_type_is_subclass_of() {
-        Python::with_gil(|py| {
-            assert!(py.get_type::<PyBool>().is_subclass_of::<PyLong>().unwrap());
+        Python::attach(|py| {
+            assert!(py.get_type::<PyBool>().is_subclass_of::<PyInt>().unwrap());
+        });
+    }
+
+    #[test]
+    fn test_mro() {
+        Python::attach(|py| {
+            assert!(py
+                .get_type::<PyBool>()
+                .mro()
+                .eq(PyTuple::new(
+                    py,
+                    [
+                        py.get_type::<PyBool>(),
+                        py.get_type::<PyInt>(),
+                        py.get_type::<PyAny>()
+                    ]
+                )
+                .unwrap())
+                .unwrap());
+        });
+    }
+
+    #[test]
+    fn test_bases_bool() {
+        Python::attach(|py| {
+            assert!(py
+                .get_type::<PyBool>()
+                .bases()
+                .eq(PyTuple::new(py, [py.get_type::<PyInt>()]).unwrap())
+                .unwrap());
+        });
+    }
+
+    #[test]
+    fn test_bases_object() {
+        Python::attach(|py| {
+            assert!(py
+                .get_type::<PyAny>()
+                .bases()
+                .eq(PyTuple::empty(py))
+                .unwrap());
+        });
+    }
+
+    #[test]
+    fn test_type_names_standard() {
+        Python::attach(|py| {
+            let module_name = generate_unique_module_name("test_module");
+            let module = PyModule::from_code(
+                py,
+                cr#"
+class MyClass:
+    pass
+"#,
+                c_str!(file!()),
+                &module_name,
+            )
+            .expect("module create failed");
+
+            let my_class = module.getattr("MyClass").unwrap();
+            let my_class_type = my_class.cast_into::<PyType>().unwrap();
+            assert_eq!(my_class_type.name().unwrap(), "MyClass");
+            assert_eq!(my_class_type.qualname().unwrap(), "MyClass");
+            let module_name = module_name.to_str().unwrap();
+            let qualname = format!("{module_name}.MyClass");
+            assert_eq!(my_class_type.module().unwrap(), module_name);
+            assert_eq!(
+                my_class_type.fully_qualified_name().unwrap(),
+                qualname.as_str()
+            );
+        });
+    }
+
+    #[test]
+    fn test_type_names_builtin() {
+        Python::attach(|py| {
+            let bool_type = py.get_type::<PyBool>();
+            assert_eq!(bool_type.name().unwrap(), "bool");
+            assert_eq!(bool_type.qualname().unwrap(), "bool");
+            assert_eq!(bool_type.module().unwrap(), "builtins");
+            assert_eq!(bool_type.fully_qualified_name().unwrap(), "bool");
+        });
+    }
+
+    #[test]
+    fn test_type_names_nested() {
+        Python::attach(|py| {
+            let module_name = generate_unique_module_name("test_module");
+            let module = PyModule::from_code(
+                py,
+                cr#"
+class OuterClass:
+    class InnerClass:
+        pass
+"#,
+                c_str!(file!()),
+                &module_name,
+            )
+            .expect("module create failed");
+
+            let outer_class = module.getattr("OuterClass").unwrap();
+            let inner_class = outer_class.getattr("InnerClass").unwrap();
+            let inner_class_type = inner_class.cast_into::<PyType>().unwrap();
+            assert_eq!(inner_class_type.name().unwrap(), "InnerClass");
+            assert_eq!(
+                inner_class_type.qualname().unwrap(),
+                "OuterClass.InnerClass"
+            );
+            let module_name = module_name.to_str().unwrap();
+            let qualname = format!("{module_name}.OuterClass.InnerClass");
+            assert_eq!(inner_class_type.module().unwrap(), module_name);
+            assert_eq!(
+                inner_class_type.fully_qualified_name().unwrap(),
+                qualname.as_str()
+            );
         });
     }
 }
diff --git a/src/types/weakref/anyref.rs b/src/types/weakref/anyref.rs
new file mode 100644
index 00000000000..efb6ed4ff41
--- /dev/null
+++ b/src/types/weakref/anyref.rs
@@ -0,0 +1,667 @@
+use crate::err::PyResult;
+use crate::ffi_ptr_ext::FfiPtrExt;
+#[cfg(feature = "experimental-inspect")]
+use crate::inspect::TypeHint;
+use crate::sync::PyOnceLock;
+use crate::type_object::{PyTypeCheck, PyTypeInfo};
+use crate::types::any::PyAny;
+use crate::types::{PyTuple, PyWeakrefProxy, PyWeakrefReference};
+use crate::{ffi, Bound, Py, Python};
+
+/// Represents any Python `weakref` reference.
+///
+/// In Python this is created by calling `weakref.ref` or `weakref.proxy`.
+#[repr(transparent)]
+pub struct PyWeakref(PyAny);
+
+pyobject_native_type_named!(PyWeakref);
+
+// TODO: We known the layout but this cannot be implemented, due to the lack of public typeobject pointers
+// #[cfg(not(Py_LIMITED_API))]
+// pyobject_native_type_sized!(PyWeakref, ffi::PyWeakReference);
+
+unsafe impl PyTypeCheck for PyWeakref {
+    const NAME: &'static str = "weakref";
+
+    #[cfg(feature = "experimental-inspect")]
+    const TYPE_HINT: TypeHint = TypeHint::union(&[
+        PyWeakrefProxy::TYPE_HINT,
+        <PyWeakrefReference as PyTypeCheck>::TYPE_HINT,
+    ]);
+
+    #[inline]
+    fn type_check(object: &Bound<'_, PyAny>) -> bool {
+        unsafe { ffi::PyWeakref_Check(object.as_ptr()) > 0 }
+    }
+
+    fn classinfo_object(py: Python<'_>) -> Bound<'_, PyAny> {
+        static TYPE: PyOnceLock<Py<PyAny>> = PyOnceLock::new();
+        TYPE.get_or_try_init(py, || {
+            PyResult::Ok(
+                PyTuple::new(
+                    py,
+                    [
+                        PyWeakrefProxy::classinfo_object(py),
+                        PyWeakrefReference::classinfo_object(py),
+                    ],
+                )?
+                .into_any()
+                .unbind(),
+            )
+        })
+        .unwrap()
+        .bind(py)
+        .clone()
+    }
+}
+
+/// Implementation of functionality for [`PyWeakref`].
+///
+/// These methods are defined for the `Bound<'py, PyWeakref>` smart pointer, so to use method call
+/// syntax these methods are separated into a trait, because stable Rust does not yet support
+/// `arbitrary_self_types`.
+#[doc(alias = "PyWeakref")]
+pub trait PyWeakrefMethods<'py>: crate::sealed::Sealed {
+    /// Upgrade the weakref to a direct Bound object reference.
+    ///
+    /// It is named `upgrade` to be inline with [rust's `Weak::upgrade`](std::rc::Weak::upgrade).
+    /// In Python it would be equivalent to [`PyWeakref_GetRef`].
+    ///
+    /// # Example
+    #[cfg_attr(
+        not(all(feature = "macros", not(all(Py_LIMITED_API, not(Py_3_9))))),
+        doc = "```rust,ignore"
+    )]
+    #[cfg_attr(
+        all(feature = "macros", not(all(Py_LIMITED_API, not(Py_3_9)))),
+        doc = "```rust"
+    )]
+    /// use pyo3::prelude::*;
+    /// use pyo3::types::PyWeakrefReference;
+    ///
+    /// #[pyclass(weakref)]
+    /// struct Foo { /* fields omitted */ }
+    ///
+    /// #[pymethods]
+    /// impl Foo {
+    ///     fn get_data(&self) -> (&str, u32) {
+    ///         ("Dave", 10)
+    ///     }
+    /// }
+    ///
+    /// fn parse_data(reference: Borrowed<'_, '_, PyWeakrefReference>) -> PyResult<String> {
+    ///     if let Some(data_src) = reference.upgrade_as::<Foo>()? {
+    ///         let data = data_src.borrow();
+    ///         let (name, score) = data.get_data();
+    ///         Ok(format!("Processing '{}': score = {}", name, score))
+    ///     } else {
+    ///         Ok("The supplied data reference is no longer relevant.".to_owned())
+    ///     }
+    /// }
+    ///
+    /// # fn main() -> PyResult<()> {
+    /// Python::attach(|py| {
+    ///     let data = Bound::new(py, Foo{})?;
+    ///     let reference = PyWeakrefReference::new(&data)?;
+    ///
+    ///     assert_eq!(
+    ///         parse_data(reference.as_borrowed())?,
+    ///         "Processing 'Dave': score = 10"
+    ///     );
+    ///
+    ///     drop(data);
+    ///
+    ///     assert_eq!(
+    ///         parse_data(reference.as_borrowed())?,
+    ///         "The supplied data reference is no longer relevant."
+    ///     );
+    ///
+    ///     Ok(())
+    /// })
+    /// # }
+    /// ```
+    ///
+    /// # Panics
+    /// This function panics is the current object is invalid.
+    /// If used properly this is never the case. (NonNull and actually a weakref type)
+    ///
+    /// [`PyWeakref_GetRef`]: https://docs.python.org/3/c-api/weakref.html#c.PyWeakref_GetRef
+    /// [`weakref.ReferenceType`]: https://docs.python.org/3/library/weakref.html#weakref.ReferenceType
+    /// [`weakref.ref`]: https://docs.python.org/3/library/weakref.html#weakref.ref
+    fn upgrade_as<T>(&self) -> PyResult<Option<Bound<'py, T>>>
+    where
+        T: PyTypeCheck,
+    {
+        self.upgrade()
+            .map(Bound::cast_into::<T>)
+            .transpose()
+            .map_err(Into::into)
+    }
+
+    /// Upgrade the weakref to a direct Bound object reference unchecked. The type of the recovered object is not checked before casting, this could lead to unexpected behavior. Use only when absolutely certain the type can be guaranteed. The `weakref` may still return `None`.
+    ///
+    /// It is named `upgrade` to be inline with [rust's `Weak::upgrade`](std::rc::Weak::upgrade).
+    /// In Python it would be equivalent to [`PyWeakref_GetRef`].
+    ///
+    /// # Safety
+    /// Callers must ensure that the type is valid or risk type confusion.
+    /// The `weakref` is still allowed to be `None`, if the referenced object has been cleaned up.
+    ///
+    /// # Example
+    #[cfg_attr(
+        not(all(feature = "macros", not(all(Py_LIMITED_API, not(Py_3_9))))),
+        doc = "```rust,ignore"
+    )]
+    #[cfg_attr(
+        all(feature = "macros", not(all(Py_LIMITED_API, not(Py_3_9)))),
+        doc = "```rust"
+    )]
+    /// use pyo3::prelude::*;
+    /// use pyo3::types::PyWeakrefReference;
+    ///
+    /// #[pyclass(weakref)]
+    /// struct Foo { /* fields omitted */ }
+    ///
+    /// #[pymethods]
+    /// impl Foo {
+    ///     fn get_data(&self) -> (&str, u32) {
+    ///         ("Dave", 10)
+    ///     }
+    /// }
+    ///
+    /// fn parse_data(reference: Borrowed<'_, '_, PyWeakrefReference>) -> String {
+    ///     if let Some(data_src) = unsafe { reference.upgrade_as_unchecked::<Foo>() } {
+    ///         let data = data_src.borrow();
+    ///         let (name, score) = data.get_data();
+    ///         format!("Processing '{}': score = {}", name, score)
+    ///     } else {
+    ///         "The supplied data reference is no longer relevant.".to_owned()
+    ///     }
+    /// }
+    ///
+    /// # fn main() -> PyResult<()> {
+    /// Python::attach(|py| {
+    ///     let data = Bound::new(py, Foo{})?;
+    ///     let reference = PyWeakrefReference::new(&data)?;
+    ///
+    ///     assert_eq!(
+    ///         parse_data(reference.as_borrowed()),
+    ///         "Processing 'Dave': score = 10"
+    ///     );
+    ///
+    ///     drop(data);
+    ///
+    ///     assert_eq!(
+    ///         parse_data(reference.as_borrowed()),
+    ///         "The supplied data reference is no longer relevant."
+    ///     );
+    ///
+    ///     Ok(())
+    /// })
+    /// # }
+    /// ```
+    ///
+    /// # Panics
+    /// This function panics is the current object is invalid.
+    /// If used properly this is never the case. (NonNull and actually a weakref type)
+    ///
+    /// [`PyWeakref_GetRef`]: https://docs.python.org/3/c-api/weakref.html#c.PyWeakref_GetRef
+    /// [`weakref.ReferenceType`]: https://docs.python.org/3/library/weakref.html#weakref.ReferenceType
+    /// [`weakref.ref`]: https://docs.python.org/3/library/weakref.html#weakref.ref
+    unsafe fn upgrade_as_unchecked<T>(&self) -> Option<Bound<'py, T>> {
+        Some(unsafe { self.upgrade()?.cast_into_unchecked() })
+    }
+
+    /// Upgrade the weakref to a exact direct Bound object reference.
+    ///
+    /// It is named `upgrade` to be inline with [rust's `Weak::upgrade`](std::rc::Weak::upgrade).
+    /// In Python it would be equivalent to [`PyWeakref_GetRef`].
+    ///
+    /// # Example
+    #[cfg_attr(
+        not(all(feature = "macros", not(all(Py_LIMITED_API, not(Py_3_9))))),
+        doc = "```rust,ignore"
+    )]
+    #[cfg_attr(
+        all(feature = "macros", not(all(Py_LIMITED_API, not(Py_3_9)))),
+        doc = "```rust"
+    )]
+    /// use pyo3::prelude::*;
+    /// use pyo3::types::PyWeakrefReference;
+    ///
+    /// #[pyclass(weakref)]
+    /// struct Foo { /* fields omitted */ }
+    ///
+    /// #[pymethods]
+    /// impl Foo {
+    ///     fn get_data(&self) -> (&str, u32) {
+    ///         ("Dave", 10)
+    ///     }
+    /// }
+    ///
+    /// fn parse_data(reference: Borrowed<'_, '_, PyWeakrefReference>) -> PyResult<String> {
+    ///     if let Some(data_src) = reference.upgrade_as_exact::<Foo>()? {
+    ///         let data = data_src.borrow();
+    ///         let (name, score) = data.get_data();
+    ///         Ok(format!("Processing '{}': score = {}", name, score))
+    ///     } else {
+    ///         Ok("The supplied data reference is no longer relevant.".to_owned())
+    ///     }
+    /// }
+    ///
+    /// # fn main() -> PyResult<()> {
+    /// Python::attach(|py| {
+    ///     let data = Bound::new(py, Foo{})?;
+    ///     let reference = PyWeakrefReference::new(&data)?;
+    ///
+    ///     assert_eq!(
+    ///         parse_data(reference.as_borrowed())?,
+    ///         "Processing 'Dave': score = 10"
+    ///     );
+    ///
+    ///     drop(data);
+    ///
+    ///     assert_eq!(
+    ///         parse_data(reference.as_borrowed())?,
+    ///         "The supplied data reference is no longer relevant."
+    ///     );
+    ///
+    ///     Ok(())
+    /// })
+    /// # }
+    /// ```
+    ///
+    /// # Panics
+    /// This function panics is the current object is invalid.
+    /// If used properly this is never the case. (NonNull and actually a weakref type)
+    ///
+    /// [`PyWeakref_GetRef`]: https://docs.python.org/3/c-api/weakref.html#c.PyWeakref_GetRef
+    /// [`weakref.ReferenceType`]: https://docs.python.org/3/library/weakref.html#weakref.ReferenceType
+    /// [`weakref.ref`]: https://docs.python.org/3/library/weakref.html#weakref.ref
+    fn upgrade_as_exact<T>(&self) -> PyResult<Option<Bound<'py, T>>>
+    where
+        T: PyTypeInfo,
+    {
+        self.upgrade()
+            .map(Bound::cast_into_exact)
+            .transpose()
+            .map_err(Into::into)
+    }
+
+    /// Upgrade the weakref to a Bound [`PyAny`] reference to the target object if possible.
+    ///
+    /// It is named `upgrade` to be inline with [rust's `Weak::upgrade`](std::rc::Weak::upgrade).
+    /// This function returns `Some(Bound<'py, PyAny>)` if the reference still exists, otherwise `None` will be returned.
+    ///
+    /// This function gets the optional target of this [`weakref.ReferenceType`] (result of calling [`weakref.ref`]).
+    /// It produces similar results to using [`PyWeakref_GetRef`] in the C api.
+    ///
+    /// # Example
+    #[cfg_attr(
+        not(all(feature = "macros", not(all(Py_LIMITED_API, not(Py_3_9))))),
+        doc = "```rust,ignore"
+    )]
+    #[cfg_attr(
+        all(feature = "macros", not(all(Py_LIMITED_API, not(Py_3_9)))),
+        doc = "```rust"
+    )]
+    /// use pyo3::prelude::*;
+    /// use pyo3::types::PyWeakrefReference;
+    ///
+    /// #[pyclass(weakref)]
+    /// struct Foo { /* fields omitted */ }
+    ///
+    /// fn parse_data(reference: Borrowed<'_, '_, PyWeakrefReference>) -> PyResult<String> {
+    ///     if let Some(object) = reference.upgrade() {
+    ///         Ok(format!("The object '{}' referred by this reference still exists.", object.getattr("__class__")?.getattr("__qualname__")?))
+    ///     } else {
+    ///         Ok("The object, which this reference referred to, no longer exists".to_owned())
+    ///     }
+    /// }
+    ///
+    /// # fn main() -> PyResult<()> {
+    /// Python::attach(|py| {
+    ///     let data = Bound::new(py, Foo{})?;
+    ///     let reference = PyWeakrefReference::new(&data)?;
+    ///
+    ///     assert_eq!(
+    ///         parse_data(reference.as_borrowed())?,
+    ///         "The object 'Foo' referred by this reference still exists."
+    ///     );
+    ///
+    ///     drop(data);
+    ///
+    ///     assert_eq!(
+    ///         parse_data(reference.as_borrowed())?,
+    ///         "The object, which this reference referred to, no longer exists"
+    ///     );
+    ///
+    ///     Ok(())
+    /// })
+    /// # }
+    /// ```
+    ///
+    /// # Panics
+    /// This function panics is the current object is invalid.
+    /// If used properly this is never the case. (NonNull and actually a weakref type)
+    ///
+    /// [`PyWeakref_GetRef`]: https://docs.python.org/3/c-api/weakref.html#c.PyWeakref_GetRef
+    /// [`weakref.ReferenceType`]: https://docs.python.org/3/library/weakref.html#weakref.ReferenceType
+    /// [`weakref.ref`]: https://docs.python.org/3/library/weakref.html#weakref.ref
+    fn upgrade(&self) -> Option<Bound<'py, PyAny>>;
+}
+
+impl<'py> PyWeakrefMethods<'py> for Bound<'py, PyWeakref> {
+    fn upgrade(&self) -> Option<Bound<'py, PyAny>> {
+        let mut obj: *mut ffi::PyObject = std::ptr::null_mut();
+        match unsafe { ffi::compat::PyWeakref_GetRef(self.as_ptr(), &mut obj) } {
+            std::ffi::c_int::MIN..=-1 => panic!("The 'weakref' weak reference instance should be valid (non-null and actually a weakref reference)"),
+            0 => None,
+            1..=std::ffi::c_int::MAX => Some(unsafe { obj.assume_owned_unchecked(self.py()) }),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::types::any::{PyAny, PyAnyMethods};
+    use crate::types::weakref::{PyWeakref, PyWeakrefMethods, PyWeakrefProxy, PyWeakrefReference};
+    use crate::{Bound, PyResult, Python};
+
+    fn new_reference<'py>(object: &Bound<'py, PyAny>) -> PyResult<Bound<'py, PyWeakref>> {
+        let reference = PyWeakrefReference::new(object)?;
+        reference.cast_into().map_err(Into::into)
+    }
+
+    fn new_proxy<'py>(object: &Bound<'py, PyAny>) -> PyResult<Bound<'py, PyWeakref>> {
+        let reference = PyWeakrefProxy::new(object)?;
+        reference.cast_into().map_err(Into::into)
+    }
+
+    mod python_class {
+        use super::*;
+        #[cfg(Py_3_10)]
+        use crate::types::PyInt;
+        use crate::PyTypeCheck;
+        use crate::{py_result_ext::PyResultExt, types::PyType};
+        use std::ptr;
+
+        fn get_type(py: Python<'_>) -> PyResult<Bound<'_, PyType>> {
+            py.run(c"class A:\n    pass\n", None, None)?;
+            py.eval(c"A", None, None).cast_into::<PyType>()
+        }
+
+        #[test]
+        fn test_weakref_upgrade_as() -> PyResult<()> {
+            fn inner(
+                create_reference: impl for<'py> FnOnce(
+                    &Bound<'py, PyAny>,
+                )
+                    -> PyResult<Bound<'py, PyWeakref>>,
+            ) -> PyResult<()> {
+                Python::attach(|py| {
+                    let class = get_type(py)?;
+                    let object = class.call0()?;
+                    let reference = create_reference(&object)?;
+
+                    {
+                        // This test is a bit weird but ok.
+                        let obj = reference.upgrade_as::<PyAny>();
+
+                        assert!(obj.is_ok());
+                        let obj = obj.unwrap();
+
+                        assert!(obj.is_some());
+                        assert!(obj.is_some_and(|obj| ptr::eq(obj.as_ptr(), object.as_ptr())
+                            && obj.is_exact_instance(&class)));
+                    }
+
+                    drop(object);
+
+                    {
+                        // This test is a bit weird but ok.
+                        let obj = reference.upgrade_as::<PyAny>();
+
+                        assert!(obj.is_ok());
+                        let obj = obj.unwrap();
+
+                        assert!(obj.is_none());
+                    }
+
+                    Ok(())
+                })
+            }
+
+            inner(new_reference)?;
+            inner(new_proxy)
+        }
+
+        #[test]
+        fn test_weakref_upgrade_as_unchecked() -> PyResult<()> {
+            fn inner(
+                create_reference: impl for<'py> FnOnce(
+                    &Bound<'py, PyAny>,
+                )
+                    -> PyResult<Bound<'py, PyWeakref>>,
+            ) -> PyResult<()> {
+                Python::attach(|py| {
+                    let class = get_type(py)?;
+                    let object = class.call0()?;
+                    let reference = create_reference(&object)?;
+
+                    {
+                        // This test is a bit weird but ok.
+                        let obj = unsafe { reference.upgrade_as_unchecked::<PyAny>() };
+
+                        assert!(obj.is_some());
+                        assert!(obj.is_some_and(|obj| ptr::eq(obj.as_ptr(), object.as_ptr())
+                            && obj.is_exact_instance(&class)));
+                    }
+
+                    drop(object);
+
+                    {
+                        // This test is a bit weird but ok.
+                        let obj = unsafe { reference.upgrade_as_unchecked::<PyAny>() };
+
+                        assert!(obj.is_none());
+                    }
+
+                    Ok(())
+                })
+            }
+
+            inner(new_reference)?;
+            inner(new_proxy)
+        }
+
+        #[test]
+        fn test_weakref_upgrade() -> PyResult<()> {
+            fn inner(
+                create_reference: impl for<'py> FnOnce(
+                    &Bound<'py, PyAny>,
+                )
+                    -> PyResult<Bound<'py, PyWeakref>>,
+                call_retrievable: bool,
+            ) -> PyResult<()> {
+                let not_call_retrievable = !call_retrievable;
+
+                Python::attach(|py| {
+                    let class = get_type(py)?;
+                    let object = class.call0()?;
+                    let reference = create_reference(&object)?;
+
+                    assert!(not_call_retrievable || reference.call0()?.is(&object));
+                    assert!(reference.upgrade().is_some());
+                    assert!(reference.upgrade().is_some_and(|obj| obj.is(&object)));
+
+                    drop(object);
+
+                    assert!(not_call_retrievable || reference.call0()?.is_none());
+                    assert!(reference.upgrade().is_none());
+
+                    Ok(())
+                })
+            }
+
+            inner(new_reference, true)?;
+            inner(new_proxy, false)
+        }
+
+        #[test]
+        fn test_classinfo_object() -> PyResult<()> {
+            fn inner(
+                create_reference: impl for<'py> FnOnce(
+                    &Bound<'py, PyAny>,
+                )
+                    -> PyResult<Bound<'py, PyWeakref>>,
+            ) -> PyResult<()> {
+                Python::attach(|py| {
+                    let class = get_type(py)?;
+                    let object = class.call0()?;
+                    let reference = create_reference(&object)?;
+                    let t = PyWeakref::classinfo_object(py);
+                    assert!(reference.is_instance(&t)?);
+                    Ok(())
+                })
+            }
+
+            inner(new_reference)?;
+            inner(new_proxy)
+        }
+
+        #[cfg(Py_3_10)] // Name is different in 3.9
+        #[test]
+        fn test_classinfo_downcast_error() -> PyResult<()> {
+            Python::attach(|py| {
+                assert_eq!(
+                    PyInt::new(py, 1)
+                        .cast_into::<PyWeakref>()
+                        .unwrap_err()
+                        .to_string(),
+                    "'int' object cannot be cast as 'ProxyType | CallableProxyType | ReferenceType'"
+                );
+                Ok(())
+            })
+        }
+    }
+
+    // under 'abi3-py37' and 'abi3-py38' PyClass cannot be weakreferencable.
+    #[cfg(all(feature = "macros", not(all(Py_LIMITED_API, not(Py_3_9)))))]
+    mod pyo3_pyclass {
+        use super::*;
+        use crate::{pyclass, Py};
+        use std::ptr;
+
+        #[pyclass(weakref, crate = "crate")]
+        struct WeakrefablePyClass {}
+
+        #[test]
+        fn test_weakref_upgrade_as() -> PyResult<()> {
+            fn inner(
+                create_reference: impl for<'py> FnOnce(
+                    &Bound<'py, PyAny>,
+                )
+                    -> PyResult<Bound<'py, PyWeakref>>,
+            ) -> PyResult<()> {
+                Python::attach(|py| {
+                    let object = Py::new(py, WeakrefablePyClass {})?;
+                    let reference = create_reference(object.bind(py))?;
+
+                    {
+                        let obj = reference.upgrade_as::<WeakrefablePyClass>();
+
+                        assert!(obj.is_ok());
+                        let obj = obj.unwrap();
+
+                        assert!(obj.is_some());
+                        assert!(obj.is_some_and(|obj| ptr::eq(obj.as_ptr(), object.as_ptr())));
+                    }
+
+                    drop(object);
+
+                    {
+                        let obj = reference.upgrade_as::<WeakrefablePyClass>();
+
+                        assert!(obj.is_ok());
+                        let obj = obj.unwrap();
+
+                        assert!(obj.is_none());
+                    }
+
+                    Ok(())
+                })
+            }
+
+            inner(new_reference)?;
+            inner(new_proxy)
+        }
+
+        #[test]
+        fn test_weakref_upgrade_as_unchecked() -> PyResult<()> {
+            fn inner(
+                create_reference: impl for<'py> FnOnce(
+                    &Bound<'py, PyAny>,
+                )
+                    -> PyResult<Bound<'py, PyWeakref>>,
+            ) -> PyResult<()> {
+                Python::attach(|py| {
+                    let object = Py::new(py, WeakrefablePyClass {})?;
+                    let reference = create_reference(object.bind(py))?;
+
+                    {
+                        let obj = unsafe { reference.upgrade_as_unchecked::<WeakrefablePyClass>() };
+
+                        assert!(obj.is_some());
+                        assert!(obj.is_some_and(|obj| ptr::eq(obj.as_ptr(), object.as_ptr())));
+                    }
+
+                    drop(object);
+
+                    {
+                        let obj = unsafe { reference.upgrade_as_unchecked::<WeakrefablePyClass>() };
+
+                        assert!(obj.is_none());
+                    }
+
+                    Ok(())
+                })
+            }
+
+            inner(new_reference)?;
+            inner(new_proxy)
+        }
+
+        #[test]
+        fn test_weakref_upgrade() -> PyResult<()> {
+            fn inner(
+                create_reference: impl for<'py> FnOnce(
+                    &Bound<'py, PyAny>,
+                )
+                    -> PyResult<Bound<'py, PyWeakref>>,
+                call_retrievable: bool,
+            ) -> PyResult<()> {
+                let not_call_retrievable = !call_retrievable;
+
+                Python::attach(|py| {
+                    let object = Py::new(py, WeakrefablePyClass {})?;
+                    let reference = create_reference(object.bind(py))?;
+
+                    assert!(not_call_retrievable || reference.call0()?.is(&object));
+                    assert!(reference.upgrade().is_some());
+                    assert!(reference.upgrade().is_some_and(|obj| obj.is(&object)));
+
+                    drop(object);
+
+                    assert!(not_call_retrievable || reference.call0()?.is_none());
+                    assert!(reference.upgrade().is_none());
+
+                    Ok(())
+                })
+            }
+
+            inner(new_reference, true)?;
+            inner(new_proxy, false)
+        }
+    }
+}
diff --git a/src/types/weakref/mod.rs b/src/types/weakref/mod.rs
new file mode 100644
index 00000000000..49d4e515b12
--- /dev/null
+++ b/src/types/weakref/mod.rs
@@ -0,0 +1,7 @@
+pub use anyref::{PyWeakref, PyWeakrefMethods};
+pub use proxy::PyWeakrefProxy;
+pub use reference::PyWeakrefReference;
+
+pub(crate) mod anyref;
+pub(crate) mod proxy;
+pub(crate) mod reference;
diff --git a/src/types/weakref/proxy.rs b/src/types/weakref/proxy.rs
new file mode 100644
index 00000000000..dce2291f3a5
--- /dev/null
+++ b/src/types/weakref/proxy.rs
@@ -0,0 +1,917 @@
+use super::PyWeakrefMethods;
+use crate::err::PyResult;
+use crate::ffi_ptr_ext::FfiPtrExt;
+#[cfg(feature = "experimental-inspect")]
+use crate::inspect::TypeHint;
+use crate::py_result_ext::PyResultExt;
+use crate::sync::PyOnceLock;
+use crate::type_object::PyTypeCheck;
+use crate::types::any::PyAny;
+use crate::{ffi, Borrowed, Bound, BoundObject, IntoPyObject, IntoPyObjectExt, Py, Python};
+
+/// Represents any Python `weakref` Proxy type.
+///
+/// In Python this is created by calling `weakref.proxy`.
+/// This is either a `weakref.ProxyType` or a `weakref.CallableProxyType` (`weakref.ProxyTypes`).
+#[repr(transparent)]
+pub struct PyWeakrefProxy(PyAny);
+
+pyobject_native_type_named!(PyWeakrefProxy);
+
+// TODO: We known the layout but this cannot be implemented, due to the lack of public typeobject pointers. And it is 2 distinct types
+// #[cfg(not(Py_LIMITED_API))]
+// pyobject_native_type_sized!(PyWeakrefProxy, ffi::PyWeakReference);
+
+unsafe impl PyTypeCheck for PyWeakrefProxy {
+    const NAME: &'static str = "weakref.ProxyTypes";
+
+    #[cfg(feature = "experimental-inspect")]
+    const TYPE_HINT: TypeHint = TypeHint::union(&[
+        TypeHint::module_attr("weakref", "ProxyType"),
+        TypeHint::module_attr("weakref", "CallableProxyType"),
+    ]);
+
+    #[inline]
+    fn type_check(object: &Bound<'_, PyAny>) -> bool {
+        unsafe { ffi::PyWeakref_CheckProxy(object.as_ptr()) > 0 }
+    }
+
+    fn classinfo_object(py: Python<'_>) -> Bound<'_, PyAny> {
+        static TYPE: PyOnceLock<Py<PyAny>> = PyOnceLock::new();
+        TYPE.import(py, "weakref", "ProxyTypes").unwrap().clone()
+    }
+}
+
+/// TODO: UPDATE DOCS
+impl PyWeakrefProxy {
+    /// Constructs a new Weak Reference (`weakref.proxy`/`weakref.ProxyType`/`weakref.CallableProxyType`) for the given object.
+    ///
+    /// Returns a `TypeError` if `object` is not weak referenceable (Most native types and PyClasses without `weakref` flag).
+    ///
+    /// # Examples
+    #[cfg_attr(
+        not(all(feature = "macros", not(all(Py_LIMITED_API, not(Py_3_9))))),
+        doc = "```rust,ignore"
+    )]
+    #[cfg_attr(
+        all(feature = "macros", not(all(Py_LIMITED_API, not(Py_3_9)))),
+        doc = "```rust"
+    )]
+    /// use pyo3::prelude::*;
+    /// use pyo3::types::PyWeakrefProxy;
+    ///
+    /// #[pyclass(weakref)]
+    /// struct Foo { /* fields omitted */ }
+    ///
+    /// # fn main() -> PyResult<()> {
+    /// Python::attach(|py| {
+    ///     let foo = Bound::new(py, Foo {})?;
+    ///     let weakref = PyWeakrefProxy::new(&foo)?;
+    ///     assert!(
+    ///         // In normal situations where a direct `Bound<'py, Foo>` is required use `upgrade::<Foo>`
+    ///         weakref.upgrade().is_some_and(|obj| obj.is(&foo))
+    ///     );
+    ///
+    ///     let weakref2 = PyWeakrefProxy::new(&foo)?;
+    ///     assert!(weakref.is(&weakref2));
+    ///
+    ///     drop(foo);
+    ///
+    ///     assert!(weakref.upgrade().is_none());
+    ///     Ok(())
+    /// })
+    /// # }
+    /// ```
+    #[inline]
+    pub fn new<'py>(object: &Bound<'py, PyAny>) -> PyResult<Bound<'py, PyWeakrefProxy>> {
+        unsafe {
+            Bound::from_owned_ptr_or_err(
+                object.py(),
+                ffi::PyWeakref_NewProxy(object.as_ptr(), ffi::Py_None()),
+            )
+            .cast_into_unchecked()
+        }
+    }
+
+    /// Constructs a new Weak Reference (`weakref.proxy`/`weakref.ProxyType`/`weakref.CallableProxyType`) for the given object with a callback.
+    ///
+    /// Returns a `TypeError` if `object` is not weak referenceable (Most native types and PyClasses without `weakref` flag) or if the `callback` is not callable or None.
+    ///
+    /// # Examples
+    #[cfg_attr(
+        not(all(feature = "macros", not(all(Py_LIMITED_API, not(Py_3_9))))),
+        doc = "```rust,ignore"
+    )]
+    #[cfg_attr(
+        all(feature = "macros", not(all(Py_LIMITED_API, not(Py_3_9)))),
+        doc = "```rust"
+    )]
+    /// use pyo3::prelude::*;
+    /// use pyo3::types::PyWeakrefProxy;
+    /// use pyo3::ffi::c_str;
+    ///
+    /// #[pyclass(weakref)]
+    /// struct Foo { /* fields omitted */ }
+    ///
+    /// #[pyfunction]
+    /// fn callback(wref: Bound<'_, PyWeakrefProxy>) -> PyResult<()> {
+    ///         let py = wref.py();
+    ///         assert!(wref.upgrade_as::<Foo>()?.is_none());
+    ///         py.run(c"counter = 1", None, None)
+    /// }
+    ///
+    /// # fn main() -> PyResult<()> {
+    /// Python::attach(|py| {
+    ///     py.run(c"counter = 0", None, None)?;
+    ///     assert_eq!(py.eval(c"counter", None, None)?.extract::<u32>()?, 0);
+    ///     let foo = Bound::new(py, Foo{})?;
+    ///
+    ///     // This is fine.
+    ///     let weakref = PyWeakrefProxy::new_with(&foo, py.None())?;
+    ///     assert!(weakref.upgrade_as::<Foo>()?.is_some());
+    ///     assert!(
+    ///         // In normal situations where a direct `Bound<'py, Foo>` is required use `upgrade::<Foo>`
+    ///         weakref.upgrade().is_some_and(|obj| obj.is(&foo))
+    ///     );
+    ///     assert_eq!(py.eval(c"counter", None, None)?.extract::<u32>()?, 0);
+    ///
+    ///     let weakref2 = PyWeakrefProxy::new_with(&foo, wrap_pyfunction!(callback, py)?)?;
+    ///     assert!(!weakref.is(&weakref2)); // Not the same weakref
+    ///     assert!(weakref.eq(&weakref2)?);  // But Equal, since they point to the same object
+    ///
+    ///     drop(foo);
+    ///
+    ///     assert!(weakref.upgrade_as::<Foo>()?.is_none());
+    ///     assert_eq!(py.eval(c"counter", None, None)?.extract::<u32>()?, 1);
+    ///     Ok(())
+    /// })
+    /// # }
+    /// ```
+    #[inline]
+    pub fn new_with<'py, C>(
+        object: &Bound<'py, PyAny>,
+        callback: C,
+    ) -> PyResult<Bound<'py, PyWeakrefProxy>>
+    where
+        C: IntoPyObject<'py>,
+    {
+        fn inner<'py>(
+            object: &Bound<'py, PyAny>,
+            callback: Borrowed<'_, 'py, PyAny>,
+        ) -> PyResult<Bound<'py, PyWeakrefProxy>> {
+            unsafe {
+                Bound::from_owned_ptr_or_err(
+                    object.py(),
+                    ffi::PyWeakref_NewProxy(object.as_ptr(), callback.as_ptr()),
+                )
+                .cast_into_unchecked()
+            }
+        }
+
+        let py = object.py();
+        inner(
+            object,
+            callback
+                .into_pyobject_or_pyerr(py)?
+                .into_any()
+                .as_borrowed(),
+        )
+    }
+}
+
+impl<'py> PyWeakrefMethods<'py> for Bound<'py, PyWeakrefProxy> {
+    fn upgrade(&self) -> Option<Bound<'py, PyAny>> {
+        let mut obj: *mut ffi::PyObject = std::ptr::null_mut();
+        match unsafe { ffi::compat::PyWeakref_GetRef(self.as_ptr(), &mut obj) } {
+            std::ffi::c_int::MIN..=-1 => panic!("The 'weakref.ProxyType' (or `weakref.CallableProxyType`) instance should be valid (non-null and actually a weakref reference)"),
+            0 => None,
+            1..=std::ffi::c_int::MAX => Some(unsafe { obj.assume_owned_unchecked(self.py()) }),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::exceptions::{PyAttributeError, PyReferenceError, PyTypeError};
+    use crate::types::any::{PyAny, PyAnyMethods};
+    use crate::types::weakref::{PyWeakrefMethods, PyWeakrefProxy};
+    use crate::{Bound, PyResult, Python};
+
+    #[cfg(all(Py_3_13, not(Py_LIMITED_API)))]
+    const DEADREF_FIX: Option<&str> = None;
+    #[cfg(all(not(Py_3_13), not(Py_LIMITED_API)))]
+    const DEADREF_FIX: Option<&str> = Some("NoneType");
+
+    #[cfg(not(Py_LIMITED_API))]
+    fn check_repr(
+        reference: &Bound<'_, PyWeakrefProxy>,
+        object: &Bound<'_, PyAny>,
+        class: Option<&str>,
+    ) -> PyResult<()> {
+        let repr = reference.repr()?.to_string();
+
+        #[cfg(Py_3_13)]
+        let (first_part, second_part) = repr.split_once(';').unwrap();
+        #[cfg(not(Py_3_13))]
+        let (first_part, second_part) = repr.split_once(" to ").unwrap();
+
+        {
+            let (msg, addr) = first_part.split_once("0x").unwrap();
+
+            assert_eq!(msg, "<weakproxy at ");
+            assert!(addr
+                .to_lowercase()
+                .contains(format!("{:x?}", reference.as_ptr()).split_at(2).1));
+        }
+
+        if let Some(class) = class.or(DEADREF_FIX) {
+            let (msg, addr) = second_part.split_once("0x").unwrap();
+
+            // Avoids not succeeding at unreliable quotation (Python 3.13-dev adds ' around classname without documenting)
+            #[cfg(Py_3_13)]
+            assert!(msg.starts_with(" to '"));
+            assert!(msg.contains(class));
+            assert!(msg.ends_with(" at "));
+
+            assert!(addr
+                .to_lowercase()
+                .contains(format!("{:x?}", object.as_ptr()).split_at(2).1));
+        } else {
+            assert!(second_part.contains("dead"));
+        }
+
+        Ok(())
+    }
+
+    mod proxy {
+        use super::*;
+
+        #[cfg(all(not(Py_LIMITED_API), Py_3_10))]
+        const CLASS_NAME: &str = "'weakref.ProxyType'";
+        #[cfg(all(not(Py_LIMITED_API), not(Py_3_10)))]
+        const CLASS_NAME: &str = "'weakproxy'";
+
+        mod python_class {
+            use super::*;
+            #[cfg(Py_3_10)]
+            use crate::types::PyInt;
+            use crate::PyTypeCheck;
+            use crate::{py_result_ext::PyResultExt, types::PyDict, types::PyType};
+            use std::ptr;
+
+            fn get_type(py: Python<'_>) -> PyResult<Bound<'_, PyType>> {
+                let globals = PyDict::new(py);
+                py.run(c"class A:\n    pass\n", Some(&globals), None)?;
+                py.eval(c"A", Some(&globals), None).cast_into::<PyType>()
+            }
+
+            #[test]
+            fn test_weakref_proxy_behavior() -> PyResult<()> {
+                Python::attach(|py| {
+                    let class = get_type(py)?;
+                    let object = class.call0()?;
+                    let reference = PyWeakrefProxy::new(&object)?;
+
+                    assert!(!reference.is(&object));
+                    assert!(reference.upgrade().unwrap().is(&object));
+
+                    #[cfg(not(Py_LIMITED_API))]
+                    assert_eq!(
+                        reference.get_type().to_string(),
+                        format!("<class {CLASS_NAME}>")
+                    );
+
+                    assert_eq!(reference.getattr("__class__")?.to_string(), "<class 'A'>");
+                    #[cfg(not(Py_LIMITED_API))]
+                    check_repr(&reference, &object, Some("A"))?;
+
+                    assert!(reference
+                        .getattr("__callback__")
+                        .err()
+                        .is_some_and(|err| err.is_instance_of::<PyAttributeError>(py)));
+
+                    assert!(reference.call0().err().is_some_and(|err| {
+                        let result = err.is_instance_of::<PyTypeError>(py);
+                        #[cfg(not(Py_LIMITED_API))]
+                        let result = result
+                            & (err.value(py).to_string()
+                                == format!("{CLASS_NAME} object is not callable"));
+                        result
+                    }));
+
+                    drop(object);
+
+                    assert!(reference.upgrade().is_none());
+                    assert!(reference
+                        .getattr("__class__")
+                        .err()
+                        .is_some_and(|err| err.is_instance_of::<PyReferenceError>(py)));
+                    #[cfg(not(Py_LIMITED_API))]
+                    check_repr(&reference, py.None().bind(py), None)?;
+
+                    assert!(reference
+                        .getattr("__callback__")
+                        .err()
+                        .is_some_and(|err| err.is_instance_of::<PyReferenceError>(py)));
+
+                    assert!(reference.call0().err().is_some_and(|err| {
+                        let result = err.is_instance_of::<PyTypeError>(py);
+                        #[cfg(not(Py_LIMITED_API))]
+                        let result = result
+                            & (err.value(py).to_string()
+                                == format!("{CLASS_NAME} object is not callable"));
+                        result
+                    }));
+
+                    Ok(())
+                })
+            }
+
+            #[test]
+            fn test_weakref_upgrade_as() -> PyResult<()> {
+                Python::attach(|py| {
+                    let class = get_type(py)?;
+                    let object = class.call0()?;
+                    let reference = PyWeakrefProxy::new(&object)?;
+
+                    {
+                        // This test is a bit weird but ok.
+                        let obj = reference.upgrade_as::<PyAny>();
+
+                        assert!(obj.is_ok());
+                        let obj = obj.unwrap();
+
+                        assert!(obj.is_some());
+                        assert!(obj.is_some_and(|obj| ptr::eq(obj.as_ptr(), object.as_ptr())
+                            && obj.is_exact_instance(&class)));
+                    }
+
+                    drop(object);
+
+                    {
+                        // This test is a bit weird but ok.
+                        let obj = reference.upgrade_as::<PyAny>();
+
+                        assert!(obj.is_ok());
+                        let obj = obj.unwrap();
+
+                        assert!(obj.is_none());
+                    }
+
+                    Ok(())
+                })
+            }
+
+            #[test]
+            fn test_weakref_upgrade_as_unchecked() -> PyResult<()> {
+                Python::attach(|py| {
+                    let class = get_type(py)?;
+                    let object = class.call0()?;
+                    let reference = PyWeakrefProxy::new(&object)?;
+
+                    {
+                        // This test is a bit weird but ok.
+                        let obj = unsafe { reference.upgrade_as_unchecked::<PyAny>() };
+
+                        assert!(obj.is_some());
+                        assert!(obj.is_some_and(|obj| ptr::eq(obj.as_ptr(), object.as_ptr())
+                            && obj.is_exact_instance(&class)));
+                    }
+
+                    drop(object);
+
+                    {
+                        // This test is a bit weird but ok.
+                        let obj = unsafe { reference.upgrade_as_unchecked::<PyAny>() };
+
+                        assert!(obj.is_none());
+                    }
+
+                    Ok(())
+                })
+            }
+
+            #[test]
+            fn test_weakref_upgrade() -> PyResult<()> {
+                Python::attach(|py| {
+                    let class = get_type(py)?;
+                    let object = class.call0()?;
+                    let reference = PyWeakrefProxy::new(&object)?;
+
+                    assert!(reference.upgrade().is_some());
+                    assert!(reference.upgrade().is_some_and(|obj| obj.is(&object)));
+
+                    drop(object);
+
+                    assert!(reference.upgrade().is_none());
+
+                    Ok(())
+                })
+            }
+
+            #[test]
+            fn test_weakref_get_object() -> PyResult<()> {
+                Python::attach(|py| {
+                    let class = get_type(py)?;
+                    let object = class.call0()?;
+                    let reference = PyWeakrefProxy::new(&object)?;
+
+                    assert!(reference.upgrade().unwrap().is(&object));
+
+                    drop(object);
+
+                    assert!(reference.upgrade().is_none());
+
+                    Ok(())
+                })
+            }
+
+            #[test]
+            fn test_type_object() -> PyResult<()> {
+                Python::attach(|py| {
+                    let class = get_type(py)?;
+                    let object = class.call0()?;
+                    let reference = PyWeakrefProxy::new(&object)?;
+                    let t = PyWeakrefProxy::classinfo_object(py);
+                    assert!(reference.is_instance(&t)?);
+                    Ok(())
+                })
+            }
+
+            #[cfg(Py_3_10)] // Name is different in 3.9
+            #[test]
+            fn test_classinfo_downcast_error() -> PyResult<()> {
+                Python::attach(|py| {
+                    assert_eq!(
+                        PyInt::new(py, 1)
+                            .cast_into::<PyWeakrefProxy>()
+                            .unwrap_err()
+                            .to_string(),
+                        "'int' object cannot be cast as 'ProxyType | CallableProxyType'"
+                    );
+                    Ok(())
+                })
+            }
+        }
+
+        // under 'abi3-py37' and 'abi3-py38' PyClass cannot be weakreferencable.
+        #[cfg(all(feature = "macros", not(all(Py_LIMITED_API, not(Py_3_9)))))]
+        mod pyo3_pyclass {
+            use super::*;
+            use crate::{pyclass, Py};
+            use std::ptr;
+
+            #[pyclass(weakref, crate = "crate")]
+            struct WeakrefablePyClass {}
+
+            #[test]
+            fn test_weakref_proxy_behavior() -> PyResult<()> {
+                Python::attach(|py| {
+                    let object: Bound<'_, WeakrefablePyClass> =
+                        Bound::new(py, WeakrefablePyClass {})?;
+                    let reference = PyWeakrefProxy::new(&object)?;
+
+                    assert!(!reference.is(&object));
+                    assert!(reference.upgrade().unwrap().is(&object));
+                    #[cfg(not(Py_LIMITED_API))]
+                    assert_eq!(
+                        reference.get_type().to_string(),
+                        format!("<class {CLASS_NAME}>")
+                    );
+
+                    assert_eq!(
+                        reference.getattr("__class__")?.to_string(),
+                        "<class 'builtins.WeakrefablePyClass'>"
+                    );
+                    #[cfg(not(Py_LIMITED_API))]
+                    check_repr(&reference, object.as_any(), Some("WeakrefablePyClass"))?;
+
+                    assert!(reference
+                        .getattr("__callback__")
+                        .err()
+                        .is_some_and(|err| err.is_instance_of::<PyAttributeError>(py)));
+
+                    assert!(reference.call0().err().is_some_and(|err| {
+                        let result = err.is_instance_of::<PyTypeError>(py);
+                        #[cfg(not(Py_LIMITED_API))]
+                        let result = result
+                            & (err.value(py).to_string()
+                                == format!("{CLASS_NAME} object is not callable"));
+                        result
+                    }));
+
+                    drop(object);
+
+                    assert!(reference.upgrade().is_none());
+                    assert!(reference
+                        .getattr("__class__")
+                        .err()
+                        .is_some_and(|err| err.is_instance_of::<PyReferenceError>(py)));
+                    #[cfg(not(Py_LIMITED_API))]
+                    check_repr(&reference, py.None().bind(py), None)?;
+
+                    assert!(reference
+                        .getattr("__callback__")
+                        .err()
+                        .is_some_and(|err| err.is_instance_of::<PyReferenceError>(py)));
+
+                    assert!(reference.call0().err().is_some_and(|err| {
+                        let result = err.is_instance_of::<PyTypeError>(py);
+                        #[cfg(not(Py_LIMITED_API))]
+                        let result = result
+                            & (err.value(py).to_string()
+                                == format!("{CLASS_NAME} object is not callable"));
+                        result
+                    }));
+
+                    Ok(())
+                })
+            }
+
+            #[test]
+            fn test_weakref_upgrade_as() -> PyResult<()> {
+                Python::attach(|py| {
+                    let object = Py::new(py, WeakrefablePyClass {})?;
+                    let reference = PyWeakrefProxy::new(object.bind(py))?;
+
+                    {
+                        let obj = reference.upgrade_as::<WeakrefablePyClass>();
+
+                        assert!(obj.is_ok());
+                        let obj = obj.unwrap();
+
+                        assert!(obj.is_some());
+                        assert!(obj.is_some_and(|obj| ptr::eq(obj.as_ptr(), object.as_ptr())));
+                    }
+
+                    drop(object);
+
+                    {
+                        let obj = reference.upgrade_as::<WeakrefablePyClass>();
+
+                        assert!(obj.is_ok());
+                        let obj = obj.unwrap();
+
+                        assert!(obj.is_none());
+                    }
+
+                    Ok(())
+                })
+            }
+
+            #[test]
+            fn test_weakref_upgrade_as_unchecked() -> PyResult<()> {
+                Python::attach(|py| {
+                    let object = Py::new(py, WeakrefablePyClass {})?;
+                    let reference = PyWeakrefProxy::new(object.bind(py))?;
+
+                    {
+                        let obj = unsafe { reference.upgrade_as_unchecked::<WeakrefablePyClass>() };
+
+                        assert!(obj.is_some());
+                        assert!(obj.is_some_and(|obj| ptr::eq(obj.as_ptr(), object.as_ptr())));
+                    }
+
+                    drop(object);
+
+                    {
+                        let obj = unsafe { reference.upgrade_as_unchecked::<WeakrefablePyClass>() };
+
+                        assert!(obj.is_none());
+                    }
+
+                    Ok(())
+                })
+            }
+
+            #[test]
+            fn test_weakref_upgrade() -> PyResult<()> {
+                Python::attach(|py| {
+                    let object = Py::new(py, WeakrefablePyClass {})?;
+                    let reference = PyWeakrefProxy::new(object.bind(py))?;
+
+                    assert!(reference.upgrade().is_some());
+                    assert!(reference.upgrade().is_some_and(|obj| obj.is(&object)));
+
+                    drop(object);
+
+                    assert!(reference.upgrade().is_none());
+
+                    Ok(())
+                })
+            }
+        }
+    }
+
+    mod callable_proxy {
+        use super::*;
+
+        #[cfg(all(not(Py_LIMITED_API), Py_3_10))]
+        const CLASS_NAME: &str = "<class 'weakref.CallableProxyType'>";
+        #[cfg(all(not(Py_LIMITED_API), not(Py_3_10)))]
+        const CLASS_NAME: &str = "<class 'weakcallableproxy'>";
+
+        mod python_class {
+            use super::*;
+            use crate::PyTypeCheck;
+            use crate::{py_result_ext::PyResultExt, types::PyDict, types::PyType};
+            use std::ptr;
+
+            fn get_type(py: Python<'_>) -> PyResult<Bound<'_, PyType>> {
+                let globals = PyDict::new(py);
+                py.run(
+                    c"class A:\n    def __call__(self):\n        return 'This class is callable!'\n",
+                    Some(&globals),
+                    None,
+                )?;
+                py.eval(c"A", Some(&globals), None).cast_into::<PyType>()
+            }
+
+            #[test]
+            fn test_weakref_proxy_behavior() -> PyResult<()> {
+                Python::attach(|py| {
+                    let class = get_type(py)?;
+                    let object = class.call0()?;
+                    let reference = PyWeakrefProxy::new(&object)?;
+
+                    assert!(!reference.is(&object));
+                    assert!(reference.upgrade().unwrap().is(&object));
+                    #[cfg(not(Py_LIMITED_API))]
+                    assert_eq!(reference.get_type().to_string(), CLASS_NAME);
+
+                    assert_eq!(reference.getattr("__class__")?.to_string(), "<class 'A'>");
+                    #[cfg(not(Py_LIMITED_API))]
+                    check_repr(&reference, &object, Some("A"))?;
+
+                    assert!(reference
+                        .getattr("__callback__")
+                        .err()
+                        .is_some_and(|err| err.is_instance_of::<PyAttributeError>(py)));
+
+                    assert_eq!(reference.call0()?.to_string(), "This class is callable!");
+
+                    drop(object);
+
+                    assert!(reference.upgrade().is_none());
+                    assert!(reference
+                        .getattr("__class__")
+                        .err()
+                        .is_some_and(|err| err.is_instance_of::<PyReferenceError>(py)));
+                    #[cfg(not(Py_LIMITED_API))]
+                    check_repr(&reference, py.None().bind(py), None)?;
+
+                    assert!(reference
+                        .getattr("__callback__")
+                        .err()
+                        .is_some_and(|err| err.is_instance_of::<PyReferenceError>(py)));
+
+                    assert!(reference
+                        .call0()
+                        .err()
+                        .is_some_and(|err| err.is_instance_of::<PyReferenceError>(py)
+                            & (err.value(py).to_string()
+                                == "weakly-referenced object no longer exists")));
+
+                    Ok(())
+                })
+            }
+
+            #[test]
+            fn test_weakref_upgrade_as() -> PyResult<()> {
+                Python::attach(|py| {
+                    let class = get_type(py)?;
+                    let object = class.call0()?;
+                    let reference = PyWeakrefProxy::new(&object)?;
+
+                    {
+                        // This test is a bit weird but ok.
+                        let obj = reference.upgrade_as::<PyAny>();
+
+                        assert!(obj.is_ok());
+                        let obj = obj.unwrap();
+
+                        assert!(obj.is_some());
+                        assert!(obj.is_some_and(|obj| ptr::eq(obj.as_ptr(), object.as_ptr())
+                            && obj.is_exact_instance(&class)));
+                    }
+
+                    drop(object);
+
+                    {
+                        // This test is a bit weird but ok.
+                        let obj = reference.upgrade_as::<PyAny>();
+
+                        assert!(obj.is_ok());
+                        let obj = obj.unwrap();
+
+                        assert!(obj.is_none());
+                    }
+
+                    Ok(())
+                })
+            }
+
+            #[test]
+            fn test_weakref_upgrade_as_unchecked() -> PyResult<()> {
+                Python::attach(|py| {
+                    let class = get_type(py)?;
+                    let object = class.call0()?;
+                    let reference = PyWeakrefProxy::new(&object)?;
+
+                    {
+                        // This test is a bit weird but ok.
+                        let obj = unsafe { reference.upgrade_as_unchecked::<PyAny>() };
+
+                        assert!(obj.is_some());
+                        assert!(obj.is_some_and(|obj| ptr::eq(obj.as_ptr(), object.as_ptr())
+                            && obj.is_exact_instance(&class)));
+                    }
+
+                    drop(object);
+
+                    {
+                        // This test is a bit weird but ok.
+                        let obj = unsafe { reference.upgrade_as_unchecked::<PyAny>() };
+
+                        assert!(obj.is_none());
+                    }
+
+                    Ok(())
+                })
+            }
+
+            #[test]
+            fn test_weakref_upgrade() -> PyResult<()> {
+                Python::attach(|py| {
+                    let class = get_type(py)?;
+                    let object = class.call0()?;
+                    let reference = PyWeakrefProxy::new(&object)?;
+
+                    assert!(reference.upgrade().is_some());
+                    assert!(reference.upgrade().is_some_and(|obj| obj.is(&object)));
+
+                    drop(object);
+
+                    assert!(reference.upgrade().is_none());
+
+                    Ok(())
+                })
+            }
+
+            #[test]
+            fn test_type_object() -> PyResult<()> {
+                Python::attach(|py| {
+                    let class = get_type(py)?;
+                    let object = class.call0()?;
+                    let reference = PyWeakrefProxy::new(&object)?;
+                    let t = PyWeakrefProxy::classinfo_object(py);
+                    assert!(reference.is_instance(&t)?);
+                    Ok(())
+                })
+            }
+        }
+
+        // under 'abi3-py37' and 'abi3-py38' PyClass cannot be weakreferencable.
+        #[cfg(all(feature = "macros", not(all(Py_LIMITED_API, not(Py_3_9)))))]
+        mod pyo3_pyclass {
+            use super::*;
+            use crate::{pyclass, pymethods, Py};
+            use std::ptr;
+
+            #[pyclass(weakref, crate = "crate")]
+            struct WeakrefablePyClass {}
+
+            #[pymethods(crate = "crate")]
+            impl WeakrefablePyClass {
+                fn __call__(&self) -> &str {
+                    "This class is callable!"
+                }
+            }
+
+            #[test]
+            fn test_weakref_proxy_behavior() -> PyResult<()> {
+                Python::attach(|py| {
+                    let object: Bound<'_, WeakrefablePyClass> =
+                        Bound::new(py, WeakrefablePyClass {})?;
+                    let reference = PyWeakrefProxy::new(&object)?;
+
+                    assert!(!reference.is(&object));
+                    assert!(reference.upgrade().unwrap().is(&object));
+                    #[cfg(not(Py_LIMITED_API))]
+                    assert_eq!(reference.get_type().to_string(), CLASS_NAME);
+
+                    assert_eq!(
+                        reference.getattr("__class__")?.to_string(),
+                        "<class 'builtins.WeakrefablePyClass'>"
+                    );
+                    #[cfg(not(Py_LIMITED_API))]
+                    check_repr(&reference, object.as_any(), Some("WeakrefablePyClass"))?;
+
+                    assert!(reference
+                        .getattr("__callback__")
+                        .err()
+                        .is_some_and(|err| err.is_instance_of::<PyAttributeError>(py)));
+
+                    assert_eq!(reference.call0()?.to_string(), "This class is callable!");
+
+                    drop(object);
+
+                    assert!(reference.upgrade().is_none());
+                    assert!(reference
+                        .getattr("__class__")
+                        .err()
+                        .is_some_and(|err| err.is_instance_of::<PyReferenceError>(py)));
+                    #[cfg(not(Py_LIMITED_API))]
+                    check_repr(&reference, py.None().bind(py), None)?;
+
+                    assert!(reference
+                        .getattr("__callback__")
+                        .err()
+                        .is_some_and(|err| err.is_instance_of::<PyReferenceError>(py)));
+
+                    assert!(reference
+                        .call0()
+                        .err()
+                        .is_some_and(|err| err.is_instance_of::<PyReferenceError>(py)
+                            & (err.value(py).to_string()
+                                == "weakly-referenced object no longer exists")));
+
+                    Ok(())
+                })
+            }
+
+            #[test]
+            fn test_weakref_upgrade_as() -> PyResult<()> {
+                Python::attach(|py| {
+                    let object = Py::new(py, WeakrefablePyClass {})?;
+                    let reference = PyWeakrefProxy::new(object.bind(py))?;
+
+                    {
+                        let obj = reference.upgrade_as::<WeakrefablePyClass>();
+
+                        assert!(obj.is_ok());
+                        let obj = obj.unwrap();
+
+                        assert!(obj.is_some());
+                        assert!(obj.is_some_and(|obj| ptr::eq(obj.as_ptr(), object.as_ptr())));
+                    }
+
+                    drop(object);
+
+                    {
+                        let obj = reference.upgrade_as::<WeakrefablePyClass>();
+
+                        assert!(obj.is_ok());
+                        let obj = obj.unwrap();
+
+                        assert!(obj.is_none());
+                    }
+
+                    Ok(())
+                })
+            }
+
+            #[test]
+            fn test_weakref_upgrade_as_unchecked() -> PyResult<()> {
+                Python::attach(|py| {
+                    let object = Py::new(py, WeakrefablePyClass {})?;
+                    let reference = PyWeakrefProxy::new(object.bind(py))?;
+
+                    {
+                        let obj = unsafe { reference.upgrade_as_unchecked::<WeakrefablePyClass>() };
+
+                        assert!(obj.is_some());
+                        assert!(obj.is_some_and(|obj| ptr::eq(obj.as_ptr(), object.as_ptr())));
+                    }
+
+                    drop(object);
+
+                    {
+                        let obj = unsafe { reference.upgrade_as_unchecked::<WeakrefablePyClass>() };
+
+                        assert!(obj.is_none());
+                    }
+
+                    Ok(())
+                })
+            }
+
+            #[test]
+            fn test_weakref_upgrade() -> PyResult<()> {
+                Python::attach(|py| {
+                    let object = Py::new(py, WeakrefablePyClass {})?;
+                    let reference = PyWeakrefProxy::new(object.bind(py))?;
+
+                    assert!(reference.upgrade().is_some());
+                    assert!(reference.upgrade().is_some_and(|obj| obj.is(&object)));
+
+                    drop(object);
+
+                    assert!(reference.upgrade().is_none());
+
+                    Ok(())
+                })
+            }
+        }
+    }
+}
diff --git a/src/types/weakref/reference.rs b/src/types/weakref/reference.rs
new file mode 100644
index 00000000000..74369a6ba5a
--- /dev/null
+++ b/src/types/weakref/reference.rs
@@ -0,0 +1,517 @@
+use crate::err::PyResult;
+use crate::ffi_ptr_ext::FfiPtrExt;
+use crate::py_result_ext::PyResultExt;
+#[cfg(any(PyPy, GraalPy, Py_LIMITED_API))]
+use crate::sync::PyOnceLock;
+use crate::types::any::PyAny;
+#[cfg(any(PyPy, GraalPy, Py_LIMITED_API))]
+use crate::types::typeobject::PyTypeMethods;
+#[cfg(any(PyPy, GraalPy, Py_LIMITED_API))]
+use crate::types::PyType;
+#[cfg(any(PyPy, GraalPy, Py_LIMITED_API))]
+use crate::Py;
+use crate::{ffi, Borrowed, Bound, BoundObject, IntoPyObject, IntoPyObjectExt};
+
+use super::PyWeakrefMethods;
+
+/// Represents a Python `weakref.ReferenceType`.
+///
+/// In Python this is created by calling `weakref.ref`.
+#[repr(transparent)]
+pub struct PyWeakrefReference(PyAny);
+
+#[cfg(not(any(PyPy, GraalPy, Py_LIMITED_API)))]
+pyobject_subclassable_native_type!(PyWeakrefReference, ffi::PyWeakReference);
+
+#[cfg(not(any(PyPy, GraalPy, Py_LIMITED_API)))]
+pyobject_native_type!(
+    PyWeakrefReference,
+    ffi::PyWeakReference,
+    // TODO: should not be depending on a private symbol here!
+    pyobject_native_static_type_object!(ffi::_PyWeakref_RefType),
+    #module=Some("weakref"),
+    #checkfunction=ffi::PyWeakref_CheckRefExact
+);
+
+// When targeting alternative or multiple interpreters, it is better to not use the internal API.
+#[cfg(any(PyPy, GraalPy, Py_LIMITED_API))]
+pyobject_native_type_core!(
+    PyWeakrefReference,
+    |py| {
+        static TYPE: PyOnceLock<Py<PyType>> = PyOnceLock::new();
+        TYPE.import(py, "weakref", "ref")
+            .unwrap()
+            .as_type_ptr()
+    },
+    #module=Some("weakref"),
+    #checkfunction=ffi::PyWeakref_CheckRef
+);
+
+impl PyWeakrefReference {
+    /// Constructs a new Weak Reference (`weakref.ref`/`weakref.ReferenceType`) for the given object.
+    ///
+    /// Returns a `TypeError` if `object` is not weak referenceable (Most native types and PyClasses without `weakref` flag).
+    ///
+    /// # Examples
+    #[cfg_attr(
+        not(all(feature = "macros", not(all(Py_LIMITED_API, not(Py_3_9))))),
+        doc = "```rust,ignore"
+    )]
+    #[cfg_attr(
+        all(feature = "macros", not(all(Py_LIMITED_API, not(Py_3_9)))),
+        doc = "```rust"
+    )]
+    /// use pyo3::prelude::*;
+    /// use pyo3::types::PyWeakrefReference;
+    ///
+    /// #[pyclass(weakref)]
+    /// struct Foo { /* fields omitted */ }
+    ///
+    /// # fn main() -> PyResult<()> {
+    /// Python::attach(|py| {
+    ///     let foo = Bound::new(py, Foo {})?;
+    ///     let weakref = PyWeakrefReference::new(&foo)?;
+    ///     assert!(
+    ///         // In normal situations where a direct `Bound<'py, Foo>` is required use `upgrade::<Foo>`
+    ///         weakref.upgrade().is_some_and(|obj| obj.is(&foo))
+    ///     );
+    ///
+    ///     let weakref2 = PyWeakrefReference::new(&foo)?;
+    ///     assert!(weakref.is(&weakref2));
+    ///
+    ///     drop(foo);
+    ///
+    ///     assert!(weakref.upgrade().is_none());
+    ///     Ok(())
+    /// })
+    /// # }
+    /// ```
+    pub fn new<'py>(object: &Bound<'py, PyAny>) -> PyResult<Bound<'py, PyWeakrefReference>> {
+        unsafe {
+            Bound::from_owned_ptr_or_err(
+                object.py(),
+                ffi::PyWeakref_NewRef(object.as_ptr(), ffi::Py_None()),
+            )
+            .cast_into_unchecked()
+        }
+    }
+
+    /// Constructs a new Weak Reference (`weakref.ref`/`weakref.ReferenceType`) for the given object with a callback.
+    ///
+    /// Returns a `TypeError` if `object` is not weak referenceable (Most native types and PyClasses without `weakref` flag) or if the `callback` is not callable or None.
+    ///
+    /// # Examples
+    #[cfg_attr(
+        not(all(feature = "macros", not(all(Py_LIMITED_API, not(Py_3_9))))),
+        doc = "```rust,ignore"
+    )]
+    #[cfg_attr(
+        all(feature = "macros", not(all(Py_LIMITED_API, not(Py_3_9)))),
+        doc = "```rust"
+    )]
+    /// use pyo3::prelude::*;
+    /// use pyo3::types::PyWeakrefReference;
+    /// use pyo3::ffi::c_str;
+    ///
+    /// #[pyclass(weakref)]
+    /// struct Foo { /* fields omitted */ }
+    ///
+    /// #[pyfunction]
+    /// fn callback(wref: Bound<'_, PyWeakrefReference>) -> PyResult<()> {
+    ///         let py = wref.py();
+    ///         assert!(wref.upgrade_as::<Foo>()?.is_none());
+    ///         py.run(c"counter = 1", None, None)
+    /// }
+    ///
+    /// # fn main() -> PyResult<()> {
+    /// Python::attach(|py| {
+    ///     py.run(c"counter = 0", None, None)?;
+    ///     assert_eq!(py.eval(c"counter", None, None)?.extract::<u32>()?, 0);
+    ///     let foo = Bound::new(py, Foo{})?;
+    ///
+    ///     // This is fine.
+    ///     let weakref = PyWeakrefReference::new_with(&foo, py.None())?;
+    ///     assert!(weakref.upgrade_as::<Foo>()?.is_some());
+    ///     assert!(
+    ///         // In normal situations where a direct `Bound<'py, Foo>` is required use `upgrade::<Foo>`
+    ///         weakref.upgrade().is_some_and(|obj| obj.is(&foo))
+    ///     );
+    ///     assert_eq!(py.eval(c"counter", None, None)?.extract::<u32>()?, 0);
+    ///
+    ///     let weakref2 = PyWeakrefReference::new_with(&foo, wrap_pyfunction!(callback, py)?)?;
+    ///     assert!(!weakref.is(&weakref2)); // Not the same weakref
+    ///     assert!(weakref.eq(&weakref2)?);  // But Equal, since they point to the same object
+    ///
+    ///     drop(foo);
+    ///
+    ///     assert!(weakref.upgrade_as::<Foo>()?.is_none());
+    ///     assert_eq!(py.eval(c"counter", None, None)?.extract::<u32>()?, 1);
+    ///     Ok(())
+    /// })
+    /// # }
+    /// ```
+    pub fn new_with<'py, C>(
+        object: &Bound<'py, PyAny>,
+        callback: C,
+    ) -> PyResult<Bound<'py, PyWeakrefReference>>
+    where
+        C: IntoPyObject<'py>,
+    {
+        fn inner<'py>(
+            object: &Bound<'py, PyAny>,
+            callback: Borrowed<'_, 'py, PyAny>,
+        ) -> PyResult<Bound<'py, PyWeakrefReference>> {
+            unsafe {
+                Bound::from_owned_ptr_or_err(
+                    object.py(),
+                    ffi::PyWeakref_NewRef(object.as_ptr(), callback.as_ptr()),
+                )
+                .cast_into_unchecked()
+            }
+        }
+
+        let py = object.py();
+        inner(
+            object,
+            callback
+                .into_pyobject_or_pyerr(py)?
+                .into_any()
+                .as_borrowed(),
+        )
+    }
+}
+
+impl<'py> PyWeakrefMethods<'py> for Bound<'py, PyWeakrefReference> {
+    fn upgrade(&self) -> Option<Bound<'py, PyAny>> {
+        let mut obj: *mut ffi::PyObject = std::ptr::null_mut();
+        match unsafe { ffi::compat::PyWeakref_GetRef(self.as_ptr(), &mut obj) } {
+            std::ffi::c_int::MIN..=-1 => panic!("The 'weakref.ReferenceType' instance should be valid (non-null and actually a weakref reference)"),
+            0 => None,
+            1..=std::ffi::c_int::MAX => Some(unsafe { obj.assume_owned_unchecked(self.py()) }),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::types::any::{PyAny, PyAnyMethods};
+    use crate::types::weakref::{PyWeakrefMethods, PyWeakrefReference};
+    use crate::{Bound, PyResult, Python};
+
+    #[cfg(all(not(Py_LIMITED_API), Py_3_10))]
+    const CLASS_NAME: &str = "<class 'weakref.ReferenceType'>";
+    #[cfg(all(not(Py_LIMITED_API), not(Py_3_10)))]
+    const CLASS_NAME: &str = "<class 'weakref'>";
+
+    fn check_repr(
+        reference: &Bound<'_, PyWeakrefReference>,
+        object: Option<(&Bound<'_, PyAny>, &str)>,
+    ) -> PyResult<()> {
+        let repr = reference.repr()?.to_string();
+        let (first_part, second_part) = repr.split_once("; ").unwrap();
+
+        {
+            let (msg, addr) = first_part.split_once("0x").unwrap();
+
+            assert_eq!(msg, "<weakref at ");
+            assert!(addr
+                .to_lowercase()
+                .contains(format!("{:x?}", reference.as_ptr()).split_at(2).1));
+        }
+
+        match object {
+            Some((object, class)) => {
+                let (msg, addr) = second_part.split_once("0x").unwrap();
+
+                // Avoid testing on reprs directly since they the quoting and full path vs class name tends to be changedi undocumented.
+                assert!(msg.starts_with("to '"));
+                assert!(msg.contains(class));
+                assert!(msg.ends_with("' at "));
+
+                assert!(addr
+                    .to_lowercase()
+                    .contains(format!("{:x?}", object.as_ptr()).split_at(2).1));
+            }
+            None => {
+                assert_eq!(second_part, "dead>")
+            }
+        }
+
+        Ok(())
+    }
+
+    mod python_class {
+        use super::*;
+        use crate::PyTypeInfo;
+        use crate::{py_result_ext::PyResultExt, types::PyType};
+        use std::ptr;
+
+        fn get_type(py: Python<'_>) -> PyResult<Bound<'_, PyType>> {
+            py.run(c"class A:\n    pass\n", None, None)?;
+            py.eval(c"A", None, None).cast_into::<PyType>()
+        }
+
+        #[test]
+        fn test_weakref_reference_behavior() -> PyResult<()> {
+            Python::attach(|py| {
+                let class = get_type(py)?;
+                let object = class.call0()?;
+                let reference = PyWeakrefReference::new(&object)?;
+
+                assert!(!reference.is(&object));
+                assert!(reference.upgrade().unwrap().is(&object));
+
+                #[cfg(not(Py_LIMITED_API))]
+                assert_eq!(reference.get_type().to_string(), CLASS_NAME);
+
+                #[cfg(not(Py_LIMITED_API))]
+                assert_eq!(reference.getattr("__class__")?.to_string(), CLASS_NAME);
+
+                #[cfg(not(Py_LIMITED_API))]
+                check_repr(&reference, Some((object.as_any(), "A")))?;
+
+                assert!(reference
+                    .getattr("__callback__")
+                    .is_ok_and(|result| result.is_none()));
+
+                assert!(reference.call0()?.is(&object));
+
+                drop(object);
+
+                assert!(reference.upgrade().is_none());
+                #[cfg(not(Py_LIMITED_API))]
+                assert_eq!(reference.getattr("__class__")?.to_string(), CLASS_NAME);
+                check_repr(&reference, None)?;
+
+                assert!(reference
+                    .getattr("__callback__")
+                    .is_ok_and(|result| result.is_none()));
+
+                assert!(reference.call0()?.is_none());
+
+                Ok(())
+            })
+        }
+
+        #[test]
+        fn test_weakref_upgrade_as() -> PyResult<()> {
+            Python::attach(|py| {
+                let class = get_type(py)?;
+                let object = class.call0()?;
+                let reference = PyWeakrefReference::new(&object)?;
+
+                {
+                    // This test is a bit weird but ok.
+                    let obj = reference.upgrade_as::<PyAny>();
+
+                    assert!(obj.is_ok());
+                    let obj = obj.unwrap();
+
+                    assert!(obj.is_some());
+                    assert!(obj.is_some_and(|obj| ptr::eq(obj.as_ptr(), object.as_ptr())
+                        && obj.is_exact_instance(&class)));
+                }
+
+                drop(object);
+
+                {
+                    // This test is a bit weird but ok.
+                    let obj = reference.upgrade_as::<PyAny>();
+
+                    assert!(obj.is_ok());
+                    let obj = obj.unwrap();
+
+                    assert!(obj.is_none());
+                }
+
+                Ok(())
+            })
+        }
+
+        #[test]
+        fn test_weakref_upgrade_as_unchecked() -> PyResult<()> {
+            Python::attach(|py| {
+                let class = get_type(py)?;
+                let object = class.call0()?;
+                let reference = PyWeakrefReference::new(&object)?;
+
+                {
+                    // This test is a bit weird but ok.
+                    let obj = unsafe { reference.upgrade_as_unchecked::<PyAny>() };
+
+                    assert!(obj.is_some());
+                    assert!(obj.is_some_and(|obj| ptr::eq(obj.as_ptr(), object.as_ptr())
+                        && obj.is_exact_instance(&class)));
+                }
+
+                drop(object);
+
+                {
+                    // This test is a bit weird but ok.
+                    let obj = unsafe { reference.upgrade_as_unchecked::<PyAny>() };
+
+                    assert!(obj.is_none());
+                }
+
+                Ok(())
+            })
+        }
+
+        #[test]
+        fn test_weakref_upgrade() -> PyResult<()> {
+            Python::attach(|py| {
+                let class = get_type(py)?;
+                let object = class.call0()?;
+                let reference = PyWeakrefReference::new(&object)?;
+
+                assert!(reference.call0()?.is(&object));
+                assert!(reference.upgrade().is_some());
+                assert!(reference.upgrade().is_some_and(|obj| obj.is(&object)));
+
+                drop(object);
+
+                assert!(reference.call0()?.is_none());
+                assert!(reference.upgrade().is_none());
+
+                Ok(())
+            })
+        }
+
+        #[test]
+        fn test_type_object() -> PyResult<()> {
+            Python::attach(|py| {
+                let class = get_type(py)?;
+                let object = class.call0()?;
+                let reference = PyWeakrefReference::new(&object)?;
+
+                assert!(reference.is_instance(&PyWeakrefReference::type_object(py))?);
+                Ok(())
+            })
+        }
+    }
+
+    // under 'abi3-py37' and 'abi3-py38' PyClass cannot be weakreferencable.
+    #[cfg(all(feature = "macros", not(all(Py_LIMITED_API, not(Py_3_9)))))]
+    mod pyo3_pyclass {
+        use super::*;
+        use crate::{pyclass, Py};
+        use std::ptr;
+
+        #[pyclass(weakref, crate = "crate")]
+        struct WeakrefablePyClass {}
+
+        #[test]
+        fn test_weakref_reference_behavior() -> PyResult<()> {
+            Python::attach(|py| {
+                let object: Bound<'_, WeakrefablePyClass> = Bound::new(py, WeakrefablePyClass {})?;
+                let reference = PyWeakrefReference::new(&object)?;
+
+                assert!(!reference.is(&object));
+                assert!(reference.upgrade().unwrap().is(&object));
+                #[cfg(not(Py_LIMITED_API))]
+                assert_eq!(reference.get_type().to_string(), CLASS_NAME);
+
+                #[cfg(not(Py_LIMITED_API))]
+                assert_eq!(reference.getattr("__class__")?.to_string(), CLASS_NAME);
+                #[cfg(not(Py_LIMITED_API))]
+                check_repr(&reference, Some((object.as_any(), "WeakrefablePyClass")))?;
+
+                assert!(reference
+                    .getattr("__callback__")
+                    .is_ok_and(|result| result.is_none()));
+
+                assert!(reference.call0()?.is(&object));
+
+                drop(object);
+
+                assert!(reference.upgrade().is_none());
+                #[cfg(not(Py_LIMITED_API))]
+                assert_eq!(reference.getattr("__class__")?.to_string(), CLASS_NAME);
+                check_repr(&reference, None)?;
+
+                assert!(reference
+                    .getattr("__callback__")
+                    .is_ok_and(|result| result.is_none()));
+
+                assert!(reference.call0()?.is_none());
+
+                Ok(())
+            })
+        }
+
+        #[test]
+        fn test_weakref_upgrade_as() -> PyResult<()> {
+            Python::attach(|py| {
+                let object = Py::new(py, WeakrefablePyClass {})?;
+                let reference = PyWeakrefReference::new(object.bind(py))?;
+
+                {
+                    let obj = reference.upgrade_as::<WeakrefablePyClass>();
+
+                    assert!(obj.is_ok());
+                    let obj = obj.unwrap();
+
+                    assert!(obj.is_some());
+                    assert!(obj.is_some_and(|obj| ptr::eq(obj.as_ptr(), object.as_ptr())));
+                }
+
+                drop(object);
+
+                {
+                    let obj = reference.upgrade_as::<WeakrefablePyClass>();
+
+                    assert!(obj.is_ok());
+                    let obj = obj.unwrap();
+
+                    assert!(obj.is_none());
+                }
+
+                Ok(())
+            })
+        }
+
+        #[test]
+        fn test_weakref_upgrade_as_unchecked() -> PyResult<()> {
+            Python::attach(|py| {
+                let object = Py::new(py, WeakrefablePyClass {})?;
+                let reference = PyWeakrefReference::new(object.bind(py))?;
+
+                {
+                    let obj = unsafe { reference.upgrade_as_unchecked::<WeakrefablePyClass>() };
+
+                    assert!(obj.is_some());
+                    assert!(obj.is_some_and(|obj| ptr::eq(obj.as_ptr(), object.as_ptr())));
+                }
+
+                drop(object);
+
+                {
+                    let obj = unsafe { reference.upgrade_as_unchecked::<WeakrefablePyClass>() };
+
+                    assert!(obj.is_none());
+                }
+
+                Ok(())
+            })
+        }
+
+        #[test]
+        fn test_weakref_upgrade() -> PyResult<()> {
+            Python::attach(|py| {
+                let object = Py::new(py, WeakrefablePyClass {})?;
+                let reference = PyWeakrefReference::new(object.bind(py))?;
+
+                assert!(reference.call0()?.is(&object));
+                assert!(reference.upgrade().is_some());
+                assert!(reference.upgrade().is_some_and(|obj| obj.is(&object)));
+
+                drop(object);
+
+                assert!(reference.call0()?.is_none());
+                assert!(reference.upgrade().is_none());
+
+                Ok(())
+            })
+        }
+    }
+}
diff --git a/src/version.rs b/src/version.rs
index ea9e9d406d7..48d8b5d36a8 100644
--- a/src/version.rs
+++ b/src/version.rs
@@ -1,21 +1,21 @@
 /// Represents the major, minor, and patch (if any) versions of this interpreter.
 ///
-/// This struct is usually created with [`Python::version`].
+/// This struct is usually created with [`Python::version_info`].
 ///
 /// # Examples
 ///
 /// ```rust
 /// # use pyo3::Python;
-/// Python::with_gil(|py| {
+/// Python::attach(|py| {
 ///     // PyO3 supports Python 3.7 and up.
 ///     assert!(py.version_info() >= (3, 7));
 ///     assert!(py.version_info() >= (3, 7, 0));
 /// });
 /// ```
 ///
-/// [`Python::version`]: crate::marker::Python::version
+/// [`Python::version_info`]: crate::marker::Python::version_info
 #[derive(Debug)]
-pub struct PythonVersionInfo<'py> {
+pub struct PythonVersionInfo<'a> {
     /// Python major version (e.g. `3`).
     pub major: u8,
     /// Python minor version (e.g. `11`).
@@ -23,12 +23,12 @@ pub struct PythonVersionInfo<'py> {
     /// Python patch version (e.g. `0`).
     pub patch: u8,
     /// Python version suffix, if applicable (e.g. `a0`).
-    pub suffix: Option<&'py str>,
+    pub suffix: Option<&'a str>,
 }
 
-impl<'py> PythonVersionInfo<'py> {
+impl<'a> PythonVersionInfo<'a> {
     /// Parses a hard-coded Python interpreter version string (e.g. 3.9.0a4+).
-    pub(crate) fn from_str(version_number_str: &'py str) -> Result<Self, &str> {
+    pub(crate) fn from_str(version_number_str: &'a str) -> Result<PythonVersionInfo<'a>, &'a str> {
         fn split_and_parse_number(version_part: &str) -> (u8, Option<&str>) {
             match version_part.find(|c: char| !c.is_ascii_digit()) {
                 None => (version_part.parse().unwrap(), None),
@@ -40,13 +40,10 @@ impl<'py> PythonVersionInfo<'py> {
             }
         }
 
-        let mut parts = version_number_str.split('.');
+        let mut parts = version_number_str.splitn(3, '.');
         let major_str = parts.next().ok_or("Python major version missing")?;
         let minor_str = parts.next().ok_or("Python minor version missing")?;
         let patch_str = parts.next();
-        if parts.next().is_some() {
-            return Err("Python version string has too many parts");
-        };
 
         let major = major_str
             .parse()
@@ -102,7 +99,7 @@ mod test {
     use crate::Python;
     #[test]
     fn test_python_version_info() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let version = py.version_info();
             #[cfg(Py_3_7)]
             assert!(version >= (3, 7));
@@ -131,13 +128,20 @@ mod test {
     fn test_python_version_info_parse() {
         assert!(PythonVersionInfo::from_str("3.5.0a1").unwrap() >= (3, 5, 0));
         assert!(PythonVersionInfo::from_str("3.5+").unwrap() >= (3, 5, 0));
-        assert!(PythonVersionInfo::from_str("3.5+").unwrap() == (3, 5, 0));
-        assert!(PythonVersionInfo::from_str("3.5+").unwrap() != (3, 5, 1));
+        assert_eq!(PythonVersionInfo::from_str("3.5+").unwrap(), (3, 5, 0));
+        assert_ne!(PythonVersionInfo::from_str("3.5+").unwrap(), (3, 5, 1));
         assert!(PythonVersionInfo::from_str("3.5.2a1+").unwrap() < (3, 5, 3));
-        assert!(PythonVersionInfo::from_str("3.5.2a1+").unwrap() == (3, 5, 2));
-        assert!(PythonVersionInfo::from_str("3.5.2a1+").unwrap() == (3, 5));
-        assert!(PythonVersionInfo::from_str("3.5+").unwrap() == (3, 5));
+        assert_eq!(PythonVersionInfo::from_str("3.5.2a1+").unwrap(), (3, 5, 2));
+        assert_eq!(PythonVersionInfo::from_str("3.5.2a1+").unwrap(), (3, 5));
+        assert_eq!(PythonVersionInfo::from_str("3.5+").unwrap(), (3, 5));
         assert!(PythonVersionInfo::from_str("3.5.2a1+").unwrap() < (3, 6));
         assert!(PythonVersionInfo::from_str("3.5.2a1+").unwrap() > (3, 4));
+        assert!(PythonVersionInfo::from_str("3.11.3+chromium.29").unwrap() >= (3, 11, 3));
+        assert_eq!(
+            PythonVersionInfo::from_str("3.11.3+chromium.29")
+                .unwrap()
+                .suffix,
+            Some("+chromium.29")
+        );
     }
 }
diff --git a/tests/test_anyhow.rs b/tests/test_anyhow.rs
index 1807cfe9708..ff09e9d296f 100644
--- a/tests/test_anyhow.rs
+++ b/tests/test_anyhow.rs
@@ -1,8 +1,10 @@
 #![cfg(feature = "anyhow")]
 
+use pyo3::wrap_pyfunction;
+
 #[test]
 fn test_anyhow_py_function_ok_result() {
-    use pyo3::{py_run, pyfunction, wrap_pyfunction, Python};
+    use pyo3::{py_run, pyfunction, Python};
 
     #[pyfunction]
     #[allow(clippy::unnecessary_wraps)]
@@ -10,7 +12,7 @@ fn test_anyhow_py_function_ok_result() {
         Ok(String::from("OK buddy"))
     }
 
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let func = wrap_pyfunction!(produce_ok_result)(py).unwrap();
 
         py_run!(
@@ -26,25 +28,18 @@ fn test_anyhow_py_function_ok_result() {
 #[test]
 fn test_anyhow_py_function_err_result() {
     use pyo3::prelude::PyDictMethods;
-    use pyo3::{pyfunction, types::PyDict, wrap_pyfunction, Python};
+    use pyo3::{pyfunction, types::PyDict, Python};
 
     #[pyfunction]
     fn produce_err_result() -> anyhow::Result<String> {
         anyhow::bail!("error time")
     }
 
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let func = wrap_pyfunction!(produce_err_result)(py).unwrap();
-        let locals = PyDict::new_bound(py);
+        let locals = PyDict::new(py);
         locals.set_item("func", func).unwrap();
 
-        py.run_bound(
-            r#"
-            func()
-            "#,
-            None,
-            Some(&locals),
-        )
-        .unwrap_err();
+        py.run(c"func()", None, Some(&locals)).unwrap_err();
     });
 }
diff --git a/tests/test_append_to_inittab.rs b/tests/test_append_to_inittab.rs
index 00cccdbb49e..2da4f29efb2 100644
--- a/tests/test_append_to_inittab.rs
+++ b/tests/test_append_to_inittab.rs
@@ -1,4 +1,5 @@
 #![cfg(all(feature = "macros", not(PyPy)))]
+
 use pyo3::prelude::*;
 
 #[pyfunction]
@@ -6,27 +7,50 @@ fn foo() -> usize {
     123
 }
 
-#[pymodule]
-fn module_with_functions(_py: Python<'_>, m: &PyModule) -> PyResult<()> {
-    m.add_function(wrap_pyfunction!(foo, m)?).unwrap();
+#[pymodule(gil_used = false)]
+fn module_fn_with_functions(m: &Bound<'_, PyModule>) -> PyResult<()> {
+    m.add_function(wrap_pyfunction!(foo, m)?)?;
     Ok(())
 }
 
-#[cfg(not(PyPy))]
+#[pymodule(gil_used = false)]
+mod module_mod_with_functions {
+    #[pymodule_export]
+    use super::foo;
+}
+
+#[cfg(not(any(PyPy, GraalPy)))]
 #[test]
 fn test_module_append_to_inittab() {
     use pyo3::append_to_inittab;
-    append_to_inittab!(module_with_functions);
-    Python::with_gil(|py| {
-        py.run_bound(
-            r#"
-import module_with_functions
-assert module_with_functions.foo() == 123
+
+    append_to_inittab!(module_fn_with_functions);
+
+    append_to_inittab!(module_mod_with_functions);
+
+    Python::attach(|py| {
+        py.run(
+            cr#"
+import module_fn_with_functions
+assert module_fn_with_functions.foo() == 123
+"#,
+            None,
+            None,
+        )
+        .map_err(|e| e.display(py))
+        .unwrap();
+    });
+
+    Python::attach(|py| {
+        py.run(
+            cr#"
+import module_mod_with_functions
+assert module_mod_with_functions.foo() == 123
 "#,
             None,
             None,
         )
         .map_err(|e| e.display(py))
         .unwrap();
-    })
+    });
 }
diff --git a/tests/test_arithmetics.rs b/tests/test_arithmetics.rs
index f336140e432..bf3f99c3462 100644
--- a/tests/test_arithmetics.rs
+++ b/tests/test_arithmetics.rs
@@ -1,11 +1,10 @@
 #![cfg(feature = "macros")]
 
 use pyo3::class::basic::CompareOp;
-use pyo3::prelude::*;
 use pyo3::py_run;
+use pyo3::{prelude::*, BoundObject};
 
-#[path = "../src/tests/common.rs"]
-mod common;
+mod test_utils;
 
 #[pyclass]
 struct UnaryArithmetic {
@@ -35,6 +34,11 @@ impl UnaryArithmetic {
         Self::new(self.inner.abs())
     }
 
+    fn __invert__(&self) -> Self {
+        Self::new(self.inner.recip())
+    }
+
+    #[pyo3(signature=(_ndigits=None))]
     fn __round__(&self, _ndigits: Option<u32>) -> Self {
         Self::new(self.inner.round())
     }
@@ -42,13 +46,23 @@ impl UnaryArithmetic {
 
 #[test]
 fn unary_arithmetic() {
-    Python::with_gil(|py| {
-        let c = PyCell::new(py, UnaryArithmetic::new(2.7)).unwrap();
+    Python::attach(|py| {
+        let c = Py::new(py, UnaryArithmetic::new(2.7)).unwrap();
         py_run!(py, c, "assert repr(-c) == 'UA(-2.7)'");
         py_run!(py, c, "assert repr(+c) == 'UA(2.7)'");
         py_run!(py, c, "assert repr(abs(c)) == 'UA(2.7)'");
+        py_run!(py, c, "assert repr(~c) == 'UA(0.37037037037037035)'");
         py_run!(py, c, "assert repr(round(c)) == 'UA(3)'");
         py_run!(py, c, "assert repr(round(c, 1)) == 'UA(3)'");
+
+        let c: Bound<'_, PyAny> = c.extract(py).unwrap();
+        assert_py_eq!(c.neg().unwrap().repr().unwrap().as_any(), "UA(-2.7)");
+        assert_py_eq!(c.pos().unwrap().repr().unwrap().as_any(), "UA(2.7)");
+        assert_py_eq!(c.abs().unwrap().repr().unwrap().as_any(), "UA(2.7)");
+        assert_py_eq!(
+            c.bitnot().unwrap().repr().unwrap().as_any(),
+            "UA(0.37037037037037035)"
+        );
     });
 }
 
@@ -76,8 +90,8 @@ impl Indexable {
 
 #[test]
 fn indexable() {
-    Python::with_gil(|py| {
-        let i = PyCell::new(py, Indexable(5)).unwrap();
+    Python::attach(|py| {
+        let i = Py::new(py, Indexable(5)).unwrap();
         py_run!(py, i, "assert int(i) == 5");
         py_run!(py, i, "assert [0, 1, 2, 3, 4, 5][i] == 5");
         py_run!(py, i, "assert float(i) == 5.0");
@@ -135,9 +149,9 @@ impl InPlaceOperations {
 
 #[test]
 fn inplace_operations() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let init = |value, code| {
-            let c = PyCell::new(py, InPlaceOperations { value }).unwrap();
+            let c = Py::new(py, InPlaceOperations { value }).unwrap();
             py_run!(py, c, code);
         };
 
@@ -166,56 +180,77 @@ impl BinaryArithmetic {
         "BA"
     }
 
-    fn __add__(&self, rhs: &PyAny) -> String {
-        format!("BA + {:?}", rhs)
+    fn __add__(&self, rhs: &Bound<'_, PyAny>) -> String {
+        format!("BA + {rhs:?}")
+    }
+
+    fn __sub__(&self, rhs: &Bound<'_, PyAny>) -> String {
+        format!("BA - {rhs:?}")
+    }
+
+    fn __mul__(&self, rhs: &Bound<'_, PyAny>) -> String {
+        format!("BA * {rhs:?}")
+    }
+
+    fn __matmul__(&self, rhs: &Bound<'_, PyAny>) -> String {
+        format!("BA @ {rhs:?}")
+    }
+
+    fn __truediv__(&self, rhs: &Bound<'_, PyAny>) -> String {
+        format!("BA / {rhs:?}")
     }
 
-    fn __sub__(&self, rhs: &PyAny) -> String {
-        format!("BA - {:?}", rhs)
+    fn __floordiv__(&self, rhs: &Bound<'_, PyAny>) -> String {
+        format!("BA // {rhs:?}")
     }
 
-    fn __mul__(&self, rhs: &PyAny) -> String {
-        format!("BA * {:?}", rhs)
+    fn __mod__(&self, rhs: &Bound<'_, PyAny>) -> String {
+        format!("BA % {rhs:?}")
     }
 
-    fn __truediv__(&self, rhs: &PyAny) -> String {
-        format!("BA / {:?}", rhs)
+    fn __divmod__(&self, rhs: &Bound<'_, PyAny>) -> String {
+        format!("divmod(BA, {rhs:?})")
     }
 
-    fn __lshift__(&self, rhs: &PyAny) -> String {
-        format!("BA << {:?}", rhs)
+    fn __lshift__(&self, rhs: &Bound<'_, PyAny>) -> String {
+        format!("BA << {rhs:?}")
     }
 
-    fn __rshift__(&self, rhs: &PyAny) -> String {
-        format!("BA >> {:?}", rhs)
+    fn __rshift__(&self, rhs: &Bound<'_, PyAny>) -> String {
+        format!("BA >> {rhs:?}")
     }
 
-    fn __and__(&self, rhs: &PyAny) -> String {
-        format!("BA & {:?}", rhs)
+    fn __and__(&self, rhs: &Bound<'_, PyAny>) -> String {
+        format!("BA & {rhs:?}")
     }
 
-    fn __xor__(&self, rhs: &PyAny) -> String {
-        format!("BA ^ {:?}", rhs)
+    fn __xor__(&self, rhs: &Bound<'_, PyAny>) -> String {
+        format!("BA ^ {rhs:?}")
     }
 
-    fn __or__(&self, rhs: &PyAny) -> String {
-        format!("BA | {:?}", rhs)
+    fn __or__(&self, rhs: &Bound<'_, PyAny>) -> String {
+        format!("BA | {rhs:?}")
     }
 
-    fn __pow__(&self, rhs: &PyAny, mod_: Option<u32>) -> String {
-        format!("BA ** {:?} (mod: {:?})", rhs, mod_)
+    fn __pow__(&self, rhs: &Bound<'_, PyAny>, mod_: Option<u32>) -> String {
+        format!("BA ** {rhs:?} (mod: {mod_:?})")
     }
 }
 
 #[test]
 fn binary_arithmetic() {
-    Python::with_gil(|py| {
-        let c = PyCell::new(py, BinaryArithmetic {}).unwrap();
+    Python::attach(|py| {
+        let c = Py::new(py, BinaryArithmetic {}).unwrap();
         py_run!(py, c, "assert c + c == 'BA + BA'");
         py_run!(py, c, "assert c.__add__(c) == 'BA + BA'");
         py_run!(py, c, "assert c + 1 == 'BA + 1'");
         py_run!(py, c, "assert c - 1 == 'BA - 1'");
         py_run!(py, c, "assert c * 1 == 'BA * 1'");
+        py_run!(py, c, "assert c @ 1 == 'BA @ 1'");
+        py_run!(py, c, "assert c / 1 == 'BA / 1'");
+        py_run!(py, c, "assert c // 1 == 'BA // 1'");
+        py_run!(py, c, "assert c % 1 == 'BA % 1'");
+        py_run!(py, c, "assert divmod(c, 1) == 'divmod(BA, 1)'");
         py_run!(py, c, "assert c << 1 == 'BA << 1'");
         py_run!(py, c, "assert c >> 1 == 'BA >> 1'");
         py_run!(py, c, "assert c & 1 == 'BA & 1'");
@@ -229,6 +264,11 @@ fn binary_arithmetic() {
         py_expect_exception!(py, c, "1 + c", PyTypeError);
         py_expect_exception!(py, c, "1 - c", PyTypeError);
         py_expect_exception!(py, c, "1 * c", PyTypeError);
+        py_expect_exception!(py, c, "1 @ c", PyTypeError);
+        py_expect_exception!(py, c, "1 / c", PyTypeError);
+        py_expect_exception!(py, c, "1 // c", PyTypeError);
+        py_expect_exception!(py, c, "1 % c", PyTypeError);
+        py_expect_exception!(py, c, "divmod(1, c)", PyTypeError);
         py_expect_exception!(py, c, "1 << c", PyTypeError);
         py_expect_exception!(py, c, "1 >> c", PyTypeError);
         py_expect_exception!(py, c, "1 & c", PyTypeError);
@@ -238,11 +278,15 @@ fn binary_arithmetic() {
 
         py_run!(py, c, "assert pow(c, 1, 100) == 'BA ** 1 (mod: Some(100))'");
 
-        let c: Bound<'_, PyAny> = c.extract().unwrap();
+        let c: Bound<'_, PyAny> = c.extract(py).unwrap();
         assert_py_eq!(c.add(&c).unwrap(), "BA + BA");
         assert_py_eq!(c.sub(&c).unwrap(), "BA - BA");
         assert_py_eq!(c.mul(&c).unwrap(), "BA * BA");
+        assert_py_eq!(c.matmul(&c).unwrap(), "BA @ BA");
         assert_py_eq!(c.div(&c).unwrap(), "BA / BA");
+        assert_py_eq!(c.floor_div(&c).unwrap(), "BA // BA");
+        assert_py_eq!(c.rem(&c).unwrap(), "BA % BA");
+        assert_py_eq!(c.divmod(&c).unwrap(), "divmod(BA, BA)");
         assert_py_eq!(c.lshift(&c).unwrap(), "BA << BA");
         assert_py_eq!(c.rshift(&c).unwrap(), "BA >> BA");
         assert_py_eq!(c.bitand(&c).unwrap(), "BA & BA");
@@ -257,47 +301,47 @@ struct RhsArithmetic {}
 
 #[pymethods]
 impl RhsArithmetic {
-    fn __radd__(&self, other: &PyAny) -> String {
-        format!("{:?} + RA", other)
+    fn __radd__(&self, other: &Bound<'_, PyAny>) -> String {
+        format!("{other:?} + RA")
     }
 
-    fn __rsub__(&self, other: &PyAny) -> String {
-        format!("{:?} - RA", other)
+    fn __rsub__(&self, other: &Bound<'_, PyAny>) -> String {
+        format!("{other:?} - RA")
     }
 
-    fn __rmul__(&self, other: &PyAny) -> String {
-        format!("{:?} * RA", other)
+    fn __rmul__(&self, other: &Bound<'_, PyAny>) -> String {
+        format!("{other:?} * RA")
     }
 
-    fn __rlshift__(&self, other: &PyAny) -> String {
-        format!("{:?} << RA", other)
+    fn __rlshift__(&self, other: &Bound<'_, PyAny>) -> String {
+        format!("{other:?} << RA")
     }
 
-    fn __rrshift__(&self, other: &PyAny) -> String {
-        format!("{:?} >> RA", other)
+    fn __rrshift__(&self, other: &Bound<'_, PyAny>) -> String {
+        format!("{other:?} >> RA")
     }
 
-    fn __rand__(&self, other: &PyAny) -> String {
-        format!("{:?} & RA", other)
+    fn __rand__(&self, other: &Bound<'_, PyAny>) -> String {
+        format!("{other:?} & RA")
     }
 
-    fn __rxor__(&self, other: &PyAny) -> String {
-        format!("{:?} ^ RA", other)
+    fn __rxor__(&self, other: &Bound<'_, PyAny>) -> String {
+        format!("{other:?} ^ RA")
     }
 
-    fn __ror__(&self, other: &PyAny) -> String {
-        format!("{:?} | RA", other)
+    fn __ror__(&self, other: &Bound<'_, PyAny>) -> String {
+        format!("{other:?} | RA")
     }
 
-    fn __rpow__(&self, other: &PyAny, _mod: Option<&PyAny>) -> String {
-        format!("{:?} ** RA", other)
+    fn __rpow__(&self, other: &Bound<'_, PyAny>, _mod: Option<&Bound<'_, PyAny>>) -> String {
+        format!("{other:?} ** RA")
     }
 }
 
 #[test]
 fn rhs_arithmetic() {
-    Python::with_gil(|py| {
-        let c = PyCell::new(py, RhsArithmetic {}).unwrap();
+    Python::attach(|py| {
+        let c = Py::new(py, RhsArithmetic {}).unwrap();
         py_run!(py, c, "assert c.__radd__(1) == '1 + RA'");
         py_run!(py, c, "assert 1 + c == '1 + RA'");
         py_run!(py, c, "assert c.__rsub__(1) == '1 - RA'");
@@ -334,99 +378,99 @@ impl LhsAndRhs {
     //     "BA"
     // }
 
-    fn __add__(lhs: PyRef<'_, Self>, rhs: &PyAny) -> String {
-        format!("{:?} + {:?}", lhs, rhs)
+    fn __add__(lhs: PyRef<'_, Self>, rhs: &Bound<'_, PyAny>) -> String {
+        format!("{lhs:?} + {rhs:?}")
     }
 
-    fn __sub__(lhs: PyRef<'_, Self>, rhs: &PyAny) -> String {
-        format!("{:?} - {:?}", lhs, rhs)
+    fn __sub__(lhs: PyRef<'_, Self>, rhs: &Bound<'_, PyAny>) -> String {
+        format!("{lhs:?} - {rhs:?}")
     }
 
-    fn __mul__(lhs: PyRef<'_, Self>, rhs: &PyAny) -> String {
-        format!("{:?} * {:?}", lhs, rhs)
+    fn __mul__(lhs: PyRef<'_, Self>, rhs: &Bound<'_, PyAny>) -> String {
+        format!("{lhs:?} * {rhs:?}")
     }
 
-    fn __lshift__(lhs: PyRef<'_, Self>, rhs: &PyAny) -> String {
-        format!("{:?} << {:?}", lhs, rhs)
+    fn __lshift__(lhs: PyRef<'_, Self>, rhs: &Bound<'_, PyAny>) -> String {
+        format!("{lhs:?} << {rhs:?}")
     }
 
-    fn __rshift__(lhs: PyRef<'_, Self>, rhs: &PyAny) -> String {
-        format!("{:?} >> {:?}", lhs, rhs)
+    fn __rshift__(lhs: PyRef<'_, Self>, rhs: &Bound<'_, PyAny>) -> String {
+        format!("{lhs:?} >> {rhs:?}")
     }
 
-    fn __and__(lhs: PyRef<'_, Self>, rhs: &PyAny) -> String {
-        format!("{:?} & {:?}", lhs, rhs)
+    fn __and__(lhs: PyRef<'_, Self>, rhs: &Bound<'_, PyAny>) -> String {
+        format!("{lhs:?} & {rhs:?}")
     }
 
-    fn __xor__(lhs: PyRef<'_, Self>, rhs: &PyAny) -> String {
-        format!("{:?} ^ {:?}", lhs, rhs)
+    fn __xor__(lhs: PyRef<'_, Self>, rhs: &Bound<'_, PyAny>) -> String {
+        format!("{lhs:?} ^ {rhs:?}")
     }
 
-    fn __or__(lhs: PyRef<'_, Self>, rhs: &PyAny) -> String {
-        format!("{:?} | {:?}", lhs, rhs)
+    fn __or__(lhs: PyRef<'_, Self>, rhs: &Bound<'_, PyAny>) -> String {
+        format!("{lhs:?} | {rhs:?}")
     }
 
-    fn __pow__(lhs: PyRef<'_, Self>, rhs: &PyAny, _mod: Option<usize>) -> String {
-        format!("{:?} ** {:?}", lhs, rhs)
+    fn __pow__(lhs: PyRef<'_, Self>, rhs: &Bound<'_, PyAny>, _mod: Option<usize>) -> String {
+        format!("{lhs:?} ** {rhs:?}")
     }
 
-    fn __matmul__(lhs: PyRef<'_, Self>, rhs: &PyAny) -> String {
-        format!("{:?} @ {:?}", lhs, rhs)
+    fn __matmul__(lhs: PyRef<'_, Self>, rhs: &Bound<'_, PyAny>) -> String {
+        format!("{lhs:?} @ {rhs:?}")
     }
 
-    fn __radd__(&self, other: &PyAny) -> String {
-        format!("{:?} + RA", other)
+    fn __radd__(&self, other: &Bound<'_, PyAny>) -> String {
+        format!("{other:?} + RA")
     }
 
-    fn __rsub__(&self, other: &PyAny) -> String {
-        format!("{:?} - RA", other)
+    fn __rsub__(&self, other: &Bound<'_, PyAny>) -> String {
+        format!("{other:?} - RA")
     }
 
-    fn __rmul__(&self, other: &PyAny) -> String {
-        format!("{:?} * RA", other)
+    fn __rmul__(&self, other: &Bound<'_, PyAny>) -> String {
+        format!("{other:?} * RA")
     }
 
-    fn __rlshift__(&self, other: &PyAny) -> String {
-        format!("{:?} << RA", other)
+    fn __rlshift__(&self, other: &Bound<'_, PyAny>) -> String {
+        format!("{other:?} << RA")
     }
 
-    fn __rrshift__(&self, other: &PyAny) -> String {
-        format!("{:?} >> RA", other)
+    fn __rrshift__(&self, other: &Bound<'_, PyAny>) -> String {
+        format!("{other:?} >> RA")
     }
 
-    fn __rand__(&self, other: &PyAny) -> String {
-        format!("{:?} & RA", other)
+    fn __rand__(&self, other: &Bound<'_, PyAny>) -> String {
+        format!("{other:?} & RA")
     }
 
-    fn __rxor__(&self, other: &PyAny) -> String {
-        format!("{:?} ^ RA", other)
+    fn __rxor__(&self, other: &Bound<'_, PyAny>) -> String {
+        format!("{other:?} ^ RA")
     }
 
-    fn __ror__(&self, other: &PyAny) -> String {
-        format!("{:?} | RA", other)
+    fn __ror__(&self, other: &Bound<'_, PyAny>) -> String {
+        format!("{other:?} | RA")
     }
 
-    fn __rpow__(&self, other: &PyAny, _mod: Option<&PyAny>) -> String {
-        format!("{:?} ** RA", other)
+    fn __rpow__(&self, other: &Bound<'_, PyAny>, _mod: Option<&Bound<'_, PyAny>>) -> String {
+        format!("{other:?} ** RA")
     }
 
-    fn __rmatmul__(&self, other: &PyAny) -> String {
-        format!("{:?} @ RA", other)
+    fn __rmatmul__(&self, other: &Bound<'_, PyAny>) -> String {
+        format!("{other:?} @ RA")
     }
 
-    fn __rtruediv__(&self, other: &PyAny) -> String {
-        format!("{:?} / RA", other)
+    fn __rtruediv__(&self, other: &Bound<'_, PyAny>) -> String {
+        format!("{other:?} / RA")
     }
 
-    fn __rfloordiv__(&self, other: &PyAny) -> String {
-        format!("{:?} // RA", other)
+    fn __rfloordiv__(&self, other: &Bound<'_, PyAny>) -> String {
+        format!("{other:?} // RA")
     }
 }
 
 #[test]
 fn lhs_fellback_to_rhs() {
-    Python::with_gil(|py| {
-        let c = PyCell::new(py, LhsAndRhs {}).unwrap();
+    Python::attach(|py| {
+        let c = Py::new(py, LhsAndRhs {}).unwrap();
         // If the light hand value is `LhsAndRhs`, LHS is used.
         py_run!(py, c, "assert c + 1 == 'LR + 1'");
         py_run!(py, c, "assert c - 1 == 'LR - 1'");
@@ -461,7 +505,7 @@ impl RichComparisons {
         "RC"
     }
 
-    fn __richcmp__(&self, other: &PyAny, op: CompareOp) -> String {
+    fn __richcmp__(&self, other: &Bound<'_, PyAny>, op: CompareOp) -> String {
         match op {
             CompareOp::Lt => format!("{} < {:?}", self.__repr__(), other),
             CompareOp::Le => format!("{} <= {:?}", self.__repr__(), other),
@@ -482,19 +526,27 @@ impl RichComparisons2 {
         "RC2"
     }
 
-    fn __richcmp__(&self, other: &PyAny, op: CompareOp) -> PyObject {
+    fn __richcmp__(&self, other: &Bound<'_, PyAny>, op: CompareOp) -> PyResult<Py<PyAny>> {
         match op {
-            CompareOp::Eq => true.into_py(other.py()),
-            CompareOp::Ne => false.into_py(other.py()),
-            _ => other.py().NotImplemented(),
+            CompareOp::Eq => true
+                .into_pyobject(other.py())
+                .map_err(Into::into)
+                .map(BoundObject::into_any)
+                .map(BoundObject::unbind),
+            CompareOp::Ne => false
+                .into_pyobject(other.py())
+                .map_err(Into::into)
+                .map(BoundObject::into_any)
+                .map(BoundObject::unbind),
+            _ => Ok(other.py().NotImplemented()),
         }
     }
 }
 
 #[test]
 fn rich_comparisons() {
-    Python::with_gil(|py| {
-        let c = PyCell::new(py, RichComparisons {}).unwrap();
+    Python::attach(|py| {
+        let c = Py::new(py, RichComparisons {}).unwrap();
         py_run!(py, c, "assert (c < c) == 'RC < RC'");
         py_run!(py, c, "assert (c < 1) == 'RC < 1'");
         py_run!(py, c, "assert (1 < c) == 'RC > 1'");
@@ -518,8 +570,8 @@ fn rich_comparisons() {
 
 #[test]
 fn rich_comparisons_python_3_type_error() {
-    Python::with_gil(|py| {
-        let c2 = PyCell::new(py, RichComparisons2 {}).unwrap();
+    Python::attach(|py| {
+        let c2 = Py::new(py, RichComparisons2 {}).unwrap();
         py_expect_exception!(py, c2, "c2 < c2", PyTypeError);
         py_expect_exception!(py, c2, "c2 < 1", PyTypeError);
         py_expect_exception!(py, c2, "1 < c2", PyTypeError);
@@ -555,7 +607,7 @@ mod return_not_implemented {
             "RC_Self"
         }
 
-        fn __richcmp__(&self, other: PyRef<'_, Self>, _op: CompareOp) -> PyObject {
+        fn __richcmp__(&self, other: PyRef<'_, Self>, _op: CompareOp) -> Py<PyAny> {
             other.py().None()
         }
 
@@ -619,15 +671,12 @@ mod return_not_implemented {
     }
 
     fn _test_binary_dunder(dunder: &str) {
-        Python::with_gil(|py| {
-            let c2 = PyCell::new(py, RichComparisonToSelf {}).unwrap();
+        Python::attach(|py| {
+            let c2 = Py::new(py, RichComparisonToSelf {}).unwrap();
             py_run!(
                 py,
                 c2,
-                &format!(
-                    "class Other: pass\nassert c2.__{}__(Other()) is NotImplemented",
-                    dunder
-                )
+                &format!("class Other: pass\nassert c2.__{dunder}__(Other()) is NotImplemented")
             );
         });
     }
@@ -635,12 +684,12 @@ mod return_not_implemented {
     fn _test_binary_operator(operator: &str, dunder: &str) {
         _test_binary_dunder(dunder);
 
-        Python::with_gil(|py| {
-            let c2 = PyCell::new(py, RichComparisonToSelf {}).unwrap();
+        Python::attach(|py| {
+            let c2 = Py::new(py, RichComparisonToSelf {}).unwrap();
             py_expect_exception!(
                 py,
                 c2,
-                &format!("class Other: pass\nc2 {} Other()", operator),
+                format!("class Other: pass\nc2 {} Other()", operator),
                 PyTypeError
             );
         });
diff --git a/tests/test_buffer.rs b/tests/test_buffer.rs
index 72f94b3bcc8..5e66e67ab3a 100644
--- a/tests/test_buffer.rs
+++ b/tests/test_buffer.rs
@@ -1,16 +1,15 @@
 #![cfg(feature = "macros")]
 #![cfg(any(not(Py_LIMITED_API), Py_3_11))]
+#![warn(unsafe_op_in_unsafe_fn)]
 
 use pyo3::{buffer::PyBuffer, exceptions::PyBufferError, ffi, prelude::*};
 use std::{
-    ffi::CStr,
     os::raw::{c_int, c_void},
     ptr,
 };
 
 #[macro_use]
-#[path = "../src/tests/common.rs"]
-mod common;
+mod test_utils;
 
 enum TestGetBufferError {
     NullShape,
@@ -43,42 +42,44 @@ impl TestBufferErrors {
 
         let bytes = &slf.buf;
 
-        (*view).buf = bytes.as_ptr() as *mut c_void;
-        (*view).len = bytes.len() as isize;
-        (*view).readonly = 1;
-        (*view).itemsize = std::mem::size_of::<u32>() as isize;
-
-        let msg = CStr::from_bytes_with_nul(b"I\0").unwrap();
-        (*view).format = msg.as_ptr() as *mut _;
-
-        (*view).ndim = 1;
-        (*view).shape = &mut (*view).len;
-
-        (*view).strides = &mut (*view).itemsize;
-
-        (*view).suboffsets = ptr::null_mut();
-        (*view).internal = ptr::null_mut();
-
-        if let Some(err) = &slf.error {
-            use TestGetBufferError::*;
-            match err {
-                NullShape => {
-                    (*view).shape = std::ptr::null_mut();
+        unsafe {
+            (*view).buf = bytes.as_ptr() as *mut c_void;
+            (*view).len = bytes.len() as isize;
+            (*view).readonly = 1;
+            (*view).itemsize = std::mem::size_of::<u32>() as isize;
+
+            let msg = c"I";
+            (*view).format = msg.as_ptr() as *mut _;
+
+            (*view).ndim = 1;
+            (*view).shape = &mut (*view).len;
+
+            (*view).strides = &mut (*view).itemsize;
+
+            (*view).suboffsets = ptr::null_mut();
+            (*view).internal = ptr::null_mut();
+
+            if let Some(err) = &slf.error {
+                use TestGetBufferError::*;
+                match err {
+                    NullShape => {
+                        (*view).shape = std::ptr::null_mut();
+                    }
+                    NullStrides => {
+                        (*view).strides = std::ptr::null_mut();
+                    }
+                    IncorrectItemSize => {
+                        (*view).itemsize += 1;
+                    }
+                    IncorrectFormat => {
+                        (*view).format = c"B".as_ptr() as _;
+                    }
+                    IncorrectAlignment => (*view).buf = (*view).buf.add(1),
                 }
-                NullStrides => {
-                    (*view).strides = std::ptr::null_mut();
-                }
-                IncorrectItemSize => {
-                    (*view).itemsize += 1;
-                }
-                IncorrectFormat => {
-                    (*view).format = CStr::from_bytes_with_nul(b"B\0").unwrap().as_ptr() as _;
-                }
-                IncorrectAlignment => (*view).buf = (*view).buf.add(1),
             }
-        }
 
-        (*view).obj = slf.into_ptr();
+            (*view).obj = slf.into_ptr();
+        }
 
         Ok(())
     }
@@ -86,7 +87,7 @@ impl TestBufferErrors {
 
 #[test]
 fn test_get_buffer_errors() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let instance = Py::new(
             py,
             TestBufferErrors {
@@ -96,11 +97,11 @@ fn test_get_buffer_errors() {
         )
         .unwrap();
 
-        assert!(PyBuffer::<u32>::get_bound(instance.bind(py).as_any()).is_ok());
+        assert!(PyBuffer::<u32>::get(instance.bind(py)).is_ok());
 
         instance.borrow_mut(py).error = Some(TestGetBufferError::NullShape);
         assert_eq!(
-            PyBuffer::<u32>::get_bound(instance.bind(py).as_any())
+            PyBuffer::<u32>::get(instance.bind(py))
                 .unwrap_err()
                 .to_string(),
             "BufferError: shape is null"
@@ -108,7 +109,7 @@ fn test_get_buffer_errors() {
 
         instance.borrow_mut(py).error = Some(TestGetBufferError::NullStrides);
         assert_eq!(
-            PyBuffer::<u32>::get_bound(instance.bind(py).as_any())
+            PyBuffer::<u32>::get(instance.bind(py))
                 .unwrap_err()
                 .to_string(),
             "BufferError: strides is null"
@@ -116,7 +117,7 @@ fn test_get_buffer_errors() {
 
         instance.borrow_mut(py).error = Some(TestGetBufferError::IncorrectItemSize);
         assert_eq!(
-            PyBuffer::<u32>::get_bound(instance.bind(py).as_any())
+            PyBuffer::<u32>::get(instance.bind(py))
                 .unwrap_err()
                 .to_string(),
             "BufferError: buffer contents are not compatible with u32"
@@ -124,7 +125,7 @@ fn test_get_buffer_errors() {
 
         instance.borrow_mut(py).error = Some(TestGetBufferError::IncorrectFormat);
         assert_eq!(
-            PyBuffer::<u32>::get_bound(instance.bind(py).as_any())
+            PyBuffer::<u32>::get(instance.bind(py))
                 .unwrap_err()
                 .to_string(),
             "BufferError: buffer contents are not compatible with u32"
@@ -132,7 +133,7 @@ fn test_get_buffer_errors() {
 
         instance.borrow_mut(py).error = Some(TestGetBufferError::IncorrectAlignment);
         assert_eq!(
-            PyBuffer::<u32>::get_bound(instance.bind(py).as_any())
+            PyBuffer::<u32>::get(instance.bind(py))
                 .unwrap_err()
                 .to_string(),
             "BufferError: buffer contents are insufficiently aligned for u32"
diff --git a/tests/test_buffer_protocol.rs b/tests/test_buffer_protocol.rs
index 85ff6a4004e..9af163f515b 100644
--- a/tests/test_buffer_protocol.rs
+++ b/tests/test_buffer_protocol.rs
@@ -1,5 +1,6 @@
 #![cfg(feature = "macros")]
 #![cfg(any(not(Py_LIMITED_API), Py_3_11))]
+#![warn(unsafe_op_in_unsafe_fn)]
 
 use pyo3::buffer::PyBuffer;
 use pyo3::exceptions::PyBufferError;
@@ -7,13 +8,12 @@ use pyo3::ffi;
 use pyo3::prelude::*;
 use pyo3::types::IntoPyDict;
 use std::ffi::CString;
-use std::os::raw::{c_int, c_void};
+use std::ffi::{c_int, c_void};
 use std::ptr;
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::Arc;
 
-#[path = "../src/tests/common.rs"]
-mod common;
+mod test_utils;
 
 #[pyclass]
 struct TestBufferClass {
@@ -24,16 +24,16 @@ struct TestBufferClass {
 #[pymethods]
 impl TestBufferClass {
     unsafe fn __getbuffer__(
-        slf: &PyCell<Self>,
+        slf: Bound<'_, Self>,
         view: *mut ffi::Py_buffer,
         flags: c_int,
     ) -> PyResult<()> {
-        fill_view_from_readonly_data(view, flags, &slf.borrow().vec, slf)
+        unsafe { fill_view_from_readonly_data(view, flags, &slf.borrow().vec, slf.into_any()) }
     }
 
     unsafe fn __releasebuffer__(&self, view: *mut ffi::Py_buffer) {
         // Release memory held by the format string
-        drop(CString::from_raw((*view).format));
+        drop(unsafe { CString::from_raw((*view).format) });
     }
 }
 
@@ -48,7 +48,7 @@ impl Drop for TestBufferClass {
 fn test_buffer() {
     let drop_called = Arc::new(AtomicBool::new(false));
 
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let instance = Py::new(
             py,
             TestBufferClass {
@@ -57,7 +57,7 @@ fn test_buffer() {
             },
         )
         .unwrap();
-        let env = [("ob", instance)].into_py_dict_bound(py);
+        let env = [("ob", instance)].into_py_dict(py).unwrap();
         py_assert!(py, *env, "bytes(ob) == b' 23'");
     });
 
@@ -70,14 +70,15 @@ fn test_buffer_referenced() {
 
     let buf = {
         let input = vec![b' ', b'2', b'3'];
-        Python::with_gil(|py| {
-            let instance: PyObject = TestBufferClass {
+        Python::attach(|py| {
+            let instance = TestBufferClass {
                 vec: input.clone(),
                 drop_called: drop_called.clone(),
             }
-            .into_py(py);
+            .into_pyobject(py)
+            .unwrap();
 
-            let buf = PyBuffer::<u8>::get_bound(instance.bind(py)).unwrap();
+            let buf = PyBuffer::<u8>::get(&instance).unwrap();
             assert_eq!(buf.to_vec(py).unwrap(), input);
             drop(instance);
             buf
@@ -86,7 +87,7 @@ fn test_buffer_referenced() {
 
     assert!(!drop_called.load(Ordering::Relaxed));
 
-    Python::with_gil(|_| {
+    Python::attach(|_| {
         drop(buf);
     });
 
@@ -96,8 +97,8 @@ fn test_buffer_referenced() {
 #[test]
 #[cfg(Py_3_8)] // sys.unraisablehook not available until Python 3.8
 fn test_releasebuffer_unraisable_error() {
-    use common::UnraisableCapture;
     use pyo3::exceptions::PyValueError;
+    use test_utils::UnraisableCapture;
 
     #[pyclass]
     struct ReleaseBufferError {}
@@ -105,12 +106,12 @@ fn test_releasebuffer_unraisable_error() {
     #[pymethods]
     impl ReleaseBufferError {
         unsafe fn __getbuffer__(
-            slf: &PyCell<Self>,
+            slf: Bound<'_, Self>,
             view: *mut ffi::Py_buffer,
             flags: c_int,
         ) -> PyResult<()> {
             static BUF_BYTES: &[u8] = b"hello world";
-            fill_view_from_readonly_data(view, flags, BUF_BYTES, slf)
+            unsafe { fill_view_from_readonly_data(view, flags, BUF_BYTES, slf.into_any()) }
         }
 
         unsafe fn __releasebuffer__(&self, _view: *mut ffi::Py_buffer) -> PyResult<()> {
@@ -118,21 +119,21 @@ fn test_releasebuffer_unraisable_error() {
         }
     }
 
-    Python::with_gil(|py| {
-        let capture = UnraisableCapture::install(py);
-
+    Python::attach(|py| {
         let instance = Py::new(py, ReleaseBufferError {}).unwrap();
-        let env = [("ob", instance.clone())].into_py_dict_bound(py);
 
-        assert!(capture.borrow(py).capture.is_none());
+        let (err, object) = UnraisableCapture::enter(py, |capture| {
+            let env = [("ob", instance.clone_ref(py))].into_py_dict(py).unwrap();
+
+            assert!(capture.take_capture().is_none());
 
-        py_assert!(py, *env, "bytes(ob) == b'hello world'");
+            py_assert!(py, *env, "bytes(ob) == b'hello world'");
+
+            capture.take_capture().unwrap()
+        });
 
-        let (err, object) = capture.borrow_mut(py).capture.take().unwrap();
         assert_eq!(err.to_string(), "ValueError: oh dear");
         assert!(object.is(&instance));
-
-        capture.borrow_mut(py).uninstall(py);
     });
 }
 
@@ -145,7 +146,7 @@ unsafe fn fill_view_from_readonly_data(
     view: *mut ffi::Py_buffer,
     flags: c_int,
     data: &[u8],
-    owner: &PyAny,
+    owner: Bound<'_, PyAny>,
 ) -> PyResult<()> {
     if view.is_null() {
         return Err(PyBufferError::new_err("View is null"));
@@ -155,35 +156,36 @@ unsafe fn fill_view_from_readonly_data(
         return Err(PyBufferError::new_err("Object is not writable"));
     }
 
-    (*view).obj = owner.into_ptr();
-
-    (*view).buf = data.as_ptr() as *mut c_void;
-    (*view).len = data.len() as isize;
-    (*view).readonly = 1;
-    (*view).itemsize = 1;
-
-    (*view).format = if (flags & ffi::PyBUF_FORMAT) == ffi::PyBUF_FORMAT {
-        let msg = CString::new("B").unwrap();
-        msg.into_raw()
-    } else {
-        ptr::null_mut()
-    };
-
-    (*view).ndim = 1;
-    (*view).shape = if (flags & ffi::PyBUF_ND) == ffi::PyBUF_ND {
-        &mut (*view).len
-    } else {
-        ptr::null_mut()
-    };
-
-    (*view).strides = if (flags & ffi::PyBUF_STRIDES) == ffi::PyBUF_STRIDES {
-        &mut (*view).itemsize
-    } else {
-        ptr::null_mut()
-    };
-
-    (*view).suboffsets = ptr::null_mut();
-    (*view).internal = ptr::null_mut();
-
+    unsafe {
+        (*view).obj = owner.into_ptr();
+
+        (*view).buf = data.as_ptr() as *mut c_void;
+        (*view).len = data.len() as isize;
+        (*view).readonly = 1;
+        (*view).itemsize = 1;
+
+        (*view).format = if (flags & ffi::PyBUF_FORMAT) == ffi::PyBUF_FORMAT {
+            let msg = CString::new("B").unwrap();
+            msg.into_raw()
+        } else {
+            ptr::null_mut()
+        };
+
+        (*view).ndim = 1;
+        (*view).shape = if (flags & ffi::PyBUF_ND) == ffi::PyBUF_ND {
+            &mut (*view).len
+        } else {
+            ptr::null_mut()
+        };
+
+        (*view).strides = if (flags & ffi::PyBUF_STRIDES) == ffi::PyBUF_STRIDES {
+            &mut (*view).itemsize
+        } else {
+            ptr::null_mut()
+        };
+
+        (*view).suboffsets = ptr::null_mut();
+        (*view).internal = ptr::null_mut();
+    }
     Ok(())
 }
diff --git a/tests/test_bytes.rs b/tests/test_bytes.rs
index cdb4ec15750..0caaf2a37ff 100644
--- a/tests/test_bytes.rs
+++ b/tests/test_bytes.rs
@@ -3,8 +3,7 @@
 use pyo3::prelude::*;
 use pyo3::types::PyBytes;
 
-#[path = "../src/tests/common.rs"]
-mod common;
+mod test_utils;
 
 #[pyfunction]
 fn bytes_pybytes_conversion(bytes: &[u8]) -> &[u8] {
@@ -13,7 +12,7 @@ fn bytes_pybytes_conversion(bytes: &[u8]) -> &[u8] {
 
 #[test]
 fn test_pybytes_bytes_conversion() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let f = wrap_pyfunction!(bytes_pybytes_conversion)(py).unwrap();
         py_assert!(py, f, "f(b'Hello World') == b'Hello World'");
     });
@@ -21,12 +20,12 @@ fn test_pybytes_bytes_conversion() {
 
 #[pyfunction]
 fn bytes_vec_conversion(py: Python<'_>, bytes: Vec<u8>) -> Bound<'_, PyBytes> {
-    PyBytes::new_bound(py, bytes.as_slice())
+    PyBytes::new(py, bytes.as_slice())
 }
 
 #[test]
 fn test_pybytes_vec_conversion() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let f = wrap_pyfunction!(bytes_vec_conversion)(py).unwrap();
         py_assert!(py, f, "f(b'Hello World') == b'Hello World'");
     });
@@ -34,7 +33,7 @@ fn test_pybytes_vec_conversion() {
 
 #[test]
 fn test_bytearray_vec_conversion() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let f = wrap_pyfunction!(bytes_vec_conversion)(py).unwrap();
         py_assert!(py, f, "f(bytearray(b'Hello World')) == b'Hello World'");
     });
@@ -43,9 +42,11 @@ fn test_bytearray_vec_conversion() {
 #[test]
 fn test_py_as_bytes() {
     let pyobj: pyo3::Py<pyo3::types::PyBytes> =
-        Python::with_gil(|py| pyo3::types::PyBytes::new_bound(py, b"abc").unbind());
+        Python::attach(|py| pyo3::types::PyBytes::new(py, b"abc").unbind());
 
-    let data = Python::with_gil(|py| pyobj.as_bytes(py));
+    let data = Python::attach(|py| pyobj.as_bytes(py));
 
     assert_eq!(data, b"abc");
+
+    Python::attach(move |_py| drop(pyobj));
 }
diff --git a/tests/test_class_attributes.rs b/tests/test_class_attributes.rs
index 906a11c8ea1..f706b414ff3 100644
--- a/tests/test_class_attributes.rs
+++ b/tests/test_class_attributes.rs
@@ -1,9 +1,9 @@
 #![cfg(feature = "macros")]
 
 use pyo3::prelude::*;
+use pyo3::py_run;
 
-#[path = "../src/tests/common.rs"]
-mod common;
+mod test_utils;
 
 #[pyclass]
 struct Foo {
@@ -55,7 +55,7 @@ impl Foo {
 
 #[test]
 fn class_attributes() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let foo_obj = py.get_type::<Foo>();
         py_assert!(py, foo_obj, "foo_obj.MY_CONST == 'foobar'");
         py_assert!(py, foo_obj, "foo_obj.RENAMED_CONST == 'foobar_2'");
@@ -66,14 +66,68 @@ fn class_attributes() {
     });
 }
 
-// Ignored because heap types are not immutable:
-// https://github.com/python/cpython/blob/master/Objects/typeobject.c#L3399-L3409
 #[test]
-#[ignore]
-fn class_attributes_are_immutable() {
-    Python::with_gil(|py| {
-        let foo_obj = py.get_type::<Foo>();
-        py_expect_exception!(py, foo_obj, "foo_obj.a = 6", PyTypeError);
+fn class_attributes_mutable() {
+    #[pyclass]
+    struct Foo {}
+
+    #[pymethods]
+    impl Foo {
+        #[classattr]
+        const MY_CONST: &'static str = "foobar";
+
+        #[classattr]
+        fn a() -> i32 {
+            5
+        }
+    }
+
+    Python::attach(|py| {
+        let obj = py.get_type::<Foo>();
+        py_run!(py, obj, "obj.MY_CONST = 'BAZ'");
+        py_run!(py, obj, "obj.a = 42");
+        py_assert!(py, obj, "obj.MY_CONST == 'BAZ'");
+        py_assert!(py, obj, "obj.a == 42");
+    });
+}
+
+#[test]
+#[cfg(any(Py_3_14, all(Py_3_10, not(Py_LIMITED_API))))]
+fn immutable_type_object() {
+    #[pyclass(immutable_type)]
+    struct ImmutableType {}
+
+    #[pymethods]
+    impl ImmutableType {
+        #[classattr]
+        const MY_CONST: &'static str = "foobar";
+
+        #[classattr]
+        fn a() -> i32 {
+            5
+        }
+    }
+
+    #[pyclass(immutable_type)]
+    enum SimpleImmutable {
+        Variant = 42,
+    }
+
+    #[pyclass(immutable_type)]
+    enum ComplexImmutable {
+        Variant(u32),
+    }
+
+    Python::attach(|py| {
+        let obj = py.get_type::<ImmutableType>();
+        py_expect_exception!(py, obj, "obj.MY_CONST = 'FOOBAR'", PyTypeError);
+        py_expect_exception!(py, obj, "obj.a = 6", PyTypeError);
+
+        let obj = py.get_type::<SimpleImmutable>();
+        py_expect_exception!(py, obj, "obj.Variant = 0", PyTypeError);
+
+        let obj = py.get_type::<ComplexImmutable>();
+        py_expect_exception!(py, obj, "obj.Variant = 0", PyTypeError);
     });
 }
 
@@ -87,7 +141,7 @@ impl Bar {
 
 #[test]
 fn recursive_class_attributes() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let foo_obj = py.get_type::<Foo>();
         let bar_obj = py.get_type::<Bar>();
         py_assert!(py, foo_obj, "foo_obj.a_foo.x == 1");
@@ -97,40 +151,10 @@ fn recursive_class_attributes() {
 }
 
 #[test]
+#[cfg(Py_3_8)] // sys.unraisablehook not available until Python 3.8
 fn test_fallible_class_attribute() {
-    use pyo3::{exceptions::PyValueError, types::PyString};
-
-    struct CaptureStdErr<'py> {
-        oldstderr: Bound<'py, PyAny>,
-        string_io: Bound<'py, PyAny>,
-    }
-
-    impl<'py> CaptureStdErr<'py> {
-        fn new(py: Python<'py>) -> PyResult<Self> {
-            let sys = py.import_bound("sys")?;
-            let oldstderr = sys.getattr("stderr")?;
-            let string_io = py.import_bound("io")?.getattr("StringIO")?.call0()?;
-            sys.setattr("stderr", &string_io)?;
-            Ok(Self {
-                oldstderr,
-                string_io,
-            })
-        }
-
-        fn reset(self) -> PyResult<String> {
-            let py = self.string_io.py();
-            let payload = self
-                .string_io
-                .getattr("getvalue")?
-                .call0()?
-                .downcast::<PyString>()?
-                .to_cow()?
-                .into_owned();
-            let sys = py.import_bound("sys")?;
-            sys.setattr("stderr", self.oldstderr)?;
-            Ok(payload)
-        }
-    }
+    use pyo3::exceptions::PyValueError;
+    use test_utils::UnraisableCapture;
 
     #[pyclass]
     struct BrokenClass;
@@ -143,22 +167,32 @@ fn test_fallible_class_attribute() {
         }
     }
 
-    Python::with_gil(|py| {
-        let stderr = CaptureStdErr::new(py).unwrap();
-        assert!(std::panic::catch_unwind(|| py.get_type::<BrokenClass>()).is_err());
-        assert_eq!(
-            stderr.reset().unwrap().trim(),
-            "\
-ValueError: failed to create class attribute
+    Python::attach(|py| {
+        let (err, object) = UnraisableCapture::enter(py, |capture| {
+            // Accessing the type will attempt to initialize the class attributes
+            assert!(std::panic::catch_unwind(|| py.get_type::<BrokenClass>()).is_err());
 
-The above exception was the direct cause of the following exception:
+            capture.take_capture().unwrap()
+        });
 
-RuntimeError: An error occurred while initializing `BrokenClass.fails_to_init`
+        assert!(object.is_none());
+        assert_eq!(
+            err.to_string(),
+            "RuntimeError: An error occurred while initializing class BrokenClass"
+        );
 
-The above exception was the direct cause of the following exception:
+        let cause = err.cause(py).unwrap();
+        assert_eq!(
+            cause.to_string(),
+            "RuntimeError: An error occurred while initializing `BrokenClass.fails_to_init`"
+        );
 
-RuntimeError: An error occurred while initializing class BrokenClass"
-        )
+        let cause = cause.cause(py).unwrap();
+        assert_eq!(
+            cause.to_string(),
+            "ValueError: failed to create class attribute"
+        );
+        assert!(cause.cause(py).is_none());
     });
 }
 
@@ -186,16 +220,16 @@ impl StructWithRenamedFields {
 fn test_renaming_all_struct_fields() {
     use pyo3::types::PyBool;
 
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let struct_class = py.get_type::<StructWithRenamedFields>();
         let struct_obj = struct_class.call0().unwrap();
         assert!(struct_obj
-            .setattr("firstField", PyBool::new_bound(py, false))
+            .setattr("firstField", PyBool::new(py, false))
             .is_ok());
         py_assert!(py, struct_obj, "struct_obj.firstField == False");
         py_assert!(py, struct_obj, "struct_obj.secondField == 5");
         assert!(struct_obj
-            .setattr("third_field", PyBool::new_bound(py, true))
+            .setattr("third_field", PyBool::new(py, true))
             .is_ok());
         py_assert!(py, struct_obj, "struct_obj.third_field == True");
     });
@@ -219,12 +253,12 @@ macro_rules! test_case {
         fn $test_name() {
             //use pyo3::types::PyInt;
 
-            Python::with_gil(|py| {
+            Python::attach(|py| {
                 let struct_class = py.get_type::<$struct_name>();
                 let struct_obj = struct_class.call0().unwrap();
                 assert!(struct_obj.setattr($renamed_field_name, 2).is_ok());
                 let attr = struct_obj.getattr($renamed_field_name).unwrap();
-                assert_eq!(2, PyAny::extract::<u8>(attr).unwrap());
+                assert_eq!(2, attr.extract::<u8>().unwrap());
             });
         }
     };
diff --git a/tests/test_class_basics.rs b/tests/test_class_basics.rs
index ff3555c3107..a4fd02584fe 100644
--- a/tests/test_class_basics.rs
+++ b/tests/test_class_basics.rs
@@ -4,15 +4,14 @@ use pyo3::prelude::*;
 use pyo3::types::PyType;
 use pyo3::{py_run, PyClass};
 
-#[path = "../src/tests/common.rs"]
-mod common;
+mod test_utils;
 
 #[pyclass]
 struct EmptyClass {}
 
 #[test]
 fn empty_class() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let typeobj = py.get_type::<EmptyClass>();
         // By default, don't allow creating instances from python.
         assert!(typeobj.call((), None).is_err());
@@ -26,7 +25,7 @@ struct UnitClass;
 
 #[test]
 fn unit_class() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let typeobj = py.get_type::<UnitClass>();
         // By default, don't allow creating instances from python.
         assert!(typeobj.call((), None).is_err());
@@ -57,7 +56,7 @@ struct ClassWithDocs {
 
 #[test]
 fn class_with_docstr() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let typeobj = py.get_type::<ClassWithDocs>();
         py_run!(
             py,
@@ -103,7 +102,7 @@ impl EmptyClass2 {
 
 #[test]
 fn custom_names() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let typeobj = py.get_type::<EmptyClass2>();
         py_assert!(py, typeobj, "typeobj.__name__ == 'CustomName'");
         py_assert!(py, typeobj, "typeobj.custom_fn.__name__ == 'custom_fn'");
@@ -123,6 +122,36 @@ fn custom_names() {
     });
 }
 
+#[pyclass(name = "loop")]
+struct ClassRustKeywords {
+    #[pyo3(name = "unsafe", get, set)]
+    unsafe_variable: usize,
+}
+
+#[pymethods]
+impl ClassRustKeywords {
+    #[pyo3(name = "struct")]
+    fn struct_method(&self) {}
+
+    #[staticmethod]
+    #[pyo3(name = "type")]
+    fn type_method() {}
+}
+
+#[test]
+fn keyword_names() {
+    Python::attach(|py| {
+        let typeobj = py.get_type::<ClassRustKeywords>();
+        py_assert!(py, typeobj, "typeobj.__name__ == 'loop'");
+        py_assert!(py, typeobj, "typeobj.struct.__name__ == 'struct'");
+        py_assert!(py, typeobj, "typeobj.type.__name__ == 'type'");
+        py_assert!(py, typeobj, "typeobj.unsafe.__name__ == 'unsafe'");
+        py_assert!(py, typeobj, "not hasattr(typeobj, 'unsafe_variable')");
+        py_assert!(py, typeobj, "not hasattr(typeobj, 'struct_method')");
+        py_assert!(py, typeobj, "not hasattr(typeobj, 'type_method')");
+    });
+}
+
 #[pyclass]
 struct RawIdents {
     #[pyo3(get, set)]
@@ -136,7 +165,7 @@ impl RawIdents {
 
 #[test]
 fn test_raw_idents() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let typeobj = py.get_type::<RawIdents>();
         py_assert!(py, typeobj, "not hasattr(typeobj, 'r#fn')");
         py_assert!(py, typeobj, "hasattr(typeobj, 'fn')");
@@ -153,7 +182,7 @@ struct EmptyClassInModule {}
 #[test]
 #[ignore]
 fn empty_class_in_module() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let module = PyModule::new(py, "test_module.nested").unwrap();
         module.add_class::<EmptyClassInModule>().unwrap();
 
@@ -177,26 +206,55 @@ struct ClassWithObjectField {
     // It used to be that PyObject was not supported with (get, set)
     // - this test is just ensuring it compiles.
     #[pyo3(get, set)]
-    value: PyObject,
+    value: Py<PyAny>,
 }
 
 #[pymethods]
 impl ClassWithObjectField {
     #[new]
-    fn new(value: PyObject) -> ClassWithObjectField {
+    fn new(value: Py<PyAny>) -> ClassWithObjectField {
         Self { value }
     }
 }
 
 #[test]
 fn class_with_object_field() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let ty = py.get_type::<ClassWithObjectField>();
         py_assert!(py, ty, "ty(5).value == 5");
         py_assert!(py, ty, "ty(None).value == None");
     });
 }
 
+#[pyclass(frozen, eq, hash)]
+#[derive(PartialEq, Hash)]
+struct ClassWithHash {
+    value: usize,
+}
+
+#[test]
+fn class_with_hash() {
+    Python::attach(|py| {
+        use pyo3::types::IntoPyDict;
+        let class = ClassWithHash { value: 42 };
+        let hash = {
+            use std::hash::{Hash, Hasher};
+            let mut hasher = std::collections::hash_map::DefaultHasher::new();
+            class.hash(&mut hasher);
+            hasher.finish() as isize
+        };
+
+        let env = [
+            ("obj", Py::new(py, class).unwrap().into_any()),
+            ("hsh", hash.into_pyobject(py).unwrap().into_any().unbind()),
+        ]
+        .into_py_dict(py)
+        .unwrap();
+
+        py_assert!(py, *env, "hash(obj) == hsh");
+    });
+}
+
 #[pyclass(unsendable, subclass)]
 struct UnsendableBase {
     value: std::rc::Rc<usize>,
@@ -229,32 +287,31 @@ impl UnsendableChild {
 }
 
 fn test_unsendable<T: PyClass + 'static>() -> PyResult<()> {
-    let obj = Python::with_gil(|py| -> PyResult<_> {
+    let (keep_obj_here, obj) = Python::attach(|py| -> PyResult<_> {
         let obj: Py<T> = PyType::new::<T>(py).call1((5,))?.extract()?;
 
         // Accessing the value inside this thread should not panic
         let caught_panic =
             std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| -> PyResult<_> {
-                assert_eq!(obj.as_ref(py).getattr("value")?.extract::<usize>()?, 5);
+                assert_eq!(obj.getattr(py, "value")?.extract::<usize>(py)?, 5);
                 Ok(())
             }))
             .is_err();
 
         assert!(!caught_panic);
-        Ok(obj)
-    })?;
 
-    let keep_obj_here = obj.clone();
+        Ok((obj.clone_ref(py), obj))
+    })?;
 
     let caught_panic = std::thread::spawn(move || {
         // This access must panic
-        Python::with_gil(|py| {
+        Python::attach(move |py| {
             obj.borrow(py);
         });
     })
     .join();
 
-    Python::with_gil(|_py| drop(keep_obj_here));
+    Python::attach(|_py| drop(keep_obj_here));
 
     if let Err(err) = caught_panic {
         if let Some(msg) = err.downcast_ref::<String>() {
@@ -290,39 +347,39 @@ fn get_length(obj: &Bound<'_, PyAny>) -> PyResult<usize> {
     Ok(length)
 }
 
+fn is_even(obj: &Bound<'_, PyAny>) -> PyResult<bool> {
+    obj.extract::<i32>().map(|i| i % 2 == 0)
+}
+
 #[pyclass]
 struct ClassWithFromPyWithMethods {}
 
 #[pymethods]
 impl ClassWithFromPyWithMethods {
-    fn instance_method(&self, #[pyo3(from_py_with = "get_length")] argument: usize) -> usize {
+    fn instance_method(&self, #[pyo3(from_py_with = get_length)] argument: usize) -> usize {
         argument
     }
     #[classmethod]
     fn classmethod(
         _cls: &Bound<'_, PyType>,
-        #[pyo3(from_py_with = "Bound::<'_, PyAny>::len")] argument: usize,
+        #[pyo3(from_py_with = Bound::<'_, PyAny>::len)] argument: usize,
     ) -> usize {
         argument
     }
 
-    #[classmethod]
-    fn classmethod_gil_ref(
-        _cls: &PyType,
-        #[pyo3(from_py_with = "PyAny::len")] argument: usize,
-    ) -> usize {
+    #[staticmethod]
+    fn staticmethod(#[pyo3(from_py_with = get_length)] argument: usize) -> usize {
         argument
     }
 
-    #[staticmethod]
-    fn staticmethod(#[pyo3(from_py_with = "get_length")] argument: usize) -> usize {
-        argument
+    fn __contains__(&self, #[pyo3(from_py_with = is_even)] obj: bool) -> bool {
+        obj
     }
 }
 
 #[test]
 fn test_pymethods_from_py_with() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let instance = Py::new(py, ClassWithFromPyWithMethods {}).unwrap();
 
         py_run!(
@@ -333,8 +390,10 @@ fn test_pymethods_from_py_with() {
 
         assert instance.instance_method(arg) == 2
         assert instance.classmethod(arg) == 2
-        assert instance.classmethod_gil_ref(arg) == 2
         assert instance.staticmethod(arg) == 2
+
+        assert 42 in instance
+        assert 73 not in instance
         "#
         );
     })
@@ -345,7 +404,7 @@ struct TupleClass(#[pyo3(get, set, name = "value")] i32);
 
 #[test]
 fn test_tuple_struct_class() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let typeobj = py.get_type::<TupleClass>();
         assert!(typeobj.call((), None).is_err());
 
@@ -366,6 +425,7 @@ fn test_tuple_struct_class() {
     });
 }
 
+#[cfg(any(Py_3_9, not(Py_LIMITED_API)))]
 #[pyclass(dict, subclass)]
 struct DunderDictSupport {
     // Make sure that dict_offset runs with non-zero sized Self
@@ -373,10 +433,10 @@ struct DunderDictSupport {
 }
 
 #[test]
-#[cfg_attr(all(Py_LIMITED_API, not(Py_3_9)), ignore)]
+#[cfg(any(Py_3_9, not(Py_LIMITED_API)))]
 fn dunder_dict_support() {
-    Python::with_gil(|py| {
-        let inst = PyCell::new(
+    Python::attach(|py| {
+        let inst = Py::new(
             py,
             DunderDictSupport {
                 _pad: *b"DEADBEEFDEADBEEFDEADBEEFDEADBEEF",
@@ -394,12 +454,11 @@ fn dunder_dict_support() {
     });
 }
 
-// Accessing inst.__dict__ only supported in limited API from Python 3.10
 #[test]
-#[cfg_attr(all(Py_LIMITED_API, not(Py_3_10)), ignore)]
+#[cfg(any(Py_3_9, not(Py_LIMITED_API)))]
 fn access_dunder_dict() {
-    Python::with_gil(|py| {
-        let inst = PyCell::new(
+    Python::attach(|py| {
+        let inst = Py::new(
             py,
             DunderDictSupport {
                 _pad: *b"DEADBEEFDEADBEEFDEADBEEFDEADBEEF",
@@ -418,16 +477,17 @@ fn access_dunder_dict() {
 }
 
 // If the base class has dict support, child class also has dict
+#[cfg(any(Py_3_9, not(Py_LIMITED_API)))]
 #[pyclass(extends=DunderDictSupport)]
 struct InheritDict {
     _value: usize,
 }
 
 #[test]
-#[cfg_attr(all(Py_LIMITED_API, not(Py_3_9)), ignore)]
+#[cfg(any(Py_3_9, not(Py_LIMITED_API)))]
 fn inherited_dict() {
-    Python::with_gil(|py| {
-        let inst = PyCell::new(
+    Python::attach(|py| {
+        let inst = Py::new(
             py,
             (
                 InheritDict { _value: 0 },
@@ -448,6 +508,7 @@ fn inherited_dict() {
     });
 }
 
+#[cfg(any(Py_3_9, not(Py_LIMITED_API)))]
 #[pyclass(weakref, dict)]
 struct WeakRefDunderDictSupport {
     // Make sure that weaklist_offset runs with non-zero sized Self
@@ -455,10 +516,10 @@ struct WeakRefDunderDictSupport {
 }
 
 #[test]
-#[cfg_attr(all(Py_LIMITED_API, not(Py_3_9)), ignore)]
+#[cfg(any(Py_3_9, not(Py_LIMITED_API)))]
 fn weakref_dunder_dict_support() {
-    Python::with_gil(|py| {
-        let inst = PyCell::new(
+    Python::attach(|py| {
+        let inst = Py::new(
             py,
             WeakRefDunderDictSupport {
                 _pad: *b"DEADBEEFDEADBEEFDEADBEEFDEADBEEF",
@@ -473,16 +534,17 @@ fn weakref_dunder_dict_support() {
     });
 }
 
+#[cfg(any(Py_3_9, not(Py_LIMITED_API)))]
 #[pyclass(weakref, subclass)]
 struct WeakRefSupport {
     _pad: [u8; 32],
 }
 
 #[test]
-#[cfg_attr(all(Py_LIMITED_API, not(Py_3_9)), ignore)]
+#[cfg(any(Py_3_9, not(Py_LIMITED_API)))]
 fn weakref_support() {
-    Python::with_gil(|py| {
-        let inst = PyCell::new(
+    Python::attach(|py| {
+        let inst = Py::new(
             py,
             WeakRefSupport {
                 _pad: *b"DEADBEEFDEADBEEFDEADBEEFDEADBEEF",
@@ -498,16 +560,17 @@ fn weakref_support() {
 }
 
 // If the base class has weakref support, child class also has weakref.
+#[cfg(any(Py_3_9, not(Py_LIMITED_API)))]
 #[pyclass(extends=WeakRefSupport)]
 struct InheritWeakRef {
     _value: usize,
 }
 
 #[test]
-#[cfg_attr(all(Py_LIMITED_API, not(Py_3_9)), ignore)]
+#[cfg(any(Py_3_9, not(Py_LIMITED_API)))]
 fn inherited_weakref() {
-    Python::with_gil(|py| {
-        let inst = PyCell::new(
+    Python::attach(|py| {
+        let inst = Py::new(
             py,
             (
                 InheritWeakRef { _value: 0 },
@@ -534,12 +597,12 @@ fn access_frozen_class_without_gil() {
         value: AtomicUsize,
     }
 
-    let py_counter: Py<FrozenCounter> = Python::with_gil(|py| {
+    let py_counter: Py<FrozenCounter> = Python::attach(|py| {
         let counter = FrozenCounter {
             value: AtomicUsize::new(0),
         };
 
-        let cell = PyCell::new(py, counter).unwrap();
+        let cell = Bound::new(py, counter).unwrap();
 
         cell.get().value.fetch_add(1, Ordering::Relaxed);
 
@@ -547,18 +610,20 @@ fn access_frozen_class_without_gil() {
     });
 
     assert_eq!(py_counter.get().value.load(Ordering::Relaxed), 1);
+
+    Python::attach(move |_py| drop(py_counter));
 }
 
 #[test]
-#[cfg(Py_3_8)] // sys.unraisablehook not available until Python 3.8
+#[cfg(Py_3_8)]
 #[cfg_attr(target_arch = "wasm32", ignore)]
 fn drop_unsendable_elsewhere() {
-    use common::UnraisableCapture;
     use std::sync::{
         atomic::{AtomicBool, Ordering},
         Arc,
     };
     use std::thread::spawn;
+    use test_utils::UnraisableCapture;
 
     #[pyclass(unsendable)]
     struct Unsendable {
@@ -571,35 +636,115 @@ fn drop_unsendable_elsewhere() {
         }
     }
 
-    Python::with_gil(|py| {
-        let capture = UnraisableCapture::install(py);
-
-        let dropped = Arc::new(AtomicBool::new(false));
-
-        let unsendable = Py::new(
-            py,
-            Unsendable {
-                dropped: dropped.clone(),
-            },
-        )
-        .unwrap();
+    Python::attach(|py| {
+        let (err, object) = UnraisableCapture::enter(py, |capture| {
+            let dropped = Arc::new(AtomicBool::new(false));
 
-        py.allow_threads(|| {
-            spawn(move || {
-                Python::with_gil(move |_py| {
-                    drop(unsendable);
-                });
-            })
-            .join()
+            let unsendable = Py::new(
+                py,
+                Unsendable {
+                    dropped: dropped.clone(),
+                },
+            )
             .unwrap();
-        });
 
-        assert!(!dropped.load(Ordering::SeqCst));
+            py.detach(|| {
+                spawn(move || {
+                    Python::attach(move |py| {
+                        drop(unsendable);
+                        // On the free-threaded build, dropping an object on its non-origin thread
+                        // will not immediately drop it because the refcounts need to be merged.
+                        //
+                        // Force GC to ensure the drop happens now on the wrong thread.
+                        py.run(c"import gc; gc.collect()", None, None).unwrap();
+                    });
+                })
+                .join()
+                .unwrap();
+            });
+
+            assert!(!dropped.load(Ordering::SeqCst));
+
+            capture.take_capture().unwrap()
+        });
 
-        let (err, object) = capture.borrow_mut(py).capture.take().unwrap();
         assert_eq!(err.to_string(), "RuntimeError: test_class_basics::drop_unsendable_elsewhere::Unsendable is unsendable, but is being dropped on another thread");
-        assert!(object.is_none(py));
+        assert!(object.is_none());
+    });
+}
 
-        capture.borrow_mut(py).uninstall(py);
+#[test]
+#[cfg(any(Py_3_9, not(Py_LIMITED_API)))]
+fn test_unsendable_dict() {
+    #[pyclass(dict, unsendable)]
+    struct UnsendableDictClass {}
+
+    #[pymethods]
+    impl UnsendableDictClass {
+        #[new]
+        fn new() -> Self {
+            UnsendableDictClass {}
+        }
+    }
+
+    Python::attach(|py| {
+        let inst = Py::new(py, UnsendableDictClass {}).unwrap();
+        py_run!(py, inst, "assert inst.__dict__ == {}");
+    });
+}
+
+#[test]
+#[cfg(any(Py_3_9, not(Py_LIMITED_API)))]
+fn test_unsendable_dict_with_weakref() {
+    #[pyclass(dict, unsendable, weakref)]
+    struct UnsendableDictClassWithWeakRef {}
+
+    #[pymethods]
+    impl UnsendableDictClassWithWeakRef {
+        #[new]
+        fn new() -> Self {
+            Self {}
+        }
+    }
+
+    Python::attach(|py| {
+        let inst = Py::new(py, UnsendableDictClassWithWeakRef {}).unwrap();
+        py_run!(py, inst, "assert inst.__dict__ == {}");
+        py_run!(
+            py,
+            inst,
+            "import weakref; assert weakref.ref(inst)() is inst; inst.a = 1; assert inst.a == 1"
+        );
+    });
+}
+
+#[cfg(Py_3_9)]
+#[pyclass(generic)]
+struct ClassWithRuntimeParametrization {
+    #[pyo3(get, set)]
+    value: Py<PyAny>,
+}
+
+#[cfg(Py_3_9)]
+#[pymethods]
+impl ClassWithRuntimeParametrization {
+    #[new]
+    fn new(value: Py<PyAny>) -> ClassWithRuntimeParametrization {
+        Self { value }
+    }
+}
+
+#[test]
+#[cfg(Py_3_9)]
+fn test_runtime_parametrization() {
+    Python::attach(|py| {
+        let ty = py.get_type::<ClassWithRuntimeParametrization>();
+        py_assert!(py, ty, "ty[int] == ty.__class_getitem__((int,))");
+        py_run!(
+            py,
+            ty,
+            "import types;
+            assert ty.__class_getitem__((int,)) == types.GenericAlias(ty, (int,))"
+        );
     });
 }
diff --git a/tests/test_class_comparisons.rs b/tests/test_class_comparisons.rs
new file mode 100644
index 00000000000..e8509d1e266
--- /dev/null
+++ b/tests/test_class_comparisons.rs
@@ -0,0 +1,286 @@
+#![cfg(feature = "macros")]
+
+use pyo3::prelude::*;
+
+mod test_utils;
+
+#[pyclass(eq)]
+#[derive(Debug, Clone, PartialEq)]
+pub enum MyEnum {
+    Variant,
+    OtherVariant,
+}
+
+#[pyclass(eq, ord)]
+#[derive(Debug, PartialEq, Eq, Clone, PartialOrd)]
+pub enum MyEnumOrd {
+    Variant,
+    OtherVariant,
+}
+
+#[test]
+fn test_enum_eq_enum() {
+    Python::attach(|py| {
+        let var1 = Py::new(py, MyEnum::Variant).unwrap();
+        let var2 = Py::new(py, MyEnum::Variant).unwrap();
+        let other_var = Py::new(py, MyEnum::OtherVariant).unwrap();
+        py_assert!(py, var1 var2, "var1 == var2");
+        py_assert!(py, var1 other_var, "var1 != other_var");
+        py_assert!(py, var1 var2, "(var1 != var2) == False");
+    })
+}
+
+#[test]
+fn test_enum_eq_incomparable() {
+    Python::attach(|py| {
+        let var1 = Py::new(py, MyEnum::Variant).unwrap();
+        py_assert!(py, var1, "(var1 == 'foo') == False");
+        py_assert!(py, var1, "(var1 != 'foo') == True");
+    })
+}
+
+#[test]
+fn test_enum_ord_comparable_opt_in_only() {
+    Python::attach(|py| {
+        let var1 = Py::new(py, MyEnum::Variant).unwrap();
+        let var2 = Py::new(py, MyEnum::OtherVariant).unwrap();
+        // ordering on simple enums if opt in only, thus raising an error below
+        py_expect_exception!(py, var1 var2, "(var1 > var2) == False", PyTypeError);
+    })
+}
+
+#[test]
+fn test_simple_enum_ord_comparable() {
+    Python::attach(|py| {
+        let var1 = Py::new(py, MyEnumOrd::Variant).unwrap();
+        let var2 = Py::new(py, MyEnumOrd::OtherVariant).unwrap();
+        let var3 = Py::new(py, MyEnumOrd::OtherVariant).unwrap();
+        py_assert!(py, var1 var2, "(var1 > var2) == False");
+        py_assert!(py, var1 var2, "(var1 < var2) == True");
+        py_assert!(py, var1 var2, "(var1 >= var2) == False");
+        py_assert!(py, var2 var3, "(var3 >= var2) == True");
+        py_assert!(py, var1 var2, "(var1 <= var2) == True");
+    })
+}
+
+#[pyclass(eq, ord)]
+#[derive(Debug, PartialEq, Eq, Clone, PartialOrd)]
+pub enum MyComplexEnumOrd {
+    Variant(i32),
+    OtherVariant(String),
+}
+
+#[pyclass(eq, ord)]
+#[derive(Debug, PartialEq, Eq, Clone, PartialOrd)]
+pub enum MyComplexEnumOrd2 {
+    Variant { msg: String, idx: u32 },
+    OtherVariant { name: String, idx: u32 },
+}
+
+#[test]
+fn test_complex_enum_ord_comparable() {
+    Python::attach(|py| {
+        let var1 = Py::new(py, MyComplexEnumOrd::Variant(-2)).unwrap();
+        let var2 = Py::new(py, MyComplexEnumOrd::Variant(5)).unwrap();
+        let var3 = Py::new(py, MyComplexEnumOrd::OtherVariant("a".to_string())).unwrap();
+        let var4 = Py::new(py, MyComplexEnumOrd::OtherVariant("b".to_string())).unwrap();
+        py_assert!(py, var1 var2, "(var1 > var2) == False");
+        py_assert!(py, var1 var2, "(var1 < var2) == True");
+        py_assert!(py, var1 var2, "(var1 >= var2) == False");
+        py_assert!(py, var1 var2, "(var1 <= var2) == True");
+
+        py_assert!(py, var1 var3, "(var1 >= var3) == False");
+        py_assert!(py, var1 var3, "(var1 <= var3) == True");
+
+        py_assert!(py, var3 var4, "(var3 >= var4) == False");
+        py_assert!(py, var3 var4, "(var3 <= var4) == True");
+
+        let var5 = Py::new(
+            py,
+            MyComplexEnumOrd2::Variant {
+                msg: "hello".to_string(),
+                idx: 1,
+            },
+        )
+        .unwrap();
+        let var6 = Py::new(
+            py,
+            MyComplexEnumOrd2::Variant {
+                msg: "hello".to_string(),
+                idx: 1,
+            },
+        )
+        .unwrap();
+        let var7 = Py::new(
+            py,
+            MyComplexEnumOrd2::Variant {
+                msg: "goodbye".to_string(),
+                idx: 7,
+            },
+        )
+        .unwrap();
+        let var8 = Py::new(
+            py,
+            MyComplexEnumOrd2::Variant {
+                msg: "about".to_string(),
+                idx: 0,
+            },
+        )
+        .unwrap();
+        let var9 = Py::new(
+            py,
+            MyComplexEnumOrd2::OtherVariant {
+                name: "albert".to_string(),
+                idx: 1,
+            },
+        )
+        .unwrap();
+
+        py_assert!(py, var5 var6, "(var5 == var6) == True");
+        py_assert!(py, var5 var6, "(var5 <= var6) == True");
+        py_assert!(py, var6 var7, "(var6 <= var7) == False");
+        py_assert!(py, var6 var7, "(var6 >= var7) == True");
+        py_assert!(py, var5 var8, "(var5 > var8) == True");
+        py_assert!(py, var8 var9, "(var9 > var8) == True");
+    })
+}
+
+#[pyclass(eq, ord)]
+#[derive(Debug, PartialEq, Eq, Clone, PartialOrd)]
+pub struct Point {
+    x: i32,
+    y: i32,
+    z: i32,
+}
+
+#[test]
+fn test_struct_numeric_ord_comparable() {
+    Python::attach(|py| {
+        let var1 = Py::new(py, Point { x: 10, y: 2, z: 3 }).unwrap();
+        let var2 = Py::new(py, Point { x: 2, y: 2, z: 3 }).unwrap();
+        let var3 = Py::new(py, Point { x: 1, y: 22, z: 4 }).unwrap();
+        let var4 = Py::new(py, Point { x: 1, y: 3, z: 4 }).unwrap();
+        let var5 = Py::new(py, Point { x: 1, y: 3, z: 4 }).unwrap();
+        py_assert!(py, var1 var2, "(var1 > var2) == True");
+        py_assert!(py, var1 var2, "(var1 <= var2) == False");
+        py_assert!(py, var2 var3, "(var3 < var2) == True");
+        py_assert!(py, var3 var4, "(var3 > var4) == True");
+        py_assert!(py, var4 var5, "(var4 == var5) == True");
+        py_assert!(py, var3 var5, "(var3 != var5) == True");
+    })
+}
+
+#[pyclass(eq, ord)]
+#[derive(Debug, PartialEq, Eq, Clone, PartialOrd)]
+pub struct Person {
+    surname: String,
+    given_name: String,
+}
+
+#[test]
+fn test_struct_string_ord_comparable() {
+    Python::attach(|py| {
+        let var1 = Py::new(
+            py,
+            Person {
+                surname: "zzz".to_string(),
+                given_name: "bob".to_string(),
+            },
+        )
+        .unwrap();
+        let var2 = Py::new(
+            py,
+            Person {
+                surname: "aaa".to_string(),
+                given_name: "sally".to_string(),
+            },
+        )
+        .unwrap();
+        let var3 = Py::new(
+            py,
+            Person {
+                surname: "eee".to_string(),
+                given_name: "qqq".to_string(),
+            },
+        )
+        .unwrap();
+        let var4 = Py::new(
+            py,
+            Person {
+                surname: "ddd".to_string(),
+                given_name: "aaa".to_string(),
+            },
+        )
+        .unwrap();
+
+        py_assert!(py, var1 var2, "(var1 > var2) == True");
+        py_assert!(py, var1 var2, "(var1 <= var2) == False");
+        py_assert!(py, var1 var3, "(var1 >= var3) == True");
+        py_assert!(py, var2 var3, "(var2 >= var3) == False");
+        py_assert!(py, var3 var4, "(var3 >= var4) == True");
+        py_assert!(py, var3 var4, "(var3 != var4) == True");
+    })
+}
+
+#[pyclass(eq, ord)]
+#[derive(Debug, PartialEq, Eq, Clone)]
+pub struct Record {
+    name: String,
+    title: String,
+    idx: u32,
+}
+
+impl PartialOrd for Record {
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        Some(self.idx.partial_cmp(&other.idx).unwrap())
+    }
+}
+
+#[test]
+fn test_struct_custom_ord_comparable() {
+    Python::attach(|py| {
+        let var1 = Py::new(
+            py,
+            Record {
+                name: "zzz".to_string(),
+                title: "bbb".to_string(),
+                idx: 9,
+            },
+        )
+        .unwrap();
+        let var2 = Py::new(
+            py,
+            Record {
+                name: "ddd".to_string(),
+                title: "aaa".to_string(),
+                idx: 1,
+            },
+        )
+        .unwrap();
+        let var3 = Py::new(
+            py,
+            Record {
+                name: "vvv".to_string(),
+                title: "ggg".to_string(),
+                idx: 19,
+            },
+        )
+        .unwrap();
+        let var4 = Py::new(
+            py,
+            Record {
+                name: "vvv".to_string(),
+                title: "ggg".to_string(),
+                idx: 19,
+            },
+        )
+        .unwrap();
+
+        py_assert!(py, var1 var2, "(var1 > var2) == True");
+        py_assert!(py, var1 var2, "(var1 <= var2) == False");
+        py_assert!(py, var1 var3, "(var1 >= var3) == False");
+        py_assert!(py, var2 var3, "(var2 >= var3) == False");
+        py_assert!(py, var3 var4, "(var3 == var4) == True");
+        py_assert!(py, var2 var4, "(var2 != var4) == True");
+    })
+}
diff --git a/tests/test_class_conversion.rs b/tests/test_class_conversion.rs
index 27a8f604b3f..2ff0f56a9b3 100644
--- a/tests/test_class_conversion.rs
+++ b/tests/test_class_conversion.rs
@@ -1,11 +1,9 @@
 #![cfg(feature = "macros")]
 
 use pyo3::prelude::*;
-use pyo3::ToPyObject;
 
 #[macro_use]
-#[path = "../src/tests/common.rs"]
-mod common;
+mod test_utils;
 
 #[pyclass]
 #[derive(Clone, Debug, PartialEq)]
@@ -17,8 +15,8 @@ struct Cloneable {
 fn test_cloneable_pyclass() {
     let c = Cloneable { x: 10 };
 
-    Python::with_gil(|py| {
-        let py_c = Py::new(py, c.clone()).unwrap().to_object(py);
+    Python::attach(|py| {
+        let py_c = Py::new(py, c.clone()).unwrap();
 
         let c2: Cloneable = py_c.extract(py).unwrap();
         assert_eq!(c, c2);
@@ -63,15 +61,14 @@ struct PolymorphicContainer {
 
 #[test]
 fn test_polymorphic_container_stores_base_class() {
-    Python::with_gil(|py| {
-        let p = PyCell::new(
+    Python::attach(|py| {
+        let p = Py::new(
             py,
             PolymorphicContainer {
                 inner: Py::new(py, BaseClass::default()).unwrap(),
             },
         )
-        .unwrap()
-        .to_object(py);
+        .unwrap();
 
         py_assert!(py, p, "p.inner.foo() == 'BaseClass'");
     });
@@ -79,20 +76,19 @@ fn test_polymorphic_container_stores_base_class() {
 
 #[test]
 fn test_polymorphic_container_stores_sub_class() {
-    Python::with_gil(|py| {
-        let p = PyCell::new(
+    Python::attach(|py| {
+        let p = Py::new(
             py,
             PolymorphicContainer {
                 inner: Py::new(py, BaseClass::default()).unwrap(),
             },
         )
-        .unwrap()
-        .to_object(py);
+        .unwrap();
 
-        p.as_ref(py)
+        p.bind(py)
             .setattr(
                 "inner",
-                PyCell::new(
+                Py::new(
                     py,
                     PyClassInitializer::from(BaseClass::default()).add_subclass(SubClass {}),
                 )
@@ -106,28 +102,27 @@ fn test_polymorphic_container_stores_sub_class() {
 
 #[test]
 fn test_polymorphic_container_does_not_accept_other_types() {
-    Python::with_gil(|py| {
-        let p = PyCell::new(
+    Python::attach(|py| {
+        let p = Py::new(
             py,
             PolymorphicContainer {
                 inner: Py::new(py, BaseClass::default()).unwrap(),
             },
         )
-        .unwrap()
-        .to_object(py);
+        .unwrap();
 
-        let setattr = |value: PyObject| p.as_ref(py).setattr("inner", value);
+        let setattr = |value: Bound<'_, PyAny>| p.bind(py).setattr("inner", value);
 
-        assert!(setattr(1i32.into_py(py)).is_err());
-        assert!(setattr(py.None()).is_err());
-        assert!(setattr((1i32, 2i32).into_py(py)).is_err());
+        assert!(setattr(1i32.into_pyobject(py).unwrap().into_any()).is_err());
+        assert!(setattr(py.None().into_bound(py)).is_err());
+        assert!(setattr((1i32, 2i32).into_pyobject(py).unwrap().into_any()).is_err());
     });
 }
 
 #[test]
 fn test_pyref_as_base() {
-    Python::with_gil(|py| {
-        let cell = PyCell::new(py, (SubClass {}, BaseClass { value: 120 })).unwrap();
+    Python::attach(|py| {
+        let cell = Bound::new(py, (SubClass {}, BaseClass { value: 120 })).unwrap();
 
         // First try PyRefMut
         let sub: PyRefMut<'_, SubClass> = cell.borrow_mut();
@@ -146,13 +141,13 @@ fn test_pyref_as_base() {
 
 #[test]
 fn test_pycell_deref() {
-    Python::with_gil(|py| {
-        let cell = PyCell::new(py, (SubClass {}, BaseClass { value: 120 })).unwrap();
+    Python::attach(|py| {
+        let obj = Bound::new(py, (SubClass {}, BaseClass { value: 120 })).unwrap();
 
         // Should be able to deref as PyAny
         assert_eq!(
-            cell.call_method0("foo")
-                .and_then(PyAny::extract::<&str>)
+            obj.call_method0("foo")
+                .and_then(|e| e.extract::<String>())
                 .unwrap(),
             "SubClass"
         );
diff --git a/tests/test_class_formatting.rs b/tests/test_class_formatting.rs
new file mode 100644
index 00000000000..1b4add063d4
--- /dev/null
+++ b/tests/test_class_formatting.rs
@@ -0,0 +1,178 @@
+#![cfg(feature = "macros")]
+
+use pyo3::prelude::*;
+use pyo3::py_run;
+use std::fmt::{Display, Formatter};
+
+mod test_utils;
+
+#[pyclass(eq, str)]
+#[derive(Debug, PartialEq)]
+pub enum MyEnum2 {
+    Variant,
+    OtherVariant,
+}
+
+impl Display for MyEnum2 {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{self:?}")
+    }
+}
+
+#[pyclass(eq, str)]
+#[derive(Debug, PartialEq)]
+pub enum MyEnum3 {
+    #[pyo3(name = "AwesomeVariant")]
+    Variant,
+    OtherVariant,
+}
+
+impl Display for MyEnum3 {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        let variant = match self {
+            MyEnum3::Variant => "AwesomeVariant",
+            MyEnum3::OtherVariant => "OtherVariant",
+        };
+        write!(f, "MyEnum.{variant}")
+    }
+}
+
+#[test]
+fn test_enum_class_fmt() {
+    Python::attach(|py| {
+        let var2 = Py::new(py, MyEnum2::Variant).unwrap();
+        let var3 = Py::new(py, MyEnum3::Variant).unwrap();
+        let var4 = Py::new(py, MyEnum3::OtherVariant).unwrap();
+        py_assert!(py, var2, "str(var2) == 'Variant'");
+        py_assert!(py, var3, "str(var3) == 'MyEnum.AwesomeVariant'");
+        py_assert!(py, var4, "str(var4) == 'MyEnum.OtherVariant'");
+    })
+}
+
+#[pyclass(str = "X: {x}, Y: {y}, Z: {z}")]
+#[derive(PartialEq, Eq, Clone, PartialOrd)]
+pub struct Point {
+    x: i32,
+    y: i32,
+    z: i32,
+}
+
+#[test]
+fn test_custom_struct_custom_str() {
+    Python::attach(|py| {
+        let var1 = Py::new(py, Point { x: 1, y: 2, z: 3 }).unwrap();
+        py_assert!(py, var1, "str(var1) == 'X: 1, Y: 2, Z: 3'");
+    })
+}
+
+#[pyclass(str)]
+#[derive(PartialEq, Eq, Clone, PartialOrd)]
+pub struct Point2 {
+    x: i32,
+    y: i32,
+    z: i32,
+}
+
+impl Display for Point2 {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "({}, {}, {})", self.x, self.y, self.z)
+    }
+}
+
+#[test]
+fn test_struct_str() {
+    Python::attach(|py| {
+        let var1 = Py::new(py, Point2 { x: 1, y: 2, z: 3 }).unwrap();
+        py_assert!(py, var1, "str(var1) == '(1, 2, 3)'");
+    })
+}
+
+#[pyclass(str)]
+#[derive(PartialEq, Debug)]
+enum ComplexEnumWithStr {
+    A(u32),
+    B { msg: String },
+}
+
+impl Display for ComplexEnumWithStr {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{self:?}")
+    }
+}
+
+#[test]
+fn test_custom_complex_enum_str() {
+    Python::attach(|py| {
+        let var1 = Py::new(py, ComplexEnumWithStr::A(45)).unwrap();
+        let var2 = Py::new(
+            py,
+            ComplexEnumWithStr::B {
+                msg: "Hello".to_string(),
+            },
+        )
+        .unwrap();
+        py_assert!(py, var1, "str(var1) == 'A(45)'");
+        py_assert!(py, var2, "str(var2) == 'B { msg: \"Hello\" }'");
+    })
+}
+
+#[pyclass(str = "{0}, {1}, {2}")]
+#[derive(PartialEq)]
+struct Coord(u32, u32, u32);
+
+#[pyclass(str = "{{{0}, {1}, {2}}}")]
+#[derive(PartialEq)]
+struct Coord2(u32, u32, u32);
+
+#[test]
+fn test_str_representation_by_position() {
+    Python::attach(|py| {
+        let var1 = Py::new(py, Coord(1, 2, 3)).unwrap();
+        let var2 = Py::new(py, Coord2(1, 2, 3)).unwrap();
+        py_assert!(py, var1, "str(var1) == '1, 2, 3'");
+        py_assert!(py, var2, "str(var2) == '{1, 2, 3}'");
+    })
+}
+
+#[pyclass(str = "name: {name}: {name}, idn: {idn:03} with message: {msg}")]
+#[derive(PartialEq, Debug)]
+struct Point4 {
+    name: String,
+    msg: String,
+    idn: u32,
+}
+
+#[test]
+fn test_mixed_and_repeated_str_formats() {
+    Python::attach(|py| {
+        let var1 = Py::new(
+            py,
+            Point4 {
+                name: "aaa".to_string(),
+                msg: "hello".to_string(),
+                idn: 1,
+            },
+        )
+        .unwrap();
+        py_run!(
+            py,
+            var1,
+            r#"
+        assert str(var1) == 'name: aaa: aaa, idn: 001 with message: hello'
+        "#
+        );
+    })
+}
+
+#[pyclass(str = "type: {r#type}")]
+struct Foo {
+    r#type: u32,
+}
+
+#[test]
+fn test_raw_identifier_struct_custom_str() {
+    Python::attach(|py| {
+        let var1 = Py::new(py, Foo { r#type: 3 }).unwrap();
+        py_assert!(py, var1, "str(var1) == 'type: 3'");
+    })
+}
diff --git a/tests/test_class_new.rs b/tests/test_class_new.rs
index 59772cc4cf2..6a35e681500 100644
--- a/tests/test_class_new.rs
+++ b/tests/test_class_new.rs
@@ -2,7 +2,7 @@
 
 use pyo3::exceptions::PyValueError;
 use pyo3::prelude::*;
-use pyo3::sync::GILOnceCell;
+use pyo3::sync::PyOnceLock;
 use pyo3::types::IntoPyDict;
 
 #[pyclass]
@@ -18,21 +18,18 @@ impl EmptyClassWithNew {
 
 #[test]
 fn empty_class_with_new() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let typeobj = py.get_type::<EmptyClassWithNew>();
         assert!(typeobj
             .call((), None)
             .unwrap()
-            .downcast::<PyCell<EmptyClassWithNew>>()
+            .cast::<EmptyClassWithNew>()
             .is_ok());
 
         // Calling with arbitrary args or kwargs is not ok
         assert!(typeobj.call(("some", "args"), None).is_err());
         assert!(typeobj
-            .call(
-                (),
-                Some([("some", "kwarg")].into_py_dict_bound(py).as_gil_ref())
-            )
+            .call((), Some(&[("some", "kwarg")].into_py_dict(py).unwrap()))
             .is_err());
     });
 }
@@ -50,12 +47,12 @@ impl UnitClassWithNew {
 
 #[test]
 fn unit_class_with_new() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let typeobj = py.get_type::<UnitClassWithNew>();
         assert!(typeobj
             .call((), None)
             .unwrap()
-            .downcast::<PyCell<UnitClassWithNew>>()
+            .cast::<UnitClassWithNew>()
             .is_ok());
     });
 }
@@ -73,10 +70,10 @@ impl TupleClassWithNew {
 
 #[test]
 fn tuple_class_with_new() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let typeobj = py.get_type::<TupleClassWithNew>();
         let wrp = typeobj.call((42,), None).unwrap();
-        let obj = wrp.downcast::<PyCell<TupleClassWithNew>>().unwrap();
+        let obj = wrp.cast::<TupleClassWithNew>().unwrap();
         let obj_ref = obj.borrow();
         assert_eq!(obj_ref.0, 42);
     });
@@ -98,10 +95,10 @@ impl NewWithOneArg {
 
 #[test]
 fn new_with_one_arg() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let typeobj = py.get_type::<NewWithOneArg>();
         let wrp = typeobj.call((42,), None).unwrap();
-        let obj = wrp.downcast::<PyCell<NewWithOneArg>>().unwrap();
+        let obj = wrp.cast::<NewWithOneArg>().unwrap();
         let obj_ref = obj.borrow();
         assert_eq!(obj_ref.data, 42);
     });
@@ -126,13 +123,13 @@ impl NewWithTwoArgs {
 
 #[test]
 fn new_with_two_args() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let typeobj = py.get_type::<NewWithTwoArgs>();
         let wrp = typeobj
             .call((10, 20), None)
             .map_err(|e| e.display(py))
             .unwrap();
-        let obj = wrp.downcast::<PyCell<NewWithTwoArgs>>().unwrap();
+        let obj = wrp.cast::<NewWithTwoArgs>().unwrap();
         let obj_ref = obj.borrow();
         assert_eq!(obj_ref.data1, 10);
         assert_eq!(obj_ref.data2, 20);
@@ -157,9 +154,9 @@ impl SuperClass {
 /// See https://github.com/PyO3/pyo3/issues/947 for the corresponding bug.
 #[test]
 fn subclass_new() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let super_cls = py.get_type::<SuperClass>();
-        let source = pyo3::indoc::indoc!(
+        let source = pyo3_ffi::c_str!(pyo3::indoc::indoc!(
             r#"
 class Class(SuperClass):
     def __new__(cls):
@@ -171,13 +168,10 @@ class Class(SuperClass):
 c = Class()
 assert c.from_rust is False
 "#
-        );
-        let globals = PyModule::import(py, "__main__")
-            .unwrap()
-            .dict()
-            .as_borrowed();
+        ));
+        let globals = PyModule::import(py, "__main__").unwrap().dict();
         globals.set_item("SuperClass", super_cls).unwrap();
-        py.run_bound(source, Some(&globals), None)
+        py.run(source, Some(&globals), None)
             .map_err(|e| e.display(py))
             .unwrap();
     });
@@ -205,7 +199,7 @@ impl NewWithCustomError {
 
 #[test]
 fn new_with_custom_error() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let typeobj = py.get_type::<NewWithCustomError>();
         let err = typeobj.call0().unwrap_err();
         assert_eq!(err.to_string(), "ValueError: custom error");
@@ -222,15 +216,11 @@ struct NewExisting {
 impl NewExisting {
     #[new]
     fn new(py: pyo3::Python<'_>, val: usize) -> pyo3::Py<NewExisting> {
-        static PRE_BUILT: GILOnceCell<[pyo3::Py<NewExisting>; 2]> = GILOnceCell::new();
+        static PRE_BUILT: PyOnceLock<[pyo3::Py<NewExisting>; 2]> = PyOnceLock::new();
         let existing = PRE_BUILT.get_or_init(py, || {
             [
-                pyo3::PyCell::new(py, NewExisting { num: 0 })
-                    .unwrap()
-                    .into(),
-                pyo3::PyCell::new(py, NewExisting { num: 1 })
-                    .unwrap()
-                    .into(),
+                pyo3::Py::new(py, NewExisting { num: 0 }).unwrap(),
+                pyo3::Py::new(py, NewExisting { num: 1 }).unwrap(),
             ]
         });
 
@@ -238,15 +228,13 @@ impl NewExisting {
             return existing[val].clone_ref(py);
         }
 
-        pyo3::PyCell::new(py, NewExisting { num: val })
-            .unwrap()
-            .into()
+        pyo3::Py::new(py, NewExisting { num: val }).unwrap()
     }
 }
 
 #[test]
 fn test_new_existing() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let typeobj = py.get_type::<NewExisting>();
 
         let obj1 = typeobj.call1((0,)).unwrap();
@@ -256,17 +244,82 @@ fn test_new_existing() {
         let obj5 = typeobj.call1((2,)).unwrap();
         let obj6 = typeobj.call1((2,)).unwrap();
 
-        assert!(obj1.getattr("num").unwrap().extract::<u32>().unwrap() == 0);
-        assert!(obj2.getattr("num").unwrap().extract::<u32>().unwrap() == 0);
-        assert!(obj3.getattr("num").unwrap().extract::<u32>().unwrap() == 1);
-        assert!(obj4.getattr("num").unwrap().extract::<u32>().unwrap() == 1);
-        assert!(obj5.getattr("num").unwrap().extract::<u32>().unwrap() == 2);
-        assert!(obj6.getattr("num").unwrap().extract::<u32>().unwrap() == 2);
-
-        assert!(obj1.is(obj2));
-        assert!(obj3.is(obj4));
-        assert!(!obj1.is(obj3));
-        assert!(!obj1.is(obj5));
-        assert!(!obj5.is(obj6));
+        assert_eq!(obj1.getattr("num").unwrap().extract::<u32>().unwrap(), 0);
+        assert_eq!(obj2.getattr("num").unwrap().extract::<u32>().unwrap(), 0);
+        assert_eq!(obj3.getattr("num").unwrap().extract::<u32>().unwrap(), 1);
+        assert_eq!(obj4.getattr("num").unwrap().extract::<u32>().unwrap(), 1);
+        assert_eq!(obj5.getattr("num").unwrap().extract::<u32>().unwrap(), 2);
+        assert_eq!(obj6.getattr("num").unwrap().extract::<u32>().unwrap(), 2);
+
+        assert!(obj1.is(&obj2));
+        assert!(obj3.is(&obj4));
+        assert!(!obj1.is(&obj3));
+        assert!(!obj1.is(&obj5));
+        assert!(!obj5.is(&obj6));
+    });
+}
+
+#[pyclass]
+struct NewReturnsPy;
+
+#[pymethods]
+impl NewReturnsPy {
+    #[new]
+    fn new(py: Python<'_>) -> PyResult<Py<NewReturnsPy>> {
+        Py::new(py, NewReturnsPy)
+    }
+}
+
+#[test]
+fn test_new_returns_py() {
+    Python::attach(|py| {
+        let type_ = py.get_type::<NewReturnsPy>();
+        let obj = type_.call0().unwrap();
+        assert!(obj.is_exact_instance_of::<NewReturnsPy>());
+    })
+}
+
+#[pyclass]
+struct NewReturnsBound;
+
+#[pymethods]
+impl NewReturnsBound {
+    #[new]
+    fn new(py: Python<'_>) -> PyResult<Bound<'_, NewReturnsBound>> {
+        Bound::new(py, NewReturnsBound)
+    }
+}
+
+#[test]
+fn test_new_returns_bound() {
+    Python::attach(|py| {
+        let type_ = py.get_type::<NewReturnsBound>();
+        let obj = type_.call0().unwrap();
+        assert!(obj.is_exact_instance_of::<NewReturnsBound>());
+    })
+}
+
+#[pyo3::pyclass]
+struct NewClassMethod {
+    #[pyo3(get)]
+    cls: pyo3::Py<PyAny>,
+}
+
+#[pyo3::pymethods]
+impl NewClassMethod {
+    #[new]
+    #[classmethod]
+    fn new(cls: &pyo3::Bound<'_, pyo3::types::PyType>) -> Self {
+        Self {
+            cls: cls.clone().into_any().unbind(),
+        }
+    }
+}
+
+#[test]
+fn test_new_class_method() {
+    pyo3::Python::attach(|py| {
+        let cls = py.get_type::<NewClassMethod>();
+        pyo3::py_run!(py, cls, "assert cls().cls is cls");
     });
 }
diff --git a/tests/test_compile_error.rs b/tests/test_compile_error.rs
index adcef887f5c..ec22d65a672 100644
--- a/tests/test_compile_error.rs
+++ b/tests/test_compile_error.rs
@@ -5,33 +5,58 @@
 fn test_compile_errors() {
     let t = trybuild::TestCases::new();
 
+    t.compile_fail("tests/ui/deprecated_pyfn.rs");
+    #[cfg(not(feature = "experimental-inspect"))]
     t.compile_fail("tests/ui/invalid_property_args.rs");
     t.compile_fail("tests/ui/invalid_proto_pymethods.rs");
     t.compile_fail("tests/ui/invalid_pyclass_args.rs");
+    t.compile_fail("tests/ui/invalid_pyclass_doc.rs");
     t.compile_fail("tests/ui/invalid_pyclass_enum.rs");
     t.compile_fail("tests/ui/invalid_pyclass_item.rs");
+    #[cfg(Py_3_9)]
+    t.compile_fail("tests/ui/invalid_pyclass_generic.rs");
+    #[cfg(Py_3_9)]
+    t.compile_fail("tests/ui/pyclass_generic_enum.rs");
+    #[cfg(not(feature = "experimental-inspect"))]
+    t.compile_fail("tests/ui/invalid_pyfunction_argument.rs");
+    t.compile_fail("tests/ui/invalid_pyfunction_definition.rs");
     t.compile_fail("tests/ui/invalid_pyfunction_signatures.rs");
     #[cfg(any(not(Py_LIMITED_API), Py_3_11))]
     t.compile_fail("tests/ui/invalid_pymethods_buffer.rs");
+    // The output is not stable across abi3 / not abi3 and features
+    #[cfg(all(not(Py_LIMITED_API), feature = "full"))]
     t.compile_fail("tests/ui/invalid_pymethods_duplicates.rs");
     t.compile_fail("tests/ui/invalid_pymethod_enum.rs");
     t.compile_fail("tests/ui/invalid_pymethod_names.rs");
     t.compile_fail("tests/ui/invalid_pymodule_args.rs");
+    t.compile_fail("tests/ui/invalid_pycallargs.rs");
     t.compile_fail("tests/ui/reject_generics.rs");
-    t.compile_fail("tests/ui/deprecations.rs");
     t.compile_fail("tests/ui/invalid_closure.rs");
     t.compile_fail("tests/ui/pyclass_send.rs");
+    #[cfg(not(feature = "experimental-inspect"))]
+    t.compile_fail("tests/ui/invalid_annotation.rs");
+    #[cfg(not(feature = "experimental-inspect"))]
+    t.compile_fail("tests/ui/invalid_annotation_return.rs");
     t.compile_fail("tests/ui/invalid_argument_attributes.rs");
+    t.compile_fail("tests/ui/invalid_intopy_derive.rs");
+    #[cfg(not(windows))]
+    t.compile_fail("tests/ui/invalid_intopy_with.rs");
     t.compile_fail("tests/ui/invalid_frompy_derive.rs");
     t.compile_fail("tests/ui/static_ref.rs");
     t.compile_fail("tests/ui/wrong_aspyref_lifetimes.rs");
+    #[cfg(not(feature = "uuid"))]
     t.compile_fail("tests/ui/invalid_pyfunctions.rs");
     t.compile_fail("tests/ui/invalid_pymethods.rs");
-    #[cfg(Py_LIMITED_API)]
+    // output changes with async feature
+    #[cfg(all(Py_LIMITED_API, feature = "experimental-async"))]
     t.compile_fail("tests/ui/abi3_nativetype_inheritance.rs");
+    #[cfg(not(feature = "experimental-async"))]
+    t.compile_fail("tests/ui/invalid_async.rs");
     t.compile_fail("tests/ui/invalid_intern_arg.rs");
     t.compile_fail("tests/ui/invalid_frozen_pyclass_borrow.rs");
+    #[cfg(not(any(feature = "hashbrown", feature = "indexmap")))]
     t.compile_fail("tests/ui/invalid_pymethod_receiver.rs");
+    #[cfg(not(feature = "experimental-inspect"))]
     t.compile_fail("tests/ui/missing_intopy.rs");
     // adding extra error conversion impls changes the output
     #[cfg(not(any(windows, feature = "eyre", feature = "anyhow", Py_LIMITED_API)))]
@@ -40,4 +65,31 @@ fn test_compile_errors() {
     t.compile_fail("tests/ui/not_send2.rs");
     t.compile_fail("tests/ui/get_set_all.rs");
     t.compile_fail("tests/ui/traverse.rs");
+    t.compile_fail("tests/ui/invalid_pymodule_in_root.rs");
+    t.compile_fail("tests/ui/invalid_pymodule_glob.rs");
+    t.compile_fail("tests/ui/invalid_pymodule_trait.rs");
+    t.compile_fail("tests/ui/invalid_pymodule_two_pymodule_init.rs");
+    #[cfg(all(feature = "experimental-async", not(feature = "experimental-inspect")))]
+    #[cfg(any(not(Py_LIMITED_API), Py_3_10))] // to avoid PyFunctionArgument for &str
+    t.compile_fail("tests/ui/invalid_cancel_handle.rs");
+    t.pass("tests/ui/pymodule_missing_docs.rs");
+    #[cfg(not(any(Py_LIMITED_API, feature = "experimental-inspect")))]
+    t.pass("tests/ui/forbid_unsafe.rs");
+    #[cfg(all(Py_LIMITED_API, not(feature = "experimental-async")))]
+    // output changes with async feature
+    t.compile_fail("tests/ui/abi3_inheritance.rs");
+    #[cfg(all(Py_LIMITED_API, not(Py_3_9)))]
+    t.compile_fail("tests/ui/abi3_weakref.rs");
+    #[cfg(all(Py_LIMITED_API, not(Py_3_9)))]
+    t.compile_fail("tests/ui/abi3_dict.rs");
+    #[cfg(not(feature = "experimental-inspect"))]
+    t.compile_fail("tests/ui/duplicate_pymodule_submodule.rs");
+    #[cfg(all(not(Py_LIMITED_API), Py_3_11))]
+    t.compile_fail("tests/ui/invalid_base_class.rs");
+    #[cfg(any(not(Py_3_10), all(not(Py_3_14), Py_LIMITED_API)))]
+    t.compile_fail("tests/ui/immutable_type.rs");
+    t.pass("tests/ui/ambiguous_associated_items.rs");
+    t.pass("tests/ui/pyclass_probe.rs");
+    t.compile_fail("tests/ui/invalid_pyfunction_warn.rs");
+    t.compile_fail("tests/ui/invalid_pymethods_warn.rs");
 }
diff --git a/tests/test_coroutine.rs b/tests/test_coroutine.rs
index 549d54aa5c4..24e007ab5a3 100644
--- a/tests/test_coroutine.rs
+++ b/tests/test_coroutine.rs
@@ -1,17 +1,20 @@
-#![cfg(feature = "macros")]
+#![cfg(feature = "experimental-async")]
 #![cfg(not(target_arch = "wasm32"))]
-use std::{ops::Deref, task::Poll, thread, time::Duration};
+use std::{ffi::CString, task::Poll, thread, time::Duration};
 
 use futures::{channel::oneshot, future::poll_fn, FutureExt};
+#[cfg(not(target_has_atomic = "64"))]
+use portable_atomic::{AtomicBool, Ordering};
 use pyo3::{
     coroutine::CancelHandle,
     prelude::*,
     py_run,
-    types::{IntoPyDict, PyType},
+    types::{IntoPyDict, PyDict, PyType},
 };
+#[cfg(target_has_atomic = "64")]
+use std::sync::atomic::{AtomicBool, Ordering};
 
-#[path = "../src/tests/common.rs"]
-mod common;
+mod test_utils;
 
 fn handle_windows(test: &str) -> String {
     let set_event_loop_policy = r#"
@@ -28,10 +31,10 @@ fn noop_coroutine() {
     async fn noop() -> usize {
         42
     }
-    Python::with_gil(|gil| {
-        let noop = wrap_pyfunction!(noop, gil).unwrap();
+    Python::attach(|py| {
+        let noop = wrap_pyfunction!(noop, py).unwrap();
         let test = "import asyncio; assert asyncio.run(noop()) == 42";
-        py_run!(gil, noop, &handle_windows(test));
+        py_run!(py, noop, &handle_windows(test));
     })
 }
 
@@ -54,7 +57,7 @@ fn test_coroutine_qualname() {
         #[staticmethod]
         async fn my_staticmethod() {}
     }
-    Python::with_gil(|gil| {
+    Python::attach(|py| {
         let test = r#"
         for coro, name, qualname in [
             (my_fn(), "my_fn", "my_fn"),
@@ -65,11 +68,12 @@ fn test_coroutine_qualname() {
             assert coro.__name__ == name and coro.__qualname__ == qualname
         "#;
         let locals = [
-            ("my_fn", wrap_pyfunction!(my_fn, gil).unwrap().deref()),
-            ("MyClass", gil.get_type::<MyClass>()),
+            ("my_fn", wrap_pyfunction!(my_fn, py).unwrap().as_any()),
+            ("MyClass", py.get_type::<MyClass>().as_any()),
         ]
-        .into_py_dict_bound(gil);
-        py_run!(gil, *locals, &handle_windows(test));
+        .into_py_dict(py)
+        .unwrap();
+        py_run!(py, *locals, &handle_windows(test));
     })
 }
 
@@ -88,10 +92,10 @@ fn sleep_0_like_coroutine() {
         })
         .await
     }
-    Python::with_gil(|gil| {
-        let sleep_0 = wrap_pyfunction!(sleep_0, gil).unwrap();
+    Python::attach(|py| {
+        let sleep_0 = wrap_pyfunction!(sleep_0, py).unwrap();
         let test = "import asyncio; assert asyncio.run(sleep_0()) == 42";
-        py_run!(gil, sleep_0, &handle_windows(test));
+        py_run!(py, sleep_0, &handle_windows(test));
     })
 }
 
@@ -107,17 +111,31 @@ async fn sleep(seconds: f64) -> usize {
 
 #[test]
 fn sleep_coroutine() {
-    Python::with_gil(|gil| {
-        let sleep = wrap_pyfunction!(sleep, gil).unwrap();
+    Python::attach(|py| {
+        let sleep = wrap_pyfunction!(sleep, py).unwrap();
         let test = r#"import asyncio; assert asyncio.run(sleep(0.1)) == 42"#;
-        py_run!(gil, sleep, &handle_windows(test));
+        py_run!(py, sleep, &handle_windows(test));
+    })
+}
+
+#[pyfunction]
+async fn return_tuple() -> (usize, usize) {
+    (42, 43)
+}
+
+#[test]
+fn tuple_coroutine() {
+    Python::attach(|py| {
+        let func = wrap_pyfunction!(return_tuple, py).unwrap();
+        let test = r#"import asyncio; assert asyncio.run(func()) == (42, 43)"#;
+        py_run!(py, func, &handle_windows(test));
     })
 }
 
 #[test]
 fn cancelled_coroutine() {
-    Python::with_gil(|gil| {
-        let sleep = wrap_pyfunction!(sleep, gil).unwrap();
+    Python::attach(|py| {
+        let sleep = wrap_pyfunction!(sleep, py).unwrap();
         let test = r#"
         import asyncio
         async def main():
@@ -127,17 +145,17 @@ fn cancelled_coroutine() {
             await task
         asyncio.run(main())
         "#;
-        let globals = gil.import_bound("__main__").unwrap().dict();
+        let globals = PyDict::new(py);
         globals.set_item("sleep", sleep).unwrap();
-        let err = gil
-            .run_bound(
-                &pyo3::unindent::unindent(&handle_windows(test)),
+        let err = py
+            .run(
+                &CString::new(pyo3::unindent::unindent(&handle_windows(test))).unwrap(),
                 Some(&globals),
                 None,
             )
             .unwrap_err();
         assert_eq!(
-            err.value(gil).get_type().qualname().unwrap(),
+            err.value(py).get_type().qualname().unwrap(),
             "CancelledError"
         );
     })
@@ -155,8 +173,8 @@ fn coroutine_cancel_handle() {
             _ = cancel.cancelled().fuse() => 0,
         }
     }
-    Python::with_gil(|gil| {
-        let cancellable_sleep = wrap_pyfunction!(cancellable_sleep, gil).unwrap();
+    Python::attach(|py| {
+        let cancellable_sleep = wrap_pyfunction!(cancellable_sleep, py).unwrap();
         let test = r#"
         import asyncio;
         async def main():
@@ -166,12 +184,12 @@ fn coroutine_cancel_handle() {
             return await task
         assert asyncio.run(main()) == 0
         "#;
-        let globals = gil.import_bound("__main__").unwrap().dict();
+        let globals = PyDict::new(py);
         globals
             .set_item("cancellable_sleep", cancellable_sleep)
             .unwrap();
-        gil.run_bound(
-            &pyo3::unindent::unindent(&handle_windows(test)),
+        py.run(
+            &CString::new(pyo3::unindent::unindent(&handle_windows(test))).unwrap(),
             Some(&globals),
             None,
         )
@@ -187,8 +205,8 @@ fn coroutine_is_cancelled() {
             sleep(0.001).await;
         }
     }
-    Python::with_gil(|gil| {
-        let sleep_loop = wrap_pyfunction!(sleep_loop, gil).unwrap();
+    Python::attach(|py| {
+        let sleep_loop = wrap_pyfunction!(sleep_loop, py).unwrap();
         let test = r#"
         import asyncio;
         async def main():
@@ -198,10 +216,10 @@ fn coroutine_is_cancelled() {
             await task
         asyncio.run(main())
         "#;
-        let globals = gil.import_bound("__main__").unwrap().dict();
+        let globals = PyDict::new(py);
         globals.set_item("sleep_loop", sleep_loop).unwrap();
-        gil.run_bound(
-            &pyo3::unindent::unindent(&handle_windows(test)),
+        py.run(
+            &CString::new(pyo3::unindent::unindent(&handle_windows(test))).unwrap(),
             Some(&globals),
             None,
         )
@@ -215,8 +233,8 @@ fn coroutine_panic() {
     async fn panic() {
         panic!("test panic");
     }
-    Python::with_gil(|gil| {
-        let panic = wrap_pyfunction!(panic, gil).unwrap();
+    Python::attach(|py| {
+        let panic = wrap_pyfunction!(panic, py).unwrap();
         let test = r#"
         import asyncio
         coro = panic()
@@ -234,7 +252,7 @@ fn coroutine_panic() {
         else:
             assert False;
         "#;
-        py_run!(gil, panic, &handle_windows(test));
+        py_run!(py, panic, &handle_windows(test));
     })
 }
 
@@ -256,10 +274,19 @@ fn test_async_method_receiver() {
             self.0
         }
     }
-    Python::with_gil(|gil| {
+
+    static IS_DROPPED: AtomicBool = AtomicBool::new(false);
+
+    impl Drop for Counter {
+        fn drop(&mut self) {
+            IS_DROPPED.store(true, Ordering::SeqCst);
+        }
+    }
+
+    Python::attach(|py| {
         let test = r#"
         import asyncio
-        
+
         obj = Counter()
         coro1 = obj.get()
         coro2 = obj.get()
@@ -286,7 +313,46 @@ fn test_async_method_receiver() {
             assert False
         assert asyncio.run(coro3) == 1
         "#;
-        let locals = [("Counter", gil.get_type::<Counter>())].into_py_dict_bound(gil);
-        py_run!(gil, *locals, test);
-    })
+        let locals = [("Counter", py.get_type::<Counter>())]
+            .into_py_dict(py)
+            .unwrap();
+        py_run!(py, *locals, test);
+    });
+
+    assert!(IS_DROPPED.load(Ordering::SeqCst));
+}
+
+#[test]
+fn test_async_method_receiver_with_other_args() {
+    #[pyclass]
+    struct Value(i32);
+    #[pymethods]
+    impl Value {
+        #[new]
+        fn new() -> Self {
+            Self(0)
+        }
+        async fn get_value_plus_with(&self, v1: i32, v2: i32) -> i32 {
+            self.0 + v1 + v2
+        }
+        async fn set_value(&mut self, new_value: i32) -> i32 {
+            self.0 = new_value;
+            self.0
+        }
+    }
+
+    Python::attach(|py| {
+        let test = r#"
+        import asyncio
+
+        v = Value()
+        assert asyncio.run(v.get_value_plus_with(3, 0)) == 3
+        assert asyncio.run(v.set_value(10)) == 10
+        assert asyncio.run(v.get_value_plus_with(1, 1)) == 12
+        "#;
+        let locals = [("Value", py.get_type::<Value>())]
+            .into_py_dict(py)
+            .unwrap();
+        py_run!(py, *locals, test);
+    });
 }
diff --git a/tests/test_datetime.rs b/tests/test_datetime.rs
index 8a9d190ff7b..d50c992288d 100644
--- a/tests/test_datetime.rs
+++ b/tests/test_datetime.rs
@@ -1,8 +1,9 @@
 #![cfg(not(Py_LIMITED_API))]
 
 use pyo3::prelude::*;
-use pyo3::types::{timezone_utc_bound, IntoPyDict, PyDate, PyDateTime, PyTime};
+use pyo3::types::{IntoPyDict, PyDate, PyDateTime, PyTime, PyTzInfo};
 use pyo3_ffi::PyDateTime_IMPORT;
+use std::ffi::CString;
 
 fn _get_subclasses<'py>(
     py: Python<'py>,
@@ -10,25 +11,39 @@ fn _get_subclasses<'py>(
     args: &str,
 ) -> PyResult<(Bound<'py, PyAny>, Bound<'py, PyAny>, Bound<'py, PyAny>)> {
     // Import the class from Python and create some subclasses
-    let datetime = py.import_bound("datetime")?;
+    let datetime = py.import("datetime")?;
 
-    let locals = [(py_type, datetime.getattr(py_type)?)].into_py_dict_bound(py);
+    let locals = [(py_type, datetime.getattr(py_type)?)]
+        .into_py_dict(py)
+        .unwrap();
 
-    let make_subclass_py = format!("class Subklass({}):\n    pass", py_type);
+    let make_subclass_py = CString::new(format!("class Subklass({py_type}):\n    pass"))?;
 
-    let make_sub_subclass_py = "class SubSubklass(Subklass):\n    pass";
+    let make_sub_subclass_py = c"class SubSubklass(Subklass):\n    pass";
 
-    py.run_bound(&make_subclass_py, None, Some(&locals))?;
-    py.run_bound(make_sub_subclass_py, None, Some(&locals))?;
+    py.run(&make_subclass_py, None, Some(&locals))?;
+    py.run(make_sub_subclass_py, None, Some(&locals))?;
 
     // Construct an instance of the base class
-    let obj = py.eval_bound(&format!("{}({})", py_type, args), None, Some(&locals))?;
+    let obj = py.eval(
+        &CString::new(format!("{py_type}({args})"))?,
+        None,
+        Some(&locals),
+    )?;
 
     // Construct an instance of the subclass
-    let sub_obj = py.eval_bound(&format!("Subklass({})", args), None, Some(&locals))?;
+    let sub_obj = py.eval(
+        &CString::new(format!("Subklass({args})"))?,
+        None,
+        Some(&locals),
+    )?;
 
     // Construct an instance of the sub-subclass
-    let sub_sub_obj = py.eval_bound(&format!("SubSubklass({})", args), None, Some(&locals))?;
+    let sub_sub_obj = py.eval(
+        &CString::new(format!("SubSubklass({args})"))?,
+        None,
+        Some(&locals),
+    )?;
 
     Ok((obj, sub_obj, sub_sub_obj))
 }
@@ -37,8 +52,8 @@ macro_rules! assert_check_exact {
     ($check_func:ident, $check_func_exact:ident, $obj: expr) => {
         unsafe {
             use pyo3::ffi::*;
-            assert!($check_func(($obj).as_ptr()) != 0);
-            assert!($check_func_exact(($obj).as_ptr()) != 0);
+            assert_ne!($check_func(($obj).as_ptr()), 0);
+            assert_ne!($check_func_exact(($obj).as_ptr()), 0);
         }
     };
 }
@@ -47,15 +62,15 @@ macro_rules! assert_check_only {
     ($check_func:ident, $check_func_exact:ident, $obj: expr) => {
         unsafe {
             use pyo3::ffi::*;
-            assert!($check_func(($obj).as_ptr()) != 0);
-            assert!($check_func_exact(($obj).as_ptr()) == 0);
+            assert_ne!($check_func(($obj).as_ptr()), 0);
+            assert_eq!($check_func_exact(($obj).as_ptr()), 0);
         }
     };
 }
 
 #[test]
 fn test_date_check() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let (obj, sub_obj, sub_sub_obj) = _get_subclasses(py, "date", "2018, 1, 1").unwrap();
         unsafe { PyDateTime_IMPORT() }
         assert_check_exact!(PyDate_Check, PyDate_CheckExact, obj);
@@ -69,7 +84,7 @@ fn test_date_check() {
 
 #[test]
 fn test_time_check() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let (obj, sub_obj, sub_sub_obj) = _get_subclasses(py, "time", "12, 30, 15").unwrap();
         unsafe { PyDateTime_IMPORT() }
 
@@ -84,7 +99,7 @@ fn test_time_check() {
 
 #[test]
 fn test_datetime_check() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let (obj, sub_obj, sub_sub_obj) = _get_subclasses(py, "datetime", "2018, 1, 1, 13, 30, 15")
             .map_err(|e| e.display(py))
             .unwrap();
@@ -102,7 +117,7 @@ fn test_datetime_check() {
 
 #[test]
 fn test_delta_check() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let (obj, sub_obj, sub_sub_obj) = _get_subclasses(py, "timedelta", "1, -3").unwrap();
         unsafe { PyDateTime_IMPORT() }
 
@@ -117,15 +132,15 @@ fn test_datetime_utc() {
     use assert_approx_eq::assert_approx_eq;
     use pyo3::types::PyDateTime;
 
-    Python::with_gil(|py| {
-        let utc = timezone_utc_bound(py);
+    Python::attach(|py| {
+        let utc = PyTzInfo::utc(py).unwrap();
 
-        let dt = PyDateTime::new_bound(py, 2018, 1, 1, 0, 0, 0, 0, Some(&utc)).unwrap();
+        let dt = PyDateTime::new(py, 2018, 1, 1, 0, 0, 0, 0, Some(&utc)).unwrap();
 
-        let locals = [("dt", dt)].into_py_dict_bound(py);
+        let locals = [("dt", dt)].into_py_dict(py).unwrap();
 
         let offset: f32 = py
-            .eval_bound("dt.utcoffset().total_seconds()", None, Some(&locals))
+            .eval(c"dt.utcoffset().total_seconds()", None, Some(&locals))
             .unwrap()
             .extract()
             .unwrap();
@@ -152,10 +167,10 @@ static INVALID_TIMES: &[(u8, u8, u8, u32)] =
 fn test_pydate_out_of_bounds() {
     use pyo3::types::PyDate;
 
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         for val in INVALID_DATES {
             let (year, month, day) = val;
-            let dt = PyDate::new_bound(py, *year, *month, *day);
+            let dt = PyDate::new(py, *year, *month, *day);
             dt.unwrap_err();
         }
     });
@@ -165,10 +180,10 @@ fn test_pydate_out_of_bounds() {
 fn test_pytime_out_of_bounds() {
     use pyo3::types::PyTime;
 
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         for val in INVALID_TIMES {
             let (hour, minute, second, microsecond) = val;
-            let dt = PyTime::new_bound(py, *hour, *minute, *second, *microsecond, None);
+            let dt = PyTime::new(py, *hour, *minute, *second, *microsecond, None);
             dt.unwrap_err();
         }
     });
@@ -179,7 +194,7 @@ fn test_pydatetime_out_of_bounds() {
     use pyo3::types::PyDateTime;
     use std::iter;
 
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let valid_time = (0, 0, 0, 0);
         let valid_date = (2018, 1, 1);
 
@@ -192,7 +207,7 @@ fn test_pydatetime_out_of_bounds() {
             let (date, time) = val;
             let (year, month, day) = date;
             let (hour, minute, second, microsecond) = time;
-            let dt = PyDateTime::new_bound(
+            let dt = PyDateTime::new(
                 py,
                 *year,
                 *month,
diff --git a/tests/test_datetime_import.rs b/tests/test_datetime_import.rs
index 619df891944..92298504fa3 100644
--- a/tests/test_datetime_import.rs
+++ b/tests/test_datetime_import.rs
@@ -1,26 +1,28 @@
 #![cfg(not(Py_LIMITED_API))]
 
 use pyo3::{prelude::*, types::PyDate};
+use tempfile::Builder;
 
 #[test]
 #[should_panic(expected = "module 'datetime' has no attribute 'datetime_CAPI'")]
 fn test_bad_datetime_module_panic() {
     // Create an empty temporary directory
     // with an empty "datetime" module which we'll put on the sys.path
-    let tmpdir = std::env::temp_dir();
-    let tmpdir = tmpdir.join("pyo3_test_date_check");
-    let _ = std::fs::remove_dir_all(&tmpdir);
-    std::fs::create_dir(&tmpdir).unwrap();
-    std::fs::File::create(tmpdir.join("datetime.py")).unwrap();
+    let tmpdir = Builder::new()
+        .prefix("pyo3_test_data_check")
+        .tempdir()
+        .unwrap();
+    std::fs::File::create(tmpdir.path().join("datetime.py")).unwrap();
 
-    Python::with_gil(|py: Python<'_>| {
-        let sys = py.import_bound("sys").unwrap();
+    Python::attach(|py: Python<'_>| {
+        let sys = py.import("sys").unwrap();
         sys.getattr("path")
             .unwrap()
-            .call_method1("insert", (0, tmpdir))
+            .call_method1("insert", (0, tmpdir.path().as_os_str()))
             .unwrap();
 
         // This should panic because the "datetime" module is empty
-        PyDate::new_bound(py, 2018, 1, 1).unwrap();
+        PyDate::new(py, 2018, 1, 1).unwrap();
     });
+    tmpdir.close().unwrap();
 }
diff --git a/tests/test_declarative_module.rs b/tests/test_declarative_module.rs
new file mode 100644
index 00000000000..57800cdce2e
--- /dev/null
+++ b/tests/test_declarative_module.rs
@@ -0,0 +1,254 @@
+#![cfg(feature = "macros")]
+
+use std::sync::OnceLock;
+
+use pyo3::create_exception;
+use pyo3::exceptions::PyException;
+use pyo3::prelude::*;
+use pyo3::sync::OnceLockExt;
+
+mod test_utils;
+
+mod some_module {
+    use pyo3::create_exception;
+    use pyo3::exceptions::PyException;
+    use pyo3::prelude::*;
+
+    #[pyclass]
+    pub struct SomePyClass;
+
+    create_exception!(some_module, SomeException, PyException);
+}
+
+#[pyclass]
+struct ValueClass {
+    value: usize,
+}
+
+#[pymethods]
+impl ValueClass {
+    #[new]
+    fn new(value: usize) -> Self {
+        Self { value }
+    }
+}
+
+#[pyclass(module = "module")]
+pub struct LocatedClass {}
+
+#[pyfunction]
+fn double(x: usize) -> usize {
+    x * 2
+}
+
+create_exception!(
+    declarative_module,
+    MyError,
+    PyException,
+    "Some description."
+);
+
+#[pymodule(submodule)]
+mod external_submodule {}
+
+/// A module written using declarative syntax.
+#[pymodule]
+mod declarative_module {
+    #[pymodule_export]
+    use super::declarative_submodule;
+    #[pymodule_export]
+    // This is not a real constraint but to test cfg attribute support
+    #[cfg(not(Py_LIMITED_API))]
+    use super::LocatedClass;
+    use super::*;
+    #[pymodule_export]
+    use super::{declarative_module2, double, MyError, ValueClass as Value};
+
+    // test for #4036
+    #[pymodule_export]
+    use super::some_module::SomePyClass;
+
+    // test for #4036
+    #[pymodule_export]
+    use super::some_module::SomeException;
+
+    #[pymodule_export]
+    use super::external_submodule;
+
+    #[pymodule_export]
+    const FOO: u32 = 42;
+
+    #[pymodule_export]
+    #[cfg(Py_LIMITED_API)]
+    const BAR: &str = "BAR";
+
+    #[pymodule_export]
+    #[allow(non_upper_case_globals)]
+    const r#type: char = '!';
+
+    #[allow(unused)]
+    const NOT_EXPORTED: &str = "not exported";
+
+    #[pymodule]
+    mod inner {
+        use super::*;
+
+        #[pyfunction]
+        fn triple(x: usize) -> usize {
+            x * 3
+        }
+
+        #[pyclass(name = "Struct")]
+        struct Struct;
+
+        #[pymethods]
+        impl Struct {
+            #[new]
+            fn new() -> Self {
+                Self
+            }
+        }
+
+        #[pyclass(module = "foo")]
+        struct StructInCustomModule;
+
+        #[pyclass(eq, eq_int, name = "Enum")]
+        #[derive(PartialEq)]
+        enum Enum {
+            A,
+            B,
+        }
+
+        #[pyclass(eq, eq_int, module = "foo")]
+        #[derive(PartialEq)]
+        enum EnumInCustomModule {
+            A,
+            B,
+        }
+    }
+
+    #[pymodule]
+    #[pyo3(module = "custom_root")]
+    mod inner_custom_root {
+        use super::*;
+
+        #[pyclass]
+        struct Struct;
+    }
+
+    #[pyo3::prelude::pymodule]
+    mod full_path_inner {}
+
+    #[pymodule_init]
+    fn init(m: &Bound<'_, PyModule>) -> PyResult<()> {
+        m.add("double2", m.getattr("double")?)
+    }
+}
+
+#[pyfunction]
+fn double_value(v: &ValueClass) -> usize {
+    v.value * 2
+}
+
+#[pymodule]
+mod declarative_submodule {
+    #[pymodule_export]
+    use super::{double, double_value};
+}
+
+#[pymodule(name = "declarative_module_renamed")]
+mod declarative_module2 {
+    #[pymodule_export]
+    use super::double;
+}
+
+fn declarative_module(py: Python<'_>) -> &Bound<'_, PyModule> {
+    static MODULE: OnceLock<Py<PyModule>> = OnceLock::new();
+
+    MODULE
+        .get_or_init_py_attached(py, || pyo3::wrap_pymodule!(declarative_module)(py))
+        .bind(py)
+}
+
+#[test]
+fn test_declarative_module() {
+    Python::attach(|py| {
+        let m = declarative_module(py);
+        py_assert!(
+            py,
+            m,
+            "m.__doc__ == 'A module written using declarative syntax.'"
+        );
+
+        py_assert!(py, m, "m.double(2) == 4");
+        py_assert!(py, m, "m.inner.triple(3) == 9");
+        py_assert!(py, m, "m.declarative_submodule.double(4) == 8");
+        py_assert!(
+            py,
+            m,
+            "m.declarative_submodule.double_value(m.ValueClass(1)) == 2"
+        );
+        py_assert!(py, m, "str(m.MyError('foo')) == 'foo'");
+        py_assert!(py, m, "m.declarative_module_renamed.double(2) == 4");
+        #[cfg(Py_LIMITED_API)]
+        py_assert!(py, m, "not hasattr(m, 'LocatedClass')");
+        #[cfg(not(Py_LIMITED_API))]
+        py_assert!(py, m, "hasattr(m, 'LocatedClass')");
+        py_assert!(py, m, "isinstance(m.inner.Struct(), m.inner.Struct)");
+        py_assert!(py, m, "isinstance(m.inner.Enum.A, m.inner.Enum)");
+        py_assert!(py, m, "hasattr(m, 'external_submodule')");
+        py_assert!(py, m, "m.FOO == 42");
+        #[cfg(Py_LIMITED_API)]
+        py_assert!(py, m, "m.BAR == 'BAR'");
+        #[cfg(not(Py_LIMITED_API))]
+        py_assert!(py, m, "not hasattr(m, 'BAR')");
+        py_assert!(py, m, "m.type == '!'");
+        py_assert!(py, m, "not hasattr(m, 'NOT_EXPORTED')");
+    })
+}
+
+#[pymodule]
+mod r#type {
+    #[pymodule_export]
+    use super::double;
+}
+
+#[test]
+fn test_raw_ident_module() {
+    Python::attach(|py| {
+        let m = pyo3::wrap_pymodule!(r#type)(py).into_bound(py);
+        py_assert!(py, m, "m.double(2) == 4");
+    })
+}
+
+#[test]
+fn test_module_names() {
+    Python::attach(|py| {
+        let m = declarative_module(py);
+        py_assert!(
+            py,
+            m,
+            "m.inner.Struct.__module__ == 'declarative_module.inner'"
+        );
+        py_assert!(py, m, "m.inner.StructInCustomModule.__module__ == 'foo'");
+        py_assert!(
+            py,
+            m,
+            "m.inner.Enum.__module__ == 'declarative_module.inner'"
+        );
+        py_assert!(py, m, "m.inner.EnumInCustomModule.__module__ == 'foo'");
+        py_assert!(
+            py,
+            m,
+            "m.inner_custom_root.Struct.__module__ == 'custom_root.inner_custom_root'"
+        );
+    })
+}
+
+#[test]
+fn test_inner_module_full_path() {
+    Python::attach(|py| {
+        let m = declarative_module(py);
+        py_assert!(py, m, "m.full_path_inner");
+    })
+}
diff --git a/tests/test_default_impls.rs b/tests/test_default_impls.rs
index 526f88e8f82..19dc0773a80 100644
--- a/tests/test_default_impls.rs
+++ b/tests/test_default_impls.rs
@@ -2,18 +2,18 @@
 
 use pyo3::prelude::*;
 
-#[path = "../src/tests/common.rs"]
-mod common;
+mod test_utils;
 
 // Test default generated __repr__.
-#[pyclass]
+#[pyclass(eq, eq_int)]
+#[derive(PartialEq)]
 enum TestDefaultRepr {
     Var,
 }
 
 #[test]
 fn test_default_slot_exists() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let test_object = Py::new(py, TestDefaultRepr::Var).unwrap();
         py_assert!(
             py,
@@ -23,7 +23,8 @@ fn test_default_slot_exists() {
     })
 }
 
-#[pyclass]
+#[pyclass(eq, eq_int)]
+#[derive(PartialEq)]
 enum OverrideSlot {
     Var,
 }
@@ -37,7 +38,7 @@ impl OverrideSlot {
 
 #[test]
 fn test_override_slot() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let test_object = Py::new(py, OverrideSlot::Var).unwrap();
         py_assert!(py, test_object, "repr(test_object) == 'overridden'");
     })
diff --git a/tests/test_dict_iter.rs b/tests/test_dict_iter.rs
deleted file mode 100644
index e502a4ca2b6..00000000000
--- a/tests/test_dict_iter.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-use pyo3::prelude::*;
-use pyo3::types::IntoPyDict;
-
-#[test]
-#[cfg_attr(target_arch = "wasm32", ignore)] // Not sure why this fails.
-fn iter_dict_nosegv() {
-    Python::with_gil(|py| {
-        const LEN: usize = 10_000_000;
-        let dict = (0..LEN as u64).map(|i| (i, i * 2)).into_py_dict_bound(py);
-        let mut sum = 0;
-        for (k, _v) in dict {
-            let i: u64 = k.extract().unwrap();
-            sum += i;
-        }
-        assert_eq!(sum, 49_999_995_000_000);
-    });
-}
diff --git a/tests/test_enum.rs b/tests/test_enum.rs
index 33e94c241c7..cdc9935a6df 100644
--- a/tests/test_enum.rs
+++ b/tests/test_enum.rs
@@ -1,12 +1,12 @@
 #![cfg(feature = "macros")]
 
 use pyo3::prelude::*;
-use pyo3::{py_run, wrap_pyfunction};
+use pyo3::py_run;
+use pyo3::types::PyString;
 
-#[path = "../src/tests/common.rs"]
-mod common;
+mod test_utils;
 
-#[pyclass]
+#[pyclass(eq, eq_int)]
 #[derive(Debug, PartialEq, Eq, Clone)]
 pub enum MyEnum {
     Variant,
@@ -15,13 +15,34 @@ pub enum MyEnum {
 
 #[test]
 fn test_enum_class_attr() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let my_enum = py.get_type::<MyEnum>();
         let var = Py::new(py, MyEnum::Variant).unwrap();
         py_assert!(py, my_enum var, "my_enum.Variant == var");
     })
 }
 
+#[test]
+fn test_enum_eq_enum() {
+    Python::attach(|py| {
+        let var1 = Py::new(py, MyEnum::Variant).unwrap();
+        let var2 = Py::new(py, MyEnum::Variant).unwrap();
+        let other_var = Py::new(py, MyEnum::OtherVariant).unwrap();
+        py_assert!(py, var1 var2, "var1 == var2");
+        py_assert!(py, var1 other_var, "var1 != other_var");
+        py_assert!(py, var1 var2, "(var1 != var2) == False");
+    })
+}
+
+#[test]
+fn test_enum_eq_incomparable() {
+    Python::attach(|py| {
+        let var1 = Py::new(py, MyEnum::Variant).unwrap();
+        py_assert!(py, var1, "(var1 == 'foo') == False");
+        py_assert!(py, var1, "(var1 != 'foo') == True");
+    })
+}
+
 #[pyfunction]
 fn return_enum() -> MyEnum {
     MyEnum::Variant
@@ -29,7 +50,7 @@ fn return_enum() -> MyEnum {
 
 #[test]
 fn test_return_enum() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let f = wrap_pyfunction!(return_enum)(py).unwrap();
         let mynum = py.get_type::<MyEnum>();
 
@@ -44,7 +65,7 @@ fn enum_arg(e: MyEnum) {
 
 #[test]
 fn test_enum_arg() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let f = wrap_pyfunction!(enum_arg)(py).unwrap();
         let mynum = py.get_type::<MyEnum>();
 
@@ -52,28 +73,8 @@ fn test_enum_arg() {
     })
 }
 
-#[test]
-fn test_enum_eq_enum() {
-    Python::with_gil(|py| {
-        let var1 = Py::new(py, MyEnum::Variant).unwrap();
-        let var2 = Py::new(py, MyEnum::Variant).unwrap();
-        let other_var = Py::new(py, MyEnum::OtherVariant).unwrap();
-        py_assert!(py, var1 var2, "var1 == var2");
-        py_assert!(py, var1 other_var, "var1 != other_var");
-        py_assert!(py, var1 var2, "(var1 != var2) == False");
-    })
-}
-
-#[test]
-fn test_enum_eq_incomparable() {
-    Python::with_gil(|py| {
-        let var1 = Py::new(py, MyEnum::Variant).unwrap();
-        py_assert!(py, var1, "(var1 == 'foo') == False");
-        py_assert!(py, var1, "(var1 != 'foo') == True");
-    })
-}
-
-#[pyclass]
+#[pyclass(eq, eq_int)]
+#[derive(Debug, PartialEq, Eq, Clone)]
 enum CustomDiscriminant {
     One = 1,
     Two = 2,
@@ -81,7 +82,7 @@ enum CustomDiscriminant {
 
 #[test]
 fn test_custom_discriminant() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         #[allow(non_snake_case)]
         let CustomDiscriminant = py.get_type::<CustomDiscriminant>();
         let one = Py::new(py, CustomDiscriminant::One).unwrap();
@@ -89,14 +90,18 @@ fn test_custom_discriminant() {
         py_run!(py, CustomDiscriminant one two, r#"
         assert CustomDiscriminant.One == one
         assert CustomDiscriminant.Two == two
+        assert CustomDiscriminant.One == 1
+        assert CustomDiscriminant.Two == 2
         assert one != two
+        assert CustomDiscriminant.One != 2
+        assert CustomDiscriminant.Two != 1
         "#);
     })
 }
 
 #[test]
 fn test_enum_to_int() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let one = Py::new(py, CustomDiscriminant::One).unwrap();
         py_assert!(py, one, "int(one) == 1");
         let v = Py::new(py, MyEnum::Variant).unwrap();
@@ -107,7 +112,7 @@ fn test_enum_to_int() {
 
 #[test]
 fn test_enum_compare_int() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let one = Py::new(py, CustomDiscriminant::One).unwrap();
         py_run!(
             py,
@@ -121,7 +126,8 @@ fn test_enum_compare_int() {
     })
 }
 
-#[pyclass]
+#[pyclass(eq, eq_int)]
+#[derive(Debug, PartialEq, Eq, Clone)]
 #[repr(u8)]
 enum SmallEnum {
     V = 1,
@@ -129,13 +135,14 @@ enum SmallEnum {
 
 #[test]
 fn test_enum_compare_int_no_throw_when_overflow() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let v = Py::new(py, SmallEnum::V).unwrap();
         py_assert!(py, v, "v != 1<<30")
     })
 }
 
-#[pyclass]
+#[pyclass(eq, eq_int)]
+#[derive(Debug, PartialEq, Eq, Clone)]
 #[repr(usize)]
 #[allow(clippy::enum_clike_unportable_variant)]
 enum BigEnum {
@@ -144,15 +151,17 @@ enum BigEnum {
 
 #[test]
 fn test_big_enum_no_overflow() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let usize_max = usize::MAX;
         let v = Py::new(py, BigEnum::V).unwrap();
+
         py_assert!(py, usize_max v, "v == usize_max");
         py_assert!(py, usize_max v, "int(v) == usize_max");
     })
 }
 
-#[pyclass]
+#[pyclass(eq, eq_int)]
+#[derive(Debug, PartialEq, Eq, Clone)]
 #[repr(u16, align(8))]
 enum TestReprParse {
     V,
@@ -163,7 +172,7 @@ fn test_repr_parse() {
     assert_eq!(std::mem::align_of::<TestReprParse>(), 8);
 }
 
-#[pyclass(name = "MyEnum")]
+#[pyclass(eq, eq_int, name = "MyEnum")]
 #[derive(Debug, PartialEq, Eq, Clone)]
 pub enum RenameEnum {
     Variant,
@@ -171,13 +180,13 @@ pub enum RenameEnum {
 
 #[test]
 fn test_rename_enum_repr_correct() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let var1 = Py::new(py, RenameEnum::Variant).unwrap();
         py_assert!(py, var1, "repr(var1) == 'MyEnum.Variant'");
     })
 }
 
-#[pyclass]
+#[pyclass(eq, eq_int)]
 #[derive(Debug, PartialEq, Eq, Clone)]
 pub enum RenameVariantEnum {
     #[pyo3(name = "VARIANT")]
@@ -186,13 +195,14 @@ pub enum RenameVariantEnum {
 
 #[test]
 fn test_rename_variant_repr_correct() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let var1 = Py::new(py, RenameVariantEnum::Variant).unwrap();
         py_assert!(py, var1, "repr(var1) == 'RenameVariantEnum.VARIANT'");
     })
 }
 
-#[pyclass(rename_all = "SCREAMING_SNAKE_CASE")]
+#[pyclass(eq, eq_int, rename_all = "SCREAMING_SNAKE_CASE")]
+#[derive(Debug, PartialEq, Eq, Clone)]
 #[allow(clippy::enum_variant_names)]
 enum RenameAllVariantsEnum {
     VariantOne,
@@ -203,7 +213,7 @@ enum RenameAllVariantsEnum {
 
 #[test]
 fn test_renaming_all_enum_variants() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let enum_obj = py.get_type::<RenameAllVariantsEnum>();
         py_assert!(py, enum_obj, "enum_obj.VARIANT_ONE == enum_obj.VARIANT_ONE");
         py_assert!(py, enum_obj, "enum_obj.VARIANT_TWO == enum_obj.VARIANT_TWO");
@@ -214,3 +224,182 @@ fn test_renaming_all_enum_variants() {
         );
     });
 }
+
+#[pyclass(module = "custom_module")]
+#[derive(Debug)]
+enum CustomModuleComplexEnum {
+    Variant(),
+    Py(Py<PyAny>),
+}
+
+#[test]
+fn test_custom_module() {
+    Python::attach(|py| {
+        let enum_obj = py.get_type::<CustomModuleComplexEnum>();
+        py_assert!(
+            py,
+            enum_obj,
+            "enum_obj.Variant.__module__ == 'custom_module'"
+        );
+    });
+}
+
+#[pyclass(eq)]
+#[derive(Debug, Clone, PartialEq)]
+pub enum EqOnly {
+    VariantA,
+    VariantB,
+}
+
+#[test]
+fn test_simple_enum_eq_only() {
+    Python::attach(|py| {
+        let var1 = Py::new(py, EqOnly::VariantA).unwrap();
+        let var2 = Py::new(py, EqOnly::VariantA).unwrap();
+        let var3 = Py::new(py, EqOnly::VariantB).unwrap();
+        py_assert!(py, var1 var2, "var1 == var2");
+        py_assert!(py, var1 var3, "var1 != var3");
+    })
+}
+
+#[pyclass(frozen, eq, eq_int, hash)]
+#[derive(PartialEq, Hash)]
+enum SimpleEnumWithHash {
+    A,
+    B,
+}
+
+#[test]
+fn test_simple_enum_with_hash() {
+    Python::attach(|py| {
+        use pyo3::types::IntoPyDict;
+        let class = SimpleEnumWithHash::A;
+        let hash = {
+            use std::hash::{Hash, Hasher};
+            let mut hasher = std::collections::hash_map::DefaultHasher::new();
+            class.hash(&mut hasher);
+            hasher.finish() as isize
+        };
+
+        let env = [
+            ("obj", Py::new(py, class).unwrap().into_any()),
+            ("hsh", hash.into_pyobject(py).unwrap().into_any().unbind()),
+        ]
+        .into_py_dict(py)
+        .unwrap();
+
+        py_assert!(py, *env, "hash(obj) == hsh");
+    });
+}
+
+#[pyclass(eq, hash)]
+#[derive(PartialEq, Hash)]
+enum ComplexEnumWithHash {
+    A(u32),
+    B { msg: String },
+}
+
+#[test]
+fn test_complex_enum_with_hash() {
+    Python::attach(|py| {
+        use pyo3::types::IntoPyDict;
+        let class = ComplexEnumWithHash::B {
+            msg: String::from("Hello"),
+        };
+        let hash = {
+            use std::hash::{Hash, Hasher};
+            let mut hasher = std::collections::hash_map::DefaultHasher::new();
+            class.hash(&mut hasher);
+            hasher.finish() as isize
+        };
+
+        let env = [
+            ("obj", Py::new(py, class).unwrap().into_any()),
+            ("hsh", hash.into_pyobject(py).unwrap().into_any().unbind()),
+        ]
+        .into_py_dict(py)
+        .unwrap();
+
+        py_assert!(py, *env, "hash(obj) == hsh");
+    });
+}
+
+#[test]
+fn custom_eq() {
+    #[pyclass(frozen)]
+    #[derive(PartialEq)]
+    pub enum CustomPyEq {
+        A,
+        B,
+    }
+
+    #[pymethods]
+    impl CustomPyEq {
+        fn __eq__(&self, other: &Bound<'_, PyAny>) -> bool {
+            if let Ok(rhs) = other.cast::<PyString>() {
+                rhs.to_cow().is_ok_and(|rhs| self.__str__() == rhs)
+            } else if let Ok(rhs) = other.cast::<Self>() {
+                self == rhs.get()
+            } else {
+                false
+            }
+        }
+
+        fn __str__(&self) -> String {
+            match self {
+                CustomPyEq::A => "A".to_string(),
+                CustomPyEq::B => "B".to_string(),
+            }
+        }
+    }
+
+    Python::attach(|py| {
+        let a = Bound::new(py, CustomPyEq::A).unwrap();
+        let b = Bound::new(py, CustomPyEq::B).unwrap();
+
+        assert!(a.as_any().eq(&a).unwrap());
+        assert!(a.as_any().eq("A").unwrap());
+        assert!(a.as_any().ne(&b).unwrap());
+        assert!(a.as_any().ne("B").unwrap());
+
+        assert!(b.as_any().eq(&b).unwrap());
+        assert!(b.as_any().eq("B").unwrap());
+        assert!(b.as_any().ne(&a).unwrap());
+        assert!(b.as_any().ne("A").unwrap());
+    })
+}
+
+#[pyclass]
+#[derive(Clone, Copy)]
+pub enum ComplexEnumWithRaw {
+    Raw { r#type: i32 },
+}
+
+// Cover simple field lookups with raw identifiers
+#[test]
+fn complex_enum_with_raw() {
+    Python::attach(|py| {
+        let complex = ComplexEnumWithRaw::Raw { r#type: 314159 };
+
+        py_assert!(py, complex, "complex.type == 314159");
+    });
+}
+
+// Cover pattern matching with raw identifiers
+#[test]
+#[cfg(Py_3_10)]
+fn complex_enum_with_raw_pattern_match() {
+    Python::attach(|py| {
+        let complex = ComplexEnumWithRaw::Raw { r#type: 314159 };
+        let cls = py.get_type::<ComplexEnumWithRaw>();
+
+        // Cover destructuring by pattern matching
+        py_run!(py, cls complex, r#"
+        match complex:
+            case cls.Raw(type=ty):
+                assert ty == 314159
+            case _:
+                assert False, "no matching variant found"
+        "#);
+    });
+}
diff --git a/tests/test_exceptions.rs b/tests/test_exceptions.rs
index d6d6b46fcad..d09dd0a1dc2 100644
--- a/tests/test_exceptions.rs
+++ b/tests/test_exceptions.rs
@@ -1,14 +1,13 @@
 #![cfg(feature = "macros")]
 
 use pyo3::prelude::*;
-use pyo3::{exceptions, py_run, PyErr, PyResult};
+use pyo3::{exceptions, py_run};
 use std::error::Error;
 use std::fmt;
 #[cfg(not(target_os = "windows"))]
 use std::fs::File;
 
-#[path = "../src/tests/common.rs"]
-mod common;
+mod test_utils;
 
 #[pyfunction]
 #[cfg(not(target_os = "windows"))]
@@ -21,7 +20,7 @@ fn fail_to_open_file() -> PyResult<()> {
 #[cfg_attr(target_arch = "wasm32", ignore)] // Not sure why this fails.
 #[cfg(not(target_os = "windows"))]
 fn test_filenotfounderror() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let fail_to_open_file = wrap_pyfunction!(fail_to_open_file)(py).unwrap();
 
         py_run!(
@@ -66,7 +65,7 @@ fn call_fail_with_custom_error() -> PyResult<()> {
 
 #[test]
 fn test_custom_error() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let call_fail_with_custom_error =
             wrap_pyfunction!(call_fail_with_custom_error)(py).unwrap();
 
@@ -100,30 +99,27 @@ fn test_exception_nosegfault() {
 
 #[test]
 #[cfg(Py_3_8)]
-#[cfg_attr(not(feature = "gil-refs"), allow(deprecated))]
 fn test_write_unraisable() {
-    use common::UnraisableCapture;
-    use pyo3::{exceptions::PyRuntimeError, ffi};
+    use pyo3::{exceptions::PyRuntimeError, types::PyNotImplemented};
+    use test_utils::UnraisableCapture;
 
-    Python::with_gil(|py| {
-        let capture = UnraisableCapture::install(py);
+    Python::attach(|py| {
+        UnraisableCapture::enter(py, |capture| {
+            let err = PyRuntimeError::new_err("foo");
+            err.write_unraisable(py, None);
 
-        assert!(capture.borrow(py).capture.is_none());
+            let (err, object) = capture.take_capture().unwrap();
 
-        let err = PyRuntimeError::new_err("foo");
-        err.write_unraisable(py, None);
+            assert_eq!(err.to_string(), "RuntimeError: foo");
+            assert!(object.is_none());
 
-        let (err, object) = capture.borrow_mut(py).capture.take().unwrap();
-        assert_eq!(err.to_string(), "RuntimeError: foo");
-        assert!(object.is_none(py));
+            let err = PyRuntimeError::new_err("bar");
+            err.write_unraisable(py, Some(&PyNotImplemented::get(py)));
 
-        let err = PyRuntimeError::new_err("bar");
-        err.write_unraisable(py, Some(py.NotImplemented().as_ref(py)));
+            let (err, object) = capture.take_capture().unwrap();
 
-        let (err, object) = capture.borrow_mut(py).capture.take().unwrap();
-        assert_eq!(err.to_string(), "RuntimeError: bar");
-        assert!(object.as_ptr() == unsafe { ffi::Py_NotImplemented() });
-
-        capture.borrow_mut(py).uninstall(py);
+            assert_eq!(err.to_string(), "RuntimeError: bar");
+            assert!(object.is(PyNotImplemented::get(py)));
+        });
     });
 }
diff --git a/tests/test_field_cfg.rs b/tests/test_field_cfg.rs
index bd671641e5b..a684772fb1e 100644
--- a/tests/test_field_cfg.rs
+++ b/tests/test_field_cfg.rs
@@ -17,13 +17,37 @@ struct CfgClass {
     pub b: u32,
 }
 
+#[pyclass(eq, eq_int)]
+#[derive(PartialEq)]
+enum CfgSimpleEnum {
+    #[cfg(any())]
+    DisabledVariant,
+    #[cfg(not(any()))]
+    EnabledVariant,
+}
+
 #[test]
 fn test_cfg() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let cfg = CfgClass { b: 3 };
         let py_cfg = Py::new(py, cfg).unwrap();
-        assert!(py_cfg.as_ref(py).getattr("a").is_err());
-        let b: u32 = py_cfg.as_ref(py).getattr("b").unwrap().extract().unwrap();
+        assert!(py_cfg.bind(py).getattr("a").is_err());
+        let b: u32 = py_cfg.bind(py).getattr("b").unwrap().extract().unwrap();
         assert_eq!(b, 3);
     });
 }
+
+#[test]
+fn test_cfg_simple_enum() {
+    Python::attach(|py| {
+        let simple = py.get_type::<CfgSimpleEnum>();
+        pyo3::py_run!(
+            py,
+            simple,
+            r#"
+            assert hasattr(simple, "EnabledVariant")
+            assert not hasattr(simple, "DisabledVariant")
+        "#
+        );
+    })
+}
diff --git a/tests/test_frompy_intopy_roundtrip.rs b/tests/test_frompy_intopy_roundtrip.rs
new file mode 100644
index 00000000000..c4b120c5292
--- /dev/null
+++ b/tests/test_frompy_intopy_roundtrip.rs
@@ -0,0 +1,288 @@
+#![cfg(feature = "macros")]
+
+use pyo3::types::{PyDict, PyString};
+use pyo3::{prelude::*, IntoPyObject, IntoPyObjectExt, IntoPyObjectRef};
+use std::collections::HashMap;
+use std::hash::Hash;
+
+#[macro_use]
+mod test_utils;
+
+#[derive(Debug, Clone, IntoPyObject, IntoPyObjectRef, FromPyObject)]
+pub struct A<'py> {
+    #[pyo3(item)]
+    s: String,
+    #[pyo3(item)]
+    t: Bound<'py, PyString>,
+    #[pyo3(item("foo"))]
+    p: Bound<'py, PyAny>,
+}
+
+#[test]
+fn test_named_fields_struct() {
+    Python::attach(|py| {
+        let a = A {
+            s: "Hello".into(),
+            t: PyString::new(py, "World"),
+            p: 42i32.into_pyobject(py).unwrap().into_any(),
+        };
+        let pya = (&a).into_pyobject(py).unwrap();
+        let new_a = pya.extract::<A<'_>>().unwrap();
+
+        assert_eq!(a.s, new_a.s);
+        assert_eq!(a.t.to_cow().unwrap(), new_a.t.to_cow().unwrap());
+        assert_eq!(
+            a.p.extract::<i32>().unwrap(),
+            new_a.p.extract::<i32>().unwrap()
+        );
+
+        let pya = a.clone().into_pyobject(py).unwrap();
+        let new_a = pya.extract::<A<'_>>().unwrap();
+
+        assert_eq!(a.s, new_a.s);
+        assert_eq!(a.t.to_cow().unwrap(), new_a.t.to_cow().unwrap());
+        assert_eq!(
+            a.p.extract::<i32>().unwrap(),
+            new_a.p.extract::<i32>().unwrap()
+        );
+    });
+}
+
+#[derive(Debug, Clone, PartialEq, IntoPyObject, IntoPyObjectRef, FromPyObject)]
+#[pyo3(transparent)]
+pub struct B {
+    test: String,
+}
+
+#[test]
+fn test_transparent_named_field_struct() {
+    Python::attach(|py| {
+        let b = B {
+            test: "test".into(),
+        };
+        let pyb = (&b).into_pyobject(py).unwrap();
+        let new_b = pyb.extract::<B>().unwrap();
+        assert_eq!(b, new_b);
+
+        let pyb = b.clone().into_pyobject(py).unwrap();
+        let new_b = pyb.extract::<B>().unwrap();
+        assert_eq!(b, new_b);
+    });
+}
+
+#[derive(Debug, Clone, PartialEq, IntoPyObject, IntoPyObjectRef, FromPyObject)]
+#[pyo3(transparent)]
+pub struct D<T> {
+    test: T,
+}
+
+#[test]
+fn test_generic_transparent_named_field_struct() {
+    Python::attach(|py| {
+        let d = D {
+            test: String::from("test"),
+        };
+        let pyd = (&d).into_pyobject(py).unwrap();
+        let new_d = pyd.extract::<D<String>>().unwrap();
+        assert_eq!(d, new_d);
+
+        let d = D { test: 1usize };
+        let pyd = (&d).into_pyobject(py).unwrap();
+        let new_d = pyd.extract::<D<usize>>().unwrap();
+        assert_eq!(d, new_d);
+
+        let d = D {
+            test: String::from("test"),
+        };
+        let pyd = d.clone().into_pyobject(py).unwrap();
+        let new_d = pyd.extract::<D<String>>().unwrap();
+        assert_eq!(d, new_d);
+
+        let d = D { test: 1usize };
+        let pyd = d.clone().into_pyobject(py).unwrap();
+        let new_d = pyd.extract::<D<usize>>().unwrap();
+        assert_eq!(d, new_d);
+    });
+}
+
+#[derive(Debug, IntoPyObject, IntoPyObjectRef, FromPyObject)]
+pub struct GenericWithBound<K: Hash + Eq, V>(HashMap<K, V>);
+
+#[test]
+fn test_generic_with_bound() {
+    Python::attach(|py| {
+        let mut hash_map = HashMap::<String, i32>::new();
+        hash_map.insert("1".into(), 1);
+        hash_map.insert("2".into(), 2);
+        let map = GenericWithBound(hash_map);
+        let py_map = (&map).into_pyobject(py).unwrap();
+        assert_eq!(py_map.len(), 2);
+        assert_eq!(
+            py_map
+                .get_item("1")
+                .unwrap()
+                .unwrap()
+                .extract::<i32>()
+                .unwrap(),
+            1
+        );
+        assert_eq!(
+            py_map
+                .get_item("2")
+                .unwrap()
+                .unwrap()
+                .extract::<i32>()
+                .unwrap(),
+            2
+        );
+        assert!(py_map.get_item("3").unwrap().is_none());
+
+        let py_map = map.into_pyobject(py).unwrap();
+        assert_eq!(py_map.len(), 2);
+        assert_eq!(
+            py_map
+                .get_item("1")
+                .unwrap()
+                .unwrap()
+                .extract::<i32>()
+                .unwrap(),
+            1
+        );
+        assert_eq!(
+            py_map
+                .get_item("2")
+                .unwrap()
+                .unwrap()
+                .extract::<i32>()
+                .unwrap(),
+            2
+        );
+        assert!(py_map.get_item("3").unwrap().is_none());
+    });
+}
+
+#[derive(Debug, Clone, PartialEq, IntoPyObject, IntoPyObjectRef, FromPyObject)]
+pub struct Tuple(String, usize);
+
+#[test]
+fn test_tuple_struct() {
+    Python::attach(|py| {
+        let tup = Tuple(String::from("test"), 1);
+        let tuple = (&tup).into_pyobject(py).unwrap();
+        let new_tup = tuple.extract::<Tuple>().unwrap();
+        assert_eq!(tup, new_tup);
+
+        let tuple = tup.clone().into_pyobject(py).unwrap();
+        let new_tup = tuple.extract::<Tuple>().unwrap();
+        assert_eq!(tup, new_tup);
+    });
+}
+
+#[derive(Debug, Clone, PartialEq, IntoPyObject, IntoPyObjectRef, FromPyObject)]
+pub struct TransparentTuple(String);
+
+#[test]
+fn test_transparent_tuple_struct() {
+    Python::attach(|py| {
+        let tup = TransparentTuple(String::from("test"));
+        let tuple = (&tup).into_pyobject(py).unwrap();
+        let new_tup = tuple.extract::<TransparentTuple>().unwrap();
+        assert_eq!(tup, new_tup);
+
+        let tuple = tup.clone().into_pyobject(py).unwrap();
+        let new_tup = tuple.extract::<TransparentTuple>().unwrap();
+        assert_eq!(tup, new_tup);
+    });
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+pub struct IntWrapper(u32);
+
+fn int_wrapper_into_py<'py>(
+    v: std::borrow::Cow<'_, IntWrapper>,
+    py: Python<'py>,
+) -> PyResult<Bound<'py, PyAny>> {
+    v.0.into_bound_py_any(py)
+}
+
+fn int_wrapper_from_py(v: &Bound<'_, PyAny>) -> PyResult<IntWrapper> {
+    v.extract().map(IntWrapper)
+}
+
+#[derive(Debug, Clone, PartialEq, IntoPyObject, IntoPyObjectRef, FromPyObject)]
+pub enum Foo {
+    TupleVar(usize, String),
+    StructVar {
+        #[pyo3(item)]
+        test: char,
+        #[pyo3(item, into_py_with=int_wrapper_into_py, from_py_with=int_wrapper_from_py)]
+        int: IntWrapper,
+    },
+    #[pyo3(transparent)]
+    TransparentTuple(usize),
+    #[pyo3(transparent)]
+    TransparentStructVar {
+        a: Option<String>,
+    },
+    #[pyo3(rename_all = "camelCase", from_item_all)]
+    RenameAll {
+        long_field_name: [u16; 2],
+        other_field: Option<String>,
+    },
+}
+
+#[test]
+fn test_enum() {
+    Python::attach(|py| {
+        let tuple_var = Foo::TupleVar(1, "test".into());
+        let foo = (&tuple_var).into_pyobject(py).unwrap();
+        assert_eq!(tuple_var, foo.extract::<Foo>().unwrap());
+
+        let foo = tuple_var.clone().into_pyobject(py).unwrap();
+        assert_eq!(tuple_var, foo.extract::<Foo>().unwrap());
+
+        let struct_var = Foo::StructVar {
+            test: 'b',
+            int: IntWrapper(42),
+        };
+        let foo = (&struct_var)
+            .into_pyobject(py)
+            .unwrap()
+            .cast_into::<PyDict>()
+            .unwrap();
+        assert_eq!(struct_var, foo.extract::<Foo>().unwrap());
+
+        let foo = struct_var
+            .clone()
+            .into_pyobject(py)
+            .unwrap()
+            .cast_into::<PyDict>()
+            .unwrap();
+
+        assert_eq!(struct_var, foo.extract::<Foo>().unwrap());
+
+        let transparent_tuple = Foo::TransparentTuple(1);
+        let foo = (&transparent_tuple).into_pyobject(py).unwrap();
+        assert_eq!(transparent_tuple, foo.extract::<Foo>().unwrap());
+
+        let foo = transparent_tuple.clone().into_pyobject(py).unwrap();
+        assert_eq!(transparent_tuple, foo.extract::<Foo>().unwrap());
+
+        let transparent_struct_var = Foo::TransparentStructVar { a: None };
+        let foo = (&transparent_struct_var).into_pyobject(py).unwrap();
+        assert_eq!(transparent_struct_var, foo.extract::<Foo>().unwrap());
+
+        let foo = transparent_struct_var.clone().into_pyobject(py).unwrap();
+        assert_eq!(transparent_struct_var, foo.extract::<Foo>().unwrap());
+
+        let rename_all_struct_var = Foo::RenameAll {
+            long_field_name: [1, 2],
+            other_field: None,
+        };
+        let foo = (&rename_all_struct_var).into_pyobject(py).unwrap();
+        assert_eq!(rename_all_struct_var, foo.extract::<Foo>().unwrap());
+
+        let foo = rename_all_struct_var.clone().into_pyobject(py).unwrap();
+        assert_eq!(rename_all_struct_var, foo.extract::<Foo>().unwrap());
+    });
+}
diff --git a/tests/test_frompyobject.rs b/tests/test_frompyobject.rs
index 5c57a954023..ecec5bcac06 100644
--- a/tests/test_frompyobject.rs
+++ b/tests/test_frompyobject.rs
@@ -2,11 +2,10 @@
 
 use pyo3::exceptions::PyValueError;
 use pyo3::prelude::*;
-use pyo3::types::{PyDict, PyList, PyString, PyTuple};
+use pyo3::types::{IntoPyDict, PyDict, PyList, PyString, PyTuple};
 
 #[macro_use]
-#[path = "../src/tests/common.rs"]
-mod common;
+mod test_utils;
 
 /// Helper function that concatenates the error message from
 /// each error in the traceback into a single string that can
@@ -52,7 +51,7 @@ impl PyA {
 
 #[test]
 fn test_named_fields_struct() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let pya = PyA {
             s: "foo".into(),
             foo: None,
@@ -75,14 +74,14 @@ pub struct B {
 
 #[test]
 fn test_transparent_named_field_struct() {
-    Python::with_gil(|py| {
-        let test: PyObject = "test".into_py(py);
+    Python::attach(|py| {
+        let test = "test".into_pyobject(py).unwrap();
         let b = test
-            .extract::<B>(py)
+            .extract::<B>()
             .expect("Failed to extract B from String");
         assert_eq!(b.test, "test");
-        let test: PyObject = 1.into_py(py);
-        let b = test.extract::<B>(py);
+        let test = 1i32.into_pyobject(py).unwrap();
+        let b = test.extract::<B>();
         assert!(b.is_err());
     });
 }
@@ -95,20 +94,35 @@ pub struct D<T> {
 
 #[test]
 fn test_generic_transparent_named_field_struct() {
-    Python::with_gil(|py| {
-        let test: PyObject = "test".into_py(py);
+    Python::attach(|py| {
+        let test = "test".into_pyobject(py).unwrap();
         let d = test
-            .extract::<D<String>>(py)
+            .extract::<D<String>>()
             .expect("Failed to extract D<String> from String");
         assert_eq!(d.test, "test");
-        let test = 1usize.into_py(py);
+        let test = 1usize.into_pyobject(py).unwrap();
         let d = test
-            .extract::<D<usize>>(py)
+            .extract::<D<usize>>()
             .expect("Failed to extract D<usize> from String");
         assert_eq!(d.test, 1);
     });
 }
 
+#[derive(Debug, FromPyObject)]
+pub struct GenericWithBound<K: std::hash::Hash + Eq, V>(std::collections::HashMap<K, V>);
+
+#[test]
+fn test_generic_with_bound() {
+    Python::attach(|py| {
+        let dict = [("1", 1), ("2", 2)].into_py_dict(py).unwrap();
+        let map = dict.extract::<GenericWithBound<String, i32>>().unwrap().0;
+        assert_eq!(map.len(), 2);
+        assert_eq!(map["1"], 1);
+        assert_eq!(map["2"], 2);
+        assert!(!map.contains_key("3"));
+    });
+}
+
 #[derive(Debug, FromPyObject)]
 pub struct E<T, T2> {
     test: T,
@@ -126,19 +140,20 @@ pub struct PyE {
 
 #[test]
 fn test_generic_named_fields_struct() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let pye = PyE {
             test: "test".into(),
             test2: 2,
         }
-        .into_py(py);
+        .into_pyobject(py)
+        .unwrap();
 
         let e = pye
-            .extract::<E<String, usize>>(py)
+            .extract::<E<String, usize>>()
             .expect("Failed to extract E<String, usize> from PyE");
         assert_eq!(e.test, "test");
         assert_eq!(e.test2, 2);
-        let e = pye.extract::<E<usize, usize>>(py);
+        let e = pye.extract::<E<usize, usize>>();
         assert!(e.is_err());
     });
 }
@@ -151,13 +166,14 @@ pub struct C {
 
 #[test]
 fn test_named_field_with_ext_fn() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let pyc = PyE {
             test: "foo".into(),
             test2: 0,
         }
-        .into_py(py);
-        let c = pyc.extract::<C>(py).expect("Failed to extract C from PyE");
+        .into_pyobject(py)
+        .unwrap();
+        let c = pyc.extract::<C>().expect("Failed to extract C from PyE");
         assert_eq!(c.test, "foo");
     });
 }
@@ -167,11 +183,25 @@ pub struct Tuple(String, usize);
 
 #[test]
 fn test_tuple_struct() {
-    Python::with_gil(|py| {
-        let tup = PyTuple::new_bound(py, &[1.into_py(py), "test".into_py(py)]);
+    Python::attach(|py| {
+        let tup = PyTuple::new(
+            py,
+            &[
+                1i32.into_pyobject(py).unwrap().into_any(),
+                "test".into_pyobject(py).unwrap().into_any(),
+            ],
+        )
+        .unwrap();
         let tup = tup.extract::<Tuple>();
         assert!(tup.is_err());
-        let tup = PyTuple::new_bound(py, &["test".into_py(py), 1.into_py(py)]);
+        let tup = PyTuple::new(
+            py,
+            &[
+                "test".into_pyobject(py).unwrap().into_any(),
+                1i32.into_pyobject(py).unwrap().into_any(),
+            ],
+        )
+        .unwrap();
         let tup = tup
             .extract::<Tuple>()
             .expect("Failed to extract Tuple from PyTuple");
@@ -185,13 +215,13 @@ pub struct TransparentTuple(String);
 
 #[test]
 fn test_transparent_tuple_struct() {
-    Python::with_gil(|py| {
-        let tup: PyObject = 1.into_py(py);
-        let tup = tup.extract::<TransparentTuple>(py);
+    Python::attach(|py| {
+        let tup = 1i32.into_pyobject(py).unwrap();
+        let tup = tup.extract::<TransparentTuple>();
         assert!(tup.is_err());
-        let test: PyObject = "test".into_py(py);
+        let test = "test".into_pyobject(py).unwrap();
         let tup = test
-            .extract::<TransparentTuple>(py)
+            .extract::<TransparentTuple>()
             .expect("Failed to extract TransparentTuple from PyTuple");
         assert_eq!(tup.0, "test");
     });
@@ -214,7 +244,7 @@ struct Baz<U, T> {
 
 #[test]
 fn test_struct_nested_type_errors() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let pybaz = PyBaz {
             tup: ("test".into(), "test".into()),
             e: PyE {
@@ -222,9 +252,10 @@ fn test_struct_nested_type_errors() {
                 test2: 0,
             },
         }
-        .into_py(py);
+        .into_pyobject(py)
+        .unwrap();
 
-        let test = pybaz.extract::<Baz<String, usize>>(py);
+        let test = pybaz.extract::<Baz<String, usize>>();
         assert!(test.is_err());
         assert_eq!(
             extract_traceback(py,test.unwrap_err()),
@@ -236,7 +267,7 @@ fn test_struct_nested_type_errors() {
 
 #[test]
 fn test_struct_nested_type_errors_with_generics() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let pybaz = PyBaz {
             tup: ("test".into(), "test".into()),
             e: PyE {
@@ -244,9 +275,10 @@ fn test_struct_nested_type_errors_with_generics() {
                 test2: 0,
             },
         }
-        .into_py(py);
+        .into_pyobject(py)
+        .unwrap();
 
-        let test = pybaz.extract::<Baz<usize, usize>>(py);
+        let test = pybaz.extract::<Baz<usize, usize>>();
         assert!(test.is_err());
         assert_eq!(
             extract_traceback(py, test.unwrap_err()),
@@ -258,46 +290,131 @@ fn test_struct_nested_type_errors_with_generics() {
 
 #[test]
 fn test_transparent_struct_error_message() {
-    Python::with_gil(|py| {
-        let tup: PyObject = 1.into_py(py);
-        let tup = tup.extract::<B>(py);
+    Python::attach(|py| {
+        let tup = 1i32.into_pyobject(py).unwrap();
+        let tup = tup.extract::<B>();
         assert!(tup.is_err());
         assert_eq!(
-            extract_traceback(py,tup.unwrap_err()),
-            "TypeError: failed to extract field B.test: TypeError: \'int\' object cannot be converted \
-         to \'PyString\'"
+            extract_traceback(py, tup.unwrap_err()),
+            "TypeError: failed to extract field B.test: TypeError: \'int\' object cannot be cast \
+         as \'str\'"
         );
     });
 }
 
 #[test]
 fn test_tuple_struct_error_message() {
-    Python::with_gil(|py| {
-        let tup: PyObject = (1, "test").into_py(py);
-        let tup = tup.extract::<Tuple>(py);
+    Python::attach(|py| {
+        let tup = (1, "test").into_pyobject(py).unwrap();
+        let tup = tup.extract::<Tuple>();
         assert!(tup.is_err());
         assert_eq!(
             extract_traceback(py, tup.unwrap_err()),
-            "TypeError: failed to extract field Tuple.0: TypeError: \'int\' object cannot be \
-         converted to \'PyString\'"
+            "TypeError: failed to extract field Tuple.0: TypeError: \'int\' object cannot be cast \
+         as \'str\'"
         );
     });
 }
 
 #[test]
 fn test_transparent_tuple_error_message() {
-    Python::with_gil(|py| {
-        let tup: PyObject = 1.into_py(py);
-        let tup = tup.extract::<TransparentTuple>(py);
+    Python::attach(|py| {
+        let tup = 1i32.into_pyobject(py).unwrap();
+        let tup = tup.extract::<TransparentTuple>();
         assert!(tup.is_err());
         assert_eq!(
             extract_traceback(py, tup.unwrap_err()),
             "TypeError: failed to extract field TransparentTuple.0: TypeError: 'int' object \
-         cannot be converted to 'PyString'",
+         cannot be cast as 'str'",
         );
     });
 }
 
+#[pyclass]
+struct RenameAllCls {}
+
+#[pymethods]
+impl RenameAllCls {
+    #[getter]
+    #[pyo3(name = "someField")]
+    fn some_field(&self) -> &'static str {
+        "Foo"
+    }
+
+    #[getter]
+    #[pyo3(name = "customNumber")]
+    fn custom_number(&self) -> i32 {
+        42
+    }
+
+    fn __getitem__(&self, key: &str) -> PyResult<f32> {
+        match key {
+            "otherField" => Ok(42.0),
+            _ => Err(pyo3::exceptions::PyKeyError::new_err("foo")),
+        }
+    }
+}
+
+#[test]
+fn test_struct_rename_all() {
+    #[derive(FromPyObject)]
+    #[pyo3(rename_all = "camelCase")]
+    struct RenameAll {
+        some_field: String,
+        #[pyo3(item)]
+        other_field: f32,
+        #[pyo3(attribute("customNumber"))]
+        custom_name: i32,
+    }
+
+    Python::attach(|py| {
+        let RenameAll {
+            some_field,
+            other_field,
+            custom_name,
+        } = RenameAllCls {}
+            .into_pyobject(py)
+            .unwrap()
+            .extract()
+            .unwrap();
+
+        assert_eq!(some_field, "Foo");
+        assert_eq!(other_field, 42.0);
+        assert_eq!(custom_name, 42);
+    });
+}
+
+#[test]
+fn test_enum_rename_all() {
+    #[derive(FromPyObject)]
+    #[pyo3(rename_all = "camelCase")]
+    enum RenameAll {
+        Foo {
+            some_field: String,
+            #[pyo3(item)]
+            other_field: f32,
+            #[pyo3(attribute("customNumber"))]
+            custom_name: i32,
+        },
+    }
+
+    Python::attach(|py| {
+        let RenameAll::Foo {
+            some_field,
+            other_field,
+            custom_name,
+        } = RenameAllCls {}
+            .into_pyobject(py)
+            .unwrap()
+            .extract()
+            .unwrap();
+
+        assert_eq!(some_field, "Foo");
+        assert_eq!(other_field, 42.0);
+        assert_eq!(custom_name, 42);
+    });
+}
+
 #[derive(Debug, FromPyObject)]
 pub enum Foo<'py> {
     TupleVar(usize, String),
@@ -332,8 +449,15 @@ pub struct PyBool {
 
 #[test]
 fn test_enum() {
-    Python::with_gil(|py| {
-        let tup = PyTuple::new_bound(py, &[1.into_py(py), "test".into_py(py)]);
+    Python::attach(|py| {
+        let tup = PyTuple::new(
+            py,
+            &[
+                1i32.into_pyobject(py).unwrap().into_any(),
+                "test".into_pyobject(py).unwrap().into_any(),
+            ],
+        )
+        .unwrap();
         let f = tup
             .extract::<Foo<'_>>()
             .expect("Failed to extract Foo from tuple");
@@ -342,29 +466,30 @@ fn test_enum() {
                 assert_eq!(test, 1);
                 assert_eq!(test2, "test");
             }
-            _ => panic!("Expected extracting Foo::TupleVar, got {:?}", f),
+            _ => panic!("Expected extracting Foo::TupleVar, got {f:?}"),
         }
 
         let pye = PyE {
             test: "foo".into(),
             test2: 0,
         }
-        .into_py(py);
+        .into_pyobject(py)
+        .unwrap();
         let f = pye
-            .extract::<Foo<'_>>(py)
+            .extract::<Foo<'_>>()
             .expect("Failed to extract Foo from PyE");
         match f {
             Foo::StructVar { test } => assert_eq!(test.to_string_lossy(), "foo"),
-            _ => panic!("Expected extracting Foo::StructVar, got {:?}", f),
+            _ => panic!("Expected extracting Foo::StructVar, got {f:?}"),
         }
 
-        let int: PyObject = 1.into_py(py);
+        let int = 1i32.into_pyobject(py).unwrap();
         let f = int
-            .extract::<Foo<'_>>(py)
+            .extract::<Foo<'_>>()
             .expect("Failed to extract Foo from int");
         match f {
             Foo::TransparentTuple(test) => assert_eq!(test, 1),
-            _ => panic!("Expected extracting Foo::TransparentTuple, got {:?}", f),
+            _ => panic!("Expected extracting Foo::TransparentTuple, got {f:?}"),
         }
         let none = py.None();
         let f = none
@@ -372,59 +497,59 @@ fn test_enum() {
             .expect("Failed to extract Foo from int");
         match f {
             Foo::TransparentStructVar { a } => assert!(a.is_none()),
-            _ => panic!("Expected extracting Foo::TransparentStructVar, got {:?}", f),
+            _ => panic!("Expected extracting Foo::TransparentStructVar, got {f:?}"),
         }
 
-        let pybool = PyBool { bla: true }.into_py(py);
+        let pybool = PyBool { bla: true }.into_pyobject(py).unwrap();
         let f = pybool
-            .extract::<Foo<'_>>(py)
+            .extract::<Foo<'_>>()
             .expect("Failed to extract Foo from PyBool");
         match f {
             Foo::StructVarGetAttrArg { a } => assert!(a),
-            _ => panic!("Expected extracting Foo::StructVarGetAttrArg, got {:?}", f),
+            _ => panic!("Expected extracting Foo::StructVarGetAttrArg, got {f:?}"),
         }
 
-        let dict = PyDict::new_bound(py);
+        let dict = PyDict::new(py);
         dict.set_item("a", "test").expect("Failed to set item");
         let f = dict
             .extract::<Foo<'_>>()
             .expect("Failed to extract Foo from dict");
         match f {
             Foo::StructWithGetItem { a } => assert_eq!(a, "test"),
-            _ => panic!("Expected extracting Foo::StructWithGetItem, got {:?}", f),
+            _ => panic!("Expected extracting Foo::StructWithGetItem, got {f:?}"),
         }
 
-        let dict = PyDict::new_bound(py);
+        let dict = PyDict::new(py);
         dict.set_item("foo", "test").expect("Failed to set item");
         let f = dict
             .extract::<Foo<'_>>()
             .expect("Failed to extract Foo from dict");
         match f {
             Foo::StructWithGetItemArg { a } => assert_eq!(a, "test"),
-            _ => panic!("Expected extracting Foo::StructWithGetItemArg, got {:?}", f),
+            _ => panic!("Expected extracting Foo::StructWithGetItemArg, got {f:?}"),
         }
     });
 }
 
 #[test]
 fn test_enum_error() {
-    Python::with_gil(|py| {
-        let dict = PyDict::new_bound(py);
+    Python::attach(|py| {
+        let dict = PyDict::new(py);
         let err = dict.extract::<Foo<'_>>().unwrap_err();
         assert_eq!(
             err.to_string(),
             "\
 TypeError: failed to extract enum Foo ('TupleVar | StructVar | TransparentTuple | TransparentStructVar | StructVarGetAttrArg | StructWithGetItem | StructWithGetItemArg')
-- variant TupleVar (TupleVar): TypeError: 'dict' object cannot be converted to 'PyTuple'
+- variant TupleVar (TupleVar): TypeError: 'dict' object cannot be cast as 'tuple'
 - variant StructVar (StructVar): AttributeError: 'dict' object has no attribute 'test'
 - variant TransparentTuple (TransparentTuple): TypeError: failed to extract field Foo::TransparentTuple.0, caused by TypeError: 'dict' object cannot be interpreted as an integer
-- variant TransparentStructVar (TransparentStructVar): TypeError: failed to extract field Foo::TransparentStructVar.a, caused by TypeError: 'dict' object cannot be converted to 'PyString'
+- variant TransparentStructVar (TransparentStructVar): TypeError: failed to extract field Foo::TransparentStructVar.a, caused by TypeError: 'dict' object cannot be cast as 'str'
 - variant StructVarGetAttrArg (StructVarGetAttrArg): AttributeError: 'dict' object has no attribute 'bla'
 - variant StructWithGetItem (StructWithGetItem): KeyError: 'a'
 - variant StructWithGetItemArg (StructWithGetItemArg): KeyError: 'foo'"
         );
 
-        let tup = PyTuple::empty_bound(py);
+        let tup = PyTuple::empty(py);
         let err = tup.extract::<Foo<'_>>().unwrap_err();
         assert_eq!(
             err.to_string(),
@@ -433,7 +558,7 @@ TypeError: failed to extract enum Foo ('TupleVar | StructVar | TransparentTuple
 - variant TupleVar (TupleVar): ValueError: expected tuple of length 2, but got tuple of length 0
 - variant StructVar (StructVar): AttributeError: 'tuple' object has no attribute 'test'
 - variant TransparentTuple (TransparentTuple): TypeError: failed to extract field Foo::TransparentTuple.0, caused by TypeError: 'tuple' object cannot be interpreted as an integer
-- variant TransparentStructVar (TransparentStructVar): TypeError: failed to extract field Foo::TransparentStructVar.a, caused by TypeError: 'tuple' object cannot be converted to 'PyString'
+- variant TransparentStructVar (TransparentStructVar): TypeError: failed to extract field Foo::TransparentStructVar.a, caused by TypeError: 'tuple' object cannot be cast as 'str'
 - variant StructVarGetAttrArg (StructVarGetAttrArg): AttributeError: 'tuple' object has no attribute 'bla'
 - variant StructWithGetItem (StructWithGetItem): TypeError: tuple indices must be integers or slices, not str
 - variant StructWithGetItemArg (StructWithGetItemArg): TypeError: tuple indices must be integers or slices, not str"
@@ -452,8 +577,8 @@ enum EnumWithCatchAll<'py> {
 
 #[test]
 fn test_enum_catch_all() {
-    Python::with_gil(|py| {
-        let dict = PyDict::new_bound(py);
+    Python::attach(|py| {
+        let dict = PyDict::new(py);
         let f = dict
             .extract::<EnumWithCatchAll<'_>>()
             .expect("Failed to extract EnumWithCatchAll from dict");
@@ -462,10 +587,7 @@ fn test_enum_catch_all() {
                 let d = any.extract::<Bound<'_, PyDict>>().expect("Expected pydict");
                 assert!(d.is_empty());
             }
-            _ => panic!(
-                "Expected extracting EnumWithCatchAll::CatchAll, got {:?}",
-                f
-            ),
+            _ => panic!("Expected extracting EnumWithCatchAll::CatchAll, got {f:?}"),
         }
     });
 }
@@ -482,15 +604,15 @@ pub enum Bar {
 
 #[test]
 fn test_err_rename() {
-    Python::with_gil(|py| {
-        let dict = PyDict::new_bound(py);
+    Python::attach(|py| {
+        let dict = PyDict::new(py);
         let f = dict.extract::<Bar>();
         assert!(f.is_err());
         assert_eq!(
             f.unwrap_err().to_string(),
             "\
 TypeError: failed to extract enum Bar ('str | uint | int')
-- variant A (str): TypeError: failed to extract field Bar::A.0, caused by TypeError: 'dict' object cannot be converted to 'PyString'
+- variant A (str): TypeError: failed to extract field Bar::A.0, caused by TypeError: 'dict' object cannot be cast as 'str'
 - variant B (uint): TypeError: failed to extract field Bar::B.0, caused by TypeError: 'dict' object cannot be interpreted as an integer
 - variant C (int): TypeError: failed to extract field Bar::C.0, caused by TypeError: 'dict' object cannot be interpreted as an integer"
         );
@@ -502,16 +624,16 @@ pub struct Zap {
     #[pyo3(item)]
     name: String,
 
-    #[pyo3(from_py_with = "Bound::<'_, PyAny>::len", item("my_object"))]
+    #[pyo3(from_py_with = Bound::<'_, PyAny>::len, item("my_object"))]
     some_object_length: usize,
 }
 
 #[test]
 fn test_from_py_with() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let py_zap = py
-            .eval_bound(
-                r#"{"name": "whatever", "my_object": [1, 2, 3]}"#,
+            .eval(
+                cr#"{"name": "whatever", "my_object": [1, 2, 3]}"#,
                 None,
                 None,
             )
@@ -527,14 +649,14 @@ fn test_from_py_with() {
 #[derive(Debug, FromPyObject)]
 pub struct ZapTuple(
     String,
-    #[pyo3(from_py_with = "Bound::<'_, PyAny>::len")] usize,
+    #[pyo3(from_py_with = Bound::<'_, PyAny>::len)] usize,
 );
 
 #[test]
 fn test_from_py_with_tuple_struct() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let py_zap = py
-            .eval_bound(r#"("whatever", [1, 2, 3])"#, None, None)
+            .eval(cr#"("whatever", [1, 2, 3])"#, None, None)
             .expect("failed to create tuple");
 
         let zap = py_zap.extract::<ZapTuple>().unwrap();
@@ -546,9 +668,9 @@ fn test_from_py_with_tuple_struct() {
 
 #[test]
 fn test_from_py_with_tuple_struct_error() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let py_zap = py
-            .eval_bound(r#"("whatever", [1, 2, 3], "third")"#, None, None)
+            .eval(cr#"("whatever", [1, 2, 3], "third")"#, None, None)
             .expect("failed to create tuple");
 
         let f = py_zap.extract::<ZapTuple>();
@@ -563,18 +685,18 @@ fn test_from_py_with_tuple_struct_error() {
 
 #[derive(Debug, FromPyObject, PartialEq, Eq)]
 pub enum ZapEnum {
-    Zip(#[pyo3(from_py_with = "Bound::<'_, PyAny>::len")] usize),
+    Zip(#[pyo3(from_py_with = Bound::<'_, PyAny>::len)] usize),
     Zap(
         String,
-        #[pyo3(from_py_with = "Bound::<'_, PyAny>::len")] usize,
+        #[pyo3(from_py_with = Bound::<'_, PyAny>::len)] usize,
     ),
 }
 
 #[test]
 fn test_from_py_with_enum() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let py_zap = py
-            .eval_bound(r#"("whatever", [1, 2, 3])"#, None, None)
+            .eval(cr#"("whatever", [1, 2, 3])"#, None, None)
             .expect("failed to create tuple");
 
         let zap = py_zap.extract::<ZapEnum>().unwrap();
@@ -587,14 +709,15 @@ fn test_from_py_with_enum() {
 #[derive(Debug, FromPyObject, PartialEq, Eq)]
 #[pyo3(transparent)]
 pub struct TransparentFromPyWith {
-    #[pyo3(from_py_with = "Bound::<'_, PyAny>::len")]
+    #[pyo3(from_py_with = Bound::<'_, PyAny>::len)]
     len: usize,
 }
 
 #[test]
 fn test_transparent_from_py_with() {
-    Python::with_gil(|py| {
-        let result = PyList::new_bound(py, [1, 2, 3])
+    Python::attach(|py| {
+        let result = PyList::new(py, [1, 2, 3])
+            .unwrap()
             .extract::<TransparentFromPyWith>()
             .unwrap();
         let expected = TransparentFromPyWith { len: 3 };
@@ -602,3 +725,155 @@ fn test_transparent_from_py_with() {
         assert_eq!(result, expected);
     });
 }
+
+#[derive(Debug, FromPyObject, PartialEq, Eq)]
+pub struct WithKeywordAttr {
+    r#box: usize,
+}
+
+#[pyclass]
+pub struct WithKeywordAttrC {
+    #[pyo3(get)]
+    r#box: usize,
+}
+
+#[test]
+fn test_with_keyword_attr() {
+    Python::attach(|py| {
+        let cls = WithKeywordAttrC { r#box: 3 }.into_pyobject(py).unwrap();
+        let result = cls.extract::<WithKeywordAttr>().unwrap();
+        let expected = WithKeywordAttr { r#box: 3 };
+        assert_eq!(result, expected);
+    });
+}
+
+#[derive(Debug, FromPyObject, PartialEq, Eq)]
+pub struct WithKeywordItem {
+    #[pyo3(item)]
+    r#box: usize,
+}
+
+#[test]
+fn test_with_keyword_item() {
+    Python::attach(|py| {
+        let dict = PyDict::new(py);
+        dict.set_item("box", 3).unwrap();
+        let result = dict.extract::<WithKeywordItem>().unwrap();
+        let expected = WithKeywordItem { r#box: 3 };
+        assert_eq!(result, expected);
+    });
+}
+
+#[derive(Debug, FromPyObject, PartialEq, Eq)]
+pub struct WithDefaultItem {
+    #[pyo3(item, default)]
+    opt: Option<usize>,
+    #[pyo3(item)]
+    value: usize,
+}
+
+#[test]
+fn test_with_default_item() {
+    Python::attach(|py| {
+        let dict = PyDict::new(py);
+        dict.set_item("value", 3).unwrap();
+        let result = dict.extract::<WithDefaultItem>().unwrap();
+        let expected = WithDefaultItem {
+            value: 3,
+            opt: None,
+        };
+        assert_eq!(result, expected);
+    });
+}
+
+#[derive(Debug, FromPyObject, PartialEq, Eq)]
+pub struct WithExplicitDefaultItem {
+    #[pyo3(item, default = 1)]
+    opt: usize,
+    #[pyo3(item)]
+    value: usize,
+}
+
+#[test]
+fn test_with_explicit_default_item() {
+    Python::attach(|py| {
+        let dict = PyDict::new(py);
+        dict.set_item("value", 3).unwrap();
+        let result = dict.extract::<WithExplicitDefaultItem>().unwrap();
+        let expected = WithExplicitDefaultItem { value: 3, opt: 1 };
+        assert_eq!(result, expected);
+    });
+}
+
+#[derive(Debug, FromPyObject, PartialEq, Eq)]
+pub struct WithDefaultItemAndConversionFunction {
+    #[pyo3(item, default, from_py_with = Bound::<'_, PyAny>::len)]
+    opt: usize,
+    #[pyo3(item)]
+    value: usize,
+}
+
+#[test]
+fn test_with_default_item_and_conversion_function() {
+    Python::attach(|py| {
+        // Filled case
+        let dict = PyDict::new(py);
+        dict.set_item("opt", (1,)).unwrap();
+        dict.set_item("value", 3).unwrap();
+        let result = dict
+            .extract::<WithDefaultItemAndConversionFunction>()
+            .unwrap();
+        let expected = WithDefaultItemAndConversionFunction { opt: 1, value: 3 };
+        assert_eq!(result, expected);
+
+        // Empty case
+        let dict = PyDict::new(py);
+        dict.set_item("value", 3).unwrap();
+        let result = dict
+            .extract::<WithDefaultItemAndConversionFunction>()
+            .unwrap();
+        let expected = WithDefaultItemAndConversionFunction { opt: 0, value: 3 };
+        assert_eq!(result, expected);
+
+        // Error case
+        let dict = PyDict::new(py);
+        dict.set_item("value", 3).unwrap();
+        dict.set_item("opt", 1).unwrap();
+        assert!(dict
+            .extract::<WithDefaultItemAndConversionFunction>()
+            .is_err());
+    });
+}
+
+#[derive(Debug, FromPyObject, PartialEq, Eq)]
+pub enum WithDefaultItemEnum {
+    #[pyo3(from_item_all)]
+    Foo {
+        a: usize,
+        #[pyo3(default)]
+        b: usize,
+    },
+    NeverUsedA {
+        a: usize,
+    },
+}
+
+#[test]
+fn test_with_default_item_enum() {
+    Python::attach(|py| {
+        // A and B filled
+        let dict = PyDict::new(py);
+        dict.set_item("a", 1).unwrap();
+        dict.set_item("b", 2).unwrap();
+        let result = dict.extract::<WithDefaultItemEnum>().unwrap();
+        let expected = WithDefaultItemEnum::Foo { a: 1, b: 2 };
+        assert_eq!(result, expected);
+
+        // A filled
+        let dict = PyDict::new(py);
+        dict.set_item("a", 1).unwrap();
+        let result = dict.extract::<WithDefaultItemEnum>().unwrap();
+        let expected = WithDefaultItemEnum::Foo { a: 1, b: 0 };
+        assert_eq!(result, expected);
+    });
+}
diff --git a/tests/test_gc.rs b/tests/test_gc.rs
index 7ed39436062..9a702a2c546 100644
--- a/tests/test_gc.rs
+++ b/tests/test_gc.rs
@@ -1,22 +1,26 @@
 #![cfg(feature = "macros")]
+#![warn(unsafe_op_in_unsafe_fn)]
 
 use pyo3::class::PyTraverseError;
 use pyo3::class::PyVisit;
+use pyo3::ffi;
 use pyo3::prelude::*;
-use pyo3::{py_run, PyCell};
+#[cfg(not(Py_GIL_DISABLED))]
+use pyo3::py_run;
+#[cfg(not(target_arch = "wasm32"))]
 use std::cell::Cell;
 use std::sync::atomic::{AtomicBool, Ordering};
-use std::sync::Arc;
+use std::sync::Once;
+use std::sync::{Arc, Mutex};
 
-#[path = "../src/tests/common.rs"]
-mod common;
+mod test_utils;
 
 #[pyclass(freelist = 2)]
 struct ClassWithFreelist {}
 
 #[test]
 fn class_with_freelist() {
-    let ptr = Python::with_gil(|py| {
+    let ptr = Python::attach(|py| {
         let inst = Py::new(py, ClassWithFreelist {}).unwrap();
         let _inst2 = Py::new(py, ClassWithFreelist {}).unwrap();
         let ptr = inst.as_ptr();
@@ -24,7 +28,7 @@ fn class_with_freelist() {
         ptr
     });
 
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let inst3 = Py::new(py, ClassWithFreelist {}).unwrap();
         assert_eq!(ptr, inst3.as_ptr());
 
@@ -33,118 +37,187 @@ fn class_with_freelist() {
     });
 }
 
-struct TestDropCall {
-    drop_called: Arc<AtomicBool>,
+#[pyclass(freelist = 2)]
+#[cfg(not(target_arch = "wasm32"))]
+struct ClassWithFreelistAndData {
+    data: Option<usize>,
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+fn spin_freelist(py: Python<'_>, data: usize) {
+    for _ in 0..500 {
+        let inst1 = Py::new(py, ClassWithFreelistAndData { data: Some(data) }).unwrap();
+        let inst2 = Py::new(py, ClassWithFreelistAndData { data: Some(data) }).unwrap();
+        assert_eq!(inst1.borrow(py).data, Some(data));
+        assert_eq!(inst2.borrow(py).data, Some(data));
+    }
+}
+
+#[test]
+#[cfg(not(target_arch = "wasm32"))]
+fn multithreaded_class_with_freelist() {
+    std::thread::scope(|s| {
+        s.spawn(|| {
+            Python::attach(|py| spin_freelist(py, 12));
+        });
+        s.spawn(|| {
+            Python::attach(|py| spin_freelist(py, 0x4d3d3d3));
+        });
+    });
+}
+
+/// Helper function to create a pair of objects that can be used to test drops;
+/// the first object is a guard that records when it has been dropped, the second
+/// object is a check that can be used to assert that the guard has been dropped.
+fn drop_check() -> (DropGuard, DropCheck) {
+    let flag = Arc::new(Once::new());
+    (DropGuard(flag.clone()), DropCheck(flag))
 }
 
-impl Drop for TestDropCall {
+/// Helper structure that records when it has been dropped in the cor
+struct DropGuard(Arc<Once>);
+impl Drop for DropGuard {
     fn drop(&mut self) {
-        self.drop_called.store(true, Ordering::Relaxed);
+        self.0.call_once(|| ());
     }
 }
 
-#[allow(dead_code)]
-#[pyclass]
-struct DataIsDropped {
-    member1: TestDropCall,
-    member2: TestDropCall,
+struct DropCheck(Arc<Once>);
+impl DropCheck {
+    #[track_caller]
+    fn assert_not_dropped(&self) {
+        assert!(!self.0.is_completed());
+    }
+
+    #[track_caller]
+    fn assert_dropped(&self) {
+        assert!(self.0.is_completed());
+    }
+
+    #[track_caller]
+    fn assert_drops_with_gc(&self, object: *mut pyo3::ffi::PyObject) {
+        // running the GC might take a few cycles to collect an object
+        for _ in 0..100 {
+            if self.0.is_completed() {
+                return;
+            }
+
+            Python::attach(|py| {
+                py.run(c"import gc; gc.collect()", None, None).unwrap();
+            });
+            #[cfg(Py_GIL_DISABLED)]
+            {
+                // on the free-threaded build, the GC might be running in a separate thread, allow
+                // some time for this
+                std::thread::sleep(std::time::Duration::from_millis(5));
+            }
+        }
+
+        panic!(
+            "Object was not dropped after 100 GC cycles, refcount is {}",
+            // this could be garbage, but it's in a test and we're just printing the value
+            unsafe { ffi::Py_REFCNT(object) }
+        );
+    }
 }
 
 #[test]
 fn data_is_dropped() {
-    let drop_called1 = Arc::new(AtomicBool::new(false));
-    let drop_called2 = Arc::new(AtomicBool::new(false));
+    #[pyclass]
+    struct DataIsDropped {
+        _guard1: DropGuard,
+        _guard2: DropGuard,
+    }
+
+    let (guard1, check1) = drop_check();
+    let (guard2, check2) = drop_check();
 
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let data_is_dropped = DataIsDropped {
-            member1: TestDropCall {
-                drop_called: Arc::clone(&drop_called1),
-            },
-            member2: TestDropCall {
-                drop_called: Arc::clone(&drop_called2),
-            },
+            _guard1: guard1,
+            _guard2: guard2,
         };
         let inst = Py::new(py, data_is_dropped).unwrap();
-        assert!(!drop_called1.load(Ordering::Relaxed));
-        assert!(!drop_called2.load(Ordering::Relaxed));
+        check1.assert_not_dropped();
+        check2.assert_not_dropped();
         drop(inst);
     });
 
-    assert!(drop_called1.load(Ordering::Relaxed));
-    assert!(drop_called2.load(Ordering::Relaxed));
+    check1.assert_dropped();
+    check2.assert_dropped();
 }
 
-#[allow(dead_code)]
-#[pyclass]
-struct GcIntegration {
-    self_ref: PyObject,
-    dropped: TestDropCall,
+#[pyclass(subclass)]
+struct CycleWithClear {
+    cycle: Option<Py<PyAny>>,
+    _guard: DropGuard,
 }
 
 #[pymethods]
-impl GcIntegration {
+impl CycleWithClear {
     fn __traverse__(&self, visit: PyVisit<'_>) -> Result<(), PyTraverseError> {
-        visit.call(&self.self_ref)
+        visit.call(&self.cycle)
     }
 
-    fn __clear__(&mut self) {
-        Python::with_gil(|py| {
-            self.self_ref = py.None();
-        });
+    fn __clear__(slf: &Bound<'_, Self>) {
+        println!("clear run, refcount before {}", slf.get_refcnt());
+        slf.borrow_mut().cycle = None;
+        println!("clear run, refcount after {}", slf.get_refcnt());
     }
 }
 
 #[test]
-fn gc_integration() {
-    let drop_called = Arc::new(AtomicBool::new(false));
+fn test_cycle_clear() {
+    let (guard, check) = drop_check();
 
-    Python::with_gil(|py| {
-        let inst = PyCell::new(
+    let ptr = Python::attach(|py| {
+        let inst = Bound::new(
             py,
-            GcIntegration {
-                self_ref: py.None(),
-                dropped: TestDropCall {
-                    drop_called: Arc::clone(&drop_called),
-                },
+            CycleWithClear {
+                cycle: None,
+                _guard: guard,
             },
         )
         .unwrap();
 
-        let mut borrow = inst.borrow_mut();
-        borrow.self_ref = inst.to_object(py);
+        inst.borrow_mut().cycle = Some(inst.clone().into_any().unbind());
 
+        // gc.get_objects can create references to partially initialized objects,
+        // leading to races on the free-threaded build.
+        // see https://github.com/python/cpython/issues/130421#issuecomment-2682924142
+        #[cfg(not(Py_GIL_DISABLED))]
         py_run!(py, inst, "import gc; assert inst in gc.get_objects()");
+        check.assert_not_dropped();
+        inst.as_ptr()
     });
 
-    Python::with_gil(|py| {
-        py.run_bound("import gc; gc.collect()", None, None).unwrap();
-        assert!(drop_called.load(Ordering::Relaxed));
-    });
+    check.assert_drops_with_gc(ptr);
 }
 
-#[pyclass]
-struct GcNullTraversal {
-    cycle: Option<Py<Self>>,
-    null: Option<Py<Self>>,
-}
-
-#[pymethods]
-impl GcNullTraversal {
-    fn __traverse__(&self, visit: PyVisit<'_>) -> Result<(), PyTraverseError> {
-        visit.call(&self.cycle)?;
-        visit.call(&self.null)?; // Should not segfault
-        Ok(())
+/// Test that traversing `None` of `Option<Py<T>>` does not cause a segfault
+#[test]
+fn gc_null_traversal() {
+    #[pyclass]
+    struct GcNullTraversal {
+        cycle: Option<Py<Self>>,
+        null: Option<Py<Self>>,
     }
 
-    fn __clear__(&mut self) {
-        self.cycle = None;
-        self.null = None;
+    #[pymethods]
+    impl GcNullTraversal {
+        fn __traverse__(&self, visit: PyVisit<'_>) -> Result<(), PyTraverseError> {
+            visit.call(&self.cycle)?;
+            visit.call(&self.null)?; // Should not segfault
+            Ok(())
+        }
+
+        fn __clear__(&mut self) {
+            self.cycle = None;
+            self.null = None;
+        }
     }
-}
 
-#[test]
-fn gc_null_traversal() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let obj = Py::new(
             py,
             GcNullTraversal {
@@ -156,382 +229,373 @@ fn gc_null_traversal() {
         obj.borrow_mut(py).cycle = Some(obj.clone_ref(py));
 
         // the object doesn't have to be cleaned up, it just needs to be traversed.
-        py.run_bound("import gc; gc.collect()", None, None).unwrap();
+        py.run(c"import gc; gc.collect()", None, None).unwrap();
     });
 }
 
-#[pyclass(subclass)]
-struct BaseClassWithDrop {
-    data: Option<Arc<AtomicBool>>,
-}
-
-#[pymethods]
-impl BaseClassWithDrop {
-    #[new]
-    fn new() -> BaseClassWithDrop {
-        BaseClassWithDrop { data: None }
+#[test]
+fn inheritance_with_new_methods_with_drop() {
+    #[pyclass(subclass)]
+    struct BaseClassWithDrop {
+        guard: Option<DropGuard>,
     }
-}
 
-impl Drop for BaseClassWithDrop {
-    fn drop(&mut self) {
-        if let Some(data) = &self.data {
-            data.store(true, Ordering::Relaxed);
+    #[pymethods]
+    impl BaseClassWithDrop {
+        #[new]
+        fn new() -> BaseClassWithDrop {
+            BaseClassWithDrop { guard: None }
         }
     }
-}
-
-#[pyclass(extends = BaseClassWithDrop)]
-struct SubClassWithDrop {
-    data: Option<Arc<AtomicBool>>,
-}
 
-#[pymethods]
-impl SubClassWithDrop {
-    #[new]
-    fn new() -> (Self, BaseClassWithDrop) {
-        (
-            SubClassWithDrop { data: None },
-            BaseClassWithDrop { data: None },
-        )
+    #[pyclass(extends = BaseClassWithDrop)]
+    struct SubClassWithDrop {
+        guard: Option<DropGuard>,
     }
-}
 
-impl Drop for SubClassWithDrop {
-    fn drop(&mut self) {
-        if let Some(data) = &self.data {
-            data.store(true, Ordering::Relaxed);
+    #[pymethods]
+    impl SubClassWithDrop {
+        #[new]
+        fn new() -> (Self, BaseClassWithDrop) {
+            (
+                SubClassWithDrop { guard: None },
+                BaseClassWithDrop { guard: None },
+            )
         }
     }
-}
 
-#[test]
-fn inheritance_with_new_methods_with_drop() {
-    let drop_called1 = Arc::new(AtomicBool::new(false));
-    let drop_called2 = Arc::new(AtomicBool::new(false));
+    let (guard_base, check_base) = drop_check();
+    let (guard_sub, check_sub) = drop_check();
 
-    Python::with_gil(|py| {
-        let _typebase = py.get_type::<BaseClassWithDrop>();
+    Python::attach(|py| {
         let typeobj = py.get_type::<SubClassWithDrop>();
-        let inst = typeobj.call((), None).unwrap();
+        let inst = typeobj
+            .call((), None)
+            .unwrap()
+            .cast_into::<SubClassWithDrop>()
+            .unwrap();
+
+        inst.as_super().borrow_mut().guard = Some(guard_base);
+        inst.borrow_mut().guard = Some(guard_sub);
 
-        let obj: &PyCell<SubClassWithDrop> = inst.downcast().unwrap();
-        let mut obj_ref_mut = obj.borrow_mut();
-        obj_ref_mut.data = Some(Arc::clone(&drop_called1));
-        let base: &mut BaseClassWithDrop = obj_ref_mut.as_mut();
-        base.data = Some(Arc::clone(&drop_called2));
+        check_base.assert_not_dropped();
+        check_sub.assert_not_dropped();
     });
 
-    assert!(drop_called1.load(Ordering::Relaxed));
-    assert!(drop_called2.load(Ordering::Relaxed));
+    check_base.assert_dropped();
+    check_sub.assert_dropped();
 }
 
-#[pyclass]
-struct TraversableClass {
-    traversed: AtomicBool,
-}
+#[test]
+fn gc_during_borrow() {
+    #[pyclass]
+    struct TraversableClass {
+        traversed: AtomicBool,
+    }
 
-impl TraversableClass {
-    fn new() -> Self {
-        Self {
-            traversed: AtomicBool::new(false),
+    impl TraversableClass {
+        fn new() -> Self {
+            Self {
+                traversed: AtomicBool::new(false),
+            }
         }
     }
-}
 
-#[pymethods]
-impl TraversableClass {
-    fn __clear__(&mut self) {}
+    #[pymethods]
+    impl TraversableClass {
+        fn __clear__(&mut self) {}
 
-    #[allow(clippy::unnecessary_wraps)]
-    fn __traverse__(&self, _visit: PyVisit<'_>) -> Result<(), PyTraverseError> {
-        self.traversed.store(true, Ordering::Relaxed);
-        Ok(())
+        #[allow(clippy::unnecessary_wraps)]
+        fn __traverse__(&self, _visit: PyVisit<'_>) -> Result<(), PyTraverseError> {
+            self.traversed.store(true, Ordering::Relaxed);
+            Ok(())
+        }
     }
-}
 
-#[test]
-fn gc_during_borrow() {
-    Python::with_gil(|py| {
-        unsafe {
-            // get the traverse function
-            let ty = py.get_type::<TraversableClass>().as_type_ptr();
-            let traverse = get_type_traverse(ty).unwrap();
-
-            // create an object and check that traversing it works normally
-            // when it's not borrowed
-            let cell = PyCell::new(py, TraversableClass::new()).unwrap();
-            let obj = cell.to_object(py);
-            assert!(!cell.borrow().traversed.load(Ordering::Relaxed));
-            traverse(obj.as_ptr(), novisit, std::ptr::null_mut());
-            assert!(cell.borrow().traversed.load(Ordering::Relaxed));
-
-            // create an object and check that it is not traversed if the GC
-            // is invoked while it is already borrowed mutably
-            let cell2 = PyCell::new(py, TraversableClass::new()).unwrap();
-            let obj2 = cell2.to_object(py);
-            let guard = cell2.borrow_mut();
-            assert!(!guard.traversed.load(Ordering::Relaxed));
-            traverse(obj2.as_ptr(), novisit, std::ptr::null_mut());
-            assert!(!guard.traversed.load(Ordering::Relaxed));
-            drop(guard);
-        }
+    Python::attach(|py| {
+        // get the traverse function
+        let ty = py.get_type::<TraversableClass>();
+        let traverse = unsafe { get_type_traverse(ty.as_type_ptr()).unwrap() };
+
+        // create an object and check that traversing it works normally
+        // when it's not borrowed
+        let cell = Bound::new(py, TraversableClass::new()).unwrap();
+        assert!(!cell.borrow().traversed.load(Ordering::Relaxed));
+        unsafe { traverse(cell.as_ptr(), novisit, std::ptr::null_mut()) };
+        assert!(cell.borrow().traversed.load(Ordering::Relaxed));
+
+        // create an object and check that it is not traversed if the GC
+        // is invoked while it is already borrowed mutably
+        let cell2 = Bound::new(py, TraversableClass::new()).unwrap();
+        let guard = cell2.borrow_mut();
+        assert!(!guard.traversed.load(Ordering::Relaxed));
+        unsafe { traverse(cell2.as_ptr(), novisit, std::ptr::null_mut()) };
+        assert!(!guard.traversed.load(Ordering::Relaxed));
+        drop(guard);
     });
 }
 
-#[pyclass]
-struct PartialTraverse {
-    member: PyObject,
-}
+#[test]
+fn traverse_partial() {
+    #[pyclass]
+    struct PartialTraverse {
+        member: Py<PyAny>,
+    }
 
-impl PartialTraverse {
-    fn new(py: Python<'_>) -> Self {
-        Self { member: py.None() }
+    impl PartialTraverse {
+        fn new(py: Python<'_>) -> Self {
+            Self { member: py.None() }
+        }
     }
-}
 
-#[pymethods]
-impl PartialTraverse {
-    fn __traverse__(&self, visit: PyVisit<'_>) -> Result<(), PyTraverseError> {
-        visit.call(&self.member)?;
-        // In the test, we expect this to never be hit
-        unreachable!()
+    #[pymethods]
+    impl PartialTraverse {
+        fn __traverse__(&self, visit: PyVisit<'_>) -> Result<(), PyTraverseError> {
+            visit.call(&self.member)?;
+            // In the test, we expect this to never be hit
+            unreachable!()
+        }
     }
-}
 
-#[test]
-fn traverse_partial() {
-    Python::with_gil(|py| unsafe {
+    Python::attach(|py| {
         // get the traverse function
-        let ty = py.get_type::<PartialTraverse>().as_type_ptr();
-        let traverse = get_type_traverse(ty).unwrap();
+        let ty = py.get_type::<PartialTraverse>();
+        let traverse = unsafe { get_type_traverse(ty.as_type_ptr()).unwrap() };
 
         // confirm that traversing errors
         let obj = Py::new(py, PartialTraverse::new(py)).unwrap();
         assert_eq!(
-            traverse(obj.as_ptr(), visit_error, std::ptr::null_mut()),
+            unsafe { traverse(obj.as_ptr(), visit_error, std::ptr::null_mut()) },
             -1
         );
     })
 }
 
-#[pyclass]
-struct PanickyTraverse {
-    member: PyObject,
-}
+#[test]
+fn traverse_panic() {
+    #[pyclass]
+    struct PanickyTraverse {
+        member: Py<PyAny>,
+    }
 
-impl PanickyTraverse {
-    fn new(py: Python<'_>) -> Self {
-        Self { member: py.None() }
+    impl PanickyTraverse {
+        fn new(py: Python<'_>) -> Self {
+            Self { member: py.None() }
+        }
     }
-}
 
-#[pymethods]
-impl PanickyTraverse {
-    fn __traverse__(&self, visit: PyVisit<'_>) -> Result<(), PyTraverseError> {
-        visit.call(&self.member)?;
-        panic!("at the disco");
+    #[pymethods]
+    impl PanickyTraverse {
+        fn __traverse__(&self, visit: PyVisit<'_>) -> Result<(), PyTraverseError> {
+            visit.call(&self.member)?;
+            panic!("at the disco");
+        }
     }
-}
 
-#[test]
-fn traverse_panic() {
-    Python::with_gil(|py| unsafe {
+    Python::attach(|py| {
         // get the traverse function
-        let ty = py.get_type::<PanickyTraverse>().as_type_ptr();
-        let traverse = get_type_traverse(ty).unwrap();
+        let ty = py.get_type::<PanickyTraverse>();
+        let traverse = unsafe { get_type_traverse(ty.as_type_ptr()).unwrap() };
 
         // confirm that traversing errors
         let obj = Py::new(py, PanickyTraverse::new(py)).unwrap();
-        assert_eq!(traverse(obj.as_ptr(), novisit, std::ptr::null_mut()), -1);
+        assert_eq!(
+            unsafe { traverse(obj.as_ptr(), novisit, std::ptr::null_mut()) },
+            -1
+        );
     })
 }
 
-#[pyclass]
-struct TriesGILInTraverse {}
+#[test]
+fn tries_gil_in_traverse() {
+    #[pyclass]
+    struct TriesGILInTraverse {}
 
-#[pymethods]
-impl TriesGILInTraverse {
-    fn __traverse__(&self, _visit: PyVisit<'_>) -> Result<(), PyTraverseError> {
-        Python::with_gil(|_py| Ok(()))
+    #[pymethods]
+    impl TriesGILInTraverse {
+        fn __traverse__(&self, _visit: PyVisit<'_>) -> Result<(), PyTraverseError> {
+            Python::attach(|_py| Ok(()))
+        }
     }
-}
 
-#[test]
-fn tries_gil_in_traverse() {
-    Python::with_gil(|py| unsafe {
+    Python::attach(|py| {
         // get the traverse function
-        let ty = py.get_type::<TriesGILInTraverse>().as_type_ptr();
-        let traverse = get_type_traverse(ty).unwrap();
+        let ty = py.get_type::<TriesGILInTraverse>();
+        let traverse = unsafe { get_type_traverse(ty.as_type_ptr()).unwrap() };
 
         // confirm that traversing panicks
         let obj = Py::new(py, TriesGILInTraverse {}).unwrap();
-        assert_eq!(traverse(obj.as_ptr(), novisit, std::ptr::null_mut()), -1);
+        assert_eq!(
+            unsafe { traverse(obj.as_ptr(), novisit, std::ptr::null_mut()) },
+            -1
+        );
     })
 }
 
-#[pyclass]
-struct HijackedTraverse {
-    traversed: Cell<bool>,
-    hijacked: Cell<bool>,
-}
+#[test]
+fn traverse_cannot_be_hijacked() {
+    #[pyclass]
+    struct HijackedTraverse {
+        traversed: AtomicBool,
+        hijacked: AtomicBool,
+    }
 
-impl HijackedTraverse {
-    fn new() -> Self {
-        Self {
-            traversed: Cell::new(false),
-            hijacked: Cell::new(false),
+    impl HijackedTraverse {
+        fn new() -> Self {
+            Self {
+                traversed: AtomicBool::new(false),
+                hijacked: AtomicBool::new(false),
+            }
         }
-    }
 
-    fn traversed_and_hijacked(&self) -> (bool, bool) {
-        (self.traversed.get(), self.hijacked.get())
+        fn traversed_and_hijacked(&self) -> (bool, bool) {
+            (
+                self.traversed.load(Ordering::Acquire),
+                self.hijacked.load(Ordering::Acquire),
+            )
+        }
     }
-}
 
-#[pymethods]
-impl HijackedTraverse {
-    #[allow(clippy::unnecessary_wraps)]
-    fn __traverse__(&self, _visit: PyVisit<'_>) -> Result<(), PyTraverseError> {
-        self.traversed.set(true);
-        Ok(())
+    #[pymethods]
+    impl HijackedTraverse {
+        #[allow(clippy::unnecessary_wraps)]
+        fn __traverse__(&self, _visit: PyVisit<'_>) -> Result<(), PyTraverseError> {
+            self.traversed.store(true, Ordering::Release);
+            Ok(())
+        }
     }
-}
 
-trait Traversable {
-    fn __traverse__(&self, visit: PyVisit<'_>) -> Result<(), PyTraverseError>;
-}
+    #[allow(dead_code)]
+    trait Traversable {
+        fn __traverse__(&self, visit: PyVisit<'_>) -> Result<(), PyTraverseError>;
+    }
 
-impl<'a> Traversable for PyRef<'a, HijackedTraverse> {
-    fn __traverse__(&self, _visit: PyVisit<'_>) -> Result<(), PyTraverseError> {
-        self.hijacked.set(true);
-        Ok(())
+    impl Traversable for PyRef<'_, HijackedTraverse> {
+        fn __traverse__(&self, _visit: PyVisit<'_>) -> Result<(), PyTraverseError> {
+            self.hijacked.store(true, Ordering::Release);
+            Ok(())
+        }
     }
-}
 
-#[test]
-fn traverse_cannot_be_hijacked() {
-    Python::with_gil(|py| unsafe {
+    Python::attach(|py| {
         // get the traverse function
-        let ty = py.get_type::<HijackedTraverse>().as_type_ptr();
-        let traverse = get_type_traverse(ty).unwrap();
+        let ty = py.get_type::<HijackedTraverse>();
+        let traverse = unsafe { get_type_traverse(ty.as_type_ptr()).unwrap() };
 
-        let cell = PyCell::new(py, HijackedTraverse::new()).unwrap();
-        let obj = cell.to_object(py);
+        let cell = Bound::new(py, HijackedTraverse::new()).unwrap();
         assert_eq!(cell.borrow().traversed_and_hijacked(), (false, false));
-        traverse(obj.as_ptr(), novisit, std::ptr::null_mut());
+        unsafe { traverse(cell.as_ptr(), novisit, std::ptr::null_mut()) };
         assert_eq!(cell.borrow().traversed_and_hijacked(), (true, false));
     })
 }
 
-#[allow(dead_code)]
 #[pyclass]
 struct DropDuringTraversal {
-    cycle: Cell<Option<Py<Self>>>,
-    dropped: TestDropCall,
+    cycle: Mutex<Option<Py<Self>>>,
+    _guard: DropGuard,
 }
 
 #[pymethods]
 impl DropDuringTraversal {
     #[allow(clippy::unnecessary_wraps)]
     fn __traverse__(&self, _visit: PyVisit<'_>) -> Result<(), PyTraverseError> {
-        self.cycle.take();
+        let mut cycle_ref = self.cycle.lock().unwrap();
+        *cycle_ref = None;
         Ok(())
     }
-
-    fn __clear__(&mut self) {
-        self.cycle.take();
-    }
 }
 
+#[cfg(not(pyo3_disable_reference_pool))]
 #[test]
 fn drop_during_traversal_with_gil() {
-    let drop_called = Arc::new(AtomicBool::new(false));
+    let (guard, check) = drop_check();
 
-    Python::with_gil(|py| {
+    let ptr = Python::attach(|py| {
+        let cycle = Mutex::new(None);
         let inst = Py::new(
             py,
             DropDuringTraversal {
-                cycle: Cell::new(None),
-                dropped: TestDropCall {
-                    drop_called: Arc::clone(&drop_called),
-                },
+                cycle,
+                _guard: guard,
             },
         )
         .unwrap();
 
-        inst.borrow_mut(py).cycle.set(Some(inst.clone_ref(py)));
+        *inst.borrow_mut(py).cycle.lock().unwrap() = Some(inst.clone_ref(py));
 
-        drop(inst);
+        check.assert_not_dropped();
+        let ptr = inst.as_ptr();
+        drop(inst); // drop the object while holding the GIL
+
+        #[cfg(not(Py_GIL_DISABLED))]
+        {
+            // other thread might have caused GC on free-threaded build
+            check.assert_not_dropped();
+        }
+
+        ptr
     });
 
-    // due to the internal GC mechanism, we may need multiple
-    // (but not too many) collections to get `inst` actually dropped.
-    for _ in 0..10 {
-        Python::with_gil(|py| {
-            py.run_bound("import gc; gc.collect()", None, None).unwrap();
-        });
-    }
-    assert!(drop_called.load(Ordering::Relaxed));
+    check.assert_drops_with_gc(ptr);
 }
 
+#[cfg(not(pyo3_disable_reference_pool))]
 #[test]
 fn drop_during_traversal_without_gil() {
-    let drop_called = Arc::new(AtomicBool::new(false));
+    let (guard, check) = drop_check();
 
-    let inst = Python::with_gil(|py| {
+    let inst = Python::attach(|py| {
+        let cycle = Mutex::new(None);
         let inst = Py::new(
             py,
             DropDuringTraversal {
-                cycle: Cell::new(None),
-                dropped: TestDropCall {
-                    drop_called: Arc::clone(&drop_called),
-                },
+                cycle,
+                _guard: guard,
             },
         )
         .unwrap();
 
-        inst.borrow_mut(py).cycle.set(Some(inst.clone_ref(py)));
+        *inst.borrow_mut(py).cycle.lock().unwrap() = Some(inst.clone_ref(py));
 
+        check.assert_not_dropped();
         inst
     });
 
-    drop(inst);
+    let ptr = inst.as_ptr();
+    drop(inst); // drop the object without holding the GIL
 
-    // due to the internal GC mechanism, we may need multiple
-    // (but not too many) collections to get `inst` actually dropped.
-    for _ in 0..10 {
-        Python::with_gil(|py| {
-            py.run_bound("import gc; gc.collect()", None, None).unwrap();
-        });
-    }
-    assert!(drop_called.load(Ordering::Relaxed));
+    check.assert_drops_with_gc(ptr);
 }
 
-#[pyclass(unsendable)]
-struct UnsendableTraversal {
-    traversed: Cell<bool>,
-}
+#[test]
+#[cfg(not(target_arch = "wasm32"))] // We are building wasm Python with pthreads disabled
+fn unsendable_are_not_traversed_on_foreign_thread() {
+    #[pyclass(unsendable)]
+    struct UnsendableTraversal {
+        traversed: Cell<bool>,
+    }
 
-#[pymethods]
-impl UnsendableTraversal {
-    fn __clear__(&mut self) {}
+    #[pymethods]
+    impl UnsendableTraversal {
+        fn __clear__(&mut self) {}
 
-    #[allow(clippy::unnecessary_wraps)]
-    fn __traverse__(&self, _visit: PyVisit<'_>) -> Result<(), PyTraverseError> {
-        self.traversed.set(true);
-        Ok(())
+        #[allow(clippy::unnecessary_wraps)]
+        fn __traverse__(&self, _visit: PyVisit<'_>) -> Result<(), PyTraverseError> {
+            self.traversed.set(true);
+            Ok(())
+        }
     }
-}
 
-#[test]
-#[cfg(not(target_arch = "wasm32"))] // We are building wasm Python with pthreads disabled
-fn unsendable_are_not_traversed_on_foreign_thread() {
-    Python::with_gil(|py| unsafe {
-        let ty = py.get_type::<UnsendableTraversal>().as_type_ptr();
-        let traverse = get_type_traverse(ty).unwrap();
+    #[derive(Clone, Copy)]
+    struct SendablePtr(*mut pyo3::ffi::PyObject);
 
-        let obj = Py::new(
+    unsafe impl Send for SendablePtr {}
+
+    Python::attach(|py| {
+        let ty = py.get_type::<UnsendableTraversal>();
+        let traverse = unsafe { get_type_traverse(ty.as_type_ptr()).unwrap() };
+
+        let obj = Bound::new(
             py,
             UnsendableTraversal {
                 traversed: Cell::new(false),
@@ -543,31 +607,125 @@ fn unsendable_are_not_traversed_on_foreign_thread() {
 
         std::thread::spawn(move || {
             // traversal on foreign thread is a no-op
-            assert_eq!(traverse({ ptr }.0, novisit, std::ptr::null_mut()), 0);
+            assert_eq!(
+                unsafe { traverse({ ptr }.0, novisit, std::ptr::null_mut()) },
+                0
+            );
         })
         .join()
         .unwrap();
 
-        assert!(!obj.borrow(py).traversed.get());
+        assert!(!obj.borrow().traversed.get());
 
         // traversal on home thread still works
-        assert_eq!(traverse({ ptr }.0, novisit, std::ptr::null_mut()), 0);
+        assert_eq!(
+            unsafe { traverse({ ptr }.0, novisit, std::ptr::null_mut()) },
+            0
+        );
+
+        assert!(obj.borrow().traversed.get());
+    });
+}
+
+#[test]
+fn test_traverse_subclass() {
+    #[pyclass(extends = CycleWithClear)]
+    struct SubOverrideTraverse {}
+
+    #[pymethods]
+    impl SubOverrideTraverse {
+        #[allow(clippy::unnecessary_wraps)]
+        fn __traverse__(&self, _visit: PyVisit<'_>) -> Result<(), PyTraverseError> {
+            // subclass traverse overrides the base class traverse
+            Ok(())
+        }
+    }
+
+    let (guard, check) = drop_check();
+
+    Python::attach(|py| {
+        let base = CycleWithClear {
+            cycle: None,
+            _guard: guard,
+        };
+        let obj = Bound::new(
+            py,
+            PyClassInitializer::from(base).add_subclass(SubOverrideTraverse {}),
+        )
+        .unwrap();
+        obj.borrow_mut().as_super().cycle = Some(obj.clone().into_any().unbind());
+
+        check.assert_not_dropped();
+        let ptr = obj.as_ptr();
+        drop(obj);
+        #[cfg(not(Py_GIL_DISABLED))]
+        {
+            // other thread might have caused GC on free-threaded build
+            check.assert_not_dropped();
+        }
+
+        check.assert_drops_with_gc(ptr);
+    });
+}
+
+#[test]
+fn test_traverse_subclass_override_clear() {
+    #[pyclass(extends = CycleWithClear)]
+    struct SubOverrideClear {}
+
+    #[pymethods]
+    impl SubOverrideClear {
+        #[allow(clippy::unnecessary_wraps)]
+        fn __traverse__(&self, _visit: PyVisit<'_>) -> Result<(), PyTraverseError> {
+            // subclass traverse overrides the base class traverse, necessary for
+            // the sub clear to be called
+            // FIXME: should this really need to be the case?
+            Ok(())
+        }
+
+        fn __clear__(&self) {
+            // subclass clear overrides the base class clear
+        }
+    }
+
+    let (guard, check) = drop_check();
+
+    Python::attach(|py| {
+        let base = CycleWithClear {
+            cycle: None,
+            _guard: guard,
+        };
+        let obj = Bound::new(
+            py,
+            PyClassInitializer::from(base).add_subclass(SubOverrideClear {}),
+        )
+        .unwrap();
+        obj.borrow_mut().as_super().cycle = Some(obj.clone().into_any().unbind());
+
+        check.assert_not_dropped();
+        let ptr = obj.as_ptr();
+        drop(obj);
+        #[cfg(not(Py_GIL_DISABLED))]
+        {
+            // other thread might have caused GC on free-threaded build
+            check.assert_not_dropped();
+        }
 
-        assert!(obj.borrow(py).traversed.get());
+        check.assert_drops_with_gc(ptr);
     });
 }
 
 // Manual traversal utilities
 
 unsafe fn get_type_traverse(tp: *mut pyo3::ffi::PyTypeObject) -> Option<pyo3::ffi::traverseproc> {
-    std::mem::transmute(pyo3::ffi::PyType_GetSlot(tp, pyo3::ffi::Py_tp_traverse))
+    unsafe { std::mem::transmute(pyo3::ffi::PyType_GetSlot(tp, pyo3::ffi::Py_tp_traverse)) }
 }
 
 // a dummy visitor function
 extern "C" fn novisit(
     _object: *mut pyo3::ffi::PyObject,
     _arg: *mut core::ffi::c_void,
-) -> std::os::raw::c_int {
+) -> std::ffi::c_int {
     0
 }
 
@@ -575,11 +733,58 @@ extern "C" fn novisit(
 extern "C" fn visit_error(
     _object: *mut pyo3::ffi::PyObject,
     _arg: *mut core::ffi::c_void,
-) -> std::os::raw::c_int {
+) -> std::ffi::c_int {
     -1
 }
 
-#[derive(Clone, Copy)]
-struct SendablePtr(*mut pyo3::ffi::PyObject);
+#[test]
+#[cfg(any(not(Py_LIMITED_API), Py_3_11))] // buffer availability
+fn test_drop_buffer_during_traversal_without_gil() {
+    use pyo3::buffer::PyBuffer;
+    use pyo3::types::PyBytes;
+
+    // `PyBuffer` has a drop method which attempts to attach to the Python interpreter,
+    // if the thread is during traverse we leak it for safety. This should _never_ be happening
+    // so it's purely a user bug, but we leak to be safe.
+
+    #[pyclass]
+    struct BufferDropDuringTraversal {
+        inner: Mutex<Option<(DropGuard, PyBuffer<u8>)>>,
+        cycle: Option<Py<PyAny>>,
+    }
 
-unsafe impl Send for SendablePtr {}
+    #[pymethods]
+    impl BufferDropDuringTraversal {
+        #[allow(clippy::unnecessary_wraps)]
+        fn __traverse__(&self, _visit: PyVisit<'_>) -> Result<(), PyTraverseError> {
+            self.inner.lock().unwrap().take();
+            Ok(())
+        }
+
+        fn __clear__(&mut self) {
+            self.cycle = None;
+        }
+    }
+
+    let (guard, check) = drop_check();
+    Python::attach(|py| {
+        let obj = Py::new(
+            py,
+            BufferDropDuringTraversal {
+                inner: Mutex::new(Some((
+                    guard,
+                    PyBuffer::get(&PyBytes::new(py, b"test")).unwrap(),
+                ))),
+                cycle: None,
+            },
+        )
+        .unwrap();
+
+        obj.borrow_mut(py).cycle = Some(obj.clone_ref(py).into_any());
+
+        let ptr = obj.as_ptr();
+        drop(obj);
+
+        check.assert_drops_with_gc(ptr);
+    });
+}
diff --git a/tests/test_getter_setter.rs b/tests/test_getter_setter.rs
index b990a82e134..582cfd89c5f 100644
--- a/tests/test_getter_setter.rs
+++ b/tests/test_getter_setter.rs
@@ -4,10 +4,10 @@ use std::cell::Cell;
 
 use pyo3::prelude::*;
 use pyo3::py_run;
+use pyo3::types::PyString;
 use pyo3::types::{IntoPyDict, PyList};
 
-#[path = "../src/tests/common.rs"]
-mod common;
+mod test_utils;
 
 #[pyclass]
 struct ClassWithProperties {
@@ -41,15 +41,30 @@ impl ClassWithProperties {
         self.num = value;
     }
 
+    #[setter]
+    fn set_from_len(&mut self, #[pyo3(from_py_with = extract_len)] value: i32) {
+        self.num = value;
+    }
+
+    #[setter]
+    fn set_from_any(&mut self, value: &Bound<'_, PyAny>) -> PyResult<()> {
+        self.num = value.extract()?;
+        Ok(())
+    }
+
     #[getter]
-    fn get_data_list<'py>(&self, py: Python<'py>) -> Bound<'py, PyList> {
-        PyList::new_bound(py, [self.num])
+    fn get_data_list<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyList>> {
+        PyList::new(py, [self.num])
     }
 }
 
+fn extract_len(any: &Bound<'_, PyAny>) -> PyResult<i32> {
+    any.len().map(|len| len as i32)
+}
+
 #[test]
 fn class_with_properties() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let inst = Py::new(py, ClassWithProperties { num: 10 }).unwrap();
 
         py_run!(py, inst, "assert inst.get_num() == 10");
@@ -64,7 +79,15 @@ fn class_with_properties() {
         py_run!(py, inst, "assert inst.get_num() == inst.unwrapped == 42");
         py_run!(py, inst, "assert inst.data_list == [42]");
 
-        let d = [("C", py.get_type::<ClassWithProperties>())].into_py_dict_bound(py);
+        py_run!(py, inst, "inst.from_len = [0, 0, 0]");
+        py_run!(py, inst, "assert inst.get_num() == 3");
+
+        py_run!(py, inst, "inst.from_any = 15");
+        py_run!(py, inst, "assert inst.get_num() == 15");
+
+        let d = [("C", py.get_type::<ClassWithProperties>())]
+            .into_py_dict(py)
+            .unwrap();
         py_assert!(py, *d, "C.DATA.__doc__ == 'a getter for data'");
     });
 }
@@ -86,7 +109,7 @@ impl GetterSetter {
 
 #[test]
 fn getter_setter_autogen() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let inst = Py::new(
             py,
             GetterSetter {
@@ -127,7 +150,7 @@ impl RefGetterSetter {
 #[test]
 fn ref_getter_setter() {
     // Regression test for #837
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let inst = Py::new(py, RefGetterSetter { num: 10 }).unwrap();
 
         py_run!(py, inst, "assert inst.num == 10");
@@ -153,7 +176,7 @@ impl TupleClassGetterSetter {
 
 #[test]
 fn tuple_struct_getter_setter() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let inst = Py::new(py, TupleClassGetterSetter(10)).unwrap();
 
         py_assert!(py, inst, "inst.num == 10");
@@ -169,7 +192,7 @@ struct All {
 
 #[test]
 fn get_set_all() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let inst = Py::new(py, All { num: 10 }).unwrap();
 
         py_run!(py, inst, "assert inst.num == 10");
@@ -185,7 +208,7 @@ struct All2 {
 
 #[test]
 fn get_all_and_set() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let inst = Py::new(py, All2 { num: 10 }).unwrap();
 
         py_run!(py, inst, "assert inst.num == 10");
@@ -193,7 +216,7 @@ fn get_all_and_set() {
     });
 }
 
-#[pyclass]
+#[pyclass(unsendable)]
 struct CellGetterSetter {
     #[pyo3(get, set)]
     cell_inner: Cell<i32>,
@@ -204,9 +227,9 @@ fn cell_getter_setter() {
     let c = CellGetterSetter {
         cell_inner: Cell::new(10),
     };
-    Python::with_gil(|py| {
-        let inst = Py::new(py, c).unwrap().to_object(py);
-        let cell = Cell::new(20).to_object(py);
+    Python::attach(|py| {
+        let inst = Py::new(py, c).unwrap();
+        let cell = Cell::new(20i32).into_pyobject(py).unwrap();
 
         py_run!(py, cell, "assert cell == 20");
         py_run!(py, inst, "assert inst.cell_inner == 10");
@@ -231,9 +254,66 @@ fn borrowed_value_with_lifetime_of_self() {
         }
     }
 
-    Python::with_gil(|py| {
-        let inst = Py::new(py, BorrowedValue {}).unwrap().to_object(py);
+    Python::attach(|py| {
+        let inst = Py::new(py, BorrowedValue {}).unwrap();
+
+        py_run!(py, inst, "assert inst.value == 'value'");
+    });
+}
+
+#[test]
+fn frozen_py_field_get() {
+    #[pyclass(frozen)]
+    struct FrozenPyField {
+        #[pyo3(get)]
+        value: Py<PyString>,
+    }
+
+    Python::attach(|py| {
+        let inst = Py::new(
+            py,
+            FrozenPyField {
+                value: "value".into_pyobject(py).unwrap().unbind(),
+            },
+        )
+        .unwrap();
 
         py_run!(py, inst, "assert inst.value == 'value'");
     });
 }
+
+#[test]
+fn test_optional_setter() {
+    #[pyclass]
+    struct SimpleClass {
+        field: Option<u32>,
+    }
+
+    #[pymethods]
+    impl SimpleClass {
+        #[getter]
+        fn get_field(&self) -> Option<u32> {
+            self.field
+        }
+
+        #[setter]
+        fn set_field(&mut self, field: Option<u32>) {
+            self.field = field;
+        }
+    }
+
+    Python::attach(|py| {
+        let instance = Py::new(py, SimpleClass { field: None }).unwrap();
+        py_run!(py, instance, "assert instance.field is None");
+        py_run!(
+            py,
+            instance,
+            "instance.field = 42; assert instance.field == 42"
+        );
+        py_run!(
+            py,
+            instance,
+            "instance.field = None; assert instance.field is None"
+        );
+    })
+}
diff --git a/tests/test_inheritance.rs b/tests/test_inheritance.rs
index 6c33dec6a9f..37c6b3ea198 100644
--- a/tests/test_inheritance.rs
+++ b/tests/test_inheritance.rs
@@ -2,11 +2,9 @@
 
 use pyo3::prelude::*;
 use pyo3::py_run;
-
 use pyo3::types::IntoPyDict;
 
-#[path = "../src/tests/common.rs"]
-mod common;
+mod test_utils;
 
 #[pyclass(subclass)]
 struct BaseClass {
@@ -19,11 +17,13 @@ struct SubclassAble {}
 
 #[test]
 fn subclass() {
-    Python::with_gil(|py| {
-        let d = [("SubclassAble", py.get_type::<SubclassAble>())].into_py_dict_bound(py);
+    Python::attach(|py| {
+        let d = [("SubclassAble", py.get_type::<SubclassAble>())]
+            .into_py_dict(py)
+            .unwrap();
 
-        py.run_bound(
-            "class A(SubclassAble): pass\nassert issubclass(A, SubclassAble)",
+        py.run(
+            c"class A(SubclassAble): pass\nassert issubclass(A, SubclassAble)",
             None,
             Some(&d),
         )
@@ -41,7 +41,7 @@ impl BaseClass {
     fn base_method(&self, x: usize) -> usize {
         x * self.val1
     }
-    fn base_set(&mut self, fn_: &pyo3::PyAny) -> PyResult<()> {
+    fn base_set(&mut self, fn_: &Bound<'_, PyAny>) -> PyResult<()> {
         let value: usize = fn_.call0()?.extract()?;
         self.val1 = value;
         Ok(())
@@ -71,7 +71,7 @@ impl SubClass {
 
 #[test]
 fn inheritance_with_new_methods() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let typeobj = py.get_type::<SubClass>();
         let inst = typeobj.call((), None).unwrap();
         py_run!(py, inst, "assert inst.val1 == 10; assert inst.val2 == 5");
@@ -80,8 +80,8 @@ fn inheritance_with_new_methods() {
 
 #[test]
 fn call_base_and_sub_methods() {
-    Python::with_gil(|py| {
-        let obj = PyCell::new(py, SubClass::new()).unwrap();
+    Python::attach(|py| {
+        let obj = Py::new(py, SubClass::new()).unwrap();
         py_run!(
             py,
             obj,
@@ -95,12 +95,12 @@ fn call_base_and_sub_methods() {
 
 #[test]
 fn mutation_fails() {
-    Python::with_gil(|py| {
-        let obj = PyCell::new(py, SubClass::new()).unwrap();
-        let global = [("obj", obj)].into_py_dict_bound(py);
+    Python::attach(|py| {
+        let obj = Py::new(py, SubClass::new()).unwrap();
+        let global = [("obj", obj)].into_py_dict(py).unwrap();
         let e = py
-            .run_bound(
-                "obj.base_set(lambda: obj.sub_set_and_ret(1))",
+            .run(
+                c"obj.base_set(lambda: obj.sub_set_and_ret(1))",
                 Some(&global),
                 None,
             )
@@ -111,17 +111,17 @@ fn mutation_fails() {
 
 #[test]
 fn is_subclass_and_is_instance() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let sub_ty = py.get_type::<SubClass>();
         let base_ty = py.get_type::<BaseClass>();
         assert!(sub_ty.is_subclass_of::<BaseClass>().unwrap());
-        assert!(sub_ty.is_subclass(base_ty).unwrap());
+        assert!(sub_ty.is_subclass(&base_ty).unwrap());
 
-        let obj = PyCell::new(py, SubClass::new()).unwrap();
+        let obj = Bound::new(py, SubClass::new()).unwrap().into_any();
         assert!(obj.is_instance_of::<SubClass>());
         assert!(obj.is_instance_of::<BaseClass>());
-        assert!(obj.is_instance(sub_ty).unwrap());
-        assert!(obj.is_instance(base_ty).unwrap());
+        assert!(obj.is_instance(&sub_ty).unwrap());
+        assert!(obj.is_instance(&base_ty).unwrap());
     });
 }
 
@@ -154,7 +154,7 @@ impl SubClass2 {
 
 #[test]
 fn handle_result_in_new() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let subclass = py.get_type::<SubClass2>();
         py_run!(
             py,
@@ -177,14 +177,13 @@ except Exception as e:
 mod inheriting_native_type {
     use super::*;
     use pyo3::exceptions::PyException;
-    use pyo3::types::{IntoPyDict, PyDict};
+    use pyo3::types::PyDict;
 
-    #[cfg(not(PyPy))]
+    #[cfg(not(any(PyPy, GraalPy)))]
     #[test]
     fn inherit_set() {
         use pyo3::types::PySet;
 
-        #[cfg(not(PyPy))]
         #[pyclass(extends=PySet)]
         #[derive(Debug)]
         struct SetWithName {
@@ -192,7 +191,6 @@ mod inheriting_native_type {
             _name: &'static str,
         }
 
-        #[cfg(not(PyPy))]
         #[pymethods]
         impl SetWithName {
             #[new]
@@ -201,8 +199,8 @@ mod inheriting_native_type {
             }
         }
 
-        Python::with_gil(|py| {
-            let set_sub = pyo3::PyCell::new(py, SetWithName::new()).unwrap();
+        Python::attach(|py| {
+            let set_sub = pyo3::Py::new(py, SetWithName::new()).unwrap();
             py_run!(
                 py,
                 set_sub,
@@ -228,8 +226,8 @@ mod inheriting_native_type {
 
     #[test]
     fn inherit_dict() {
-        Python::with_gil(|py| {
-            let dict_sub = pyo3::PyCell::new(py, DictWithName::new()).unwrap();
+        Python::attach(|py| {
+            let dict_sub = pyo3::Py::new(py, DictWithName::new()).unwrap();
             py_run!(
                 py,
                 dict_sub,
@@ -240,14 +238,14 @@ mod inheriting_native_type {
 
     #[test]
     fn inherit_dict_drop() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let dict_sub = pyo3::Py::new(py, DictWithName::new()).unwrap();
             assert_eq!(dict_sub.get_refcnt(py), 1);
 
-            let item = &py.eval_bound("object()", None, None).unwrap();
+            let item = &py.eval(c"object()", None, None).unwrap();
             assert_eq!(item.get_refcnt(), 1);
 
-            dict_sub.as_ref(py).set_item("foo", item).unwrap();
+            dict_sub.bind(py).set_item("foo", item).unwrap();
             assert_eq!(item.get_refcnt(), 2);
 
             drop(dict_sub);
@@ -264,7 +262,7 @@ mod inheriting_native_type {
     #[pymethods]
     impl CustomException {
         #[new]
-        fn new(_exc_arg: &PyAny) -> Self {
+        fn new(_exc_arg: &Bound<'_, PyAny>) -> Self {
             CustomException {
                 context: "Hello :)",
             }
@@ -273,16 +271,16 @@ mod inheriting_native_type {
 
     #[test]
     fn custom_exception() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let cls = py.get_type::<CustomException>();
-            let dict = [("cls", cls)].into_py_dict_bound(py);
-            let res = py.run_bound(
-            "e = cls('hello'); assert str(e) == 'hello'; assert e.context == 'Hello :)'; raise e",
+            let dict = [("cls", &cls)].into_py_dict(py).unwrap();
+            let res = py.run(
+            c"e = cls('hello'); assert str(e) == 'hello'; assert e.context == 'Hello :)'; raise e",
             None,
             Some(&dict)
             );
             let err = res.unwrap_err();
-            assert!(err.matches(py, cls), "{}", err);
+            assert!(err.matches(py, &cls).unwrap(), "{}", err);
 
             // catching the exception in Python also works:
             py_run!(
@@ -313,7 +311,7 @@ impl SimpleClass {
 #[test]
 fn test_subclass_ref_counts() {
     // regression test for issue #1363
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         #[allow(non_snake_case)]
         let SimpleClass = py.get_type::<SimpleClass>();
         py_run!(
@@ -344,26 +342,3 @@ fn test_subclass_ref_counts() {
         );
     })
 }
-
-#[test]
-#[cfg(not(Py_LIMITED_API))]
-fn module_add_class_inherit_bool_fails() {
-    use pyo3::types::PyBool;
-
-    #[pyclass(extends = PyBool)]
-    struct ExtendsBool;
-
-    Python::with_gil(|py| {
-        let m = PyModule::new(py, "test_module").unwrap();
-
-        let err = m.add_class::<ExtendsBool>().unwrap_err();
-        assert_eq!(
-            err.to_string(),
-            "RuntimeError: An error occurred while initializing class ExtendsBool"
-        );
-        assert_eq!(
-            err.cause(py).unwrap().to_string(),
-            "TypeError: type 'bool' is not an acceptable base type"
-        );
-    })
-}
diff --git a/tests/test_intopyobject.rs b/tests/test_intopyobject.rs
new file mode 100644
index 00000000000..72ecc0f234d
--- /dev/null
+++ b/tests/test_intopyobject.rs
@@ -0,0 +1,288 @@
+#![cfg(feature = "macros")]
+
+use pyo3::types::{PyDict, PyList, PyString};
+use pyo3::{prelude::*, py_run, IntoPyObject, IntoPyObjectExt};
+use std::collections::HashMap;
+use std::hash::Hash;
+
+#[macro_use]
+mod test_utils;
+
+#[derive(Debug, IntoPyObject)]
+pub struct A<'py> {
+    s: String,
+    t: Bound<'py, PyString>,
+    p: Bound<'py, PyAny>,
+}
+
+#[test]
+fn test_named_fields_struct() {
+    Python::attach(|py| {
+        let a = A {
+            s: "Hello".into(),
+            t: PyString::new(py, "World"),
+            p: 42i32.into_pyobject(py).unwrap().into_any(),
+        };
+        let pya = a.into_pyobject(py).unwrap();
+        assert_eq!(
+            pya.get_item("s")
+                .unwrap()
+                .unwrap()
+                .cast::<PyString>()
+                .unwrap(),
+            "Hello"
+        );
+        assert_eq!(
+            pya.get_item("t")
+                .unwrap()
+                .unwrap()
+                .cast::<PyString>()
+                .unwrap(),
+            "World"
+        );
+        assert_eq!(
+            pya.get_item("p")
+                .unwrap()
+                .unwrap()
+                .extract::<i32>()
+                .unwrap(),
+            42
+        );
+    });
+}
+
+#[derive(Debug, IntoPyObject)]
+#[pyo3(transparent)]
+pub struct B<'a> {
+    test: &'a str,
+}
+
+#[test]
+fn test_transparent_named_field_struct() {
+    Python::attach(|py| {
+        let pyb = B { test: "test" }.into_pyobject(py).unwrap();
+        let b = pyb.extract::<String>().unwrap();
+        assert_eq!(b, "test");
+    });
+}
+
+#[derive(Debug, IntoPyObject)]
+#[pyo3(transparent)]
+pub struct D<T> {
+    test: T,
+}
+
+#[test]
+fn test_generic_transparent_named_field_struct() {
+    Python::attach(|py| {
+        let pyd = D {
+            test: String::from("test"),
+        }
+        .into_pyobject(py)
+        .unwrap();
+        let d = pyd.extract::<String>().unwrap();
+        assert_eq!(d, "test");
+
+        let pyd = D { test: 1usize }.into_pyobject(py).unwrap();
+        let d = pyd.extract::<usize>().unwrap();
+        assert_eq!(d, 1);
+    });
+}
+
+#[derive(Debug, IntoPyObject)]
+pub struct GenericWithBound<K: Hash + Eq, V>(HashMap<K, V>);
+
+#[test]
+fn test_generic_with_bound() {
+    Python::attach(|py| {
+        let mut hash_map = HashMap::<String, i32>::new();
+        hash_map.insert("1".into(), 1);
+        hash_map.insert("2".into(), 2);
+        let map = GenericWithBound(hash_map).into_pyobject(py).unwrap();
+        assert_eq!(map.len(), 2);
+        assert_eq!(
+            map.get_item("1")
+                .unwrap()
+                .unwrap()
+                .extract::<i32>()
+                .unwrap(),
+            1
+        );
+        assert_eq!(
+            map.get_item("2")
+                .unwrap()
+                .unwrap()
+                .extract::<i32>()
+                .unwrap(),
+            2
+        );
+        assert!(map.get_item("3").unwrap().is_none());
+    });
+}
+
+#[derive(Debug, IntoPyObject)]
+pub struct Tuple(String, usize);
+
+#[test]
+fn test_tuple_struct() {
+    Python::attach(|py| {
+        let tup = Tuple(String::from("test"), 1).into_pyobject(py).unwrap();
+        assert!(tup.extract::<(usize, String)>().is_err());
+        let tup = tup.extract::<(String, usize)>().unwrap();
+        assert_eq!(tup.0, "test");
+        assert_eq!(tup.1, 1);
+    });
+}
+
+#[derive(Debug, IntoPyObject)]
+pub struct TransparentTuple(String);
+
+#[test]
+fn test_transparent_tuple_struct() {
+    Python::attach(|py| {
+        let tup = TransparentTuple(String::from("test"))
+            .into_pyobject(py)
+            .unwrap();
+        assert!(tup.extract::<(String,)>().is_err());
+        let tup = tup.extract::<String>().unwrap();
+        assert_eq!(tup, "test");
+    });
+}
+
+fn phantom_into_py<'py, T>(
+    _: std::borrow::Cow<'_, std::marker::PhantomData<T>>,
+    py: Python<'py>,
+) -> PyResult<Bound<'py, PyAny>> {
+    std::any::type_name::<T>().into_bound_py_any(py)
+}
+
+#[derive(Debug, IntoPyObject, IntoPyObjectRef)]
+pub enum Foo<'py> {
+    TupleVar(
+        usize,
+        String,
+        #[pyo3(into_py_with = phantom_into_py::<()>)] std::marker::PhantomData<()>,
+    ),
+    StructVar {
+        test: Bound<'py, PyString>,
+    },
+    #[pyo3(transparent)]
+    TransparentTuple(usize),
+    #[pyo3(transparent)]
+    TransparentStructVar {
+        a: Option<String>,
+    },
+}
+
+#[test]
+fn test_enum() {
+    Python::attach(|py| {
+        let foo = Foo::TupleVar(1, "test".into(), std::marker::PhantomData)
+            .into_pyobject(py)
+            .unwrap();
+        assert_eq!(
+            foo.extract::<(usize, String, String)>().unwrap(),
+            (1, String::from("test"), String::from("()"))
+        );
+
+        let foo = Foo::StructVar {
+            test: PyString::new(py, "test"),
+        }
+        .into_pyobject(py)
+        .unwrap()
+        .cast_into::<PyDict>()
+        .unwrap();
+
+        assert_eq!(
+            foo.get_item("test")
+                .unwrap()
+                .unwrap()
+                .cast_into::<PyString>()
+                .unwrap(),
+            "test"
+        );
+
+        let foo = Foo::TransparentTuple(1).into_pyobject(py).unwrap();
+        assert_eq!(foo.extract::<usize>().unwrap(), 1);
+
+        let foo = Foo::TransparentStructVar { a: None }
+            .into_pyobject(py)
+            .unwrap();
+        assert!(foo.is_none());
+    });
+}
+
+#[derive(Debug, IntoPyObject, IntoPyObjectRef)]
+pub struct Zap {
+    #[pyo3(item)]
+    name: String,
+
+    #[pyo3(into_py_with = zap_into_py, item("my_object"))]
+    some_object_length: usize,
+}
+
+fn zap_into_py<'py>(
+    len: std::borrow::Cow<'_, usize>,
+    py: Python<'py>,
+) -> PyResult<Bound<'py, PyAny>> {
+    Ok(PyList::new(py, 1..*len + 1)?.into_any())
+}
+
+#[test]
+fn test_into_py_with() {
+    Python::attach(|py| {
+        let zap = Zap {
+            name: "whatever".into(),
+            some_object_length: 3,
+        };
+
+        let py_zap_ref = (&zap).into_pyobject(py).unwrap();
+        let py_zap = zap.into_pyobject(py).unwrap();
+
+        py_run!(
+            py,
+            py_zap_ref,
+            "assert py_zap_ref == {'name': 'whatever', 'my_object': [1, 2, 3]},f'{py_zap_ref}'"
+        );
+        py_run!(
+            py,
+            py_zap,
+            "assert py_zap == {'name': 'whatever', 'my_object': [1, 2, 3]},f'{py_zap}'"
+        );
+    });
+}
+
+#[test]
+fn test_struct_into_py_rename_all() {
+    #[derive(IntoPyObject, IntoPyObjectRef)]
+    #[pyo3(rename_all = "camelCase")]
+    struct Foo {
+        foo_bar: String,
+        #[pyo3(item("BAZ"))]
+        baz: usize,
+        #[pyo3(item)]
+        long_field_name: f32,
+    }
+
+    let foo = Foo {
+        foo_bar: "foobar".into(),
+        baz: 42,
+        long_field_name: 0.0,
+    };
+
+    Python::attach(|py| {
+        let py_foo_ref = (&foo).into_pyobject(py).unwrap();
+        let py_foo = foo.into_pyobject(py).unwrap();
+
+        py_run!(
+            py,
+            py_foo_ref,
+            "assert py_foo_ref == {'fooBar': 'foobar', 'BAZ': 42, 'longFieldName': 0},f'{py_foo_ref}'"
+        );
+        py_run!(
+            py,
+            py_foo,
+            "assert py_foo == {'fooBar': 'foobar', 'BAZ': 42, 'longFieldName': 0},f'{py_foo}'"
+        );
+    });
+}
diff --git a/tests/test_macro_docs.rs b/tests/test_macro_docs.rs
index 5e240816cd2..e27277a9326 100644
--- a/tests/test_macro_docs.rs
+++ b/tests/test_macro_docs.rs
@@ -4,8 +4,7 @@ use pyo3::prelude::*;
 use pyo3::types::IntoPyDict;
 
 #[macro_use]
-#[path = "../src/tests/common.rs"]
-mod common;
+mod test_utils;
 
 #[pyclass]
 /// The MacroDocs class.
@@ -22,8 +21,10 @@ impl MacroDocs {
 
 #[test]
 fn meth_doc() {
-    Python::with_gil(|py| {
-        let d = [("C", py.get_type::<MacroDocs>())].into_py_dict_bound(py);
+    Python::attach(|py| {
+        let d = [("C", py.get_type::<MacroDocs>())]
+            .into_py_dict(py)
+            .unwrap();
         py_assert!(
             py,
             *d,
diff --git a/tests/test_macros.rs b/tests/test_macros.rs
index c01ba853685..f276890aa0b 100644
--- a/tests/test_macros.rs
+++ b/tests/test_macros.rs
@@ -5,14 +5,13 @@
 use pyo3::prelude::*;
 
 #[macro_use]
-#[path = "../src/tests/common.rs"]
-mod common;
+mod test_utils;
 
 macro_rules! make_struct_using_macro {
     // Ensure that one doesn't need to fall back on the escape type: tt
     // in order to macro create pyclass.
     ($class_name:ident, $py_name:literal) => {
-        #[pyclass(name=$py_name)]
+        #[pyclass(name=$py_name, subclass)]
         struct $class_name {}
     };
 }
@@ -22,6 +21,7 @@ make_struct_using_macro!(MyBaseClass, "MyClass");
 macro_rules! set_extends_via_macro {
     ($class_name:ident, $base_class:path) => {
         // Try and pass a variable into the extends parameter
+        #[allow(dead_code)]
         #[pyclass(extends=$base_class)]
         struct $class_name {}
     };
@@ -30,7 +30,7 @@ macro_rules! set_extends_via_macro {
 set_extends_via_macro!(MyClass2, MyBaseClass);
 
 //
-// Check that pyfunctiona nd text_signature can be called with macro arguments.
+// Check that pyfunctions and text_signature can be called with macro arguments.
 //
 
 macro_rules! fn_macro {
@@ -72,7 +72,7 @@ property_rename_via_macro!(my_new_property_name);
 
 #[test]
 fn test_macro_rules_interactions() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let my_base = py.get_type::<MyBaseClass>();
         py_assert!(py, my_base, "my_base.__name__ == 'MyClass'");
 
diff --git a/tests/test_mapping.rs b/tests/test_mapping.rs
index 9c99d56467f..df52372d143 100644
--- a/tests/test_mapping.rs
+++ b/tests/test_mapping.rs
@@ -10,8 +10,7 @@ use pyo3::types::PyList;
 use pyo3::types::PyMapping;
 use pyo3::types::PySequence;
 
-#[path = "../src/tests/common.rs"]
-mod common;
+mod test_utils;
 
 #[pyclass(mapping)]
 struct Mapping {
@@ -21,11 +20,12 @@ struct Mapping {
 #[pymethods]
 impl Mapping {
     #[new]
-    fn new(elements: Option<&PyList>) -> PyResult<Self> {
+    #[pyo3(signature=(elements=None))]
+    fn new(elements: Option<&Bound<'_, PyList>>) -> PyResult<Self> {
         if let Some(pylist) = elements {
             let mut elems = HashMap::with_capacity(pylist.len());
             for (i, pyelem) in pylist.into_iter().enumerate() {
-                let elem = String::extract(pyelem)?;
+                let elem = pyelem.extract()?;
                 elems.insert(elem, i);
             }
             Ok(Self { index: elems })
@@ -59,24 +59,32 @@ impl Mapping {
         }
     }
 
-    fn get(&self, py: Python<'_>, key: &str, default: Option<PyObject>) -> Option<PyObject> {
-        self.index
-            .get(key)
-            .map(|value| value.into_py(py))
-            .or(default)
+    #[pyo3(signature=(key, default=None))]
+    fn get(
+        &self,
+        py: Python<'_>,
+        key: &str,
+        default: Option<Py<PyAny>>,
+    ) -> PyResult<Option<Py<PyAny>>> {
+        match self.index.get(key) {
+            Some(value) => Ok(Some(value.into_pyobject(py)?.into_any().unbind())),
+            None => Ok(default),
+        }
     }
 }
 
 /// Return a dict with `m = Mapping(['1', '2', '3'])`.
 fn map_dict(py: Python<'_>) -> Bound<'_, pyo3::types::PyDict> {
-    let d = [("Mapping", py.get_type::<Mapping>())].into_py_dict_bound(py);
+    let d = [("Mapping", py.get_type::<Mapping>())]
+        .into_py_dict(py)
+        .unwrap();
     py_run!(py, *d, "m = Mapping(['1', '2', '3'])");
     d
 }
 
 #[test]
 fn test_getitem() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let d = map_dict(py);
 
         py_assert!(py, *d, "m['1'] == 0");
@@ -88,7 +96,7 @@ fn test_getitem() {
 
 #[test]
 fn test_setitem() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let d = map_dict(py);
 
         py_run!(py, *d, "m['1'] = 4; assert m['1'] == 4");
@@ -101,7 +109,7 @@ fn test_setitem() {
 
 #[test]
 fn test_delitem() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let d = map_dict(py);
         py_run!(
             py,
@@ -115,7 +123,7 @@ fn test_delitem() {
 
 #[test]
 fn mapping_is_not_sequence() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let mut index = HashMap::new();
         index.insert("Foo".into(), 1);
         index.insert("Bar".into(), 2);
@@ -123,7 +131,7 @@ fn mapping_is_not_sequence() {
 
         PyMapping::register::<Mapping>(py).unwrap();
 
-        assert!(m.as_ref(py).downcast::<PyMapping>().is_ok());
-        assert!(m.as_ref(py).downcast::<PySequence>().is_err());
+        assert!(m.bind(py).cast::<PyMapping>().is_ok());
+        assert!(m.bind(py).cast::<PySequence>().is_err());
     });
 }
diff --git a/tests/test_methods.rs b/tests/test_methods.rs
index 2114ead25c4..64fe36592e0 100644
--- a/tests/test_methods.rs
+++ b/tests/test_methods.rs
@@ -1,12 +1,18 @@
 #![cfg(feature = "macros")]
 
+#[cfg(not(Py_LIMITED_API))]
+use pyo3::exceptions::PyWarning;
+use pyo3::exceptions::{PyFutureWarning, PyUserWarning};
 use pyo3::prelude::*;
 use pyo3::py_run;
+use pyo3::types::PySequence;
 use pyo3::types::{IntoPyDict, PyDict, PyList, PySet, PyString, PyTuple, PyType};
-use pyo3::PyCell;
+use pyo3::BoundObject;
+use pyo3_macros::pyclass;
 
-#[path = "../src/tests/common.rs"]
-mod common;
+use crate::test_utils::CatchWarnings;
+
+mod test_utils;
 
 #[pyclass]
 struct InstanceMethod {
@@ -28,8 +34,8 @@ impl InstanceMethod {
 
 #[test]
 fn instance_method() {
-    Python::with_gil(|py| {
-        let obj = PyCell::new(py, InstanceMethod { member: 42 }).unwrap();
+    Python::attach(|py| {
+        let obj = Bound::new(py, InstanceMethod { member: 42 }).unwrap();
         let obj_ref = obj.borrow();
         assert_eq!(obj_ref.method(), 42);
         py_assert!(py, obj, "obj.method() == 42");
@@ -52,8 +58,8 @@ impl InstanceMethodWithArgs {
 
 #[test]
 fn instance_method_with_args() {
-    Python::with_gil(|py| {
-        let obj = PyCell::new(py, InstanceMethodWithArgs { member: 7 }).unwrap();
+    Python::attach(|py| {
+        let obj = Bound::new(py, InstanceMethodWithArgs { member: 7 }).unwrap();
         let obj_ref = obj.borrow();
         assert_eq!(obj_ref.method(6), 42);
         py_assert!(py, obj, "obj.method(3) == 21");
@@ -74,28 +80,21 @@ impl ClassMethod {
     #[classmethod]
     /// Test class method.
     fn method(cls: &Bound<'_, PyType>) -> PyResult<String> {
-        Ok(format!("{}.method()!", cls.as_gil_ref().qualname()?))
-    }
-
-    #[classmethod]
-    /// Test class method.
-    fn method_gil_ref(cls: &PyType) -> PyResult<String> {
         Ok(format!("{}.method()!", cls.qualname()?))
     }
 
     #[classmethod]
-    fn method_owned(cls: Py<PyType>) -> PyResult<String> {
-        Ok(format!(
-            "{}.method_owned()!",
-            Python::with_gil(|gil| cls.as_ref(gil).qualname())?
-        ))
+    fn method_owned(cls: Py<PyType>, py: Python<'_>) -> PyResult<String> {
+        Ok(format!("{}.method_owned()!", cls.bind(py).qualname()?))
     }
 }
 
 #[test]
 fn class_method() {
-    Python::with_gil(|py| {
-        let d = [("C", py.get_type::<ClassMethod>())].into_py_dict_bound(py);
+    Python::attach(|py| {
+        let d = [("C", py.get_type::<ClassMethod>())]
+            .into_py_dict(py)
+            .unwrap();
         py_assert!(py, *d, "C.method() == 'ClassMethod.method()!'");
         py_assert!(py, *d, "C().method() == 'ClassMethod.method()!'");
         py_assert!(
@@ -114,19 +113,17 @@ struct ClassMethodWithArgs {}
 #[pymethods]
 impl ClassMethodWithArgs {
     #[classmethod]
-    fn method(cls: &Bound<'_, PyType>, input: &PyString) -> PyResult<String> {
-        Ok(format!(
-            "{}.method({})",
-            cls.as_gil_ref().qualname()?,
-            input
-        ))
+    fn method(cls: &Bound<'_, PyType>, input: &Bound<'_, PyString>) -> PyResult<String> {
+        Ok(format!("{}.method({})", cls.qualname()?, input))
     }
 }
 
 #[test]
 fn class_method_with_args() {
-    Python::with_gil(|py| {
-        let d = [("C", py.get_type::<ClassMethodWithArgs>())].into_py_dict_bound(py);
+    Python::attach(|py| {
+        let d = [("C", py.get_type::<ClassMethodWithArgs>())]
+            .into_py_dict(py)
+            .unwrap();
         py_assert!(
             py,
             *d,
@@ -154,10 +151,12 @@ impl StaticMethod {
 
 #[test]
 fn static_method() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         assert_eq!(StaticMethod::method(py), "StaticMethod.method()!");
 
-        let d = [("C", py.get_type::<StaticMethod>())].into_py_dict_bound(py);
+        let d = [("C", py.get_type::<StaticMethod>())]
+            .into_py_dict(py)
+            .unwrap();
         py_assert!(py, *d, "C.method() == 'StaticMethod.method()!'");
         py_assert!(py, *d, "C().method() == 'StaticMethod.method()!'");
         py_assert!(py, *d, "C.method.__doc__ == 'Test static method.'");
@@ -172,16 +171,18 @@ struct StaticMethodWithArgs {}
 impl StaticMethodWithArgs {
     #[staticmethod]
     fn method(_py: Python<'_>, input: i32) -> String {
-        format!("0x{:x}", input)
+        format!("0x{input:x}")
     }
 }
 
 #[test]
 fn static_method_with_args() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         assert_eq!(StaticMethodWithArgs::method(py, 1234), "0x4d2");
 
-        let d = [("C", py.get_type::<StaticMethodWithArgs>())].into_py_dict_bound(py);
+        let d = [("C", py.get_type::<StaticMethodWithArgs>())]
+            .into_py_dict(py)
+            .unwrap();
         py_assert!(py, *d, "C.method(1337) == '0x539'");
     });
 }
@@ -199,6 +200,7 @@ impl MethSignature {
     fn get_optional2(&self, test: Option<i32>) -> Option<i32> {
         test
     }
+    #[pyo3(signature=(_t1 = None, t2 = None, _t3 = None))]
     fn get_optional_positional(
         &self,
         _t1: Option<i32>,
@@ -217,19 +219,33 @@ impl MethSignature {
         test
     }
     #[pyo3(signature = (*args, **kwargs))]
-    fn get_kwargs(&self, py: Python<'_>, args: &PyTuple, kwargs: Option<&PyDict>) -> PyObject {
-        [args.into(), kwargs.to_object(py)].to_object(py)
+    fn get_kwargs<'py>(
+        &self,
+        py: Python<'py>,
+        args: &Bound<'py, PyTuple>,
+        kwargs: Option<&Bound<'py, PyDict>>,
+    ) -> PyResult<Bound<'py, PyAny>> {
+        [
+            args.as_any().clone(),
+            kwargs.into_pyobject(py)?.into_any().into_bound(),
+        ]
+        .into_pyobject(py)
     }
 
     #[pyo3(signature = (a, *args, **kwargs))]
-    fn get_pos_arg_kw(
+    fn get_pos_arg_kw<'py>(
         &self,
-        py: Python<'_>,
+        py: Python<'py>,
         a: i32,
-        args: &PyTuple,
-        kwargs: Option<&PyDict>,
-    ) -> PyObject {
-        [a.to_object(py), args.into(), kwargs.to_object(py)].to_object(py)
+        args: &Bound<'py, PyTuple>,
+        kwargs: Option<&Bound<'py, PyDict>>,
+    ) -> PyResult<Bound<'py, PyAny>> {
+        [
+            a.into_pyobject(py)?.into_any().into_bound(),
+            args.as_any().clone(),
+            kwargs.into_pyobject(py)?.into_any().into_bound(),
+        ]
+        .into_pyobject(py)
     }
 
     #[pyo3(signature = (a, b, /))]
@@ -272,9 +288,14 @@ impl MethSignature {
         &self,
         py: Python<'_>,
         a: i32,
-        kwargs: Option<&PyDict>,
-    ) -> PyObject {
-        [a.to_object(py), kwargs.to_object(py)].to_object(py)
+        kwargs: Option<&Bound<'_, PyDict>>,
+    ) -> PyResult<Py<PyAny>> {
+        [
+            a.into_pyobject(py)?.into_any().into_bound(),
+            kwargs.into_pyobject(py)?.into_any().into_bound(),
+        ]
+        .into_pyobject(py)
+        .map(Bound::unbind)
     }
 
     #[pyo3(signature = (a=0, /, **kwargs))]
@@ -282,9 +303,14 @@ impl MethSignature {
         &self,
         py: Python<'_>,
         a: i32,
-        kwargs: Option<&PyDict>,
-    ) -> PyObject {
-        [a.to_object(py), kwargs.to_object(py)].to_object(py)
+        kwargs: Option<&Bound<'_, PyDict>>,
+    ) -> PyResult<Py<PyAny>> {
+        [
+            a.into_pyobject(py)?.into_any().into_bound(),
+            kwargs.into_pyobject(py)?.into_any().into_bound(),
+        ]
+        .into_pyobject(py)
+        .map(Bound::unbind)
     }
 
     #[pyo3(signature = (*, a = 2, b = 3))]
@@ -303,8 +329,16 @@ impl MethSignature {
     }
 
     #[pyo3(signature = (*args, a))]
-    fn get_args_and_required_keyword(&self, py: Python<'_>, args: &PyTuple, a: i32) -> PyObject {
-        (args, a).to_object(py)
+    fn get_args_and_required_keyword(
+        &self,
+        py: Python<'_>,
+        args: &Bound<'_, PyTuple>,
+        a: i32,
+    ) -> PyResult<Py<PyAny>> {
+        (args, a)
+            .into_pyobject(py)
+            .map(BoundObject::into_any)
+            .map(Bound::unbind)
     }
 
     #[pyo3(signature = (a, b = 2, *, c = 3))]
@@ -318,8 +352,18 @@ impl MethSignature {
     }
 
     #[pyo3(signature = (a, **kwargs))]
-    fn get_pos_kw(&self, py: Python<'_>, a: i32, kwargs: Option<&PyDict>) -> PyObject {
-        [a.to_object(py), kwargs.to_object(py)].to_object(py)
+    fn get_pos_kw(
+        &self,
+        py: Python<'_>,
+        a: i32,
+        kwargs: Option<&Bound<'_, PyDict>>,
+    ) -> PyResult<Py<PyAny>> {
+        [
+            a.into_pyobject(py)?.into_any().into_bound(),
+            kwargs.into_pyobject(py)?.into_any().into_bound(),
+        ]
+        .into_pyobject(py)
+        .map(Bound::unbind)
     }
 
     // "args" can be anything that can be extracted from PyTuple
@@ -331,7 +375,7 @@ impl MethSignature {
 
 #[test]
 fn meth_signature() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let inst = Py::new(py, MethSignature {}).unwrap();
 
         py_run!(py, inst, "assert inst.get_optional() == 10");
@@ -678,8 +722,8 @@ impl MethDocs {
 
 #[test]
 fn meth_doc() {
-    Python::with_gil(|py| {
-        let d = [("C", py.get_type::<MethDocs>())].into_py_dict_bound(py);
+    Python::attach(|py| {
+        let d = [("C", py.get_type::<MethDocs>())].into_py_dict(py).unwrap();
         py_assert!(py, *d, "C.__doc__ == 'A class with \"documentation\".'");
         py_assert!(
             py,
@@ -699,12 +743,13 @@ struct MethodWithLifeTime {}
 
 #[pymethods]
 impl MethodWithLifeTime {
-    fn set_to_list<'py>(&self, py: Python<'py>, set: &'py PySet) -> PyResult<Bound<'py, PyList>> {
+    fn set_to_list<'py>(&self, set: &Bound<'py, PySet>) -> PyResult<Bound<'py, PyList>> {
+        let py = set.py();
         let mut items = vec![];
         for _ in 0..set.len() {
             items.push(set.pop().unwrap());
         }
-        let list = PyList::new_bound(py, items);
+        let list = PyList::new(py, items)?;
         list.sort()?;
         Ok(list)
     }
@@ -712,8 +757,8 @@ impl MethodWithLifeTime {
 
 #[test]
 fn method_with_lifetime() {
-    Python::with_gil(|py| {
-        let obj = PyCell::new(py, MethodWithLifeTime {}).unwrap();
+    Python::attach(|py| {
+        let obj = Py::new(py, MethodWithLifeTime {}).unwrap();
         py_run!(
             py,
             obj,
@@ -746,11 +791,13 @@ impl MethodWithPyClassArg {
     fn inplace_add_pyref(&self, mut other: PyRefMut<'_, MethodWithPyClassArg>) {
         other.value += self.value;
     }
+    #[pyo3(signature=(other = None))]
     fn optional_add(&self, other: Option<&MethodWithPyClassArg>) -> MethodWithPyClassArg {
         MethodWithPyClassArg {
             value: self.value + other.map(|o| o.value).unwrap_or(10),
         }
     }
+    #[pyo3(signature=(other = None))]
     fn optional_inplace_add(&self, other: Option<&mut MethodWithPyClassArg>) {
         if let Some(other) = other {
             other.value += self.value;
@@ -760,10 +807,10 @@ impl MethodWithPyClassArg {
 
 #[test]
 fn method_with_pyclassarg() {
-    Python::with_gil(|py| {
-        let obj1 = PyCell::new(py, MethodWithPyClassArg { value: 10 }).unwrap();
-        let obj2 = PyCell::new(py, MethodWithPyClassArg { value: 10 }).unwrap();
-        let d = [("obj1", obj1), ("obj2", obj2)].into_py_dict_bound(py);
+    Python::attach(|py| {
+        let obj1 = Py::new(py, MethodWithPyClassArg { value: 10 }).unwrap();
+        let obj2 = Py::new(py, MethodWithPyClassArg { value: 10 }).unwrap();
+        let d = [("obj1", obj1), ("obj2", obj2)].into_py_dict(py).unwrap();
         py_run!(py, *d, "obj = obj1.add(obj2); assert obj.value == 20");
         py_run!(py, *d, "obj = obj1.add_pyref(obj2); assert obj.value == 20");
         py_run!(py, *d, "obj = obj1.optional_add(); assert obj.value == 20");
@@ -823,7 +870,7 @@ impl CfgStruct {
 
 #[test]
 fn test_cfg_attrs() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let inst = Py::new(py, CfgStruct {}).unwrap();
 
         #[cfg(unix)]
@@ -852,10 +899,11 @@ struct FromSequence {
 #[pymethods]
 impl FromSequence {
     #[new]
-    fn new(seq: Option<&pyo3::types::PySequence>) -> PyResult<Self> {
+    #[pyo3(signature=(seq = None))]
+    fn new(seq: Option<&Bound<'_, PySequence>>) -> PyResult<Self> {
         if let Some(seq) = seq {
             Ok(FromSequence {
-                numbers: seq.as_ref().extract::<Vec<_>>()?,
+                numbers: seq.as_any().extract::<Vec<_>>()?,
             })
         } else {
             Ok(FromSequence::default())
@@ -865,7 +913,7 @@ impl FromSequence {
 
 #[test]
 fn test_from_sequence() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let typeobj = py.get_type::<FromSequence>();
         py_assert!(py, typeobj, "typeobj(range(0, 4)).numbers == [0, 1, 2, 3]");
     });
@@ -874,9 +922,9 @@ fn test_from_sequence() {
 #[pyclass]
 struct r#RawIdents {
     #[pyo3(get, set)]
-    r#type: PyObject,
-    r#subtype: PyObject,
-    r#subsubtype: PyObject,
+    r#type: Py<PyAny>,
+    r#subtype: Py<PyAny>,
+    r#subsubtype: Py<PyAny>,
 }
 
 #[pymethods]
@@ -884,9 +932,9 @@ impl r#RawIdents {
     #[new]
     pub fn r#new(
         r#_py: Python<'_>,
-        r#type: PyObject,
-        r#subtype: PyObject,
-        r#subsubtype: PyObject,
+        r#type: Py<PyAny>,
+        r#subtype: Py<PyAny>,
+        r#subsubtype: Py<PyAny>,
     ) -> Self {
         Self {
             r#type,
@@ -896,36 +944,36 @@ impl r#RawIdents {
     }
 
     #[getter(r#subtype)]
-    pub fn r#get_subtype(&self) -> PyObject {
-        self.r#subtype.clone()
+    pub fn r#get_subtype(&self, py: Python<'_>) -> Py<PyAny> {
+        self.r#subtype.clone_ref(py)
     }
 
     #[setter(r#subtype)]
-    pub fn r#set_subtype(&mut self, r#subtype: PyObject) {
+    pub fn r#set_subtype(&mut self, r#subtype: Py<PyAny>) {
         self.r#subtype = r#subtype;
     }
 
     #[getter]
-    pub fn r#get_subsubtype(&self) -> PyObject {
-        self.r#subsubtype.clone()
+    pub fn r#get_subsubtype(&self, py: Python<'_>) -> Py<PyAny> {
+        self.r#subsubtype.clone_ref(py)
     }
 
     #[setter]
-    pub fn r#set_subsubtype(&mut self, r#subsubtype: PyObject) {
+    pub fn r#set_subsubtype(&mut self, r#subsubtype: Py<PyAny>) {
         self.r#subsubtype = r#subsubtype;
     }
 
-    pub fn r#__call__(&mut self, r#type: PyObject) {
+    pub fn r#__call__(&mut self, r#type: Py<PyAny>) {
         self.r#type = r#type;
     }
 
     #[staticmethod]
-    pub fn r#static_method(r#type: PyObject) -> PyObject {
+    pub fn r#static_method(r#type: Py<PyAny>) -> Py<PyAny> {
         r#type
     }
 
     #[classmethod]
-    pub fn r#class_method(_: &Bound<'_, PyType>, r#type: PyObject) -> PyObject {
+    pub fn r#class_method(_: &Bound<'_, PyType>, r#type: Py<PyAny>) -> Py<PyAny> {
         r#type
     }
 
@@ -945,7 +993,7 @@ impl r#RawIdents {
 
 #[test]
 fn test_raw_idents() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let raw_idents_type = py.get_type::<r#RawIdents>();
         assert_eq!(raw_idents_type.qualname().unwrap(), "RawIdents");
         py_run!(
@@ -1027,48 +1075,53 @@ macro_rules! issue_1506 {
 issue_1506!(
     #[pymethods]
     impl Issue1506 {
+        #[pyo3(signature = (_arg, _args, _kwargs=None))]
         fn issue_1506(
             &self,
             _py: Python<'_>,
-            _arg: &PyAny,
-            _args: &PyTuple,
-            _kwargs: Option<&PyDict>,
+            _arg: &Bound<'_, PyAny>,
+            _args: &Bound<'_, PyTuple>,
+            _kwargs: Option<&Bound<'_, PyDict>>,
         ) {
         }
 
+        #[pyo3(signature = (_arg, _args, _kwargs=None))]
         fn issue_1506_mut(
             &mut self,
             _py: Python<'_>,
-            _arg: &PyAny,
-            _args: &PyTuple,
-            _kwargs: Option<&PyDict>,
+            _arg: &Bound<'_, PyAny>,
+            _args: &Bound<'_, PyTuple>,
+            _kwargs: Option<&Bound<'_, PyDict>>,
         ) {
         }
 
+        #[pyo3(signature = (_arg, _args, _kwargs=None))]
         fn issue_1506_custom_receiver(
             _slf: Py<Self>,
             _py: Python<'_>,
-            _arg: &PyAny,
-            _args: &PyTuple,
-            _kwargs: Option<&PyDict>,
+            _arg: &Bound<'_, PyAny>,
+            _args: &Bound<'_, PyTuple>,
+            _kwargs: Option<&Bound<'_, PyDict>>,
         ) {
         }
 
+        #[pyo3(signature = (_arg, _args, _kwargs=None))]
         fn issue_1506_custom_receiver_explicit(
             _slf: Py<Issue1506>,
             _py: Python<'_>,
-            _arg: &PyAny,
-            _args: &PyTuple,
-            _kwargs: Option<&PyDict>,
+            _arg: &Bound<'_, PyAny>,
+            _args: &Bound<'_, PyTuple>,
+            _kwargs: Option<&Bound<'_, PyDict>>,
         ) {
         }
 
         #[new]
+        #[pyo3(signature = (_arg, _args, _kwargs=None))]
         fn issue_1506_new(
             _py: Python<'_>,
-            _arg: &PyAny,
-            _args: &PyTuple,
-            _kwargs: Option<&PyDict>,
+            _arg: &Bound<'_, PyAny>,
+            _args: &Bound<'_, PyTuple>,
+            _kwargs: Option<&Bound<'_, PyDict>>,
         ) -> Self {
             Issue1506 {}
         }
@@ -1082,21 +1135,23 @@ issue_1506!(
         fn issue_1506_setter(&self, _py: Python<'_>, _value: i32) {}
 
         #[staticmethod]
+        #[pyo3(signature = (_arg, _args, _kwargs=None))]
         fn issue_1506_static(
             _py: Python<'_>,
-            _arg: &PyAny,
-            _args: &PyTuple,
-            _kwargs: Option<&PyDict>,
+            _arg: &Bound<'_, PyAny>,
+            _args: &Bound<'_, PyTuple>,
+            _kwargs: Option<&Bound<'_, PyDict>>,
         ) {
         }
 
         #[classmethod]
+        #[pyo3(signature = (_arg, _args, _kwargs=None))]
         fn issue_1506_class(
             _cls: &Bound<'_, PyType>,
             _py: Python<'_>,
-            _arg: &PyAny,
-            _args: &PyTuple,
-            _kwargs: Option<&PyDict>,
+            _arg: &Bound<'_, PyAny>,
+            _args: &Bound<'_, PyTuple>,
+            _kwargs: Option<&Bound<'_, PyDict>>,
         ) {
         }
     }
@@ -1125,7 +1180,7 @@ fn test_option_pyclass_arg() {
         arg.map(|_| SomePyClass {})
     }
 
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let f = wrap_pyfunction!(option_class_arg, py).unwrap();
         assert!(f.call0().unwrap().is_none());
         let obj = Py::new(py, SomePyClass {}).unwrap();
@@ -1148,7 +1203,270 @@ fn test_issue_2988() {
         _data: Vec<i32>,
         // The from_py_with here looks a little odd, we just need some way
         // to encourage the macro to expand the from_py_with default path too
-        #[pyo3(from_py_with = "PyAny::extract")] _data2: Vec<i32>,
+        #[pyo3(from_py_with = <Bound<'_, _> as PyAnyMethods>::extract)] _data2: Vec<i32>,
     ) {
     }
 }
+
+#[cfg(not(Py_LIMITED_API))]
+#[pyclass(extends=PyWarning)]
+pub struct UserDefinedWarning {}
+
+#[cfg(not(Py_LIMITED_API))]
+#[pymethods]
+impl UserDefinedWarning {
+    #[new]
+    #[pyo3(signature = (*_args, **_kwargs))]
+    fn new(_args: Bound<'_, PyAny>, _kwargs: Option<Bound<'_, PyAny>>) -> Self {
+        Self {}
+    }
+}
+
+#[test]
+fn test_pymethods_warn() {
+    // We do not test #[classattr] nor __traverse__
+    // because it doesn't make sense to implement deprecated methods for them.
+
+    #[pyclass]
+    struct WarningMethodContainer {
+        value: i32,
+    }
+
+    #[pymethods]
+    impl WarningMethodContainer {
+        #[new]
+        #[pyo3(warn(message = "this __new__ method raises warning"))]
+        fn new() -> Self {
+            Self { value: 0 }
+        }
+
+        #[pyo3(warn(message = "this method raises warning"))]
+        fn method_with_warning(_slf: PyRef<'_, Self>) {}
+
+        #[pyo3(warn(message = "this method raises warning", category = PyFutureWarning))]
+        fn method_with_warning_and_custom_category(_slf: PyRef<'_, Self>) {}
+
+        #[cfg(not(Py_LIMITED_API))]
+        #[pyo3(warn(message = "this method raises user-defined warning", category = UserDefinedWarning))]
+        fn method_with_warning_and_user_defined_category(&self) {}
+
+        #[staticmethod]
+        #[pyo3(warn(message = "this static method raises warning"))]
+        fn static_method() {}
+
+        #[staticmethod]
+        #[pyo3(warn(message = "this class method raises warning"))]
+        fn class_method() {}
+
+        #[getter]
+        #[pyo3(warn(message = "this getter raises warning"))]
+        fn get_value(&self) -> i32 {
+            self.value
+        }
+
+        #[setter]
+        #[pyo3(warn(message = "this setter raises warning"))]
+        fn set_value(&mut self, value: i32) {
+            self.value = value;
+        }
+
+        #[pyo3(warn(message = "this subscript op method raises warning"))]
+        fn __getitem__(&self, _key: i32) -> i32 {
+            0
+        }
+
+        #[pyo3(warn(message = "the + op method raises warning"))]
+        fn __add__(&self, other: PyRef<'_, Self>) -> Self {
+            Self {
+                value: self.value + other.value,
+            }
+        }
+
+        #[pyo3(warn(message = "this __call__ method raises warning"))]
+        fn __call__(&self) -> i32 {
+            self.value
+        }
+    }
+
+    Python::attach(|py| {
+        let typeobj = py.get_type::<WarningMethodContainer>();
+        let obj = CatchWarnings::enter(py, |_| typeobj.call0()).unwrap();
+
+        // FnType::Fn
+        py_expect_warning!(
+            py,
+            obj,
+            "obj.method_with_warning()",
+            [("this method raises warning", PyUserWarning)],
+        );
+
+        // FnType::Fn
+        py_expect_warning!(
+            py,
+            obj,
+            "obj.method_with_warning_and_custom_category()",
+            [("this method raises warning", PyFutureWarning)]
+        );
+
+        // FnType::Fn, user-defined warning
+        #[cfg(not(Py_LIMITED_API))]
+        py_expect_warning!(
+            py,
+            obj,
+            "obj.method_with_warning_and_user_defined_category()",
+            [(
+                "this method raises user-defined warning",
+                UserDefinedWarning
+            )]
+        );
+
+        // #[staticmethod], FnType::FnStatic
+        py_expect_warning!(
+            py,
+            typeobj,
+            "typeobj.static_method()",
+            [("this static method raises warning", PyUserWarning)]
+        );
+
+        // #[classmethod], FnType::FnClass
+        py_expect_warning!(
+            py,
+            typeobj,
+            "typeobj.class_method()",
+            [("this class method raises warning", PyUserWarning)]
+        );
+
+        // #[classmethod], FnType::FnClass
+        py_expect_warning!(
+            py,
+            obj,
+            "obj.class_method()",
+            [("this class method raises warning", PyUserWarning)]
+        );
+
+        // #[new], FnType::FnNew
+        py_expect_warning!(
+            py,
+            typeobj,
+            "typeobj()",
+            [("this __new__ method raises warning", PyUserWarning)]
+        );
+
+        // #[getter], FnType::Getter
+        py_expect_warning!(
+            py,
+            obj,
+            "val = obj.value",
+            [("this getter raises warning", PyUserWarning)]
+        );
+
+        // #[setter], FnType::Setter
+        py_expect_warning!(
+            py,
+            obj,
+            "obj.value = 10",
+            [("this setter raises warning", PyUserWarning)]
+        );
+
+        // PyMethodProtoKind::Slot
+        py_expect_warning!(
+            py,
+            obj,
+            "obj[0]",
+            [("this subscript op method raises warning", PyUserWarning)]
+        );
+
+        // PyMethodProtoKind::SlotFragment
+        py_expect_warning!(
+            py,
+            obj,
+            "obj + obj",
+            [("the + op method raises warning", PyUserWarning)]
+        );
+
+        // PyMethodProtoKind::Call
+        py_expect_warning!(
+            py,
+            obj,
+            "obj()",
+            [("this __call__ method raises warning", PyUserWarning)]
+        );
+    });
+
+    #[pyclass]
+    struct WarningMethodContainer2 {}
+
+    #[pymethods]
+    impl WarningMethodContainer2 {
+        #[new]
+        #[classmethod]
+        #[pyo3(warn(message = "this class-method __new__ method raises warning"))]
+        fn new(_cls: Bound<'_, PyType>) -> Self {
+            Self {}
+        }
+    }
+
+    Python::attach(|py| {
+        let typeobj = py.get_type::<WarningMethodContainer2>();
+
+        // #[new], #[classmethod], FnType::FnNewClass
+        py_expect_warning!(
+            py,
+            typeobj,
+            "typeobj()",
+            [(
+                "this class-method __new__ method raises warning",
+                PyUserWarning
+            )]
+        );
+    });
+}
+
+#[test]
+fn test_py_methods_multiple_warn() {
+    #[pyclass]
+    struct MultipleWarnContainer {}
+
+    #[pymethods]
+    impl MultipleWarnContainer {
+        #[new]
+        fn new() -> Self {
+            Self {}
+        }
+
+        #[pyo3(warn(message = "this method raises warning 1"))]
+        #[pyo3(warn(message = "this method raises warning 2", category = PyFutureWarning))]
+        fn multiple_warn_method(&self) {}
+
+        #[cfg(not(Py_LIMITED_API))]
+        #[pyo3(warn(message = "this method raises FutureWarning", category = PyFutureWarning))]
+        #[pyo3(warn(message = "this method raises UserDefinedWarning", category = UserDefinedWarning))]
+        fn multiple_warn_custom_category_method(&self) {}
+    }
+
+    Python::attach(|py| {
+        let typeobj = py.get_type::<MultipleWarnContainer>();
+        let obj = typeobj.call0().unwrap();
+
+        py_expect_warning!(
+            py,
+            obj,
+            "obj.multiple_warn_method()",
+            [
+                ("this method raises warning 1", PyUserWarning),
+                ("this method raises warning 2", PyFutureWarning)
+            ]
+        );
+
+        #[cfg(not(Py_LIMITED_API))]
+        py_expect_warning!(
+            py,
+            obj,
+            "obj.multiple_warn_custom_category_method()",
+            [
+                ("this method raises FutureWarning", PyFutureWarning),
+                ("this method raises UserDefinedWarning", UserDefinedWarning)
+            ]
+        );
+    });
+}
diff --git a/tests/test_module.rs b/tests/test_module.rs
index 9a59770e047..5ba238cd91e 100644
--- a/tests/test_module.rs
+++ b/tests/test_module.rs
@@ -6,8 +6,7 @@ use pyo3::py_run;
 use pyo3::types::PyString;
 use pyo3::types::{IntoPyDict, PyDict, PyTuple};
 
-#[path = "../src/tests/common.rs"]
-mod common;
+mod test_utils;
 
 #[pyclass]
 struct AnonClass {}
@@ -34,48 +33,52 @@ fn double(x: usize) -> usize {
     x * 2
 }
 
-/// This module is implemented in Rust.
-#[pymodule]
-fn module_with_functions(_py: Python<'_>, m: &PyModule) -> PyResult<()> {
-    #[pyfn(m)]
-    #[pyo3(name = "no_parameters")]
-    fn function_with_name() -> usize {
-        42
-    }
-
-    #[pyfn(m)]
-    #[pyo3(pass_module)]
-    fn with_module(module: &PyModule) -> PyResult<&str> {
-        module.name()
-    }
+#[test]
+fn test_module_with_functions() {
+    use pyo3::wrap_pymodule;
 
-    #[pyfn(m)]
-    fn double_value(v: &ValueClass) -> usize {
-        v.value * 2
-    }
+    /// This module is implemented in Rust.
+    #[pymodule(gil_used = false)]
+    mod module_with_functions {
+        use super::*;
 
-    m.add_class::<AnonClass>().unwrap();
-    m.add_class::<ValueClass>().unwrap();
-    m.add_class::<LocatedClass>().unwrap();
+        #[pymodule_export]
+        use super::{AnonClass, ValueClass};
 
-    m.add("foo", "bar").unwrap();
+        #[pymodule_init]
+        fn init_module(m: &Bound<'_, PyModule>) -> PyResult<()> {
+            m.add_class::<LocatedClass>()?;
+            m.add("foo", "bar")?;
+            m.add_function(wrap_pyfunction!(double, m)?)?;
+            m.add("also_double", wrap_pyfunction!(double, m)?)?;
+            Ok(())
+        }
 
-    m.add_function(wrap_pyfunction!(double, m)?).unwrap();
-    m.add("also_double", wrap_pyfunction!(double, m)?).unwrap();
+        #[pyfunction]
+        #[pyo3(name = "no_parameters")]
+        fn function_with_name() -> usize {
+            42
+        }
 
-    Ok(())
-}
+        #[pyfunction]
+        #[pyo3(pass_module)]
+        fn with_module<'py>(module: &Bound<'py, PyModule>) -> PyResult<Bound<'py, PyString>> {
+            module.name()
+        }
 
-#[test]
-fn test_module_with_functions() {
-    use pyo3::wrap_pymodule;
+        #[pyfunction]
+        fn double_value(v: &ValueClass) -> usize {
+            v.value * 2
+        }
+    }
 
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let d = [(
             "module_with_functions",
             wrap_pymodule!(module_with_functions)(py),
         )]
-        .into_py_dict_bound(py);
+        .into_py_dict(py)
+        .unwrap();
 
         py_assert!(
             py,
@@ -116,9 +119,112 @@ fn test_module_with_functions() {
     });
 }
 
+#[test]
+#[allow(deprecated)]
+fn test_module_with_pyfn() {
+    use pyo3::wrap_pymodule;
+
+    /// This module is implemented in Rust.
+    #[pymodule(gil_used = false)]
+    fn module_with_pyfn(m: &Bound<'_, PyModule>) -> PyResult<()> {
+        #[pyfn(m)]
+        #[pyo3(name = "no_parameters")]
+        fn function_with_name() -> usize {
+            42
+        }
+
+        #[pyfn(m)]
+        #[pyo3(pass_module)]
+        fn with_module<'py>(module: &Bound<'py, PyModule>) -> PyResult<Bound<'py, PyString>> {
+            module.name()
+        }
+
+        #[pyfn(m)]
+        fn double_value(v: &ValueClass) -> usize {
+            v.value * 2
+        }
+
+        m.add_class::<AnonClass>()?;
+        m.add_class::<ValueClass>()?;
+        m.add_class::<LocatedClass>()?;
+
+        m.add("foo", "bar")?;
+
+        m.add_function(wrap_pyfunction!(double, m)?)?;
+        m.add("also_double", wrap_pyfunction!(double, m)?)?;
+
+        Ok(())
+    }
+
+    Python::attach(|py| {
+        let d = [("module_with_pyfn", wrap_pymodule!(module_with_pyfn)(py))]
+            .into_py_dict(py)
+            .unwrap();
+
+        py_assert!(
+            py,
+            *d,
+            "module_with_pyfn.__doc__ == 'This module is implemented in Rust.'"
+        );
+        py_assert!(py, *d, "module_with_pyfn.no_parameters() == 42");
+        py_assert!(py, *d, "module_with_pyfn.foo == 'bar'");
+        py_assert!(py, *d, "module_with_pyfn.AnonClass != None");
+        py_assert!(py, *d, "module_with_pyfn.LocatedClass != None");
+        py_assert!(
+            py,
+            *d,
+            "module_with_pyfn.LocatedClass.__module__ == 'module'"
+        );
+        py_assert!(py, *d, "module_with_pyfn.double(3) == 6");
+        py_assert!(
+            py,
+            *d,
+            "module_with_pyfn.double.__doc__ == 'Doubles the given value'"
+        );
+        py_assert!(py, *d, "module_with_pyfn.also_double(3) == 6");
+        py_assert!(
+            py,
+            *d,
+            "module_with_pyfn.also_double.__doc__ == 'Doubles the given value'"
+        );
+        py_assert!(
+            py,
+            *d,
+            "module_with_pyfn.double_value(module_with_pyfn.ValueClass(1)) == 2"
+        );
+        py_assert!(
+            py,
+            *d,
+            "module_with_pyfn.with_module() == 'module_with_pyfn'"
+        );
+    });
+}
+
+/// This module uses a legacy two-argument module function.
 #[pymodule]
-#[pyo3(name = "other_name")]
-fn some_name(_: Python<'_>, m: &PyModule) -> PyResult<()> {
+fn module_with_explicit_py_arg(_py: Python<'_>, m: &Bound<'_, PyModule>) -> PyResult<()> {
+    m.add_function(wrap_pyfunction!(double, m)?)?;
+    Ok(())
+}
+
+#[test]
+fn test_module_with_explicit_py_arg() {
+    use pyo3::wrap_pymodule;
+
+    Python::attach(|py| {
+        let d = [(
+            "module_with_explicit_py_arg",
+            wrap_pymodule!(module_with_explicit_py_arg)(py),
+        )]
+        .into_py_dict(py)
+        .unwrap();
+
+        py_assert!(py, *d, "module_with_explicit_py_arg.double(3) == 6");
+    });
+}
+
+#[pymodule(name = "other_name")]
+fn some_name(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add("other_name", "other_name")?;
     Ok(())
 }
@@ -127,35 +233,38 @@ fn some_name(_: Python<'_>, m: &PyModule) -> PyResult<()> {
 fn test_module_renaming() {
     use pyo3::wrap_pymodule;
 
-    Python::with_gil(|py| {
-        let d = [("different_name", wrap_pymodule!(some_name)(py))].into_py_dict_bound(py);
+    Python::attach(|py| {
+        let d = [("different_name", wrap_pymodule!(some_name)(py))]
+            .into_py_dict(py)
+            .unwrap();
 
         py_run!(py, *d, "assert different_name.__name__ == 'other_name'");
     });
 }
 
 #[test]
-fn test_module_from_code() {
-    Python::with_gil(|py| {
+fn test_module_from_code_bound() {
+    Python::attach(|py| {
         let adder_mod = PyModule::from_code(
             py,
-            "def add(a,b):\n\treturn a+b",
-            "adder_mod.py",
-            "adder_mod",
+            c"def add(a,b):\n\treturn a+b",
+            c"adder_mod.py",
+            &test_utils::generate_unique_module_name("adder_mod"),
         )
         .expect("Module code should be loaded");
 
         let add_func = adder_mod
             .getattr("add")
-            .expect("Add function should be in the module")
-            .to_object(py);
+            .expect("Add function should be in the module");
 
         let ret_value: i32 = add_func
-            .call1(py, (1, 2))
+            .call1((1, 2))
             .expect("A value should be returned")
-            .extract(py)
+            .extract()
             .expect("The value should be able to be converted to an i32");
 
+        adder_mod.gil_used(false).expect("Disabling the GIL failed");
+
         assert_eq!(ret_value, 3);
     });
 }
@@ -166,7 +275,7 @@ fn r#move() -> usize {
 }
 
 #[pymodule]
-fn raw_ident_module(_py: Python<'_>, module: &PyModule) -> PyResult<()> {
+fn raw_ident_module(module: &Bound<'_, PyModule>) -> PyResult<()> {
     module.add_function(wrap_pyfunction!(r#move, module)?)
 }
 
@@ -174,7 +283,7 @@ fn raw_ident_module(_py: Python<'_>, module: &PyModule) -> PyResult<()> {
 fn test_raw_idents() {
     use pyo3::wrap_pymodule;
 
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let module = wrap_pymodule!(raw_ident_module)(py);
 
         py_assert!(py, module, "module.move() == 42");
@@ -190,12 +299,12 @@ fn custom_named_fn() -> usize {
 #[test]
 fn test_custom_names() {
     #[pymodule]
-    fn custom_names(_py: Python<'_>, m: &PyModule) -> PyResult<()> {
+    fn custom_names(m: &Bound<'_, PyModule>) -> PyResult<()> {
         m.add_function(wrap_pyfunction!(custom_named_fn, m)?)?;
         Ok(())
     }
 
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let module = pyo3::wrap_pymodule!(custom_names)(py);
 
         py_assert!(py, module, "not hasattr(module, 'custom_named_fn')");
@@ -206,12 +315,12 @@ fn test_custom_names() {
 #[test]
 fn test_module_dict() {
     #[pymodule]
-    fn module_dict(_py: Python<'_>, m: &PyModule) -> PyResult<()> {
+    fn module_dict(m: &Bound<'_, PyModule>) -> PyResult<()> {
         m.dict().set_item("yay", "me")?;
         Ok(())
     }
 
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let module = pyo3::wrap_pymodule!(module_dict)(py);
 
         py_assert!(py, module, "module.yay == 'me'");
@@ -220,9 +329,9 @@ fn test_module_dict() {
 
 #[test]
 fn test_module_dunder_all() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         #[pymodule]
-        fn dunder_all(_py: Python<'_>, m: &PyModule) -> PyResult<()> {
+        fn dunder_all(m: &Bound<'_, PyModule>) -> PyResult<()> {
             m.dict().set_item("yay", "me")?;
             m.add_function(wrap_pyfunction!(custom_named_fn, m)?)?;
             Ok(())
@@ -239,13 +348,13 @@ fn subfunction() -> String {
     "Subfunction".to_string()
 }
 
-fn submodule(module: &PyModule) -> PyResult<()> {
+fn submodule(module: &Bound<'_, PyModule>) -> PyResult<()> {
     module.add_function(wrap_pyfunction!(subfunction, module)?)?;
     Ok(())
 }
 
 #[pymodule]
-fn submodule_with_init_fn(_py: Python<'_>, module: &PyModule) -> PyResult<()> {
+fn submodule_with_init_fn(module: &Bound<'_, PyModule>) -> PyResult<()> {
     module.add_function(wrap_pyfunction!(subfunction, module)?)?;
     Ok(())
 }
@@ -256,14 +365,14 @@ fn superfunction() -> String {
 }
 
 #[pymodule]
-fn supermodule(py: Python<'_>, module: &PyModule) -> PyResult<()> {
+fn supermodule(module: &Bound<'_, PyModule>) -> PyResult<()> {
     module.add_function(wrap_pyfunction!(superfunction, module)?)?;
-    let module_to_add = PyModule::new(py, "submodule")?;
-    submodule(module_to_add)?;
-    module.add_submodule(module_to_add)?;
-    let module_to_add = PyModule::new(py, "submodule_with_init_fn")?;
-    submodule_with_init_fn(py, module_to_add)?;
-    module.add_submodule(module_to_add)?;
+    let module_to_add = PyModule::new(module.py(), "submodule")?;
+    submodule(&module_to_add)?;
+    module.add_submodule(&module_to_add)?;
+    let module_to_add = PyModule::new(module.py(), "submodule_with_init_fn")?;
+    submodule_with_init_fn(&module_to_add)?;
+    module.add_submodule(&module_to_add)?;
     Ok(())
 }
 
@@ -271,7 +380,7 @@ fn supermodule(py: Python<'_>, module: &PyModule) -> PyResult<()> {
 fn test_module_nesting() {
     use pyo3::wrap_pymodule;
 
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let supermodule = wrap_pymodule!(supermodule)(py);
 
         py_assert!(
@@ -292,43 +401,12 @@ fn test_module_nesting() {
     });
 }
 
-// Test that argument parsing specification works for pyfunctions
-
-#[pyfunction(signature = (a=5, *args))]
-fn ext_vararg_fn(py: Python<'_>, a: i32, args: &PyTuple) -> PyObject {
-    [a.to_object(py), args.into()].to_object(py)
-}
-
-#[pymodule]
-fn vararg_module(_py: Python<'_>, m: &PyModule) -> PyResult<()> {
-    #[pyfn(m, signature = (a=5, *args))]
-    fn int_vararg_fn(py: Python<'_>, a: i32, args: &PyTuple) -> PyObject {
-        ext_vararg_fn(py, a, args)
-    }
-
-    m.add_function(wrap_pyfunction!(ext_vararg_fn, m)?).unwrap();
-    Ok(())
-}
-
-#[test]
-fn test_vararg_module() {
-    Python::with_gil(|py| {
-        let m = pyo3::wrap_pymodule!(vararg_module)(py);
-
-        py_assert!(py, m, "m.ext_vararg_fn() == [5, ()]");
-        py_assert!(py, m, "m.ext_vararg_fn(1, 2) == [1, (2,)]");
-
-        py_assert!(py, m, "m.int_vararg_fn() == [5, ()]");
-        py_assert!(py, m, "m.int_vararg_fn(1, 2) == [1, (2,)]");
-    });
-}
-
 #[test]
 fn test_module_with_constant() {
     // Regression test for #1102
 
     #[pymodule]
-    fn module_with_constant(_py: Python<'_>, m: &PyModule) -> PyResult<()> {
+    fn module_with_constant(m: &Bound<'_, PyModule>) -> PyResult<()> {
         const ANON: AnonClass = AnonClass {};
 
         m.add("ANON", ANON)?;
@@ -337,7 +415,7 @@ fn test_module_with_constant() {
         Ok(())
     }
 
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let m = pyo3::wrap_pymodule!(module_with_constant)(py);
         py_assert!(py, m, "isinstance(m.ANON, m.AnonClass)");
     });
@@ -349,12 +427,6 @@ fn pyfunction_with_module<'py>(module: &Bound<'py, PyModule>) -> PyResult<Bound<
     module.name()
 }
 
-#[pyfunction]
-#[pyo3(pass_module)]
-fn pyfunction_with_module_gil_ref(module: &PyModule) -> PyResult<&str> {
-    module.name()
-}
-
 #[pyfunction]
 #[pyo3(pass_module)]
 fn pyfunction_with_module_owned(
@@ -403,43 +475,27 @@ fn pyfunction_with_module_and_args_kwargs<'py>(
         .map(|s| (s, args.len(), kwargs.map(|d| d.len())))
 }
 
-#[pyfunction]
-#[pyo3(pass_module)]
-fn pyfunction_with_pass_module_in_attribute(module: &PyModule) -> PyResult<&str> {
-    module.name()
-}
-
 #[pymodule]
-fn module_with_functions_with_module(_py: Python<'_>, m: &PyModule) -> PyResult<()> {
+fn module_with_functions_with_module(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(pyfunction_with_module, m)?)?;
-    m.add_function(wrap_pyfunction!(pyfunction_with_module_gil_ref, m)?)?;
     m.add_function(wrap_pyfunction!(pyfunction_with_module_owned, m)?)?;
     m.add_function(wrap_pyfunction!(pyfunction_with_module_and_py, m)?)?;
     m.add_function(wrap_pyfunction!(pyfunction_with_module_and_arg, m)?)?;
     m.add_function(wrap_pyfunction!(pyfunction_with_module_and_default_arg, m)?)?;
     m.add_function(wrap_pyfunction!(pyfunction_with_module_and_args_kwargs, m)?)?;
-    m.add_function(wrap_pyfunction!(
-        pyfunction_with_pass_module_in_attribute,
-        m
-    )?)?;
     m.add_function(wrap_pyfunction!(pyfunction_with_module, m)?)?;
     Ok(())
 }
 
 #[test]
 fn test_module_functions_with_module() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let m = pyo3::wrap_pymodule!(module_with_functions_with_module)(py);
         py_assert!(
             py,
             m,
             "m.pyfunction_with_module() == 'module_with_functions_with_module'"
         );
-        py_assert!(
-            py,
-            m,
-            "m.pyfunction_with_module_gil_ref() == 'module_with_functions_with_module'"
-        );
         py_assert!(
             py,
             m,
@@ -462,11 +518,6 @@ fn test_module_functions_with_module() {
             "m.pyfunction_with_module_and_args_kwargs(1, x=1, y=2) \
                         == ('module_with_functions_with_module', 1, 2)"
         );
-        py_assert!(
-            py,
-            m,
-            "m.pyfunction_with_pass_module_in_attribute() == 'module_with_functions_with_module'"
-        );
     });
 }
 
@@ -475,11 +526,11 @@ fn test_module_doc_hidden() {
     #[doc(hidden)]
     #[allow(clippy::unnecessary_wraps)]
     #[pymodule]
-    fn my_module(_py: Python<'_>, _m: &PyModule) -> PyResult<()> {
+    fn my_module(_m: &Bound<'_, PyModule>) -> PyResult<()> {
         Ok(())
     }
 
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let m = pyo3::wrap_pymodule!(my_module)(py);
         py_assert!(py, m, "m.__doc__ == ''");
     })
diff --git a/tests/test_multiple_pymethods.rs b/tests/test_multiple_pymethods.rs
index 13baeed3815..1a788425113 100644
--- a/tests/test_multiple_pymethods.rs
+++ b/tests/test_multiple_pymethods.rs
@@ -4,8 +4,7 @@ use pyo3::prelude::*;
 use pyo3::types::PyType;
 
 #[macro_use]
-#[path = "../src/tests/common.rs"]
-mod common;
+mod test_utils;
 
 #[pyclass]
 struct PyClassWithMultiplePyMethods {}
@@ -64,7 +63,7 @@ impl PyClassWithMultiplePyMethods {
 
 #[test]
 fn test_class_with_multiple_pymethods() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let cls = py.get_type::<PyClassWithMultiplePyMethods>();
         py_assert!(py, cls, "cls()() == 'call'");
         py_assert!(py, cls, "cls().method() == 'method'");
diff --git a/tests/test_no_imports.rs b/tests/test_no_imports.rs
deleted file mode 100644
index 4abdcdf2e5b..00000000000
--- a/tests/test_no_imports.rs
+++ /dev/null
@@ -1,150 +0,0 @@
-//! Tests that various macros work correctly without any PyO3 imports.
-
-#![cfg(feature = "macros")]
-
-#[pyo3::pyfunction]
-#[pyo3(name = "identity", signature = (x = None))]
-fn basic_function(py: pyo3::Python<'_>, x: Option<pyo3::PyObject>) -> pyo3::PyObject {
-    x.unwrap_or_else(|| py.None())
-}
-
-#[pyo3::pymodule]
-fn basic_module(_py: pyo3::Python<'_>, m: &pyo3::types::PyModule) -> pyo3::PyResult<()> {
-    #[pyfn(m)]
-    fn answer() -> usize {
-        42
-    }
-
-    m.add_function(pyo3::wrap_pyfunction!(basic_function, m)?)?;
-
-    Ok(())
-}
-
-#[pyo3::pyclass]
-struct BasicClass {
-    #[pyo3(get)]
-    v: usize,
-    #[pyo3(get, set)]
-    s: String,
-}
-
-#[pyo3::pymethods]
-impl BasicClass {
-    #[classattr]
-    const OKAY: bool = true;
-
-    #[new]
-    fn new(arg: &pyo3::PyAny) -> pyo3::PyResult<Self> {
-        if let Ok(v) = arg.extract::<usize>() {
-            Ok(Self {
-                v,
-                s: "".to_string(),
-            })
-        } else {
-            Ok(Self {
-                v: 0,
-                s: arg.extract()?,
-            })
-        }
-    }
-
-    #[getter]
-    fn get_property(&self) -> usize {
-        self.v * 100
-    }
-
-    #[setter]
-    fn set_property(&mut self, value: usize) {
-        self.v = value / 100
-    }
-
-    /// Some documentation here
-    #[classmethod]
-    fn classmethod<'a, 'py>(
-        cls: &'a pyo3::Bound<'py, pyo3::types::PyType>,
-    ) -> &'a pyo3::Bound<'py, pyo3::types::PyType> {
-        cls
-    }
-
-    #[staticmethod]
-    fn staticmethod(py: pyo3::Python<'_>, v: usize) -> pyo3::Py<pyo3::PyAny> {
-        use pyo3::IntoPy;
-        v.to_string().into_py(py)
-    }
-
-    fn __add__(&self, other: usize) -> usize {
-        self.v + other
-    }
-
-    fn __iadd__(&mut self, other: pyo3::PyRef<'_, Self>) {
-        self.v += other.v;
-        self.s.push_str(&other.s);
-    }
-
-    fn mutate(mut slf: pyo3::PyRefMut<'_, Self>) {
-        slf.v += slf.v;
-        slf.s.push('!');
-    }
-}
-
-#[test]
-fn test_basic() {
-    pyo3::Python::with_gil(|py| {
-        let module = pyo3::wrap_pymodule!(basic_module)(py);
-        let cls = py.get_type::<BasicClass>();
-        let d = pyo3::types::IntoPyDict::into_py_dict_bound(
-            [
-                ("mod", module.as_ref(py).as_ref()),
-                ("cls", cls.as_ref()),
-                ("a", cls.call1((8,)).unwrap()),
-                ("b", cls.call1(("foo",)).unwrap()),
-            ],
-            py,
-        );
-
-        pyo3::py_run!(py, *d, "assert mod.answer() == 42");
-        pyo3::py_run!(py, *d, "assert mod.identity() is None");
-        pyo3::py_run!(py, *d, "v = object(); assert mod.identity(v) is v");
-        pyo3::py_run!(py, *d, "assert cls.OKAY");
-        pyo3::py_run!(py, *d, "assert (a.v, a.s) == (8, '')");
-        pyo3::py_run!(py, *d, "assert (b.v, b.s) == (0, 'foo')");
-        pyo3::py_run!(py, *d, "b.property = 314");
-        pyo3::py_run!(py, *d, "assert b.property == 300");
-        pyo3::py_run!(
-            py,
-            *d,
-            "assert cls.classmethod.__doc__ == 'Some documentation here'"
-        );
-        pyo3::py_run!(py, *d, "assert cls.classmethod() is cls");
-        pyo3::py_run!(py, *d, "assert cls.staticmethod(5) == '5'");
-        pyo3::py_run!(py, *d, "a.s = 'bar'; assert a.s == 'bar'");
-        pyo3::py_run!(py, *d, "a.mutate(); assert (a.v, a.s) == (16, 'bar!')");
-        pyo3::py_run!(py, *d, "assert a + 9 == 25");
-        pyo3::py_run!(py, *d, "b += a; assert (b.v, b.s) == (19, 'foobar!')");
-    });
-}
-
-#[pyo3::pyclass]
-struct NewClassMethod {
-    #[pyo3(get)]
-    cls: pyo3::PyObject,
-}
-
-#[pyo3::pymethods]
-impl NewClassMethod {
-    #[new]
-    #[classmethod]
-    fn new(cls: &pyo3::Bound<'_, pyo3::types::PyType>) -> Self {
-        Self {
-            cls: cls.clone().into_any().unbind(),
-        }
-    }
-}
-
-#[test]
-fn test_new_class_method() {
-    pyo3::Python::with_gil(|py| {
-        let cls = py.get_type::<NewClassMethod>();
-        pyo3::py_run!(py, cls, "assert cls().cls is cls");
-    });
-}
diff --git a/tests/test_proto_methods.rs b/tests/test_proto_methods.rs
index 872777bf706..900d874eb66 100644
--- a/tests/test_proto_methods.rs
+++ b/tests/test_proto_methods.rs
@@ -2,11 +2,11 @@
 
 use pyo3::exceptions::{PyAttributeError, PyIndexError, PyValueError};
 use pyo3::types::{PyDict, PyList, PyMapping, PySequence, PySlice, PyType};
-use pyo3::{prelude::*, py_run, PyCell};
-use std::{isize, iter};
+use pyo3::{prelude::*, py_run};
+use std::iter;
+use std::sync::Mutex;
 
-#[path = "../src/tests/common.rs"]
-mod common;
+mod test_utils;
 
 #[pyclass]
 struct EmptyClass;
@@ -20,15 +20,15 @@ struct ExampleClass {
 
 #[pymethods]
 impl ExampleClass {
-    fn __getattr__(&self, py: Python<'_>, attr: &str) -> PyResult<PyObject> {
+    fn __getattr__(&self, py: Python<'_>, attr: &str) -> PyResult<Py<PyAny>> {
         if attr == "special_custom_attr" {
-            Ok(self.custom_attr.into_py(py))
+            Ok(self.custom_attr.into_pyobject(py)?.into_any().unbind())
         } else {
             Err(PyAttributeError::new_err(attr.to_string()))
         }
     }
 
-    fn __setattr__(&mut self, attr: &str, value: &PyAny) -> PyResult<()> {
+    fn __setattr__(&mut self, attr: &str, value: &Bound<'_, PyAny>) -> PyResult<()> {
         if attr == "special_custom_attr" {
             self.custom_attr = Some(value.extract()?);
             Ok(())
@@ -64,8 +64,8 @@ impl ExampleClass {
     }
 }
 
-fn make_example(py: Python<'_>) -> &PyCell<ExampleClass> {
-    Py::new(
+fn make_example(py: Python<'_>) -> Bound<'_, ExampleClass> {
+    Bound::new(
         py,
         ExampleClass {
             value: 5,
@@ -73,12 +73,11 @@ fn make_example(py: Python<'_>) -> &PyCell<ExampleClass> {
         },
     )
     .unwrap()
-    .into_ref(py)
 }
 
 #[test]
 fn test_getattr() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let example_py = make_example(py);
         assert_eq!(
             example_py
@@ -105,7 +104,7 @@ fn test_getattr() {
 
 #[test]
 fn test_setattr() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let example_py = make_example(py);
         example_py.setattr("special_custom_attr", 15).unwrap();
         assert_eq!(
@@ -121,7 +120,7 @@ fn test_setattr() {
 
 #[test]
 fn test_delattr() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let example_py = make_example(py);
         example_py.delattr("special_custom_attr").unwrap();
         assert!(example_py.getattr("special_custom_attr").unwrap().is_none());
@@ -130,26 +129,23 @@ fn test_delattr() {
 
 #[test]
 fn test_str() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let example_py = make_example(py);
-        assert_eq!(example_py.str().unwrap().to_str().unwrap(), "5");
+        assert_eq!(example_py.str().unwrap(), "5");
     })
 }
 
 #[test]
 fn test_repr() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let example_py = make_example(py);
-        assert_eq!(
-            example_py.repr().unwrap().to_str().unwrap(),
-            "ExampleClass(value=5)"
-        );
+        assert_eq!(example_py.repr().unwrap(), "ExampleClass(value=5)");
     })
 }
 
 #[test]
 fn test_hash() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let example_py = make_example(py);
         assert_eq!(example_py.hash().unwrap(), 5);
     })
@@ -157,7 +153,7 @@ fn test_hash() {
 
 #[test]
 fn test_bool() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let example_py = make_example(py);
         assert!(example_py.is_truthy().unwrap());
         example_py.borrow_mut().value = 0;
@@ -177,7 +173,7 @@ impl LenOverflow {
 
 #[test]
 fn len_overflow() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let inst = Py::new(py, LenOverflow).unwrap();
         py_expect_exception!(py, inst, "len(inst)", PyOverflowError);
     });
@@ -191,37 +187,37 @@ pub struct Mapping {
 #[pymethods]
 impl Mapping {
     fn __len__(&self, py: Python<'_>) -> usize {
-        self.values.as_ref(py).len()
+        self.values.bind(py).len()
     }
 
-    fn __getitem__<'a>(&'a self, key: &'a PyAny) -> PyResult<&'a PyAny> {
-        let any: &PyAny = self.values.as_ref(key.py()).as_ref();
+    fn __getitem__<'py>(&self, key: &Bound<'py, PyAny>) -> PyResult<Bound<'py, PyAny>> {
+        let any: &Bound<'py, PyAny> = self.values.bind(key.py());
         any.get_item(key)
     }
 
-    fn __setitem__(&self, key: &PyAny, value: &PyAny) -> PyResult<()> {
-        self.values.as_ref(key.py()).set_item(key, value)
+    fn __setitem__<'py>(&self, key: &Bound<'py, PyAny>, value: &Bound<'py, PyAny>) -> PyResult<()> {
+        self.values.bind(key.py()).set_item(key, value)
     }
 
-    fn __delitem__(&self, key: &PyAny) -> PyResult<()> {
-        self.values.as_ref(key.py()).del_item(key)
+    fn __delitem__(&self, key: &Bound<'_, PyAny>) -> PyResult<()> {
+        self.values.bind(key.py()).del_item(key)
     }
 }
 
 #[test]
 fn mapping() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         PyMapping::register::<Mapping>(py).unwrap();
 
         let inst = Py::new(
             py,
             Mapping {
-                values: PyDict::new_bound(py).into(),
+                values: PyDict::new(py).into(),
             },
         )
         .unwrap();
 
-        let mapping: &PyMapping = inst.as_ref(py).downcast().unwrap();
+        let mapping: &Bound<'_, PyMapping> = inst.bind(py).cast().unwrap();
 
         py_assert!(py, inst, "len(inst) == 0");
 
@@ -248,14 +244,14 @@ fn mapping() {
 }
 
 #[derive(FromPyObject)]
-enum SequenceIndex<'a> {
+enum SequenceIndex<'py> {
     Integer(isize),
-    Slice(&'a PySlice),
+    Slice(Bound<'py, PySlice>),
 }
 
 #[pyclass]
 pub struct Sequence {
-    values: Vec<PyObject>,
+    values: Vec<Py<PyAny>>,
 }
 
 #[pymethods]
@@ -264,7 +260,7 @@ impl Sequence {
         self.values.len()
     }
 
-    fn __getitem__(&self, index: SequenceIndex<'_>, py: Python<'_>) -> PyResult<PyObject> {
+    fn __getitem__(&self, index: SequenceIndex<'_>, py: Python<'_>) -> PyResult<Py<PyAny>> {
         match index {
             SequenceIndex::Integer(index) => {
                 let uindex = self.usize_index(index)?;
@@ -278,7 +274,7 @@ impl Sequence {
         }
     }
 
-    fn __setitem__(&mut self, index: isize, value: PyObject) -> PyResult<()> {
+    fn __setitem__(&mut self, index: isize, value: Py<PyAny>) -> PyResult<()> {
         let uindex = self.usize_index(index)?;
         self.values
             .get_mut(uindex)
@@ -296,7 +292,7 @@ impl Sequence {
         }
     }
 
-    fn append(&mut self, value: PyObject) {
+    fn append(&mut self, value: Py<PyAny>) {
         self.values.push(value);
     }
 }
@@ -318,12 +314,12 @@ impl Sequence {
 
 #[test]
 fn sequence() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         PySequence::register::<Sequence>(py).unwrap();
 
         let inst = Py::new(py, Sequence { values: vec![] }).unwrap();
 
-        let sequence: &PySequence = inst.as_ref(py).downcast().unwrap();
+        let sequence: &Bound<'_, PySequence> = inst.bind(py).cast().unwrap();
 
         py_assert!(py, inst, "len(inst) == 0");
 
@@ -350,22 +346,22 @@ fn sequence() {
         // indices.
         assert!(sequence.len().is_err());
         // however regular python len() works thanks to mp_len slot
-        assert_eq!(inst.as_ref(py).len().unwrap(), 0);
+        assert_eq!(inst.bind(py).len().unwrap(), 0);
 
         py_run!(py, inst, "inst.append(0)");
         sequence.set_item(0, 5).unwrap();
-        assert_eq!(inst.as_ref(py).len().unwrap(), 1);
+        assert_eq!(inst.bind(py).len().unwrap(), 1);
 
         assert_eq!(sequence.get_item(0).unwrap().extract::<u8>().unwrap(), 5);
         sequence.del_item(0).unwrap();
 
-        assert_eq!(inst.as_ref(py).len().unwrap(), 0);
+        assert_eq!(inst.bind(py).len().unwrap(), 0);
     });
 }
 
 #[pyclass]
 struct Iterator {
-    iter: Box<dyn iter::Iterator<Item = i32> + Send>,
+    iter: Mutex<Box<dyn iter::Iterator<Item = i32> + Send>>,
 }
 
 #[pymethods]
@@ -374,18 +370,18 @@ impl Iterator {
         slf
     }
 
-    fn __next__(mut slf: PyRefMut<'_, Self>) -> Option<i32> {
-        slf.iter.next()
+    fn __next__(slf: PyRefMut<'_, Self>) -> Option<i32> {
+        slf.iter.lock().unwrap().next()
     }
 }
 
 #[test]
 fn iterator() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let inst = Py::new(
             py,
             Iterator {
-                iter: Box::new(5..8),
+                iter: Mutex::new(Box::new(5..8)),
             },
         )
         .unwrap();
@@ -409,7 +405,7 @@ struct NotCallable;
 
 #[test]
 fn callable() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let c = Py::new(py, Callable).unwrap();
         py_assert!(py, c, "callable(c)");
         py_assert!(py, c, "c(7) == 42");
@@ -436,8 +432,8 @@ impl SetItem {
 
 #[test]
 fn setitem() {
-    Python::with_gil(|py| {
-        let c = PyCell::new(py, SetItem { key: 0, val: 0 }).unwrap();
+    Python::attach(|py| {
+        let c = Bound::new(py, SetItem { key: 0, val: 0 }).unwrap();
         py_run!(py, c, "c[1] = 2");
         {
             let c = c.borrow();
@@ -462,8 +458,8 @@ impl DelItem {
 
 #[test]
 fn delitem() {
-    Python::with_gil(|py| {
-        let c = PyCell::new(py, DelItem { key: 0 }).unwrap();
+    Python::attach(|py| {
+        let c = Bound::new(py, DelItem { key: 0 }).unwrap();
         py_run!(py, c, "del c[1]");
         {
             let c = c.borrow();
@@ -491,8 +487,8 @@ impl SetDelItem {
 
 #[test]
 fn setdelitem() {
-    Python::with_gil(|py| {
-        let c = PyCell::new(py, SetDelItem { val: None }).unwrap();
+    Python::attach(|py| {
+        let c = Bound::new(py, SetDelItem { val: None }).unwrap();
         py_run!(py, c, "c[1] = 2");
         {
             let c = c.borrow();
@@ -516,7 +512,7 @@ impl Contains {
 
 #[test]
 fn contains() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let c = Py::new(py, Contains {}).unwrap();
         py_run!(py, c, "assert 1 in c");
         py_run!(py, c, "assert -1 not in c");
@@ -529,8 +525,8 @@ struct GetItem {}
 
 #[pymethods]
 impl GetItem {
-    fn __getitem__(&self, idx: &PyAny) -> PyResult<&'static str> {
-        if let Ok(slice) = idx.downcast::<PySlice>() {
+    fn __getitem__(&self, idx: &Bound<'_, PyAny>) -> PyResult<&'static str> {
+        if let Ok(slice) = idx.cast::<PySlice>() {
             let indices = slice.indices(1000)?;
             if indices.start == 100 && indices.stop == 200 && indices.step == 1 {
                 return Ok("slice");
@@ -546,7 +542,7 @@ impl GetItem {
 
 #[test]
 fn test_getitem() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let ob = Py::new(py, GetItem {}).unwrap();
 
         py_assert!(py, ob, "ob[1] == 'int'");
@@ -569,8 +565,8 @@ impl ClassWithGetAttr {
 
 #[test]
 fn getattr_doesnt_override_member() {
-    Python::with_gil(|py| {
-        let inst = PyCell::new(py, ClassWithGetAttr { data: 4 }).unwrap();
+    Python::attach(|py| {
+        let inst = Py::new(py, ClassWithGetAttr { data: 4 }).unwrap();
         py_assert!(py, inst, "inst.data == 4");
         py_assert!(py, inst, "inst.a == 8");
     });
@@ -591,8 +587,8 @@ impl ClassWithGetAttribute {
 
 #[test]
 fn getattribute_overrides_member() {
-    Python::with_gil(|py| {
-        let inst = PyCell::new(py, ClassWithGetAttribute { data: 4 }).unwrap();
+    Python::attach(|py| {
+        let inst = Py::new(py, ClassWithGetAttribute { data: 4 }).unwrap();
         py_assert!(py, inst, "inst.data == 8");
         py_assert!(py, inst, "inst.y == 8");
     });
@@ -624,8 +620,8 @@ impl ClassWithGetAttrAndGetAttribute {
 
 #[test]
 fn getattr_and_getattribute() {
-    Python::with_gil(|py| {
-        let inst = PyCell::new(py, ClassWithGetAttrAndGetAttribute).unwrap();
+    Python::attach(|py| {
+        let inst = Py::new(py, ClassWithGetAttrAndGetAttribute).unwrap();
         py_assert!(py, inst, "inst.exists == 42");
         py_assert!(py, inst, "inst.lucky == 57");
         py_expect_exception!(py, inst, "inst.error", PyValueError);
@@ -637,14 +633,14 @@ fn getattr_and_getattribute() {
 #[pyclass]
 #[derive(Debug)]
 struct OnceFuture {
-    future: PyObject,
+    future: Py<PyAny>,
     polled: bool,
 }
 
 #[pymethods]
 impl OnceFuture {
     #[new]
-    fn new(future: PyObject) -> Self {
+    fn new(future: Py<PyAny>) -> Self {
         OnceFuture {
             future,
             polled: false,
@@ -658,10 +654,10 @@ impl OnceFuture {
     fn __iter__(slf: PyRef<'_, Self>) -> PyRef<'_, Self> {
         slf
     }
-    fn __next__<'py>(&'py mut self, py: Python<'py>) -> Option<&'py PyAny> {
+    fn __next__<'py>(&mut self, py: Python<'py>) -> Option<&Bound<'py, PyAny>> {
         if !self.polled {
             self.polled = true;
-            Some(self.future.as_ref(py))
+            Some(self.future.bind(py))
         } else {
             None
         }
@@ -671,9 +667,9 @@ impl OnceFuture {
 #[test]
 #[cfg(not(target_arch = "wasm32"))] // Won't work without wasm32 event loop (e.g., Pyodide has WebLoop)
 fn test_await() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let once = py.get_type::<OnceFuture>();
-        let source = r#"
+        let source = cr#"
 import asyncio
 import sys
 
@@ -687,12 +683,9 @@ if sys.platform == "win32" and sys.version_info >= (3, 8, 0):
 
 asyncio.run(main())
 "#;
-        let globals = PyModule::import(py, "__main__")
-            .unwrap()
-            .dict()
-            .as_borrowed();
+        let globals = PyModule::import(py, "__main__").unwrap().dict();
         globals.set_item("Once", once).unwrap();
-        py.run_bound(source, Some(&globals), None)
+        py.run(source, Some(&globals), None)
             .map_err(|e| e.display(py))
             .unwrap();
     });
@@ -724,9 +717,9 @@ impl AsyncIterator {
 #[test]
 #[cfg(not(target_arch = "wasm32"))] // Won't work without wasm32 event loop (e.g., Pyodide has WebLoop)
 fn test_anext_aiter() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let once = py.get_type::<OnceFuture>();
-        let source = r#"
+        let source = cr#"
 import asyncio
 import sys
 
@@ -744,15 +737,12 @@ if sys.platform == "win32" and sys.version_info >= (3, 8, 0):
 
 asyncio.run(main())
 "#;
-        let globals = PyModule::import(py, "__main__")
-            .unwrap()
-            .dict()
-            .as_borrowed();
+        let globals = PyModule::import(py, "__main__").unwrap().dict();
         globals.set_item("Once", once).unwrap();
         globals
             .set_item("AsyncIterator", py.get_type::<AsyncIterator>())
             .unwrap();
-        py.run_bound(source, Some(&globals), None)
+        py.run(source, Some(&globals), None)
             .map_err(|e| e.display(py))
             .unwrap();
     });
@@ -774,27 +764,27 @@ impl DescrCounter {
     /// Each access will increase the count
     fn __get__<'a>(
         mut slf: PyRefMut<'a, Self>,
-        _instance: &PyAny,
-        _owner: Option<&PyType>,
+        _instance: &Bound<'_, PyAny>,
+        _owner: Option<&Bound<'_, PyType>>,
     ) -> PyRefMut<'a, Self> {
         slf.count += 1;
         slf
     }
     /// Allow assigning a new counter to the descriptor, copying the count across
-    fn __set__(&self, _instance: &PyAny, new_value: &mut Self) {
+    fn __set__(&self, _instance: &Bound<'_, PyAny>, new_value: &mut Self) {
         new_value.count = self.count;
     }
     /// Delete to reset the counter
-    fn __delete__(&mut self, _instance: &PyAny) {
+    fn __delete__(&mut self, _instance: &Bound<'_, PyAny>) {
         self.count = 0;
     }
 }
 
 #[test]
 fn descr_getset() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let counter = py.get_type::<DescrCounter>();
-        let source = pyo3::indoc::indoc!(
+        let source = pyo3_ffi::c_str!(indoc::indoc!(
             r#"
 class Class:
     counter = Counter()
@@ -818,13 +808,10 @@ assert c.counter.count == 4
 del c.counter
 assert c.counter.count == 1
 "#
-        );
-        let globals = PyModule::import(py, "__main__")
-            .unwrap()
-            .dict()
-            .as_borrowed();
+        ));
+        let globals = PyModule::import(py, "__main__").unwrap().dict();
         globals.set_item("Counter", counter).unwrap();
-        py.run_bound(source, Some(&globals), None)
+        py.run(source, Some(&globals), None)
             .map_err(|e| e.display(py))
             .unwrap();
     });
@@ -836,14 +823,14 @@ struct NotHashable;
 #[pymethods]
 impl NotHashable {
     #[classattr]
-    const __hash__: Option<PyObject> = None;
+    const __hash__: Option<Py<PyAny>> = None;
 }
 
 #[test]
 fn test_hash_opt_out() {
     // By default Python provides a hash implementation, which can be disabled by setting __hash__
     // to None.
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let empty = Py::new(py, EmptyClass).unwrap();
         py_assert!(py, empty, "hash(empty) is not None");
 
@@ -858,10 +845,11 @@ struct DefaultedContains;
 
 #[pymethods]
 impl DefaultedContains {
-    fn __iter__(&self, py: Python<'_>) -> PyObject {
-        PyList::new_bound(py, ["a", "b", "c"])
-            .as_ref()
-            .iter()
+    fn __iter__(&self, py: Python<'_>) -> Py<PyAny> {
+        PyList::new(py, ["a", "b", "c"])
+            .unwrap()
+            .as_any()
+            .try_iter()
             .unwrap()
             .into()
     }
@@ -872,10 +860,11 @@ struct NoContains;
 
 #[pymethods]
 impl NoContains {
-    fn __iter__(&self, py: Python<'_>) -> PyObject {
-        PyList::new_bound(py, ["a", "b", "c"])
-            .as_ref()
-            .iter()
+    fn __iter__(&self, py: Python<'_>) -> Py<PyAny> {
+        PyList::new(py, ["a", "b", "c"])
+            .unwrap()
+            .as_any()
+            .try_iter()
             .unwrap()
             .into()
     }
@@ -883,14 +872,14 @@ impl NoContains {
     // Equivalent to the opt-out const form in NotHashable above, just more verbose, to confirm this
     // also works.
     #[classattr]
-    fn __contains__() -> Option<PyObject> {
+    fn __contains__() -> Option<Py<PyAny>> {
         None
     }
 }
 
 #[test]
 fn test_contains_opt_out() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let defaulted_contains = Py::new(py, DefaultedContains).unwrap();
         py_assert!(py, defaulted_contains, "'a' in defaulted_contains");
 
diff --git a/tests/test_pybuffer_drop_without_interpreter.rs b/tests/test_pybuffer_drop_without_interpreter.rs
new file mode 100644
index 00000000000..bd1521ae573
--- /dev/null
+++ b/tests/test_pybuffer_drop_without_interpreter.rs
@@ -0,0 +1,34 @@
+#![cfg(any(not(Py_LIMITED_API), Py_3_11))] // buffer availability
+#![cfg(not(any(PyPy, GraalPy)))] // cannot control interpreter lifecycle in PyPy or GraalPy
+
+//! Dropping `Py<T>` after the interpreter has been finalized should be sound.
+//!
+//! See e.g. https://github.com/PyO3/pyo3/issues/4632 for an extension of this problem
+//! where the interpreter was finalized before `PyBuffer<T>` was dropped.
+//!
+//! This test runs in its own process to control the interpreter lifecycle.
+
+use pyo3::{buffer::PyBuffer, types::PyBytes};
+
+#[test]
+fn test_pybuffer_drop_without_interpreter() {
+    // SAFETY: this is knowingly unsafe as we're preserving the `Py<T>` object
+    // after the Python interpreter has been finalized.
+    //
+    // However we should still be able to drop it without causing undefined behavior,
+    // so that process shutdown is sound.
+    let obj: PyBuffer<u8> = unsafe {
+        pyo3::with_embedded_python_interpreter(|py| {
+            PyBuffer::get(&PyBytes::new(py, b"abcdef")).unwrap()
+        })
+    };
+
+    // there should be no interpreter outside of the `with_embedded_python_interpreter` block
+    assert_eq!(unsafe { pyo3_ffi::Py_IsInitialized() }, 0);
+
+    // dropping object should be sound
+    drop(obj);
+
+    // dropping object should not re-initialize the interpreter
+    assert_eq!(unsafe { pyo3_ffi::Py_IsInitialized() }, 0);
+}
diff --git a/tests/test_pyerr_debug_unformattable.rs b/tests/test_pyerr_debug_unformattable.rs
new file mode 100644
index 00000000000..0ae234061b8
--- /dev/null
+++ b/tests/test_pyerr_debug_unformattable.rs
@@ -0,0 +1,61 @@
+use pyo3::prelude::*;
+
+// This test mucks around with sys.modules, so run it separately to prevent it
+// from potentially corrupting the state of the python interpreter used in other
+// tests.
+
+#[test]
+fn err_debug_unformattable() {
+    // Debug representation should be like the following (without the newlines):
+    // PyErr {
+    //     type: <class 'Exception'>,
+    //     value: Exception('banana'),
+    //     traceback: Some(\"<unformattable <traceback object at 0x...>>\")
+    // }
+
+    Python::attach(|py| {
+        // PyTracebackMethods::format uses io.StringIO. Mock it out to trigger a
+        // formatting failure:
+        // TypeError: 'Mock' object cannot be cast as 'str'
+        let err = py
+            .run(
+                cr#"
+import io, sys, unittest.mock
+sys.modules['orig_io'] = sys.modules['io']
+sys.modules['io'] = unittest.mock.Mock()
+raise Exception('banana')"#,
+                None,
+                None,
+            )
+            .expect_err("raising should have given us an error");
+
+        let debug_str = format!("{err:?}");
+        assert!(debug_str.starts_with("PyErr { "));
+        assert!(debug_str.ends_with(" }"));
+
+        // Strip "PyErr { " and " }". Split into 3 substrings to separate type,
+        // value, and traceback while not splitting the string within traceback.
+        let mut fields = debug_str["PyErr { ".len()..debug_str.len() - 2].splitn(3, ", ");
+
+        assert_eq!(fields.next().unwrap(), "type: <class 'Exception'>");
+        assert_eq!(fields.next().unwrap(), "value: Exception('banana')");
+
+        let traceback = fields.next().unwrap();
+        assert!(
+            traceback.starts_with("traceback: Some(\"<unformattable <traceback object at 0x"),
+            "assertion failed, actual traceback str: {traceback:?}"
+        );
+        assert!(fields.next().is_none());
+
+        py.run(
+            cr#"
+import io, sys, unittest.mock
+sys.modules['io'] = sys.modules['orig_io']
+del sys.modules['orig_io']
+"#,
+            None,
+            None,
+        )
+        .unwrap();
+    });
+}
diff --git a/tests/test_pyfunction.rs b/tests/test_pyfunction.rs
index e06f7c2fb9c..dc601dd653a 100644
--- a/tests/test_pyfunction.rs
+++ b/tests/test_pyfunction.rs
@@ -1,28 +1,44 @@
 #![cfg(feature = "macros")]
+#![warn(unsafe_op_in_unsafe_fn)]
 
 use std::collections::HashMap;
 
 #[cfg(not(Py_LIMITED_API))]
 use pyo3::buffer::PyBuffer;
+#[cfg(not(Py_LIMITED_API))]
+use pyo3::exceptions::PyWarning;
+use pyo3::exceptions::{PyFutureWarning, PyUserWarning};
 use pyo3::prelude::*;
 #[cfg(not(Py_LIMITED_API))]
 use pyo3::types::PyDateTime;
 #[cfg(not(any(Py_LIMITED_API, PyPy)))]
 use pyo3::types::PyFunction;
 use pyo3::types::{self, PyCFunction};
+use pyo3_macros::pyclass;
+
+mod test_utils;
+
+#[pyfunction(name = "struct")]
+fn struct_function() {}
+
+#[test]
+fn test_rust_keyword_name() {
+    Python::attach(|py| {
+        let f = wrap_pyfunction!(struct_function)(py).unwrap();
 
-#[path = "../src/tests/common.rs"]
-mod common;
+        py_assert!(py, f, "f.__name__ == 'struct'");
+    });
+}
 
 #[pyfunction(signature = (arg = true))]
 fn optional_bool(arg: Option<bool>) -> String {
-    format!("{:?}", arg)
+    format!("{arg:?}")
 }
 
 #[test]
 fn test_optional_bool() {
     // Regression test for issue #932
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let f = wrap_pyfunction!(optional_bool)(py).unwrap();
 
         py_assert!(py, f, "f() == 'Some(true)'");
@@ -32,6 +48,45 @@ fn test_optional_bool() {
     });
 }
 
+#[pyfunction]
+#[pyo3(signature=(arg))]
+fn required_optional_str(arg: Option<&str>) -> &str {
+    arg.unwrap_or("")
+}
+
+#[test]
+fn test_optional_str() {
+    // Regression test for issue #4965
+    Python::attach(|py| {
+        let f = wrap_pyfunction!(required_optional_str)(py).unwrap();
+
+        py_assert!(py, f, "f('') == ''");
+        py_assert!(py, f, "f('foo') == 'foo'");
+        py_assert!(py, f, "f(None) == ''");
+    });
+}
+
+#[pyclass]
+struct MyClass();
+
+#[pyfunction]
+#[pyo3(signature=(arg))]
+fn required_optional_class(arg: Option<&MyClass>) {
+    let _ = arg;
+}
+
+#[test]
+fn test_required_optional_class() {
+    // Regression test for issue #4965
+    Python::attach(|py| {
+        let f = wrap_pyfunction!(required_optional_class)(py).unwrap();
+        let val = Bound::new(py, MyClass()).unwrap();
+
+        py_assert!(py, f val, "f(val) is None");
+        py_assert!(py, f, "f(None) is None");
+    });
+}
+
 #[cfg(not(Py_LIMITED_API))]
 #[pyfunction]
 fn buffer_inplace_add(py: Python<'_>, x: PyBuffer<i32>, y: PyBuffer<i32>) {
@@ -46,7 +101,7 @@ fn buffer_inplace_add(py: Python<'_>, x: PyBuffer<i32>, y: PyBuffer<i32>) {
 #[cfg(not(Py_LIMITED_API))]
 #[test]
 fn test_buffer_add() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let f = wrap_pyfunction!(buffer_inplace_add)(py).unwrap();
 
         py_expect_exception!(
@@ -77,18 +132,20 @@ assert a, array.array("i", [2, 4, 6, 8])
 
 #[cfg(not(any(Py_LIMITED_API, PyPy)))]
 #[pyfunction]
-fn function_with_pyfunction_arg(fun: &PyFunction) -> PyResult<&PyAny> {
+fn function_with_pyfunction_arg<'py>(fun: &Bound<'py, PyFunction>) -> PyResult<Bound<'py, PyAny>> {
     fun.call((), None)
 }
 
 #[pyfunction]
-fn function_with_pycfunction_arg(fun: &PyCFunction) -> PyResult<&PyAny> {
+fn function_with_pycfunction_arg<'py>(
+    fun: &Bound<'py, PyCFunction>,
+) -> PyResult<Bound<'py, PyAny>> {
     fun.call((), None)
 }
 
 #[test]
 fn test_functions_with_function_args() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let py_cfunc_arg = wrap_pyfunction!(function_with_pycfunction_arg)(py).unwrap();
         let bool_to_string = wrap_pyfunction!(optional_bool)(py).unwrap();
 
@@ -118,8 +175,8 @@ fn test_functions_with_function_args() {
 }
 
 #[cfg(not(Py_LIMITED_API))]
-fn datetime_to_timestamp(dt: &PyAny) -> PyResult<i64> {
-    let dt: &PyDateTime = dt.extract()?;
+fn datetime_to_timestamp(dt: &Bound<'_, PyAny>) -> PyResult<i64> {
+    let dt = dt.cast::<PyDateTime>()?;
     let ts: f64 = dt.call_method0("timestamp")?.extract()?;
 
     Ok(ts as i64)
@@ -128,7 +185,7 @@ fn datetime_to_timestamp(dt: &PyAny) -> PyResult<i64> {
 #[cfg(not(Py_LIMITED_API))]
 #[pyfunction]
 fn function_with_custom_conversion(
-    #[pyo3(from_py_with = "datetime_to_timestamp")] timestamp: i64,
+    #[pyo3(from_py_with = datetime_to_timestamp)] timestamp: i64,
 ) -> i64 {
     timestamp
 }
@@ -136,7 +193,7 @@ fn function_with_custom_conversion(
 #[cfg(not(Py_LIMITED_API))]
 #[test]
 fn test_function_with_custom_conversion() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let custom_conv_func = wrap_pyfunction!(function_with_custom_conversion)(py).unwrap();
 
         pyo3::py_run!(
@@ -155,7 +212,7 @@ fn test_function_with_custom_conversion() {
 #[cfg(not(Py_LIMITED_API))]
 #[test]
 fn test_function_with_custom_conversion_error() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let custom_conv_func = wrap_pyfunction!(function_with_custom_conversion)(py).unwrap();
 
         py_expect_exception!(
@@ -163,14 +220,14 @@ fn test_function_with_custom_conversion_error() {
             custom_conv_func,
             "custom_conv_func(['a'])",
             PyTypeError,
-            "argument 'timestamp': 'list' object cannot be converted to 'PyDateTime'"
+            "argument 'timestamp': 'list' object cannot be cast as 'datetime'"
         );
     });
 }
 
 #[test]
 fn test_from_py_with_defaults() {
-    fn optional_int(x: &PyAny) -> PyResult<Option<i32>> {
+    fn optional_int(x: &Bound<'_, PyAny>) -> PyResult<Option<i32>> {
         if x.is_none() {
             Ok(None)
         } else {
@@ -180,16 +237,19 @@ fn test_from_py_with_defaults() {
 
     // issue 2280 combination of from_py_with and Option<T> did not compile
     #[pyfunction]
-    fn from_py_with_option(#[pyo3(from_py_with = "optional_int")] int: Option<i32>) -> i32 {
+    #[pyo3(signature = (int=None))]
+    fn from_py_with_option(#[pyo3(from_py_with = optional_int)] int: Option<i32>) -> i32 {
         int.unwrap_or(0)
     }
 
     #[pyfunction(signature = (len=0))]
-    fn from_py_with_default(#[pyo3(from_py_with = "PyAny::len")] len: usize) -> usize {
+    fn from_py_with_default(
+        #[pyo3(from_py_with = <Bound<'_, _> as PyAnyMethods>::len)] len: usize,
+    ) -> usize {
         len
     }
 
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let f = wrap_pyfunction!(from_py_with_option)(py).unwrap();
 
         assert_eq!(f.call0().unwrap().extract::<i32>().unwrap(), 0);
@@ -212,36 +272,34 @@ struct ValueClass {
 }
 
 #[pyfunction]
+#[pyo3(signature=(str_arg, int_arg, tuple_arg, option_arg = None, struct_arg = None))]
 fn conversion_error(
     str_arg: &str,
     int_arg: i64,
-    tuple_arg: (&str, f64),
+    tuple_arg: (String, f64),
     option_arg: Option<i64>,
     struct_arg: Option<ValueClass>,
 ) {
-    println!(
-        "{:?} {:?} {:?} {:?} {:?}",
-        str_arg, int_arg, tuple_arg, option_arg, struct_arg
-    );
+    println!("{str_arg:?} {int_arg:?} {tuple_arg:?} {option_arg:?} {struct_arg:?}");
 }
 
 #[test]
 fn test_conversion_error() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let conversion_error = wrap_pyfunction!(conversion_error)(py).unwrap();
         py_expect_exception!(
             py,
             conversion_error,
             "conversion_error(None, None, None, None, None)",
             PyTypeError,
-            "argument 'str_arg': 'NoneType' object cannot be converted to 'PyString'"
+            "argument 'str_arg': 'NoneType' object cannot be cast as 'str'"
         );
         py_expect_exception!(
             py,
             conversion_error,
             "conversion_error(100, None, None, None, None)",
             PyTypeError,
-            "argument 'str_arg': 'int' object cannot be converted to 'PyString'"
+            "argument 'str_arg': 'int' object cannot be cast as 'str'"
         );
         py_expect_exception!(
             py,
@@ -255,7 +313,7 @@ fn test_conversion_error() {
             conversion_error,
             "conversion_error('string1', -100, 'string2', None, None)",
             PyTypeError,
-            "argument 'tuple_arg': 'str' object cannot be converted to 'PyTuple'"
+            "argument 'tuple_arg': 'str' object cannot be cast as 'tuple'"
         );
         py_expect_exception!(
             py,
@@ -315,19 +373,20 @@ fn extract_traceback(py: Python<'_>, mut error: PyErr) -> String {
 fn test_pycfunction_new() {
     use pyo3::ffi;
 
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         unsafe extern "C" fn c_fn(
             _self: *mut ffi::PyObject,
             _args: *mut ffi::PyObject,
         ) -> *mut ffi::PyObject {
-            ffi::PyLong_FromLong(4200)
+            unsafe { ffi::PyLong_FromLong(4200) }
         }
 
-        let py_fn = PyCFunction::new_bound(
+        let py_fn = PyCFunction::new(
+            py,
             c_fn,
-            "py_fn",
-            "py_fn for test (this is the docstring)",
-            py.into(),
+            c"py_fn",
+            c"py_fn for test (this is the docstring)",
+            None,
         )
         .unwrap();
 
@@ -343,11 +402,10 @@ fn test_pycfunction_new() {
 #[test]
 fn test_pycfunction_new_with_keywords() {
     use pyo3::ffi;
-    use std::ffi::CString;
-    use std::os::raw::{c_char, c_long};
+    use std::ffi::c_long;
     use std::ptr;
 
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         unsafe extern "C" fn c_fn(
             _self: *mut ffi::PyObject,
             args: *mut ffi::PyObject,
@@ -355,36 +413,45 @@ fn test_pycfunction_new_with_keywords() {
         ) -> *mut ffi::PyObject {
             let mut foo: c_long = 0;
             let mut bar: c_long = 0;
-            let foo_ptr: *mut c_long = &mut foo;
-            let bar_ptr: *mut c_long = &mut bar;
-
-            let foo_name = CString::new("foo").unwrap();
-            let foo_name_raw: *mut c_char = foo_name.into_raw();
-            let kw_bar_name = CString::new("kw_bar").unwrap();
-            let kw_bar_name_raw: *mut c_char = kw_bar_name.into_raw();
-
-            let mut arglist = vec![foo_name_raw, kw_bar_name_raw, ptr::null_mut()];
-            let arglist_ptr: *mut *mut c_char = arglist.as_mut_ptr();
-
-            let arg_pattern: *const c_char = CString::new("l|l").unwrap().into_raw();
-
-            ffi::PyArg_ParseTupleAndKeywords(
-                args,
-                kwds,
-                arg_pattern,
-                arglist_ptr,
-                foo_ptr,
-                bar_ptr,
-            );
 
-            ffi::PyLong_FromLong(foo * bar)
+            #[cfg(not(Py_3_13))]
+            let foo_name = std::ffi::CString::new("foo").unwrap();
+            #[cfg(not(Py_3_13))]
+            let kw_bar_name = std::ffi::CString::new("kw_bar").unwrap();
+            #[cfg(not(Py_3_13))]
+            let mut args_names = [foo_name.into_raw(), kw_bar_name.into_raw(), ptr::null_mut()];
+
+            #[cfg(Py_3_13)]
+            let args_names = [c"foo".as_ptr(), c"kw_bar".as_ptr(), ptr::null_mut()];
+
+            unsafe {
+                ffi::PyArg_ParseTupleAndKeywords(
+                    args,
+                    kwds,
+                    c"l|l".as_ptr(),
+                    #[cfg(Py_3_13)]
+                    args_names.as_ptr(),
+                    #[cfg(not(Py_3_13))]
+                    args_names.as_mut_ptr(),
+                    &mut foo,
+                    &mut bar,
+                )
+            };
+
+            #[cfg(not(Py_3_13))]
+            drop(unsafe { std::ffi::CString::from_raw(args_names[0]) });
+            #[cfg(not(Py_3_13))]
+            drop(unsafe { std::ffi::CString::from_raw(args_names[1]) });
+
+            unsafe { ffi::PyLong_FromLong(foo * bar) }
         }
 
-        let py_fn = PyCFunction::new_with_keywords_bound(
+        let py_fn = PyCFunction::new_with_keywords(
+            py,
             c_fn,
-            "py_fn",
-            "py_fn for test (this is the docstring)",
-            py.into(),
+            c"py_fn",
+            c"py_fn for test (this is the docstring)",
+            None,
         )
         .unwrap();
 
@@ -400,29 +467,31 @@ fn test_pycfunction_new_with_keywords() {
 
 #[test]
 fn test_closure() {
-    Python::with_gil(|py| {
-        let f = |args: &types::PyTuple, _kwargs: Option<&types::PyDict>| -> PyResult<_> {
-            Python::with_gil(|py| {
-                let res: Vec<_> = args
+    Python::attach(|py| {
+        let f = |args: &Bound<'_, types::PyTuple>,
+                 _kwargs: Option<&Bound<'_, types::PyDict>>|
+         -> PyResult<_> {
+            Python::attach(|py| {
+                let res: PyResult<Vec<_>> = args
                     .iter()
                     .map(|elem| {
                         if let Ok(i) = elem.extract::<i64>() {
-                            (i + 1).into_py(py)
+                            Ok((i + 1).into_pyobject(py)?.into_any().unbind())
                         } else if let Ok(f) = elem.extract::<f64>() {
-                            (2. * f).into_py(py)
+                            Ok((2. * f).into_pyobject(py)?.into_any().unbind())
                         } else if let Ok(mut s) = elem.extract::<String>() {
                             s.push_str("-py");
-                            s.into_py(py)
+                            Ok(s.into_pyobject(py)?.into_any().unbind())
                         } else {
-                            panic!("unexpected argument type for {:?}", elem)
+                            panic!("unexpected argument type for {elem:?}")
                         }
                     })
                     .collect();
-                Ok(res)
+                res
             })
         };
         let closure_py =
-            PyCFunction::new_closure_bound(py, Some("test_fn"), Some("test_fn doc"), f).unwrap();
+            PyCFunction::new_closure(py, Some(c"test_fn"), Some(c"test_fn doc"), f).unwrap();
 
         py_assert!(py, closure_py, "closure_py(42) == [43]");
         py_assert!(py, closure_py, "closure_py.__name__ == 'test_fn'");
@@ -437,15 +506,16 @@ fn test_closure() {
 
 #[test]
 fn test_closure_counter() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let counter = std::cell::RefCell::new(0);
-        let counter_fn =
-            move |_args: &types::PyTuple, _kwargs: Option<&types::PyDict>| -> PyResult<i32> {
-                let mut counter = counter.borrow_mut();
-                *counter += 1;
-                Ok(*counter)
-            };
-        let counter_py = PyCFunction::new_closure_bound(py, None, None, counter_fn).unwrap();
+        let counter_fn = move |_args: &Bound<'_, types::PyTuple>,
+                               _kwargs: Option<&Bound<'_, types::PyDict>>|
+              -> PyResult<i32> {
+            let mut counter = counter.borrow_mut();
+            *counter += 1;
+            Ok(*counter)
+        };
+        let counter_py = PyCFunction::new_closure(py, None, None, counter_fn).unwrap();
 
         py_assert!(py, counter_py, "counter_py() == 1");
         py_assert!(py, counter_py, "counter_py() == 2");
@@ -464,7 +534,7 @@ fn use_pyfunction() {
         }
     }
 
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         use function_in_module::foo;
 
         // check imported name can be wrapped
@@ -491,7 +561,7 @@ fn return_value_borrows_from_arguments<'py>(
     key: &'py Key,
     value: &'py Value,
 ) -> HashMap<&'py str, i32> {
-    py.allow_threads(move || {
+    py.detach(move || {
         let mut map = HashMap::new();
         map.insert(key.0.as_str(), value.0);
         map
@@ -500,7 +570,7 @@ fn return_value_borrows_from_arguments<'py>(
 
 #[test]
 fn test_return_value_borrows_from_arguments() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let function = wrap_pyfunction!(return_value_borrows_from_arguments, py).unwrap();
 
         let key = Py::new(py, Key("key".to_owned())).unwrap();
@@ -513,6 +583,7 @@ fn test_return_value_borrows_from_arguments() {
 #[test]
 fn test_some_wrap_arguments() {
     // https://github.com/PyO3/pyo3/issues/3460
+    #[allow(unused)]
     const NONE: Option<u8> = None;
     #[pyfunction(signature = (a = 1, b = Some(2), c = None, d = NONE))]
     fn some_wrap_arguments(
@@ -524,7 +595,7 @@ fn test_some_wrap_arguments() {
         [a, b, c, d]
     }
 
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let function = wrap_pyfunction!(some_wrap_arguments, py).unwrap();
         py_assert!(py, function, "function() == [1, 2, None, None]");
     })
@@ -533,6 +604,7 @@ fn test_some_wrap_arguments() {
 #[test]
 fn test_reference_to_bound_arguments() {
     #[pyfunction]
+    #[pyo3(signature = (x, y = None))]
     fn reference_args<'py>(
         x: &Bound<'py, PyAny>,
         y: Option<&Bound<'py, PyAny>>,
@@ -540,9 +612,140 @@ fn test_reference_to_bound_arguments() {
         y.map_or_else(|| Ok(x.clone()), |y| y.add(x))
     }
 
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let function = wrap_pyfunction!(reference_args, py).unwrap();
         py_assert!(py, function, "function(1) == 1");
         py_assert!(py, function, "function(1, 2) == 3");
     })
 }
+
+#[test]
+fn test_pyfunction_raw_ident() {
+    #[pyfunction]
+    fn r#struct() -> bool {
+        true
+    }
+
+    #[pyfunction]
+    #[pyo3(name = "r#enum")]
+    fn raw_ident() -> bool {
+        true
+    }
+
+    #[pymodule]
+    fn m(m: &Bound<'_, PyModule>) -> PyResult<()> {
+        m.add_function(wrap_pyfunction!(r#struct, m)?)?;
+        m.add_function(wrap_pyfunction!(raw_ident, m)?)?;
+        Ok(())
+    }
+
+    Python::attach(|py| {
+        let m = pyo3::wrap_pymodule!(m)(py);
+        py_assert!(py, m, "m.struct()");
+        py_assert!(py, m, "m.enum()");
+    })
+}
+
+#[cfg(not(Py_LIMITED_API))]
+#[pyclass(extends=PyWarning)]
+pub struct UserDefinedWarning {}
+
+#[cfg(not(Py_LIMITED_API))]
+#[pymethods]
+impl UserDefinedWarning {
+    #[new]
+    #[pyo3(signature = (*_args, **_kwargs))]
+    fn new(_args: Bound<'_, PyAny>, _kwargs: Option<Bound<'_, PyAny>>) -> Self {
+        Self {}
+    }
+}
+
+#[test]
+fn test_pyfunction_warn() {
+    #[pyfunction]
+    #[pyo3(warn(message = "TPW: this function raises warning"))]
+    fn function_with_warning() {}
+
+    py_expect_warning_for_fn!(
+        function_with_warning,
+        f,
+        [("TPW: this function raises warning", PyUserWarning)]
+    );
+
+    #[pyfunction]
+    #[pyo3(warn(message = "TPW: this function raises warning with category", category = PyFutureWarning))]
+    fn function_with_warning_with_category() {}
+
+    py_expect_warning_for_fn!(
+        function_with_warning_with_category,
+        f,
+        [(
+            "TPW: this function raises warning with category",
+            PyFutureWarning
+        )]
+    );
+
+    #[pyfunction]
+    #[pyo3(warn(message = "TPW: custom deprecated category", category = pyo3::exceptions::PyDeprecationWarning))]
+    fn function_with_warning_with_custom_category() {}
+
+    py_expect_warning_for_fn!(
+        function_with_warning_with_custom_category,
+        f,
+        [(
+            "TPW: custom deprecated category",
+            pyo3::exceptions::PyDeprecationWarning
+        )]
+    );
+
+    #[cfg(not(Py_LIMITED_API))]
+    #[pyfunction]
+    #[pyo3(warn(message = "TPW: this function raises user-defined warning", category = UserDefinedWarning))]
+    fn function_with_warning_and_user_defined_category() {}
+
+    #[cfg(not(Py_LIMITED_API))]
+    py_expect_warning_for_fn!(
+        function_with_warning_and_user_defined_category,
+        f,
+        [(
+            "TPW: this function raises user-defined warning",
+            UserDefinedWarning
+        )]
+    );
+}
+
+#[test]
+fn test_pyfunction_multiple_warnings() {
+    #[pyfunction]
+    #[pyo3(warn(message = "TPMW: this function raises warning"))]
+    #[pyo3(warn(message = "TPMW: this function raises FutureWarning", category = PyFutureWarning))]
+    fn function_with_multiple_warnings() {}
+
+    py_expect_warning_for_fn!(
+        function_with_multiple_warnings,
+        f,
+        [
+            ("TPMW: this function raises warning", PyUserWarning),
+            ("TPMW: this function raises FutureWarning", PyFutureWarning)
+        ]
+    );
+
+    #[cfg(not(Py_LIMITED_API))]
+    #[pyfunction]
+    #[pyo3(warn(message = "TPMW: this function raises FutureWarning", category = PyFutureWarning))]
+    #[pyo3(warn(message = "TPMW: this function raises user-defined warning", category = UserDefinedWarning))]
+    fn function_with_multiple_custom_warnings() {}
+
+    #[cfg(not(Py_LIMITED_API))]
+    py_expect_warning_for_fn!(
+        function_with_multiple_custom_warnings,
+        f,
+        [
+            ("TPMW: this function raises FutureWarning", PyFutureWarning),
+            (
+                "TPMW: this function raises user-defined warning",
+                UserDefinedWarning
+            )
+        ]
+    );
+}
diff --git a/tests/test_pyself.rs b/tests/test_pyself.rs
index 7abec02b0a2..b9b9b0ea4d2 100644
--- a/tests/test_pyself.rs
+++ b/tests/test_pyself.rs
@@ -3,11 +3,9 @@
 //! Test slf: PyRef/PyMutRef<Self>(especially, slf.into::<Py>) works
 use pyo3::prelude::*;
 use pyo3::types::{PyBytes, PyString};
-use pyo3::PyCell;
 use std::collections::HashMap;
 
-#[path = "../src/tests/common.rs"]
-mod common;
+mod test_utils;
 
 /// Assumes it's a file reader or so.
 /// Inspired by https://github.com/jothan/cordoba, thanks.
@@ -19,15 +17,18 @@ struct Reader {
 
 #[pymethods]
 impl Reader {
-    fn clone_ref(slf: &PyCell<Self>) -> &PyCell<Self> {
+    fn clone_ref<'a, 'py>(slf: &'a Bound<'py, Self>) -> &'a Bound<'py, Self> {
         slf
     }
-    fn clone_ref_with_py<'py>(slf: &'py PyCell<Self>, _py: Python<'py>) -> &'py PyCell<Self> {
+    fn clone_ref_with_py<'a, 'py>(
+        slf: &'a Bound<'py, Self>,
+        _py: Python<'py>,
+    ) -> &'a Bound<'py, Self> {
         slf
     }
-    fn get_iter(slf: &PyCell<Self>, keys: Py<PyBytes>) -> Iter {
+    fn get_iter(slf: &Bound<'_, Self>, keys: Py<PyBytes>) -> Iter {
         Iter {
-            reader: slf.into(),
+            reader: slf.clone().unbind(),
             keys,
             idx: 0,
         }
@@ -62,18 +63,18 @@ impl Iter {
         slf
     }
 
-    fn __next__(mut slf: PyRefMut<'_, Self>) -> PyResult<Option<PyObject>> {
-        let bytes = slf.keys.as_ref(slf.py()).as_bytes();
+    fn __next__(mut slf: PyRefMut<'_, Self>) -> PyResult<Option<Py<PyAny>>> {
+        let bytes = slf.keys.bind(slf.py()).as_bytes();
         match bytes.get(slf.idx) {
             Some(&b) => {
                 slf.idx += 1;
                 let py = slf.py();
-                let reader = slf.reader.as_ref(py);
+                let reader = slf.reader.bind(py);
                 let reader_ref = reader.try_borrow()?;
                 let res = reader_ref
                     .inner
                     .get(&b)
-                    .map(|s| PyString::new_bound(py, s).into());
+                    .map(|s| PyString::new(py, s).into());
                 Ok(res)
             }
             None => Ok(None),
@@ -90,8 +91,8 @@ fn reader() -> Reader {
 
 #[test]
 fn test_nested_iter() {
-    Python::with_gil(|py| {
-        let reader: PyObject = reader().into_py(py);
+    Python::attach(|py| {
+        let reader = reader().into_pyobject(py).unwrap();
         py_assert!(
             py,
             reader,
@@ -102,8 +103,8 @@ fn test_nested_iter() {
 
 #[test]
 fn test_clone_ref() {
-    Python::with_gil(|py| {
-        let reader: PyObject = reader().into_py(py);
+    Python::attach(|py| {
+        let reader = reader().into_pyobject(py).unwrap();
         py_assert!(py, reader, "reader == reader.clone_ref()");
         py_assert!(py, reader, "reader == reader.clone_ref_with_py()");
     });
@@ -111,8 +112,8 @@ fn test_clone_ref() {
 
 #[test]
 fn test_nested_iter_reset() {
-    Python::with_gil(|py| {
-        let reader = PyCell::new(py, reader()).unwrap();
+    Python::attach(|py| {
+        let reader = Bound::new(py, reader()).unwrap();
         py_assert!(
             py,
             reader,
diff --git a/tests/test_sequence.rs b/tests/test_sequence.rs
index d3c84b76c8c..970f143503f 100644
--- a/tests/test_sequence.rs
+++ b/tests/test_sequence.rs
@@ -6,8 +6,7 @@ use pyo3::{ffi, prelude::*};
 
 use pyo3::py_run;
 
-#[path = "../src/tests/common.rs"]
-mod common;
+mod test_utils;
 
 #[pyclass]
 struct ByteSequence {
@@ -17,11 +16,12 @@ struct ByteSequence {
 #[pymethods]
 impl ByteSequence {
     #[new]
-    fn new(elements: Option<&PyList>) -> PyResult<Self> {
+    #[pyo3(signature=(elements = None))]
+    fn new(elements: Option<&Bound<'_, PyList>>) -> PyResult<Self> {
         if let Some(pylist) = elements {
             let mut elems = Vec::with_capacity(pylist.len());
             for pyelem in pylist {
-                let elem = u8::extract(pyelem)?;
+                let elem = pyelem.extract()?;
                 elems.push(elem);
             }
             Ok(Self { elements: elems })
@@ -60,8 +60,8 @@ impl ByteSequence {
         }
     }
 
-    fn __contains__(&self, other: &PyAny) -> bool {
-        match u8::extract(other) {
+    fn __contains__(&self, other: &Bound<'_, PyAny>) -> bool {
+        match other.extract::<u8>() {
             Ok(x) => self.elements.contains(&x),
             Err(_) => false,
         }
@@ -106,7 +106,9 @@ impl ByteSequence {
 
 /// Return a dict with `s = ByteSequence([1, 2, 3])`.
 fn seq_dict(py: Python<'_>) -> Bound<'_, pyo3::types::PyDict> {
-    let d = [("ByteSequence", py.get_type::<ByteSequence>())].into_py_dict_bound(py);
+    let d = [("ByteSequence", py.get_type::<ByteSequence>())]
+        .into_py_dict(py)
+        .unwrap();
     // Though we can construct `s` in Rust, let's test `__new__` works.
     py_run!(py, *d, "s = ByteSequence([1, 2, 3])");
     d
@@ -114,7 +116,7 @@ fn seq_dict(py: Python<'_>) -> Bound<'_, pyo3::types::PyDict> {
 
 #[test]
 fn test_getitem() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let d = seq_dict(py);
 
         py_assert!(py, *d, "s[0] == 1");
@@ -127,7 +129,7 @@ fn test_getitem() {
 
 #[test]
 fn test_setitem() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let d = seq_dict(py);
 
         py_run!(py, *d, "s[0] = 4; assert list(s) == [4, 2, 3]");
@@ -137,8 +139,10 @@ fn test_setitem() {
 
 #[test]
 fn test_delitem() {
-    Python::with_gil(|py| {
-        let d = [("ByteSequence", py.get_type::<ByteSequence>())].into_py_dict_bound(py);
+    Python::attach(|py| {
+        let d = [("ByteSequence", py.get_type::<ByteSequence>())]
+            .into_py_dict(py)
+            .unwrap();
 
         py_run!(
             py,
@@ -177,7 +181,7 @@ fn test_delitem() {
 
 #[test]
 fn test_contains() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let d = seq_dict(py);
 
         py_assert!(py, *d, "1 in s");
@@ -190,7 +194,7 @@ fn test_contains() {
 
 #[test]
 fn test_concat() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let d = seq_dict(py);
 
         py_run!(
@@ -209,7 +213,7 @@ fn test_concat() {
 
 #[test]
 fn test_inplace_concat() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let d = seq_dict(py);
 
         py_run!(
@@ -223,7 +227,7 @@ fn test_inplace_concat() {
 
 #[test]
 fn test_repeat() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let d = seq_dict(py);
 
         py_run!(py, *d, "s2 = s * 2; assert list(s2) == [1, 2, 3, 1, 2, 3]");
@@ -233,8 +237,10 @@ fn test_repeat() {
 
 #[test]
 fn test_inplace_repeat() {
-    Python::with_gil(|py| {
-        let d = [("ByteSequence", py.get_type::<ByteSequence>())].into_py_dict_bound(py);
+    Python::attach(|py| {
+        let d = [("ByteSequence", py.get_type::<ByteSequence>())]
+            .into_py_dict(py)
+            .unwrap();
 
         py_run!(
             py,
@@ -248,27 +254,31 @@ fn test_inplace_repeat() {
 // Check that #[pyo3(get, set)] works correctly for Vec<PyObject>
 
 #[pyclass]
-struct GenericList {
+struct AnyObjectList {
     #[pyo3(get, set)]
-    items: Vec<PyObject>,
+    items: Vec<Py<PyAny>>,
 }
 
 #[test]
-fn test_generic_list_get() {
-    Python::with_gil(|py| {
-        let list: PyObject = GenericList {
-            items: [1, 2, 3].iter().map(|i| i.to_object(py)).collect(),
+fn test_any_object_list_get() {
+    Python::attach(|py| {
+        let list = AnyObjectList {
+            items: [1i32, 2, 3]
+                .iter()
+                .map(|i| i.into_pyobject(py).unwrap().into_any().unbind())
+                .collect(),
         }
-        .into_py(py);
+        .into_pyobject(py)
+        .unwrap();
 
         py_assert!(py, list, "list.items == [1, 2, 3]");
     });
 }
 
 #[test]
-fn test_generic_list_set() {
-    Python::with_gil(|py| {
-        let list = PyCell::new(py, GenericList { items: vec![] }).unwrap();
+fn test_any_object_list_set() {
+    Python::attach(|py| {
+        let list = Bound::new(py, AnyObjectList { items: vec![] }).unwrap();
 
         py_run!(py, list, "list.items = [1, 2, 3]");
         assert!(list
@@ -276,7 +286,7 @@ fn test_generic_list_set() {
             .items
             .iter()
             .zip(&[1u32, 2, 3])
-            .all(|(a, b)| a.as_ref(py).eq(&b.into_py(py)).unwrap()));
+            .all(|(a, b)| a.bind(py).eq(b.into_pyobject(py).unwrap()).unwrap()));
     });
 }
 
@@ -303,8 +313,8 @@ impl OptionList {
 #[test]
 fn test_option_list_get() {
     // Regression test for #798
-    Python::with_gil(|py| {
-        let list = PyCell::new(
+    Python::attach(|py| {
+        let list = Py::new(
             py,
             OptionList {
                 items: vec![Some(1), None],
@@ -320,32 +330,34 @@ fn test_option_list_get() {
 
 #[test]
 fn sequence_is_not_mapping() {
-    Python::with_gil(|py| {
-        let list = PyCell::new(
+    Python::attach(|py| {
+        let list = Bound::new(
             py,
             OptionList {
                 items: vec![Some(1), None],
             },
         )
-        .unwrap();
+        .unwrap()
+        .into_any();
 
         PySequence::register::<OptionList>(py).unwrap();
 
-        assert!(list.as_ref().downcast::<PyMapping>().is_err());
-        assert!(list.as_ref().downcast::<PySequence>().is_ok());
+        assert!(list.cast::<PyMapping>().is_err());
+        assert!(list.cast::<PySequence>().is_ok());
     })
 }
 
 #[test]
 fn sequence_length() {
-    Python::with_gil(|py| {
-        let list = PyCell::new(
+    Python::attach(|py| {
+        let list = Bound::new(
             py,
             OptionList {
                 items: vec![Some(1), None],
             },
         )
-        .unwrap();
+        .unwrap()
+        .into_any();
 
         assert_eq!(list.len().unwrap(), 2);
         assert_eq!(unsafe { ffi::PySequence_Length(list.as_ptr()) }, 2);
@@ -354,3 +366,60 @@ fn sequence_length() {
         unsafe { ffi::PyErr_Clear() };
     })
 }
+
+#[cfg(Py_3_10)]
+#[pyclass(generic, sequence)]
+struct GenericList {
+    #[pyo3(get, set)]
+    items: Vec<Py<PyAny>>,
+}
+
+#[cfg(Py_3_10)]
+#[pymethods]
+impl GenericList {
+    fn __len__(&self) -> usize {
+        self.items.len()
+    }
+
+    fn __getitem__(&self, idx: isize) -> PyResult<Py<PyAny>> {
+        match self.items.get(idx as usize) {
+            Some(x) => pyo3::Python::attach(|py| Ok(x.clone_ref(py))),
+            None => Err(PyIndexError::new_err("Index out of bounds")),
+        }
+    }
+}
+
+#[cfg(Py_3_10)]
+#[test]
+fn test_generic_both_subscriptions_types() {
+    use pyo3::types::PyInt;
+    use std::convert::Infallible;
+
+    Python::attach(|py| {
+        let l = Bound::new(
+            py,
+            GenericList {
+                items: [1, 2, 3]
+                    .iter()
+                    .map(|x| -> Py<PyAny> {
+                        let x: Result<Bound<'_, PyInt>, Infallible> = x.into_pyobject(py);
+                        x.unwrap().into_any().unbind()
+                    })
+                    .chain([py.None()])
+                    .collect(),
+            },
+        )
+        .unwrap();
+        let ty = py.get_type::<GenericList>();
+        py_assert!(py, l, "l[0] == 1");
+        py_run!(
+            py,
+            ty,
+            "import types;
+            import typing;
+            IntOrNone: typing.TypeAlias = typing.Union[int, None];
+            assert ty[IntOrNone] == types.GenericAlias(ty, (IntOrNone,))"
+        );
+        py_assert!(py, l, "list(reversed(l)) == [None, 3, 2, 1]");
+    });
+}
diff --git a/tests/test_serde.rs b/tests/test_serde.rs
index f1d5bee4bee..ec4d859084e 100644
--- a/tests/test_serde.rs
+++ b/tests/test_serde.rs
@@ -11,7 +11,7 @@ mod test_serde {
     }
 
     #[pyclass]
-    #[derive(Debug, Clone, Serialize, Deserialize)]
+    #[derive(Debug, Serialize, Deserialize)]
     struct User {
         username: String,
         group: Option<Py<Group>>,
@@ -27,10 +27,11 @@ mod test_serde {
         };
         let friend2 = User {
             username: "friend 2".into(),
-            ..friend1.clone()
+            group: None,
+            friends: vec![],
         };
 
-        let user = Python::with_gil(|py| {
+        let user = Python::attach(|py| {
             let py_friend1 = Py::new(py, friend1).expect("failed to create friend 1");
             let py_friend2 = Py::new(py, friend2).expect("failed to create friend 2");
 
@@ -68,7 +69,7 @@ mod test_serde {
         assert_eq!(user.friends.len(), 1usize);
         let friend = user.friends.first().unwrap();
 
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             assert_eq!(friend.borrow(py).username, "friend");
             assert_eq!(
                 friend.borrow(py).group.as_ref().unwrap().borrow(py).name,
diff --git a/tests/test_static_slots.rs b/tests/test_static_slots.rs
index b01c87cd507..c00a8815270 100644
--- a/tests/test_static_slots.rs
+++ b/tests/test_static_slots.rs
@@ -6,8 +6,7 @@ use pyo3::types::IntoPyDict;
 
 use pyo3::py_run;
 
-#[path = "../src/tests/common.rs"]
-mod common;
+mod test_utils;
 
 #[pyclass]
 struct Count5();
@@ -38,7 +37,9 @@ impl Count5 {
 
 /// Return a dict with `s = Count5()`.
 fn test_dict(py: Python<'_>) -> Bound<'_, pyo3::types::PyDict> {
-    let d = [("Count5", py.get_type::<Count5>())].into_py_dict_bound(py);
+    let d = [("Count5", py.get_type::<Count5>())]
+        .into_py_dict(py)
+        .unwrap();
     // Though we can construct `s` in Rust, let's test `__new__` works.
     py_run!(py, *d, "s = Count5()");
     d
@@ -46,7 +47,7 @@ fn test_dict(py: Python<'_>) -> Bound<'_, pyo3::types::PyDict> {
 
 #[test]
 fn test_len() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let d = test_dict(py);
 
         py_assert!(py, *d, "len(s) == 5");
@@ -55,7 +56,7 @@ fn test_len() {
 
 #[test]
 fn test_getitem() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let d = test_dict(py);
 
         py_assert!(py, *d, "s[4] == 5.0");
@@ -64,7 +65,7 @@ fn test_getitem() {
 
 #[test]
 fn test_list() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let d = test_dict(py);
 
         py_assert!(py, *d, "list(s) == [1.0, 2.0, 3.0, 4.0, 5.0]");
diff --git a/tests/test_string.rs b/tests/test_string.rs
index 02bf2ecd4df..1648e067760 100644
--- a/tests/test_string.rs
+++ b/tests/test_string.rs
@@ -2,15 +2,14 @@
 
 use pyo3::prelude::*;
 
-#[path = "../src/tests/common.rs"]
-mod common;
+mod test_utils;
 
 #[pyfunction]
 fn take_str(_s: &str) {}
 
 #[test]
 fn test_unicode_encode_error() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let take_str = wrap_pyfunction!(take_str)(py).unwrap();
         py_expect_exception!(
             py,
diff --git a/tests/test_super.rs b/tests/test_super.rs
index 208290df87b..644365e8829 100644
--- a/tests/test_super.rs
+++ b/tests/test_super.rs
@@ -1,4 +1,4 @@
-#![cfg(all(feature = "macros", not(PyPy)))]
+#![cfg(all(feature = "macros", not(any(PyPy, GraalPy))))]
 
 use pyo3::{prelude::*, types::PySuper};
 
@@ -29,21 +29,20 @@ impl SubClass {
         (SubClass {}, BaseClass::new())
     }
 
-    fn method(self_: &PyCell<Self>) -> PyResult<&PyAny> {
+    fn method<'py>(self_: &Bound<'py, Self>) -> PyResult<Bound<'py, PyAny>> {
         let super_ = self_.py_super()?;
         super_.call_method("method", (), None)
     }
 
-    fn method_super_new(self_: &PyCell<Self>) -> PyResult<&PyAny> {
-        #[cfg_attr(not(feature = "gil-refs"), allow(deprecated))]
-        let super_ = PySuper::new(self_.get_type(), self_)?;
+    fn method_super_new<'py>(self_: &Bound<'py, Self>) -> PyResult<Bound<'py, PyAny>> {
+        let super_ = PySuper::new(&self_.get_type(), self_)?;
         super_.call_method("method", (), None)
     }
 }
 
 #[test]
 fn test_call_super_method() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let cls = py.get_type::<SubClass>();
         pyo3::py_run!(
             py,
diff --git a/tests/test_text_signature.rs b/tests/test_text_signature.rs
index 9056ca21e14..b4815d692a1 100644
--- a/tests/test_text_signature.rs
+++ b/tests/test_text_signature.rs
@@ -2,17 +2,16 @@
 
 use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyTuple};
-use pyo3::{types::PyType, wrap_pymodule, PyCell};
+use pyo3::{types::PyType, wrap_pymodule};
 
-#[path = "../src/tests/common.rs"]
-mod common;
+mod test_utils;
 
 #[test]
 fn class_without_docs_or_signature() {
     #[pyclass]
     struct MyClass {}
 
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let typeobj = py.get_type::<MyClass>();
 
         py_assert!(py, typeobj, "typeobj.__doc__ is None");
@@ -27,7 +26,7 @@ fn class_with_docs() {
     /// docs line2
     struct MyClass {}
 
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let typeobj = py.get_type::<MyClass>();
 
         py_assert!(py, typeobj, "typeobj.__doc__ == 'docs line1\\ndocs line2'");
@@ -51,7 +50,7 @@ fn class_with_signature_no_doc() {
         }
     }
 
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let typeobj = py.get_type::<MyClass>();
         py_assert!(py, typeobj, "typeobj.__doc__ == ''");
         py_assert!(
@@ -80,7 +79,7 @@ fn class_with_docs_and_signature() {
         }
     }
 
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let typeobj = py.get_type::<MyClass>();
 
         py_assert!(py, typeobj, "typeobj.__doc__ == 'docs line1\\ndocs line2'");
@@ -100,7 +99,7 @@ fn test_function() {
         let _ = (a, b, c);
     }
 
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let f = wrap_pyfunction!(my_function)(py).unwrap();
 
         py_assert!(py, f, "f.__text_signature__ == '(a, b=None, *, c=42)'");
@@ -128,10 +127,10 @@ fn test_auto_test_signature_function() {
     fn my_function_4(
         a: i32,
         b: Option<i32>,
-        args: &PyTuple,
+        args: &Bound<'_, PyTuple>,
         c: i32,
         d: i32,
-        kwargs: Option<&PyDict>,
+        kwargs: Option<&Bound<'_, PyDict>>,
     ) {
         let _ = (a, b, args, c, d, kwargs);
     }
@@ -142,11 +141,12 @@ fn test_auto_test_signature_function() {
     }
 
     #[pyfunction]
+    #[pyo3(signature=(a, b=None, c=None))]
     fn my_function_6(a: i32, b: Option<i32>, c: Option<i32>) {
         let _ = (a, b, c);
     }
 
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let f = wrap_pyfunction!(my_function)(py).unwrap();
         py_assert!(
             py,
@@ -218,10 +218,10 @@ fn test_auto_test_signature_method() {
             &self,
             a: i32,
             b: Option<i32>,
-            args: &PyTuple,
+            args: &Bound<'_, PyTuple>,
             c: i32,
             d: i32,
-            kwargs: Option<&PyDict>,
+            kwargs: Option<&Bound<'_, PyDict>>,
         ) {
             let _ = (a, b, args, c, d, kwargs);
         }
@@ -237,7 +237,7 @@ fn test_auto_test_signature_method() {
         }
     }
 
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let cls = py.get_type::<MyClass>();
         #[cfg(any(not(Py_LIMITED_API), Py_3_10))]
         py_assert!(py, cls, "cls.__text_signature__ == '(a, b, c)'");
@@ -316,7 +316,7 @@ fn test_auto_test_signature_opt_out() {
         }
     }
 
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let f = wrap_pyfunction!(my_function)(py).unwrap();
         py_assert!(py, f, "f.__text_signature__ == None");
 
@@ -333,9 +333,10 @@ fn test_auto_test_signature_opt_out() {
 }
 
 #[test]
+#[allow(deprecated)]
 fn test_pyfn() {
     #[pymodule]
-    fn my_module(_py: Python<'_>, m: &PyModule) -> PyResult<()> {
+    fn my_module(m: &Bound<'_, PyModule>) -> PyResult<()> {
         #[pyfn(m, signature = (a, b=None, *, c=42))]
         #[pyo3(text_signature = "(a, b=None, *, c=42)")]
         fn my_function(a: i32, b: Option<i32>, c: i32) {
@@ -344,7 +345,7 @@ fn test_pyfn() {
         Ok(())
     }
 
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let m = wrap_pymodule!(my_module)(py);
 
         py_assert!(
@@ -367,7 +368,7 @@ fn test_methods() {
             let _ = a;
         }
         #[pyo3(text_signature = "($self, b)")]
-        fn pyself_method(_this: &PyCell<Self>, b: i32) {
+        fn pyself_method(_this: &Bound<'_, Self>, b: i32) {
             let _ = b;
         }
         #[classmethod]
@@ -382,7 +383,7 @@ fn test_methods() {
         }
     }
 
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let typeobj = py.get_type::<MyClass>();
 
         py_assert!(
@@ -423,7 +424,7 @@ fn test_raw_identifiers() {
         fn r#method(&self) {}
     }
 
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let typeobj = py.get_type::<MyClass>();
 
         py_assert!(py, typeobj, "typeobj.__text_signature__ == '()'");
diff --git a/tests/test_unsendable_dict.rs b/tests/test_unsendable_dict.rs
deleted file mode 100644
index a39aa1ab714..00000000000
--- a/tests/test_unsendable_dict.rs
+++ /dev/null
@@ -1,49 +0,0 @@
-#![cfg(feature = "macros")]
-
-use pyo3::prelude::*;
-use pyo3::py_run;
-
-#[pyclass(dict, unsendable)]
-struct UnsendableDictClass {}
-
-#[pymethods]
-impl UnsendableDictClass {
-    #[new]
-    fn new() -> Self {
-        UnsendableDictClass {}
-    }
-}
-
-#[test]
-#[cfg_attr(all(Py_LIMITED_API, not(Py_3_10)), ignore)]
-fn test_unsendable_dict() {
-    Python::with_gil(|py| {
-        let inst = Py::new(py, UnsendableDictClass {}).unwrap();
-        py_run!(py, inst, "assert inst.__dict__ == {}");
-    });
-}
-
-#[pyclass(dict, unsendable, weakref)]
-struct UnsendableDictClassWithWeakRef {}
-
-#[pymethods]
-impl UnsendableDictClassWithWeakRef {
-    #[new]
-    fn new() -> Self {
-        Self {}
-    }
-}
-
-#[test]
-#[cfg_attr(all(Py_LIMITED_API, not(Py_3_10)), ignore)]
-fn test_unsendable_dict_with_weakref() {
-    Python::with_gil(|py| {
-        let inst = Py::new(py, UnsendableDictClassWithWeakRef {}).unwrap();
-        py_run!(py, inst, "assert inst.__dict__ == {}");
-        py_run!(
-            py,
-            inst,
-            "import weakref; assert weakref.ref(inst)() is inst; inst.a = 1; assert inst.a == 1"
-        );
-    });
-}
diff --git a/tests/test_utils/mod.rs b/tests/test_utils/mod.rs
new file mode 100644
index 00000000000..e154c16372d
--- /dev/null
+++ b/tests/test_utils/mod.rs
@@ -0,0 +1,279 @@
+// Common macros and helpers for tests
+//
+// This file is used in two different ways, which makes it a bit of a pain to build:
+// - as a module `include!`-ed from `src/test_utils.rs`
+// - as a module `mod test_utils` in various integration tests
+//
+// the inner mod enables the #![allow(dead_code)] to
+// be applied - `src/test_utils.rs` uses `include!` to pull in this file
+
+#[allow(dead_code, unused_macros)] // many tests do not use the complete set of functionality offered here
+#[allow(missing_docs)] // only used in tests
+#[macro_use]
+mod inner {
+
+    #[allow(unused_imports)]
+    // pulls in `use crate as pyo3` in `src/test_utils.rs`, no function in integration tests
+    use super::*;
+
+    use pyo3::prelude::*;
+
+    #[cfg(any(not(all(Py_GIL_DISABLED, Py_3_14)), all(feature = "macros", Py_3_8)))]
+    use pyo3::sync::MutexExt;
+    use pyo3::types::{IntoPyDict, PyList};
+
+    #[cfg(any(not(all(Py_GIL_DISABLED, Py_3_14)), all(feature = "macros", Py_3_8)))]
+    use std::sync::{Mutex, PoisonError};
+
+    use uuid::Uuid;
+
+    #[macro_export]
+    macro_rules! py_assert {
+        ($py:expr, $($val:ident)+, $assertion:literal) => {
+            pyo3::py_run!($py, $($val)+, concat!("assert ", $assertion))
+        };
+        ($py:expr, *$dict:expr, $assertion:literal) => {
+            pyo3::py_run!($py, *$dict, concat!("assert ", $assertion))
+        };
+    }
+
+    #[macro_export]
+    macro_rules! assert_py_eq {
+        ($val:expr, $expected:expr) => {
+            assert!($val.eq($expected).unwrap());
+        };
+    }
+
+    #[macro_export]
+    macro_rules! py_expect_exception {
+        // Case1: idents & no err_msg
+        ($py:expr, $($val:ident)+, $code:expr, $err:ident) => {{
+            use pyo3::types::IntoPyDict;
+            use pyo3::BoundObject;
+            let d = [$((stringify!($val), (&$val).into_pyobject($py).unwrap().into_any().into_bound()),)+].into_py_dict($py).unwrap();
+            py_expect_exception!($py, *d, $code, $err)
+        }};
+        // Case2: dict & no err_msg
+        ($py:expr, *$dict:expr, $code:expr, $err:ident) => {{
+            let res = $py.run(&std::ffi::CString::new($code).unwrap(), None, Some(&$dict.as_borrowed()));
+            let err = res.expect_err(&format!("Did not raise {}", stringify!($err)));
+            if !err.matches($py, $py.get_type::<pyo3::exceptions::$err>()).unwrap() {
+                panic!("Expected {} but got {:?}", stringify!($err), err)
+            }
+            err
+        }};
+        // Case3: idents & err_msg
+        ($py:expr, $($val:ident)+, $code:expr, $err:ident, $err_msg:literal) => {{
+            let err = py_expect_exception!($py, $($val)+, $code, $err);
+            // Suppose that the error message looks like 'TypeError: ~'
+            assert_eq!(format!("Py{}", err), concat!(stringify!($err), ": ", $err_msg));
+            err
+        }};
+        // Case4: dict & err_msg
+        ($py:expr, *$dict:expr, $code:expr, $err:ident, $err_msg:literal) => {{
+            let err = py_expect_exception!($py, *$dict, $code, $err);
+            assert_eq!(format!("Py{}", err), concat!(stringify!($err), ": ", $err_msg));
+            err
+        }};
+    }
+
+    #[macro_export]
+    macro_rules! py_expect_warning {
+        ($py:expr, $($val:ident)+, $code:expr, [$(($warning_msg:literal, $warning_category:path)),+] $(,)?) => {{
+            use pyo3::types::IntoPyDict;
+            let d = [$((stringify!($val), ($val.as_ref() as &Bound<'_, PyAny>).into_pyobject($py).expect("Failed to create test dict element")),)+].into_py_dict($py).expect("Failed to create test dict");
+            py_expect_warning!($py, *d, $code, [$(($warning_msg, $warning_category)),+])
+        }};
+        ($py:expr, *$dict:expr, $code:expr, [$(($warning_msg:literal, $warning_category:path)),+] $(,)?) => {{
+            $crate::test_utils::CatchWarnings::enter($py, |warning_record| {
+                $py.run(&std::ffi::CString::new($code).unwrap(), None, Some(&$dict.as_borrowed())).expect("Failed to run warning testing code");
+                let expected_warnings = [$(($warning_msg, <$warning_category as pyo3::PyTypeInfo>::type_object($py))),+];
+
+                assert_eq!(warning_record.len(), expected_warnings.len(), "Expecting {} warnings but got {}", expected_warnings.len(), warning_record.len());
+
+                for ((index, warning), (msg, category)) in warning_record.iter().enumerate().zip(expected_warnings.iter()) {
+                    let actual_msg = warning.getattr("message").unwrap().str().unwrap().to_string_lossy().to_string();
+                    let actual_category = warning.getattr("category").unwrap();
+
+                    assert_eq!(actual_msg, msg.to_string(), "Warning message mismatch at index {}, expecting `{}` but got `{}`", index, msg, actual_msg);
+                    assert!(actual_category.is(category), "Warning category mismatch at index {}, expecting {:?} but got {:?}", index, category, actual_category);
+                }
+
+                Ok(())
+            }).expect("failed to test warnings");
+        }};
+    }
+
+    #[macro_export]
+    macro_rules! py_expect_warning_for_fn {
+        ($fn:ident, $($val:ident)+, [$(($warning_msg:literal, $warning_category:path)),+] $(,)?) => {
+            pyo3::Python::attach(|py| {
+                let f = wrap_pyfunction!($fn)(py).unwrap();
+                py_expect_warning!(
+                    py,
+                    f,
+                    "f()",
+                    [$(($warning_msg, $warning_category)),+]
+                );
+            });
+        };
+    }
+
+    // sys.unraisablehook not available until Python 3.8
+    #[cfg(all(feature = "macros", Py_3_8))]
+    pub struct UnraisableCapture<'py> {
+        hook: Bound<'py, UnraisableCaptureHook>,
+    }
+
+    #[cfg(all(feature = "macros", Py_3_8))]
+    impl<'py> UnraisableCapture<'py> {
+        /// Runs the closure `f` with a custom sys.unraisablehook installed.
+        ///
+        /// `f`
+        pub fn enter<R>(py: Python<'py>, f: impl FnOnce(&Self) -> R) -> R {
+            // unraisablehook is a global, so only one thread can be using this struct at a time.
+            static UNRAISABLE_HOOK_MUTEX: Mutex<()> = Mutex::new(());
+
+            // NB this is best-effort, other tests could always modify sys.unraisablehook directly.
+            let mutex_guard = UNRAISABLE_HOOK_MUTEX
+                .lock_py_attached(py)
+                .unwrap_or_else(PoisonError::into_inner);
+
+            let guard = Self {
+                hook: UnraisableCaptureHook::install(py),
+            };
+
+            let result = f(&guard);
+
+            drop(guard);
+            drop(mutex_guard);
+
+            result
+        }
+
+        /// Takes the captured unraisable error, if any.
+        pub fn take_capture(&self) -> Option<(PyErr, Bound<'py, PyAny>)> {
+            let mut guard = self.hook.get().capture.lock().unwrap();
+            guard.take().map(|(e, o)| (e, o.into_bound(self.hook.py())))
+        }
+    }
+
+    #[cfg(all(feature = "macros", Py_3_8))]
+    impl Drop for UnraisableCapture<'_> {
+        fn drop(&mut self) {
+            let py = self.hook.py();
+            self.hook.get().uninstall(py);
+        }
+    }
+
+    #[cfg(all(feature = "macros", Py_3_8))]
+    #[pyclass(crate = "pyo3", frozen)]
+    struct UnraisableCaptureHook {
+        pub capture: Mutex<Option<(PyErr, Py<PyAny>)>>,
+        old_hook: Py<PyAny>,
+    }
+
+    #[cfg(all(feature = "macros", Py_3_8))]
+    #[pymethods(crate = "pyo3")]
+    impl UnraisableCaptureHook {
+        pub fn hook(&self, unraisable: Bound<'_, PyAny>) {
+            let err = PyErr::from_value(unraisable.getattr("exc_value").unwrap());
+            let instance = unraisable.getattr("object").unwrap();
+            self.capture.lock().unwrap().replace((err, instance.into()));
+        }
+    }
+
+    #[cfg(all(feature = "macros", Py_3_8))]
+    impl UnraisableCaptureHook {
+        fn install(py: Python<'_>) -> Bound<'_, Self> {
+            let sys = py.import("sys").unwrap();
+
+            let old_hook = sys.getattr("unraisablehook").unwrap().into();
+            let capture = Mutex::new(None);
+
+            let capture = Bound::new(py, UnraisableCaptureHook { capture, old_hook }).unwrap();
+
+            sys.setattr("unraisablehook", capture.getattr("hook").unwrap())
+                .unwrap();
+
+            capture
+        }
+
+        fn uninstall(&self, py: Python<'_>) {
+            let sys = py.import("sys").unwrap();
+            sys.setattr("unraisablehook", &self.old_hook).unwrap();
+        }
+    }
+
+    pub struct CatchWarnings<'py> {
+        catch_warnings: Bound<'py, PyAny>,
+    }
+
+    /// catch_warnings is not thread-safe, so only one thread can be using this struct at
+    /// a time.
+    #[cfg(not(all(Py_GIL_DISABLED, Py_3_14)))] // Python 3.14t has thread-safe catch_warnings
+    static CATCH_WARNINGS_MUTEX: Mutex<()> = Mutex::new(());
+
+    impl<'py> CatchWarnings<'py> {
+        pub fn enter<R>(
+            py: Python<'py>,
+            f: impl FnOnce(&Bound<'py, PyList>) -> PyResult<R>,
+        ) -> PyResult<R> {
+            // NB this is best-effort, other tests could always call the warnings API directly.
+            #[cfg(not(all(Py_GIL_DISABLED, Py_3_14)))]
+            let _mutex_guard = CATCH_WARNINGS_MUTEX
+                .lock_py_attached(py)
+                .unwrap_or_else(PoisonError::into_inner);
+            let warnings = py.import("warnings")?;
+            let kwargs = [("record", true)].into_py_dict(py)?;
+            let catch_warnings = warnings
+                .getattr("catch_warnings")?
+                .call((), Some(&kwargs))?;
+            let list = catch_warnings.call_method0("__enter__")?.cast_into()?;
+            let _guard = Self { catch_warnings };
+            f(&list)
+        }
+    }
+
+    impl Drop for CatchWarnings<'_> {
+        fn drop(&mut self) {
+            let py = self.catch_warnings.py();
+            self.catch_warnings
+                .call_method1("__exit__", (py.None(), py.None(), py.None()))
+                .unwrap();
+        }
+    }
+
+    macro_rules! assert_warnings {
+        ($py:expr, $body:expr, [$(($category:ty, $message:literal)),+] $(,)? ) => {{
+            $crate::test_utils::CatchWarnings::enter($py, |w| {
+                use $crate::types::{PyListMethods, PyStringMethods};
+                $body;
+                let expected_warnings = [$((<$category as $crate::type_object::PyTypeInfo>::type_object($py), $message)),+];
+                assert_eq!(w.len(), expected_warnings.len());
+                for (warning, (category, message)) in w.iter().zip(expected_warnings) {
+
+                    assert!(warning.getattr("category").unwrap().is(&category));
+                    assert_eq!(
+                        warning.getattr("message").unwrap().str().unwrap().to_string_lossy(),
+                        message
+                    );
+                }
+
+                Ok(())
+            })
+            .unwrap();
+        }};
+    }
+
+    #[allow(unused_imports)] // not all tests use this macro
+    pub(crate) use assert_warnings;
+
+    pub fn generate_unique_module_name(base: &str) -> std::ffi::CString {
+        let uuid = Uuid::new_v4().simple().to_string();
+        std::ffi::CString::new(format!("{base}_{uuid}")).unwrap()
+    }
+}
+
+#[allow(unused_imports)] // some tests use just the macros and none of the other functionality
+pub use inner::*;
diff --git a/tests/test_variable_arguments.rs b/tests/test_variable_arguments.rs
index a1f8bb354cf..d186e8def3b 100644
--- a/tests/test_variable_arguments.rs
+++ b/tests/test_variable_arguments.rs
@@ -3,8 +3,7 @@
 use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyTuple};
 
-#[path = "../src/tests/common.rs"]
-mod common;
+mod test_utils;
 
 #[pyclass]
 struct MyClass {}
@@ -13,20 +12,20 @@ struct MyClass {}
 impl MyClass {
     #[staticmethod]
     #[pyo3(signature = (*args))]
-    fn test_args(args: &PyTuple) -> &PyTuple {
+    fn test_args(args: Bound<'_, PyTuple>) -> Bound<'_, PyTuple> {
         args
     }
 
     #[staticmethod]
     #[pyo3(signature = (**kwargs))]
-    fn test_kwargs(kwargs: Option<&PyDict>) -> Option<&PyDict> {
+    fn test_kwargs(kwargs: Option<Bound<'_, PyDict>>) -> Option<Bound<'_, PyDict>> {
         kwargs
     }
 }
 
 #[test]
 fn variable_args() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let my_obj = py.get_type::<MyClass>();
         py_assert!(py, my_obj, "my_obj.test_args() == ()");
         py_assert!(py, my_obj, "my_obj.test_args(1) == (1,)");
@@ -36,7 +35,7 @@ fn variable_args() {
 
 #[test]
 fn variable_kwargs() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let my_obj = py.get_type::<MyClass>();
         py_assert!(py, my_obj, "my_obj.test_kwargs() == None");
         py_assert!(py, my_obj, "my_obj.test_kwargs(test=1) == {'test': 1}");
diff --git a/tests/test_various.rs b/tests/test_various.rs
index d0df8d4a04e..cf2ae82b5ff 100644
--- a/tests/test_various.rs
+++ b/tests/test_various.rs
@@ -1,13 +1,12 @@
 #![cfg(feature = "macros")]
 
 use pyo3::prelude::*;
-use pyo3::types::{PyDict, PyTuple};
-use pyo3::{py_run, PyCell};
+use pyo3::py_run;
+use pyo3::types::PyTuple;
 
 use std::fmt;
 
-#[path = "../src/tests/common.rs"]
-mod common;
+mod test_utils;
 
 #[pyclass]
 struct MutRefArg {
@@ -26,12 +25,12 @@ impl MutRefArg {
 
 #[test]
 fn mut_ref_arg() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let inst1 = Py::new(py, MutRefArg { n: 0 }).unwrap();
         let inst2 = Py::new(py, MutRefArg { n: 0 }).unwrap();
 
         py_run!(py, inst1 inst2, "inst1.set_other(inst2)");
-        let inst2 = inst2.as_ref(py).borrow();
+        let inst2 = inst2.bind(py).borrow();
         assert_eq!(inst2.n, 100);
     });
 }
@@ -51,7 +50,7 @@ fn get_zero() -> PyUsize {
 /// Checks that we can use return a custom class in arbitrary function and use those functions
 /// both in rust and python
 fn return_custom_class() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         // Using from rust
         assert_eq!(get_zero().value, 0);
 
@@ -63,7 +62,7 @@ fn return_custom_class() {
 
 #[test]
 fn intopytuple_primitive() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let tup = (1, 2, "foo");
         py_assert!(py, tup, "tup == (1, 2, 'foo')");
         py_assert!(py, tup, "tup[0] == 1");
@@ -77,10 +76,10 @@ struct SimplePyClass {}
 
 #[test]
 fn intopytuple_pyclass() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let tup = (
-            PyCell::new(py, SimplePyClass {}).unwrap(),
-            PyCell::new(py, SimplePyClass {}).unwrap(),
+            Py::new(py, SimplePyClass {}).unwrap(),
+            Py::new(py, SimplePyClass {}).unwrap(),
         );
         py_assert!(py, tup, "type(tup[0]).__name__ == 'SimplePyClass'");
         py_assert!(py, tup, "type(tup[0]).__name__ == type(tup[1]).__name__");
@@ -90,67 +89,70 @@ fn intopytuple_pyclass() {
 
 #[test]
 fn pytuple_primitive_iter() {
-    Python::with_gil(|py| {
-        let tup = PyTuple::new_bound(py, [1u32, 2, 3].iter());
+    Python::attach(|py| {
+        let tup = PyTuple::new(py, [1u32, 2, 3].iter()).unwrap();
         py_assert!(py, tup, "tup == (1, 2, 3)");
     });
 }
 
 #[test]
 fn pytuple_pyclass_iter() {
-    Python::with_gil(|py| {
-        let tup = PyTuple::new_bound(
+    Python::attach(|py| {
+        let tup = PyTuple::new(
             py,
             [
-                PyCell::new(py, SimplePyClass {}).unwrap(),
-                PyCell::new(py, SimplePyClass {}).unwrap(),
+                Py::new(py, SimplePyClass {}).unwrap(),
+                Py::new(py, SimplePyClass {}).unwrap(),
             ]
             .iter(),
-        );
+        )
+        .unwrap();
         py_assert!(py, tup, "type(tup[0]).__name__ == 'SimplePyClass'");
         py_assert!(py, tup, "type(tup[0]).__name__ == type(tup[0]).__name__");
         py_assert!(py, tup, "tup[0] != tup[1]");
     });
 }
 
-#[pyclass(dict, module = "test_module")]
-struct PickleSupport {}
-
-#[pymethods]
-impl PickleSupport {
-    #[new]
-    fn new() -> PickleSupport {
-        PickleSupport {}
+#[test]
+#[cfg(any(Py_3_9, not(Py_LIMITED_API)))]
+fn test_pickle() {
+    use pyo3::types::PyDict;
+
+    #[pyclass(dict, module = "test_module")]
+    struct PickleSupport {}
+
+    #[pymethods]
+    impl PickleSupport {
+        #[new]
+        fn new() -> PickleSupport {
+            PickleSupport {}
+        }
+
+        pub fn __reduce__<'py>(
+            slf: &Bound<'py, Self>,
+            py: Python<'py>,
+        ) -> PyResult<(Bound<'py, PyAny>, Bound<'py, PyTuple>, Bound<'py, PyAny>)> {
+            let cls = slf.getattr("__class__")?;
+            let dict = slf.getattr("__dict__")?;
+            Ok((cls, PyTuple::empty(py), dict))
+        }
     }
 
-    pub fn __reduce__<'py>(
-        slf: &'py PyCell<Self>,
-        py: Python<'py>,
-    ) -> PyResult<(PyObject, Bound<'py, PyTuple>, PyObject)> {
-        let cls = slf.to_object(py).getattr(py, "__class__")?;
-        let dict = slf.to_object(py).getattr(py, "__dict__")?;
-        Ok((cls, PyTuple::empty_bound(py), dict))
+    fn add_module(module: Bound<'_, PyModule>) -> PyResult<()> {
+        PyModule::import(module.py(), "sys")?
+            .dict()
+            .get_item("modules")
+            .unwrap()
+            .unwrap()
+            .cast::<PyDict>()?
+            .set_item(module.name()?, module)
     }
-}
-
-fn add_module(py: Python<'_>, module: &PyModule) -> PyResult<()> {
-    py.import_bound("sys")?
-        .dict()
-        .get_item("modules")
-        .unwrap()
-        .unwrap()
-        .downcast::<PyDict>()?
-        .set_item(module.name()?, module)
-}
 
-#[test]
-#[cfg_attr(all(Py_LIMITED_API, not(Py_3_10)), ignore)]
-fn test_pickle() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let module = PyModule::new(py, "test_module").unwrap();
         module.add_class::<PickleSupport>().unwrap();
-        add_module(py, module).unwrap();
-        let inst = PyCell::new(py, PickleSupport {}).unwrap();
+        add_module(module).unwrap();
+        let inst = Py::new(py, PickleSupport {}).unwrap();
         py_run!(
             py,
             inst,
@@ -200,7 +202,7 @@ fn result_conversion_function() -> Result<(), MyError> {
 
 #[test]
 fn test_result_conversion() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         wrap_pyfunction!(result_conversion_function)(py).unwrap();
     });
 }
diff --git a/tests/test_wrap_pyfunction_deduction.rs b/tests/test_wrap_pyfunction_deduction.rs
deleted file mode 100644
index 8723ad43fbd..00000000000
--- a/tests/test_wrap_pyfunction_deduction.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-#![cfg(feature = "macros")]
-
-use pyo3::{prelude::*, types::PyCFunction};
-
-#[pyfunction]
-fn f() {}
-
-pub fn add_wrapped(wrapper: &impl Fn(Python<'_>) -> PyResult<&PyCFunction>) {
-    let _ = wrapper;
-}
-
-#[test]
-fn wrap_pyfunction_deduction() {
-    add_wrapped(wrap_pyfunction!(f));
-}
diff --git a/tests/ui/abi3_dict.rs b/tests/ui/abi3_dict.rs
new file mode 100644
index 00000000000..764a4d415a7
--- /dev/null
+++ b/tests/ui/abi3_dict.rs
@@ -0,0 +1,7 @@
+//! With abi3, dict not supported until python 3.9 or greater
+use pyo3::prelude::*;
+
+#[pyclass(dict)]
+struct TestClass {}
+
+fn main() {}
diff --git a/tests/ui/abi3_dict.stderr b/tests/ui/abi3_dict.stderr
new file mode 100644
index 00000000000..5887d5aa84a
--- /dev/null
+++ b/tests/ui/abi3_dict.stderr
@@ -0,0 +1,5 @@
+error: `dict` requires Python >= 3.9 when using the `abi3` feature
+ --> tests/ui/abi3_dict.rs:4:11
+  |
+4 | #[pyclass(dict)]
+  |           ^^^^
diff --git a/tests/ui/abi3_inheritance.rs b/tests/ui/abi3_inheritance.rs
new file mode 100644
index 00000000000..60972e4cf7a
--- /dev/null
+++ b/tests/ui/abi3_inheritance.rs
@@ -0,0 +1,10 @@
+use pyo3::exceptions::PyException;
+use pyo3::prelude::*;
+
+#[pyclass(extends=PyException)]
+#[derive(Clone)]
+struct MyException {
+    code: u32,
+}
+
+fn main() {}
diff --git a/tests/ui/abi3_inheritance.stderr b/tests/ui/abi3_inheritance.stderr
new file mode 100644
index 00000000000..309b67a633d
--- /dev/null
+++ b/tests/ui/abi3_inheritance.stderr
@@ -0,0 +1,27 @@
+error[E0277]: pyclass `PyException` cannot be subclassed
+ --> tests/ui/abi3_inheritance.rs:4:19
+  |
+4 | #[pyclass(extends=PyException)]
+  |                   ^^^^^^^^^^^ required for `#[pyclass(extends=PyException)]`
+  |
+  = help: the trait `PyClassBaseType` is not implemented for `PyException`
+  = note: `PyException` must have `#[pyclass(subclass)]` to be eligible for subclassing
+  = note: with the `abi3` feature enabled, PyO3 does not support subclassing native types
+  = help: the trait `PyClassBaseType` is implemented for `PyAny`
+note: required by a bound in `PyClassImpl::BaseType`
+ --> src/impl_/pyclass.rs
+  |
+  |     type BaseType: PyTypeInfo + PyClassBaseType;
+  |                                 ^^^^^^^^^^^^^^^ required by this bound in `PyClassImpl::BaseType`
+
+error[E0277]: pyclass `PyException` cannot be subclassed
+ --> tests/ui/abi3_inheritance.rs:4:1
+  |
+4 | #[pyclass(extends=PyException)]
+  | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required for `#[pyclass(extends=PyException)]`
+  |
+  = help: the trait `PyClassBaseType` is not implemented for `PyException`
+  = note: `PyException` must have `#[pyclass(subclass)]` to be eligible for subclassing
+  = note: with the `abi3` feature enabled, PyO3 does not support subclassing native types
+  = help: the trait `PyClassBaseType` is implemented for `PyAny`
+  = note: this error originates in the attribute macro `pyclass` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/tests/ui/abi3_nativetype_inheritance.stderr b/tests/ui/abi3_nativetype_inheritance.stderr
index f0672fbf0a7..872de60b244 100644
--- a/tests/ui/abi3_nativetype_inheritance.stderr
+++ b/tests/ui/abi3_nativetype_inheritance.stderr
@@ -1,27 +1,27 @@
-error[E0277]: the trait bound `PyDict: PyClass` is not satisfied
- --> tests/ui/abi3_nativetype_inheritance.rs:5:1
-  |
-5 | #[pyclass(extends=PyDict)]
-  | ^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `PyClass` is not implemented for `PyDict`
-  |
-  = help: the following other types implement trait `PyClass`:
-            TestClass
-            pyo3::coroutine::Coroutine
-  = note: required for `PyDict` to implement `PyClassBaseType`
-  = note: this error originates in the attribute macro `pyclass` (in Nightly builds, run with -Z macro-backtrace for more info)
-
-error[E0277]: the trait bound `PyDict: PyClass` is not satisfied
+error[E0277]: pyclass `PyDict` cannot be subclassed
  --> tests/ui/abi3_nativetype_inheritance.rs:5:19
   |
 5 | #[pyclass(extends=PyDict)]
-  |                   ^^^^^^ the trait `PyClass` is not implemented for `PyDict`
+  |                   ^^^^^^ required for `#[pyclass(extends=PyDict)]`
   |
-  = help: the following other types implement trait `PyClass`:
-            TestClass
-            pyo3::coroutine::Coroutine
-  = note: required for `PyDict` to implement `PyClassBaseType`
+  = help: the trait `PyClassBaseType` is not implemented for `PyDict`
+  = note: `PyDict` must have `#[pyclass(subclass)]` to be eligible for subclassing
+  = note: with the `abi3` feature enabled, PyO3 does not support subclassing native types
+  = help: the trait `PyClassBaseType` is implemented for `PyAny`
 note: required by a bound in `PyClassImpl::BaseType`
  --> src/impl_/pyclass.rs
   |
   |     type BaseType: PyTypeInfo + PyClassBaseType;
   |                                 ^^^^^^^^^^^^^^^ required by this bound in `PyClassImpl::BaseType`
+
+error[E0277]: pyclass `PyDict` cannot be subclassed
+ --> tests/ui/abi3_nativetype_inheritance.rs:5:1
+  |
+5 | #[pyclass(extends=PyDict)]
+  | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required for `#[pyclass(extends=PyDict)]`
+  |
+  = help: the trait `PyClassBaseType` is not implemented for `PyDict`
+  = note: `PyDict` must have `#[pyclass(subclass)]` to be eligible for subclassing
+  = note: with the `abi3` feature enabled, PyO3 does not support subclassing native types
+  = help: the trait `PyClassBaseType` is implemented for `PyAny`
+  = note: this error originates in the attribute macro `pyclass` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/tests/ui/abi3_weakref.rs b/tests/ui/abi3_weakref.rs
new file mode 100644
index 00000000000..f45b2258c96
--- /dev/null
+++ b/tests/ui/abi3_weakref.rs
@@ -0,0 +1,7 @@
+//! With abi3, weakref not supported until python 3.9 or greater
+use pyo3::prelude::*;
+
+#[pyclass(weakref)]
+struct TestClass {}
+
+fn main() {}
diff --git a/tests/ui/abi3_weakref.stderr b/tests/ui/abi3_weakref.stderr
new file mode 100644
index 00000000000..b8ef3936cdb
--- /dev/null
+++ b/tests/ui/abi3_weakref.stderr
@@ -0,0 +1,5 @@
+error: `weakref` requires Python >= 3.9 when using the `abi3` feature
+ --> tests/ui/abi3_weakref.rs:4:11
+  |
+4 | #[pyclass(weakref)]
+  |           ^^^^^^^
diff --git a/tests/ui/ambiguous_associated_items.rs b/tests/ui/ambiguous_associated_items.rs
new file mode 100644
index 00000000000..34ebd931ce3
--- /dev/null
+++ b/tests/ui/ambiguous_associated_items.rs
@@ -0,0 +1,25 @@
+use pyo3::prelude::*;
+
+#[pyclass(eq)]
+#[derive(PartialEq)]
+pub enum SimpleItems {
+    Error,
+    Output,
+    Target,
+}
+
+#[pyclass]
+pub enum ComplexItems {
+    Error(Py<PyAny>),
+    Output(Py<PyAny>),
+    Target(Py<PyAny>),
+}
+
+#[derive(IntoPyObject)]
+enum DeriveItems {
+    Error(Py<PyAny>),
+    Output(Py<PyAny>),
+    Target(Py<PyAny>),
+}
+
+fn main() {}
diff --git a/tests/ui/deprecated_pyfn.rs b/tests/ui/deprecated_pyfn.rs
new file mode 100644
index 00000000000..1c5edbafd31
--- /dev/null
+++ b/tests/ui/deprecated_pyfn.rs
@@ -0,0 +1,13 @@
+#![deny(deprecated)]
+
+use pyo3::prelude::*;
+
+#[pymodule]
+fn module_with_pyfn(m: &Bound<'_, PyModule>) -> PyResult<()> {
+    #[pyfn(m)]
+    fn foo() {}
+
+    Ok(())
+}
+
+fn main() {}
diff --git a/tests/ui/deprecated_pyfn.stderr b/tests/ui/deprecated_pyfn.stderr
new file mode 100644
index 00000000000..c5dd0b3b4ac
--- /dev/null
+++ b/tests/ui/deprecated_pyfn.stderr
@@ -0,0 +1,11 @@
+error: use of deprecated constant `module_with_pyfn::PYFN_ATTRIBUTE`: `pyfn` will be removed in a future PyO3 version, use declarative `#[pymodule]` with `mod` instead
+ --> tests/ui/deprecated_pyfn.rs:7:7
+  |
+7 |     #[pyfn(m)]
+  |       ^^^^
+  |
+note: the lint level is defined here
+ --> tests/ui/deprecated_pyfn.rs:1:9
+  |
+1 | #![deny(deprecated)]
+  |         ^^^^^^^^^^
diff --git a/tests/ui/deprecations.rs b/tests/ui/deprecations.rs
deleted file mode 100644
index 4177dd6da22..00000000000
--- a/tests/ui/deprecations.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-#![deny(deprecated)]
-
-use pyo3::prelude::*;
-
-#[pyclass]
-struct MyClass;
-
-#[pymethods]
-impl MyClass {
-    #[__new__]
-    fn new() -> Self {
-        Self
-    }
-}
-
-fn main() {}
diff --git a/tests/ui/deprecations.stderr b/tests/ui/deprecations.stderr
deleted file mode 100644
index a857b5ee420..00000000000
--- a/tests/ui/deprecations.stderr
+++ /dev/null
@@ -1,11 +0,0 @@
-error: use of deprecated constant `pyo3::impl_::deprecations::PYMETHODS_NEW_DEPRECATED_FORM`: use `#[new]` instead of `#[__new__]`
-  --> tests/ui/deprecations.rs:10:7
-   |
-10 |     #[__new__]
-   |       ^^^^^^^
-   |
-note: the lint level is defined here
-  --> tests/ui/deprecations.rs:1:9
-   |
-1  | #![deny(deprecated)]
-   |         ^^^^^^^^^^
diff --git a/tests/ui/duplicate_pymodule_submodule.rs b/tests/ui/duplicate_pymodule_submodule.rs
new file mode 100644
index 00000000000..774d3819645
--- /dev/null
+++ b/tests/ui/duplicate_pymodule_submodule.rs
@@ -0,0 +1,7 @@
+#[pyo3::pymodule]
+mod mymodule {
+	#[pyo3::pymodule(submodule)]
+	mod submod {}
+}
+
+fn main() {}
diff --git a/tests/ui/duplicate_pymodule_submodule.stderr b/tests/ui/duplicate_pymodule_submodule.stderr
new file mode 100644
index 00000000000..a2141b0dcd3
--- /dev/null
+++ b/tests/ui/duplicate_pymodule_submodule.stderr
@@ -0,0 +1,17 @@
+error: `submodule` may only be specified once (it is implicitly always specified for nested modules)
+ --> tests/ui/duplicate_pymodule_submodule.rs:4:2
+  |
+4 |     mod submod {}
+  |     ^^^
+
+error[E0425]: cannot find value `_PYO3_DEF` in module `submod`
+ --> tests/ui/duplicate_pymodule_submodule.rs:1:1
+  |
+1 | #[pyo3::pymodule]
+  | ^^^^^^^^^^^^^^^^^ not found in `submod`
+  |
+  = note: this error originates in the attribute macro `pyo3::pymodule` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: consider importing this static
+  |
+3 +     use crate::mymodule::_PYO3_DEF;
+  |
diff --git a/tests/ui/empty.rs b/tests/ui/empty.rs
new file mode 100644
index 00000000000..be89c636426
--- /dev/null
+++ b/tests/ui/empty.rs
@@ -0,0 +1 @@
+// see invalid_pymodule_in_root.rs
diff --git a/tests/ui/forbid_unsafe.rs b/tests/ui/forbid_unsafe.rs
new file mode 100644
index 00000000000..1966ab99a8f
--- /dev/null
+++ b/tests/ui/forbid_unsafe.rs
@@ -0,0 +1,43 @@
+#![forbid(unsafe_code)]
+#![forbid(unsafe_op_in_unsafe_fn)]
+
+use pyo3::*;
+
+#[allow(unexpected_cfgs)]
+#[path = "../../src/tests/hygiene/mod.rs"]
+mod hygiene;
+
+mod gh_4394 {
+    use pyo3::prelude::*;
+
+    #[derive(Eq, Ord, PartialEq, PartialOrd, Clone)]
+    #[pyclass(get_all)]
+    pub struct VersionSpecifier {
+        pub(crate) operator: Operator,
+        pub(crate) version: Version,
+    }
+
+    #[derive(Eq, Ord, PartialEq, PartialOrd, Debug, Hash, Clone, Copy)]
+    #[pyo3::pyclass(eq, eq_int)]
+    pub enum Operator {
+        Equal,
+    }
+
+    #[derive(Clone, Eq, PartialEq, PartialOrd, Ord)]
+    #[pyclass]
+    pub struct Version;
+}
+
+mod from_py_with {
+    use pyo3::prelude::*;
+    use pyo3::types::PyBytes;
+
+    fn bytes_from_py(bytes: &Bound<'_, PyAny>) -> PyResult<Vec<u8>> {
+        Ok(bytes.cast::<PyBytes>()?.as_bytes().to_vec())
+    }
+
+    #[pyfunction]
+    fn f(#[pyo3(from_py_with = bytes_from_py)] _bytes: Vec<u8>) {}
+}
+
+fn main() {}
diff --git a/tests/ui/immutable_type.rs b/tests/ui/immutable_type.rs
new file mode 100644
index 00000000000..a311eb5b249
--- /dev/null
+++ b/tests/ui/immutable_type.rs
@@ -0,0 +1,6 @@
+use pyo3::prelude::*;
+
+#[pyclass(immutable_type)]
+struct ImmutableType {}
+
+fn main() {}
diff --git a/tests/ui/immutable_type.stderr b/tests/ui/immutable_type.stderr
new file mode 100644
index 00000000000..45696c747a1
--- /dev/null
+++ b/tests/ui/immutable_type.stderr
@@ -0,0 +1,5 @@
+error: `immutable_type` requires Python >= 3.10 or >= 3.14 (ABI3)
+ --> tests/ui/immutable_type.rs:3:11
+  |
+3 | #[pyclass(immutable_type)]
+  |           ^^^^^^^^^^^^^^
diff --git a/tests/ui/invalid_annotation.rs b/tests/ui/invalid_annotation.rs
new file mode 100644
index 00000000000..d8b803550ca
--- /dev/null
+++ b/tests/ui/invalid_annotation.rs
@@ -0,0 +1,9 @@
+use pyo3::prelude::*;
+
+#[pyfunction]
+#[pyo3(signature = (a: "int"))]
+fn check(a: usize) -> usize {
+    a
+}
+
+fn main() {}
diff --git a/tests/ui/invalid_annotation.stderr b/tests/ui/invalid_annotation.stderr
new file mode 100644
index 00000000000..ff2981b4818
--- /dev/null
+++ b/tests/ui/invalid_annotation.stderr
@@ -0,0 +1,5 @@
+error: Type annotations in the signature is only supported with the `experimental-inspect` feature
+ --> tests/ui/invalid_annotation.rs:4:24
+  |
+4 | #[pyo3(signature = (a: "int"))]
+  |                        ^^^^^
diff --git a/tests/ui/invalid_annotation_return.rs b/tests/ui/invalid_annotation_return.rs
new file mode 100644
index 00000000000..5cb4298ec8b
--- /dev/null
+++ b/tests/ui/invalid_annotation_return.rs
@@ -0,0 +1,9 @@
+use pyo3::prelude::*;
+
+#[pyfunction]
+#[pyo3(signature = (a) -> "int")]
+fn check(a: usize) -> usize {
+    a
+}
+
+fn main() {}
diff --git a/tests/ui/invalid_annotation_return.stderr b/tests/ui/invalid_annotation_return.stderr
new file mode 100644
index 00000000000..2a70079f82d
--- /dev/null
+++ b/tests/ui/invalid_annotation_return.stderr
@@ -0,0 +1,5 @@
+error: Return type annotation in the signature is only supported with the `experimental-inspect` feature
+ --> tests/ui/invalid_annotation_return.rs:4:27
+  |
+4 | #[pyo3(signature = (a) -> "int")]
+  |                           ^^^^^
diff --git a/tests/ui/invalid_argument_attributes.rs b/tests/ui/invalid_argument_attributes.rs
index ed9d6ce6971..e4066e5fd9c 100644
--- a/tests/ui/invalid_argument_attributes.rs
+++ b/tests/ui/invalid_argument_attributes.rs
@@ -1,43 +1,25 @@
 use pyo3::prelude::*;
 
 #[pyfunction]
-fn invalid_attribute(#[pyo3(get)] param: String) {}
+fn invalid_attribute(#[pyo3(get)] _param: String) {}
 
 #[pyfunction]
-fn from_py_with_no_value(#[pyo3(from_py_with)] param: String) {}
+fn from_py_with_no_value(#[pyo3(from_py_with)] _param: String) {}
 
 #[pyfunction]
-fn from_py_with_string(#[pyo3("from_py_with")] param: String) {}
+fn from_py_with_string(#[pyo3("from_py_with")] _param: String) {}
 
 #[pyfunction]
-fn from_py_with_value_not_a_string(#[pyo3(from_py_with = func)] param: String) {}
+fn from_py_with_value_not_found(#[pyo3(from_py_with = func)] _param: String) {}
 
 #[pyfunction]
-fn from_py_with_repeated(#[pyo3(from_py_with = "func", from_py_with = "func")] param: String) {}
+fn from_py_with_repeated(#[pyo3(from_py_with = func, from_py_with = func)] _param: String) {}
 
-#[pyfunction]
-async fn from_py_with_value_and_cancel_handle(
-    #[pyo3(from_py_with = "func", cancel_handle)] _param: String,
-) {
-}
-
-#[pyfunction]
-async fn cancel_handle_repeated(#[pyo3(cancel_handle, cancel_handle)] _param: String) {}
-
-#[pyfunction]
-async fn cancel_handle_repeated2(
-    #[pyo3(cancel_handle)] _param: String,
-    #[pyo3(cancel_handle)] _param2: String,
-) {
+fn bytes_from_py(bytes: &Bound<'_, pyo3::types::PyBytes>) -> Vec<u8> {
+    bytes.as_bytes().to_vec()
 }
 
 #[pyfunction]
-fn cancel_handle_synchronous(#[pyo3(cancel_handle)] _param: String) {}
-
-#[pyfunction]
-async fn cancel_handle_wrong_type(#[pyo3(cancel_handle)] _param: String) {}
-
-#[pyfunction]
-async fn missing_cancel_handle_attribute(_param: pyo3::coroutine::CancelHandle) {}
+fn f(#[pyo3(from_py_with = "bytes_from_py")] _bytes: Vec<u8>) {}
 
 fn main() {}
diff --git a/tests/ui/invalid_argument_attributes.stderr b/tests/ui/invalid_argument_attributes.stderr
index c122dd25f8c..d59558c16b9 100644
--- a/tests/ui/invalid_argument_attributes.stderr
+++ b/tests/ui/invalid_argument_attributes.stderr
@@ -1,108 +1,35 @@
 error: expected `cancel_handle` or `from_py_with`
  --> tests/ui/invalid_argument_attributes.rs:4:29
   |
-4 | fn invalid_attribute(#[pyo3(get)] param: String) {}
+4 | fn invalid_attribute(#[pyo3(get)] _param: String) {}
   |                             ^^^
 
 error: expected `=`
  --> tests/ui/invalid_argument_attributes.rs:7:45
   |
-7 | fn from_py_with_no_value(#[pyo3(from_py_with)] param: String) {}
+7 | fn from_py_with_no_value(#[pyo3(from_py_with)] _param: String) {}
   |                                             ^
 
 error: expected `cancel_handle` or `from_py_with`
   --> tests/ui/invalid_argument_attributes.rs:10:31
    |
-10 | fn from_py_with_string(#[pyo3("from_py_with")] param: String) {}
+10 | fn from_py_with_string(#[pyo3("from_py_with")] _param: String) {}
    |                               ^^^^^^^^^^^^^^
 
-error: expected string literal
-  --> tests/ui/invalid_argument_attributes.rs:13:58
-   |
-13 | fn from_py_with_value_not_a_string(#[pyo3(from_py_with = func)] param: String) {}
-   |                                                          ^^^^
-
 error: `from_py_with` may only be specified once per argument
-  --> tests/ui/invalid_argument_attributes.rs:16:56
-   |
-16 | fn from_py_with_repeated(#[pyo3(from_py_with = "func", from_py_with = "func")] param: String) {}
-   |                                                        ^^^^^^^^^^^^
-
-error: `from_py_with` and `cancel_handle` cannot be specified together
-  --> tests/ui/invalid_argument_attributes.rs:20:35
-   |
-20 |     #[pyo3(from_py_with = "func", cancel_handle)] _param: String,
-   |                                   ^^^^^^^^^^^^^
-
-error: `cancel_handle` may only be specified once per argument
-  --> tests/ui/invalid_argument_attributes.rs:25:55
-   |
-25 | async fn cancel_handle_repeated(#[pyo3(cancel_handle, cancel_handle)] _param: String) {}
-   |                                                       ^^^^^^^^^^^^^
-
-error: `cancel_handle` may only be specified once
-  --> tests/ui/invalid_argument_attributes.rs:30:28
-   |
-30 |     #[pyo3(cancel_handle)] _param2: String,
-   |                            ^^^^^^^
-
-error: `cancel_handle` attribute can only be used with `async fn`
-  --> tests/ui/invalid_argument_attributes.rs:35:53
+  --> tests/ui/invalid_argument_attributes.rs:16:54
    |
-35 | fn cancel_handle_synchronous(#[pyo3(cancel_handle)] _param: String) {}
-   |                                                     ^^^^^^
+16 | fn from_py_with_repeated(#[pyo3(from_py_with = func, from_py_with = func)] _param: String) {}
+   |                                                      ^^^^^^^^^^^^
 
-error[E0308]: mismatched types
-  --> tests/ui/invalid_argument_attributes.rs:37:1
-   |
-37 | #[pyfunction]
-   | ^^^^^^^^^^^^^
-   | |
-   | expected `String`, found `CancelHandle`
-   | arguments to this function are incorrect
-   |
-note: function defined here
-  --> tests/ui/invalid_argument_attributes.rs:38:10
+error: expected identifier
+  --> tests/ui/invalid_argument_attributes.rs:23:28
    |
-38 | async fn cancel_handle_wrong_type(#[pyo3(cancel_handle)] _param: String) {}
-   |          ^^^^^^^^^^^^^^^^^^^^^^^^                        --------------
-   = note: this error originates in the attribute macro `pyfunction` (in Nightly builds, run with -Z macro-backtrace for more info)
+23 | fn f(#[pyo3(from_py_with = "bytes_from_py")] _bytes: Vec<u8>) {}
+   |                            ^^^^^^^^^^^^^^^
 
-error[E0277]: the trait bound `CancelHandle: PyClass` is not satisfied
-  --> tests/ui/invalid_argument_attributes.rs:41:50
-   |
-41 | async fn missing_cancel_handle_attribute(_param: pyo3::coroutine::CancelHandle) {}
-   |                                                  ^^^^ the trait `PyClass` is not implemented for `CancelHandle`
-   |
-   = help: the trait `PyClass` is implemented for `pyo3::coroutine::Coroutine`
-   = note: required for `CancelHandle` to implement `FromPyObject<'_>`
-   = note: required for `CancelHandle` to implement `PyFunctionArgument<'_, '_>`
-note: required by a bound in `extract_argument`
-  --> src/impl_/extract_argument.rs
-   |
-   | pub fn extract_argument<'a, 'py, T>(
-   |        ---------------- required by a bound in this function
-...
-   |     T: PyFunctionArgument<'a, 'py>,
-   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `extract_argument`
-
-error[E0277]: the trait bound `CancelHandle: Clone` is not satisfied
-  --> tests/ui/invalid_argument_attributes.rs:41:50
-   |
-41 | async fn missing_cancel_handle_attribute(_param: pyo3::coroutine::CancelHandle) {}
-   |                                                  ^^^^ the trait `Clone` is not implemented for `CancelHandle`
-   |
-   = help: the following other types implement trait `PyFunctionArgument<'a, 'py>`:
-             &'a pyo3::Bound<'py, T>
-             &'a pyo3::coroutine::Coroutine
-             &'a mut pyo3::coroutine::Coroutine
-   = note: required for `CancelHandle` to implement `FromPyObject<'_>`
-   = note: required for `CancelHandle` to implement `PyFunctionArgument<'_, '_>`
-note: required by a bound in `extract_argument`
-  --> src/impl_/extract_argument.rs
+error[E0425]: cannot find value `func` in this scope
+  --> tests/ui/invalid_argument_attributes.rs:13:55
    |
-   | pub fn extract_argument<'a, 'py, T>(
-   |        ---------------- required by a bound in this function
-...
-   |     T: PyFunctionArgument<'a, 'py>,
-   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `extract_argument`
+13 | fn from_py_with_value_not_found(#[pyo3(from_py_with = func)] _param: String) {}
+   |                                                       ^^^^ not found in this scope
diff --git a/tests/ui/invalid_async.rs b/tests/ui/invalid_async.rs
new file mode 100644
index 00000000000..2c7375fd2f9
--- /dev/null
+++ b/tests/ui/invalid_async.rs
@@ -0,0 +1,20 @@
+use pyo3::prelude::*;
+
+#[pyfunction]
+async fn check(){}
+
+#[pyclass]
+pub(crate) struct AsyncRange {
+    count: i32,
+    target: i32,
+}
+#[pymethods]
+impl AsyncRange {
+    async fn __anext__(mut _pyself: PyRefMut<'_, Self>) -> PyResult<i32> {
+        Ok(0)
+    }
+
+    async fn foo(&self) {}
+}
+
+fn main() {}
\ No newline at end of file
diff --git a/tests/ui/invalid_async.stderr b/tests/ui/invalid_async.stderr
new file mode 100644
index 00000000000..0bf9f53f8c3
--- /dev/null
+++ b/tests/ui/invalid_async.stderr
@@ -0,0 +1,17 @@
+error: async functions are only supported with the `experimental-async` feature
+ --> tests/ui/invalid_async.rs:4:1
+  |
+4 | async fn check(){}
+  | ^^^^^
+
+error: async functions are only supported with the `experimental-async` feature
+  --> tests/ui/invalid_async.rs:13:5
+   |
+13 |     async fn __anext__(mut _pyself: PyRefMut<'_, Self>) -> PyResult<i32> {
+   |     ^^^^^
+
+error: async functions are only supported with the `experimental-async` feature
+  --> tests/ui/invalid_async.rs:17:5
+   |
+17 |     async fn foo(&self) {}
+   |     ^^^^^
diff --git a/tests/ui/invalid_base_class.rs b/tests/ui/invalid_base_class.rs
new file mode 100644
index 00000000000..7433dcb2b96
--- /dev/null
+++ b/tests/ui/invalid_base_class.rs
@@ -0,0 +1,7 @@
+use pyo3::prelude::*;
+use pyo3::types::PyBool;
+
+#[pyclass(extends=PyBool)]
+struct ExtendsBool;
+
+fn main() {}
diff --git a/tests/ui/invalid_base_class.stderr b/tests/ui/invalid_base_class.stderr
new file mode 100644
index 00000000000..c40bed9eaa6
--- /dev/null
+++ b/tests/ui/invalid_base_class.stderr
@@ -0,0 +1,43 @@
+error[E0277]: pyclass `PyBool` cannot be subclassed
+ --> tests/ui/invalid_base_class.rs:4:19
+  |
+4 | #[pyclass(extends=PyBool)]
+  |                   ^^^^^^ required for `#[pyclass(extends=PyBool)]`
+  |
+  = help: the trait `PyClassBaseType` is not implemented for `PyBool`
+  = note: `PyBool` must have `#[pyclass(subclass)]` to be eligible for subclassing
+  = help: the following other types implement trait `PyClassBaseType`:
+            PyAny
+            PyArithmeticError
+            PyAssertionError
+            PyAttributeError
+            PyBaseException
+            PyBaseExceptionGroup
+            PyBlockingIOError
+            PyBrokenPipeError
+          and $N others
+note: required by a bound in `PyClassImpl::BaseType`
+ --> src/impl_/pyclass.rs
+  |
+  |     type BaseType: PyTypeInfo + PyClassBaseType;
+  |                                 ^^^^^^^^^^^^^^^ required by this bound in `PyClassImpl::BaseType`
+
+error[E0277]: pyclass `PyBool` cannot be subclassed
+ --> tests/ui/invalid_base_class.rs:4:1
+  |
+4 | #[pyclass(extends=PyBool)]
+  | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required for `#[pyclass(extends=PyBool)]`
+  |
+  = help: the trait `PyClassBaseType` is not implemented for `PyBool`
+  = note: `PyBool` must have `#[pyclass(subclass)]` to be eligible for subclassing
+  = help: the following other types implement trait `PyClassBaseType`:
+            PyAny
+            PyArithmeticError
+            PyAssertionError
+            PyAttributeError
+            PyBaseException
+            PyBaseExceptionGroup
+            PyBlockingIOError
+            PyBrokenPipeError
+          and $N others
+  = note: this error originates in the attribute macro `pyclass` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/tests/ui/invalid_cancel_handle.rs b/tests/ui/invalid_cancel_handle.rs
new file mode 100644
index 00000000000..b61397d4161
--- /dev/null
+++ b/tests/ui/invalid_cancel_handle.rs
@@ -0,0 +1,28 @@
+use pyo3::prelude::*;
+
+#[pyfunction]
+async fn cancel_handle_repeated(#[pyo3(cancel_handle, cancel_handle)] _param: String) {}
+
+#[pyfunction]
+async fn cancel_handle_repeated2(
+    #[pyo3(cancel_handle)] _param: String,
+    #[pyo3(cancel_handle)] _param2: String,
+) {
+}
+
+#[pyfunction]
+fn cancel_handle_synchronous(#[pyo3(cancel_handle)] _param: String) {}
+
+#[pyfunction]
+async fn cancel_handle_wrong_type(#[pyo3(cancel_handle)] _param: String) {}
+
+#[pyfunction]
+async fn missing_cancel_handle_attribute(_param: pyo3::coroutine::CancelHandle) {}
+
+#[pyfunction]
+async fn cancel_handle_and_from_py_with(
+    #[pyo3(cancel_handle, from_py_with = cancel_handle)] _param: pyo3::coroutine::CancelHandle,
+) {
+}
+
+fn main() {}
diff --git a/tests/ui/invalid_cancel_handle.stderr b/tests/ui/invalid_cancel_handle.stderr
new file mode 100644
index 00000000000..8fdea4c951a
--- /dev/null
+++ b/tests/ui/invalid_cancel_handle.stderr
@@ -0,0 +1,97 @@
+error: `cancel_handle` may only be specified once per argument
+ --> tests/ui/invalid_cancel_handle.rs:4:55
+  |
+4 | async fn cancel_handle_repeated(#[pyo3(cancel_handle, cancel_handle)] _param: String) {}
+  |                                                       ^^^^^^^^^^^^^
+
+error: `cancel_handle` may only be specified once
+ --> tests/ui/invalid_cancel_handle.rs:9:28
+  |
+9 |     #[pyo3(cancel_handle)] _param2: String,
+  |                            ^^^^^^^
+
+error: `cancel_handle` attribute can only be used with `async fn`
+  --> tests/ui/invalid_cancel_handle.rs:14:53
+   |
+14 | fn cancel_handle_synchronous(#[pyo3(cancel_handle)] _param: String) {}
+   |                                                     ^^^^^^
+
+error: `from_py_with` and `cancel_handle` cannot be specified together
+  --> tests/ui/invalid_cancel_handle.rs:24:12
+   |
+24 |     #[pyo3(cancel_handle, from_py_with = cancel_handle)] _param: pyo3::coroutine::CancelHandle,
+   |            ^^^^^^^^^^^^^
+
+error[E0308]: mismatched types
+  --> tests/ui/invalid_cancel_handle.rs:16:1
+   |
+16 | #[pyfunction]
+   | ^^^^^^^^^^^^^
+   | |
+   | expected `String`, found `CancelHandle`
+   | arguments to this function are incorrect
+   |
+note: function defined here
+  --> tests/ui/invalid_cancel_handle.rs:17:10
+   |
+17 | async fn cancel_handle_wrong_type(#[pyo3(cancel_handle)] _param: String) {}
+   |          ^^^^^^^^^^^^^^^^^^^^^^^^                        --------------
+   = note: this error originates in the attribute macro `pyfunction` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0277]: `CancelHandle` cannot be used as a Python function argument
+  --> tests/ui/invalid_cancel_handle.rs:20:50
+   |
+20 | async fn missing_cancel_handle_attribute(_param: pyo3::coroutine::CancelHandle) {}
+   |                                                  ^^^^ the trait `PyClass` is not implemented for `CancelHandle`
+   |
+   = note: implement `FromPyObject` to enable using `CancelHandle` as a function argument
+   = note: `Python<'py>` is also a valid argument type to pass the Python token into `#[pyfunction]`s and `#[pymethods]`
+   = help: the trait `PyClass` is implemented for `pyo3::coroutine::Coroutine`
+   = note: required for `CancelHandle` to implement `FromPyObject<'_, '_>`
+   = note: required for `CancelHandle` to implement `PyFunctionArgument<'_, '_, '_, true>`
+note: required by a bound in `extract_argument`
+  --> src/impl_/extract_argument.rs
+   |
+   | pub fn extract_argument<'a, 'holder, 'py, T, const IMPLEMENTS_FROMPYOBJECT: bool>(
+   |        ---------------- required by a bound in this function
+...
+   |     T: PyFunctionArgument<'a, 'holder, 'py, IMPLEMENTS_FROMPYOBJECT>,
+   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `extract_argument`
+
+error[E0277]: `CancelHandle` cannot be used as a Python function argument
+  --> tests/ui/invalid_cancel_handle.rs:20:50
+   |
+20 | async fn missing_cancel_handle_attribute(_param: pyo3::coroutine::CancelHandle) {}
+   |                                                  ^^^^ the trait `Clone` is not implemented for `CancelHandle`
+   |
+   = note: implement `FromPyObject` to enable using `CancelHandle` as a function argument
+   = note: `Python<'py>` is also a valid argument type to pass the Python token into `#[pyfunction]`s and `#[pymethods]`
+   = help: the following other types implement trait `PyFunctionArgument<'a, 'holder, 'py, IMPLEMENTS_FROMPYOBJECT>`:
+             `&'a pyo3::Bound<'py, T>` implements `PyFunctionArgument<'a, '_, 'py, false>`
+             `&'holder T` implements `PyFunctionArgument<'a, 'holder, '_, false>`
+             `&'holder mut T` implements `PyFunctionArgument<'a, 'holder, '_, false>`
+             `Option<T>` implements `PyFunctionArgument<'a, 'holder, 'py, false>`
+   = note: required for `CancelHandle` to implement `FromPyObject<'_, '_>`
+   = note: required for `CancelHandle` to implement `PyFunctionArgument<'_, '_, '_, true>`
+note: required by a bound in `extract_argument`
+  --> src/impl_/extract_argument.rs
+   |
+   | pub fn extract_argument<'a, 'holder, 'py, T, const IMPLEMENTS_FROMPYOBJECT: bool>(
+   |        ---------------- required by a bound in this function
+...
+   |     T: PyFunctionArgument<'a, 'holder, 'py, IMPLEMENTS_FROMPYOBJECT>,
+   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `extract_argument`
+
+error[E0277]: `CancelHandle` cannot be used as a Python function argument
+  --> tests/ui/invalid_cancel_handle.rs:20:50
+   |
+20 | async fn missing_cancel_handle_attribute(_param: pyo3::coroutine::CancelHandle) {}
+   |                                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `PyFunctionArgument<'_, '_, '_, false>` is not implemented for `CancelHandle`
+   |
+   = note: implement `FromPyObject` to enable using `CancelHandle` as a function argument
+   = note: `Python<'py>` is also a valid argument type to pass the Python token into `#[pyfunction]`s and `#[pymethods]`
+   = help: the following other types implement trait `PyFunctionArgument<'a, 'holder, 'py, IMPLEMENTS_FROMPYOBJECT>`:
+             `&'a pyo3::Bound<'py, T>` implements `PyFunctionArgument<'a, '_, 'py, false>`
+             `&'holder T` implements `PyFunctionArgument<'a, 'holder, '_, false>`
+             `&'holder mut T` implements `PyFunctionArgument<'a, 'holder, '_, false>`
+             `Option<T>` implements `PyFunctionArgument<'a, 'holder, 'py, false>`
diff --git a/tests/ui/invalid_closure.rs b/tests/ui/invalid_closure.rs
index 0613b027665..6dd7d508703 100644
--- a/tests/ui/invalid_closure.rs
+++ b/tests/ui/invalid_closure.rs
@@ -2,20 +2,21 @@ use pyo3::prelude::*;
 use pyo3::types::{PyCFunction, PyDict, PyTuple};
 
 fn main() {
-    let fun: Py<PyCFunction> = Python::with_gil(|py| {
+    let fun: Py<PyCFunction> = Python::attach(|py| {
         let local_data = vec![0, 1, 2, 3, 4];
         let ref_: &[u8] = &local_data;
 
-        let closure_fn = |_args: &PyTuple, _kwargs: Option<&PyDict>| -> PyResult<()> {
-            println!("This is five: {:?}", ref_.len());
-            Ok(())
-        };
-        PyCFunction::new_closure_bound(py, None, None, closure_fn)
+        let closure_fn =
+            |_args: &Bound<'_, PyTuple>, _kwargs: Option<&Bound<'_, PyDict>>| -> PyResult<()> {
+                println!("This is five: {:?}", ref_.len());
+                Ok(())
+            };
+        PyCFunction::new_closure(py, None, None, closure_fn)
             .unwrap()
             .into()
     });
 
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         fun.call0(py).unwrap();
     });
 }
diff --git a/tests/ui/invalid_closure.stderr b/tests/ui/invalid_closure.stderr
index 7fed8908583..7864a898c28 100644
--- a/tests/ui/invalid_closure.stderr
+++ b/tests/ui/invalid_closure.stderr
@@ -1,13 +1,13 @@
 error[E0597]: `local_data` does not live long enough
   --> tests/ui/invalid_closure.rs:7:27
    |
-6  |         let local_data = vec![0, 1, 2, 3, 4];
+ 6 |         let local_data = vec![0, 1, 2, 3, 4];
    |             ---------- binding `local_data` declared here
-7  |         let ref_: &[u8] = &local_data;
+ 7 |         let ref_: &[u8] = &local_data;
    |                           ^^^^^^^^^^^ borrowed value does not live long enough
 ...
-13 |         PyCFunction::new_closure_bound(py, None, None, closure_fn)
-   |         ---------------------------------------------------------- argument requires that `local_data` is borrowed for `'static`
+14 |         PyCFunction::new_closure(py, None, None, closure_fn)
+   |         ---------------------------------------------------- argument requires that `local_data` is borrowed for `'static`
 ...
-16 |     });
+17 |     });
    |     - `local_data` dropped here while still borrowed
diff --git a/tests/ui/invalid_frompy_derive.rs b/tests/ui/invalid_frompy_derive.rs
index f123b149fb8..b6682345d9a 100644
--- a/tests/ui/invalid_frompy_derive.rs
+++ b/tests/ui/invalid_frompy_derive.rs
@@ -160,7 +160,7 @@ struct InvalidFromPyWith {
 }
 
 #[derive(FromPyObject)]
-struct InvalidFromPyWithLiteral {
+struct InvalidFromPyWithNotFound {
     #[pyo3(from_py_with = func)]
     field: String,
 }
@@ -213,4 +213,50 @@ struct FromItemAllConflictAttrWithArgs {
     field: String,
 }
 
+#[derive(FromPyObject)]
+struct StructWithOnlyDefaultValues {
+    #[pyo3(default)]
+    field: String,
+}
+
+#[derive(FromPyObject)]
+enum EnumVariantWithOnlyDefaultValues {
+    Foo {
+        #[pyo3(default)]
+        field: String,
+    },
+}
+
+#[derive(FromPyObject)]
+struct NamedTuplesWithDefaultValues(#[pyo3(default)] String);
+
+#[derive(FromPyObject)]
+#[pyo3(rename_all = "camelCase", rename_all = "kebab-case")]
+struct MultipleRenames {
+    snake_case: String,
+}
+
+#[derive(FromPyObject)]
+#[pyo3(rename_all = "camelCase")]
+struct RenameAllTuple(String);
+
+#[derive(FromPyObject)]
+enum RenameAllEnum {
+    #[pyo3(rename_all = "camelCase")]
+    Tuple(String),
+}
+
+#[derive(FromPyObject)]
+#[pyo3(transparent, rename_all = "camelCase")]
+struct RenameAllTransparent {
+    inner: String,
+}
+
+#[derive(FromPyObject)]
+#[pyo3(rename_all = "camelCase")]
+enum UselessRenameAllEnum {
+    #[pyo3(rename_all = "camelCase")]
+    Tuple { inner_field: String },
+}
+
 fn main() {}
diff --git a/tests/ui/invalid_frompy_derive.stderr b/tests/ui/invalid_frompy_derive.stderr
index 8ed03caafb4..484c4ce44f4 100644
--- a/tests/ui/invalid_frompy_derive.stderr
+++ b/tests/ui/invalid_frompy_derive.stderr
@@ -84,7 +84,7 @@ error: transparent structs and variants can only have 1 field
 70 | |     },
    | |_____^
 
-error: expected one of: `attribute`, `item`, `from_py_with`
+error: expected one of: `attribute`, `item`, `from_py_with`, `into_py_with`, `default`
   --> tests/ui/invalid_frompy_derive.rs:76:12
    |
 76 |     #[pyo3(attr)]
@@ -127,12 +127,12 @@ error: unexpected end of input, expected literal
     |                 ^
 
 error: only one of `attribute` or `item` can be provided
-   --> tests/ui/invalid_frompy_derive.rs:118:5
+   --> tests/ui/invalid_frompy_derive.rs:118:18
     |
 118 |     #[pyo3(item, attribute)]
-    |     ^
+    |                  ^^^^^^^^^
 
-error: expected one of: `transparent`, `from_item_all`, `annotation`, `crate`
+error: expected one of: `transparent`, `from_item_all`, `annotation`, `crate`, `rename_all`
    --> tests/ui/invalid_frompy_derive.rs:123:8
     |
 123 | #[pyo3(unknown = "should not work")]
@@ -176,12 +176,6 @@ error: expected `=`
 158 |     #[pyo3(from_py_with)]
     |                        ^
 
-error: expected string literal
-   --> tests/ui/invalid_frompy_derive.rs:164:27
-    |
-164 |     #[pyo3(from_py_with = func)]
-    |                           ^^^^
-
 error: `getter` is not permitted on tuple struct elements.
    --> tests/ui/invalid_frompy_derive.rs:169:27
     |
@@ -200,7 +194,7 @@ error: `transparent` structs may not have a `getter` for the inner field
 186 |     field: String,
     |     ^^^^^
 
-error: `from_item_all` may only be provided once
+error: `from_item_all` may only be specified once
    --> tests/ui/invalid_frompy_derive.rs:190:23
     |
 190 | #[pyo3(from_item_all, from_item_all)]
@@ -223,3 +217,65 @@ error: The struct is already annotated with `from_item_all`, `attribute` is not
     |
 210 | #[pyo3(from_item_all)]
     |        ^^^^^^^^^^^^^
+
+error: cannot derive FromPyObject for structs and variants with only default values
+   --> tests/ui/invalid_frompy_derive.rs:217:36
+    |
+217 |   struct StructWithOnlyDefaultValues {
+    |  ____________________________________^
+218 | |     #[pyo3(default)]
+219 | |     field: String,
+220 | | }
+    | |_^
+
+error: cannot derive FromPyObject for structs and variants with only default values
+   --> tests/ui/invalid_frompy_derive.rs:224:9
+    |
+224 |       Foo {
+    |  _________^
+225 | |         #[pyo3(default)]
+226 | |         field: String,
+227 | |     },
+    | |_____^
+
+error: `default` is not permitted on tuple struct elements.
+   --> tests/ui/invalid_frompy_derive.rs:231:37
+    |
+231 | struct NamedTuplesWithDefaultValues(#[pyo3(default)] String);
+    |                                     ^
+
+error: `rename_all` may only be specified once
+   --> tests/ui/invalid_frompy_derive.rs:234:34
+    |
+234 | #[pyo3(rename_all = "camelCase", rename_all = "kebab-case")]
+    |                                  ^^^^^^^^^^
+
+error: `rename_all` is useless on tuple structs and variants.
+   --> tests/ui/invalid_frompy_derive.rs:240:8
+    |
+240 | #[pyo3(rename_all = "camelCase")]
+    |        ^^^^^^^^^^
+
+error: `rename_all` is useless on tuple structs and variants.
+   --> tests/ui/invalid_frompy_derive.rs:245:12
+    |
+245 |     #[pyo3(rename_all = "camelCase")]
+    |            ^^^^^^^^^^
+
+error: `rename_all` is not permitted on `transparent` structs and variants
+   --> tests/ui/invalid_frompy_derive.rs:250:21
+    |
+250 | #[pyo3(transparent, rename_all = "camelCase")]
+    |                     ^^^^^^^^^^
+
+error: Useless variant `rename_all` - enum is already annotated with `rename_all
+   --> tests/ui/invalid_frompy_derive.rs:258:12
+    |
+258 |     #[pyo3(rename_all = "camelCase")]
+    |            ^^^^^^^^^^
+
+error[E0425]: cannot find value `func` in this scope
+   --> tests/ui/invalid_frompy_derive.rs:164:27
+    |
+164 |     #[pyo3(from_py_with = func)]
+    |                           ^^^^ not found in this scope
diff --git a/tests/ui/invalid_frozen_pyclass_borrow.rs b/tests/ui/invalid_frozen_pyclass_borrow.rs
index 1f18eab6170..6379a8707c5 100644
--- a/tests/ui/invalid_frozen_pyclass_borrow.rs
+++ b/tests/ui/invalid_frozen_pyclass_borrow.rs
@@ -12,7 +12,7 @@ impl Foo {
 }
 
 fn borrow_mut_fails(foo: Py<Foo>, py: Python) {
-    let borrow = foo.as_ref(py).borrow_mut();
+    let borrow = foo.bind(py).borrow_mut();
 }
 
 #[pyclass(subclass)]
@@ -22,14 +22,14 @@ struct MutableBase;
 struct ImmutableChild;
 
 fn borrow_mut_of_child_fails(child: Py<ImmutableChild>, py: Python) {
-    let borrow = child.as_ref(py).borrow_mut();
+    let borrow = child.bind(py).borrow_mut();
 }
 
 fn py_get_of_mutable_class_fails(class: Py<MutableBase>) {
     class.get();
 }
 
-fn pyclass_get_of_mutable_class_fails(class: &PyCell<MutableBase>) {
+fn pyclass_get_of_mutable_class_fails(class: &Bound<'_, MutableBase>) {
     class.get();
 }
 
diff --git a/tests/ui/invalid_frozen_pyclass_borrow.stderr b/tests/ui/invalid_frozen_pyclass_borrow.stderr
index 5e09d512ae7..5bfa9ee0808 100644
--- a/tests/ui/invalid_frozen_pyclass_borrow.stderr
+++ b/tests/ui/invalid_frozen_pyclass_borrow.stderr
@@ -8,50 +8,91 @@ error[E0271]: type mismatch resolving `<Foo as PyClass>::Frozen == False`
   --> tests/ui/invalid_frozen_pyclass_borrow.rs:11:19
    |
 11 |     fn mut_method(&mut self) {}
-   |                   ^ expected `False`, found `True`
+   |                   ^ type mismatch resolving `<Foo as PyClass>::Frozen == False`
    |
+note: expected this to be `False`
+  --> tests/ui/invalid_frozen_pyclass_borrow.rs:3:1
+   |
+ 3 | #[pyclass(frozen)]
+   | ^^^^^^^^^^^^^^^^^^
 note: required by a bound in `extract_pyclass_ref_mut`
   --> src/impl_/extract_argument.rs
    |
-   | pub fn extract_pyclass_ref_mut<'a, 'py: 'a, T: PyClass<Frozen = False>>(
+   | pub fn extract_pyclass_ref_mut<'a, 'holder, T: PyClass<Frozen = False>>(
    |                                                        ^^^^^^^^^^^^^^ required by this bound in `extract_pyclass_ref_mut`
+   = note: this error originates in the attribute macro `pyclass` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0271]: type mismatch resolving `<Foo as PyClass>::Frozen == False`
+ --> tests/ui/invalid_frozen_pyclass_borrow.rs:9:1
+  |
+9 | #[pymethods]
+  | ^^^^^^^^^^^^ type mismatch resolving `<Foo as PyClass>::Frozen == False`
+  |
+note: expected this to be `False`
+ --> tests/ui/invalid_frozen_pyclass_borrow.rs:3:1
+  |
+3 | #[pyclass(frozen)]
+  | ^^^^^^^^^^^^^^^^^^
+note: required by a bound in `PyClassGuardMut`
+ --> src/pyclass/guard.rs
+  |
+  | pub struct PyClassGuardMut<'a, T: PyClass<Frozen = False>> {
+  |                                           ^^^^^^^^^^^^^^ required by this bound in `PyClassGuardMut`
+  = note: this error originates in the attribute macro `pymethods` which comes from the expansion of the attribute macro `pyclass` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0271]: type mismatch resolving `<Foo as PyClass>::Frozen == False`
-  --> tests/ui/invalid_frozen_pyclass_borrow.rs:15:33
+  --> tests/ui/invalid_frozen_pyclass_borrow.rs:15:31
    |
-15 |     let borrow = foo.as_ref(py).borrow_mut();
-   |                                 ^^^^^^^^^^ expected `False`, found `True`
+15 |     let borrow = foo.bind(py).borrow_mut();
+   |                               ^^^^^^^^^^ type mismatch resolving `<Foo as PyClass>::Frozen == False`
    |
-note: required by a bound in `pyo3::PyCell::<T>::borrow_mut`
-  --> src/pycell.rs
+note: expected this to be `False`
+  --> tests/ui/invalid_frozen_pyclass_borrow.rs:3:1
+   |
+ 3 | #[pyclass(frozen)]
+   | ^^^^^^^^^^^^^^^^^^
+note: required by a bound in `pyo3::Bound::<'py, T>::borrow_mut`
+  --> src/instance.rs
    |
-   |     pub fn borrow_mut(&self) -> PyRefMut<'_, T>
+   |     pub fn borrow_mut(&self) -> PyRefMut<'py, T>
    |            ---------- required by a bound in this associated function
    |     where
    |         T: PyClass<Frozen = False>,
-   |                    ^^^^^^^^^^^^^^ required by this bound in `PyCell::<T>::borrow_mut`
+   |                    ^^^^^^^^^^^^^^ required by this bound in `Bound::<'py, T>::borrow_mut`
+   = note: this error originates in the attribute macro `pyclass` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0271]: type mismatch resolving `<ImmutableChild as PyClass>::Frozen == False`
-  --> tests/ui/invalid_frozen_pyclass_borrow.rs:25:35
+  --> tests/ui/invalid_frozen_pyclass_borrow.rs:25:33
    |
-25 |     let borrow = child.as_ref(py).borrow_mut();
-   |                                   ^^^^^^^^^^ expected `False`, found `True`
+25 |     let borrow = child.bind(py).borrow_mut();
+   |                                 ^^^^^^^^^^ type mismatch resolving `<ImmutableChild as PyClass>::Frozen == False`
    |
-note: required by a bound in `pyo3::PyCell::<T>::borrow_mut`
-  --> src/pycell.rs
+note: expected this to be `False`
+  --> tests/ui/invalid_frozen_pyclass_borrow.rs:21:1
    |
-   |     pub fn borrow_mut(&self) -> PyRefMut<'_, T>
+21 | #[pyclass(frozen, extends = MutableBase)]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+note: required by a bound in `pyo3::Bound::<'py, T>::borrow_mut`
+  --> src/instance.rs
+   |
+   |     pub fn borrow_mut(&self) -> PyRefMut<'py, T>
    |            ---------- required by a bound in this associated function
    |     where
    |         T: PyClass<Frozen = False>,
-   |                    ^^^^^^^^^^^^^^ required by this bound in `PyCell::<T>::borrow_mut`
+   |                    ^^^^^^^^^^^^^^ required by this bound in `Bound::<'py, T>::borrow_mut`
+   = note: this error originates in the attribute macro `pyclass` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0271]: type mismatch resolving `<MutableBase as PyClass>::Frozen == True`
   --> tests/ui/invalid_frozen_pyclass_borrow.rs:29:11
    |
 29 |     class.get();
-   |           ^^^ expected `True`, found `False`
+   |           ^^^ type mismatch resolving `<MutableBase as PyClass>::Frozen == True`
+   |
+note: expected this to be `True`
+  --> tests/ui/invalid_frozen_pyclass_borrow.rs:18:1
    |
+18 | #[pyclass(subclass)]
+   | ^^^^^^^^^^^^^^^^^^^^
 note: required by a bound in `pyo3::Py::<T>::get`
   --> src/instance.rs
    |
@@ -60,18 +101,25 @@ note: required by a bound in `pyo3::Py::<T>::get`
    |     where
    |         T: PyClass<Frozen = True> + Sync,
    |                    ^^^^^^^^^^^^^ required by this bound in `Py::<T>::get`
+   = note: this error originates in the attribute macro `pyclass` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0271]: type mismatch resolving `<MutableBase as PyClass>::Frozen == True`
   --> tests/ui/invalid_frozen_pyclass_borrow.rs:33:11
    |
 33 |     class.get();
-   |           ^^^ expected `True`, found `False`
+   |           ^^^ type mismatch resolving `<MutableBase as PyClass>::Frozen == True`
    |
-note: required by a bound in `pyo3::PyCell::<T>::get`
-  --> src/pycell.rs
+note: expected this to be `True`
+  --> tests/ui/invalid_frozen_pyclass_borrow.rs:18:1
+   |
+18 | #[pyclass(subclass)]
+   | ^^^^^^^^^^^^^^^^^^^^
+note: required by a bound in `pyo3::Bound::<'py, T>::get`
+  --> src/instance.rs
    |
    |     pub fn get(&self) -> &T
    |            --- required by a bound in this associated function
    |     where
    |         T: PyClass<Frozen = True> + Sync,
-   |                    ^^^^^^^^^^^^^ required by this bound in `PyCell::<T>::get`
+   |                    ^^^^^^^^^^^^^ required by this bound in `Bound::<'py, T>::get`
+   = note: this error originates in the attribute macro `pyclass` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/tests/ui/invalid_intern_arg.rs b/tests/ui/invalid_intern_arg.rs
index 3c7bd592175..a90dbdd351a 100644
--- a/tests/ui/invalid_intern_arg.rs
+++ b/tests/ui/invalid_intern_arg.rs
@@ -1,6 +1,6 @@
 use pyo3::Python;
 
 fn main() {
-    let foo = if true { "foo" } else { "bar" };
-    Python::with_gil(|py| py.import_bound(pyo3::intern!(py, foo)).unwrap());
+    let _foo = if true { "foo" } else { "bar" };
+    Python::attach(|py| py.import(pyo3::intern!(py, _foo)).unwrap());
 }
diff --git a/tests/ui/invalid_intern_arg.stderr b/tests/ui/invalid_intern_arg.stderr
index dce2d85bf09..eabbc058948 100644
--- a/tests/ui/invalid_intern_arg.stderr
+++ b/tests/ui/invalid_intern_arg.stderr
@@ -1,8 +1,21 @@
 error[E0435]: attempt to use a non-constant value in a constant
- --> tests/ui/invalid_intern_arg.rs:5:61
+ --> tests/ui/invalid_intern_arg.rs:5:53
   |
-5 |     Python::with_gil(|py| py.import_bound(pyo3::intern!(py, foo)).unwrap());
-  |                                           ------------------^^^-
-  |                                           |                 |
-  |                                           |                 non-constant value
-  |                                           help: consider using `let` instead of `static`: `let INTERNED`
+5 |     Python::attach(|py| py.import(pyo3::intern!(py, _foo)).unwrap());
+  |                                                     ^^^^ non-constant value
+  |
+help: consider using `let` instead of `static`
+ --> src/sync.rs
+  |
+  -         static INTERNED: $crate::sync::Interned = $crate::sync::Interned::new($text);
+  +         let INTERNED: $crate::sync::Interned = $crate::sync::Interned::new($text);
+  |
+
+error: lifetime may not live long enough
+ --> tests/ui/invalid_intern_arg.rs:5:25
+  |
+5 |     Python::attach(|py| py.import(pyo3::intern!(py, _foo)).unwrap());
+  |                     --- ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ returning this value requires that `'1` must outlive `'2`
+  |                     | |
+  |                     | return type of closure is pyo3::Bound<'2, PyModule>
+  |                     has type `Python<'1>`
diff --git a/tests/ui/invalid_intopy_derive.rs b/tests/ui/invalid_intopy_derive.rs
new file mode 100644
index 00000000000..5d65e36bfcb
--- /dev/null
+++ b/tests/ui/invalid_intopy_derive.rs
@@ -0,0 +1,170 @@
+use pyo3::{IntoPyObject, IntoPyObjectRef};
+
+#[derive(IntoPyObject, IntoPyObjectRef)]
+struct Foo();
+
+#[derive(IntoPyObject, IntoPyObjectRef)]
+struct Foo2 {}
+
+#[derive(IntoPyObject, IntoPyObjectRef)]
+enum EmptyEnum {}
+
+#[derive(IntoPyObject, IntoPyObjectRef)]
+enum EnumWithEmptyTupleVar {
+    EmptyTuple(),
+    Valid(String),
+}
+
+#[derive(IntoPyObject, IntoPyObjectRef)]
+enum EnumWithEmptyStructVar {
+    EmptyStruct {},
+    Valid(String),
+}
+
+#[derive(IntoPyObject, IntoPyObjectRef)]
+#[pyo3(transparent)]
+struct EmptyTransparentTup();
+
+#[derive(IntoPyObject, IntoPyObjectRef)]
+#[pyo3(transparent)]
+struct EmptyTransparentStruct {}
+
+#[derive(IntoPyObject, IntoPyObjectRef)]
+enum EnumWithTransparentEmptyTupleVar {
+    #[pyo3(transparent)]
+    EmptyTuple(),
+    Valid(String),
+}
+
+#[derive(IntoPyObject, IntoPyObjectRef)]
+enum EnumWithTransparentEmptyStructVar {
+    #[pyo3(transparent)]
+    EmptyStruct {},
+    Valid(String),
+}
+
+#[derive(IntoPyObject, IntoPyObjectRef)]
+#[pyo3(transparent)]
+struct TransparentTupTooManyFields(String, String);
+
+#[derive(IntoPyObject, IntoPyObjectRef)]
+#[pyo3(transparent)]
+struct TransparentStructTooManyFields {
+    foo: String,
+    bar: String,
+}
+
+#[derive(IntoPyObject, IntoPyObjectRef)]
+enum EnumWithTransparentTupleTooMany {
+    #[pyo3(transparent)]
+    EmptyTuple(String, String),
+    Valid(String),
+}
+
+#[derive(IntoPyObject, IntoPyObjectRef)]
+enum EnumWithTransparentStructTooMany {
+    #[pyo3(transparent)]
+    EmptyStruct {
+        foo: String,
+        bar: String,
+    },
+    Valid(String),
+}
+
+#[derive(IntoPyObject, IntoPyObjectRef)]
+#[pyo3(unknown = "should not work")]
+struct UnknownContainerAttr {
+    a: String,
+}
+
+#[derive(IntoPyObject, IntoPyObjectRef)]
+union Union {
+    a: usize,
+}
+
+#[derive(IntoPyObject, IntoPyObjectRef)]
+enum UnitEnum {
+    Unit,
+}
+
+#[derive(IntoPyObject, IntoPyObjectRef)]
+struct TupleAttribute(#[pyo3(attribute)] String, usize);
+
+#[derive(IntoPyObject, IntoPyObjectRef)]
+struct TupleItem(#[pyo3(item)] String, usize);
+
+#[derive(IntoPyObject, IntoPyObjectRef)]
+struct StructAttribute {
+    #[pyo3(attribute)]
+    foo: String,
+}
+
+#[derive(IntoPyObject, IntoPyObjectRef)]
+#[pyo3(transparent)]
+struct StructTransparentItem {
+    #[pyo3(item)]
+    foo: String,
+}
+
+#[derive(IntoPyObject)]
+#[pyo3(transparent)]
+struct StructTransparentIntoPyWith {
+    #[pyo3(into_py_with = into)]
+    foo: String,
+}
+
+#[derive(IntoPyObjectRef)]
+#[pyo3(transparent)]
+struct StructTransparentIntoPyWithRef {
+    #[pyo3(into_py_with = into_ref)]
+    foo: String,
+}
+
+#[derive(IntoPyObject)]
+#[pyo3(transparent)]
+struct TupleTransparentIntoPyWith(#[pyo3(into_py_with = into)] String);
+
+#[derive(IntoPyObject)]
+enum EnumTupleIntoPyWith {
+    TransparentTuple(#[pyo3(into_py_with = into)] usize),
+}
+
+#[derive(IntoPyObject)]
+enum EnumStructIntoPyWith {
+    #[pyo3(transparent)]
+    TransparentStruct {
+        #[pyo3(into_py_with = into)]
+        a: usize,
+    },
+}
+
+#[derive(IntoPyObject, IntoPyObjectRef)]
+#[pyo3(transparent, rename_all = "camelCase")]
+struct StructTransparentRenameAll {
+    foo_bar: String,
+}
+
+#[derive(IntoPyObject, IntoPyObjectRef)]
+#[pyo3(rename_all = "camelCase")]
+struct StructTupleRenameAll(String, usize);
+
+#[derive(IntoPyObject, IntoPyObjectRef)]
+enum EnumTransparentVariantRenameAll {
+    #[pyo3(rename_all = "camelCase")]
+    #[pyo3(transparent)]
+    Variant { foo: String },
+}
+
+#[derive(IntoPyObject, IntoPyObjectRef)]
+enum EnumTupleVariantRenameAll {
+    #[pyo3(rename_all = "camelCase")]
+    Variant(String, usize),
+}
+
+#[derive(IntoPyObject, IntoPyObjectRef)]
+#[pyo3(rename_all = "camelCase")]
+enum EnumTopRenameAll {
+    Variant { foo: String },
+}
+
+fn main() {}
diff --git a/tests/ui/invalid_intopy_derive.stderr b/tests/ui/invalid_intopy_derive.stderr
new file mode 100644
index 00000000000..518066f3460
--- /dev/null
+++ b/tests/ui/invalid_intopy_derive.stderr
@@ -0,0 +1,181 @@
+error: cannot derive `IntoPyObject` for empty structs
+ --> tests/ui/invalid_intopy_derive.rs:4:11
+  |
+4 | struct Foo();
+  |           ^^
+
+error: cannot derive `IntoPyObject` for empty structs
+ --> tests/ui/invalid_intopy_derive.rs:7:13
+  |
+7 | struct Foo2 {}
+  |             ^^
+
+error: cannot derive `IntoPyObject` for empty enum
+  --> tests/ui/invalid_intopy_derive.rs:10:6
+   |
+10 | enum EmptyEnum {}
+   |      ^^^^^^^^^
+
+error: cannot derive `IntoPyObject` for empty variants
+  --> tests/ui/invalid_intopy_derive.rs:14:5
+   |
+14 |     EmptyTuple(),
+   |     ^^^^^^^^^^
+
+error: cannot derive `IntoPyObject` for empty variants
+  --> tests/ui/invalid_intopy_derive.rs:20:5
+   |
+20 |     EmptyStruct {},
+   |     ^^^^^^^^^^^
+
+error: cannot derive `IntoPyObject` for empty structs
+  --> tests/ui/invalid_intopy_derive.rs:26:27
+   |
+26 | struct EmptyTransparentTup();
+   |                           ^^
+
+error: cannot derive `IntoPyObject` for empty structs
+  --> tests/ui/invalid_intopy_derive.rs:30:31
+   |
+30 | struct EmptyTransparentStruct {}
+   |                               ^^
+
+error: cannot derive `IntoPyObject` for empty variants
+  --> tests/ui/invalid_intopy_derive.rs:35:5
+   |
+35 |     EmptyTuple(),
+   |     ^^^^^^^^^^
+
+error: cannot derive `IntoPyObject` for empty variants
+  --> tests/ui/invalid_intopy_derive.rs:42:5
+   |
+42 |     EmptyStruct {},
+   |     ^^^^^^^^^^^
+
+error: transparent structs and variants can only have 1 field
+  --> tests/ui/invalid_intopy_derive.rs:48:35
+   |
+48 | struct TransparentTupTooManyFields(String, String);
+   |                                   ^^^^^^^^^^^^^^^^
+
+error: transparent structs and variants can only have 1 field
+  --> tests/ui/invalid_intopy_derive.rs:52:39
+   |
+52 |   struct TransparentStructTooManyFields {
+   |  _______________________________________^
+53 | |     foo: String,
+54 | |     bar: String,
+55 | | }
+   | |_^
+
+error: transparent structs and variants can only have 1 field
+  --> tests/ui/invalid_intopy_derive.rs:60:15
+   |
+60 |     EmptyTuple(String, String),
+   |               ^^^^^^^^^^^^^^^^
+
+error: transparent structs and variants can only have 1 field
+  --> tests/ui/invalid_intopy_derive.rs:67:17
+   |
+67 |       EmptyStruct {
+   |  _________________^
+68 | |         foo: String,
+69 | |         bar: String,
+70 | |     },
+   | |_____^
+
+error: expected one of: `transparent`, `from_item_all`, `annotation`, `crate`, `rename_all`
+  --> tests/ui/invalid_intopy_derive.rs:75:8
+   |
+75 | #[pyo3(unknown = "should not work")]
+   |        ^^^^^^^
+
+error: #[derive(`IntoPyObject`)] is not supported for unions
+  --> tests/ui/invalid_intopy_derive.rs:81:1
+   |
+81 | union Union {
+   | ^^^^^
+
+error: cannot derive `IntoPyObject` for empty variants
+  --> tests/ui/invalid_intopy_derive.rs:87:5
+   |
+87 |     Unit,
+   |     ^^^^
+
+error: `item` and `attribute` are not permitted on tuple struct elements.
+  --> tests/ui/invalid_intopy_derive.rs:91:30
+   |
+91 | struct TupleAttribute(#[pyo3(attribute)] String, usize);
+   |                              ^^^^^^^^^
+
+error: `item` and `attribute` are not permitted on tuple struct elements.
+  --> tests/ui/invalid_intopy_derive.rs:94:25
+   |
+94 | struct TupleItem(#[pyo3(item)] String, usize);
+   |                         ^^^^
+
+error: `transparent` structs may not have `item` nor `attribute` for the inner field
+   --> tests/ui/invalid_intopy_derive.rs:105:12
+    |
+105 |     #[pyo3(item)]
+    |            ^^^^
+
+error: `into_py_with` is not permitted on `transparent` structs or variants
+   --> tests/ui/invalid_intopy_derive.rs:112:12
+    |
+112 |     #[pyo3(into_py_with = into)]
+    |            ^^^^^^^^^^^^
+
+error: `into_py_with` is not permitted on `transparent` structs or variants
+   --> tests/ui/invalid_intopy_derive.rs:119:12
+    |
+119 |     #[pyo3(into_py_with = into_ref)]
+    |            ^^^^^^^^^^^^
+
+error: `into_py_with` is not permitted on `transparent` structs
+   --> tests/ui/invalid_intopy_derive.rs:125:42
+    |
+125 | struct TupleTransparentIntoPyWith(#[pyo3(into_py_with = into)] String);
+    |                                          ^^^^^^^^^^^^
+
+error: `into_py_with` is not permitted on `transparent` structs
+   --> tests/ui/invalid_intopy_derive.rs:129:29
+    |
+129 |     TransparentTuple(#[pyo3(into_py_with = into)] usize),
+    |                             ^^^^^^^^^^^^
+
+error: `into_py_with` is not permitted on `transparent` structs or variants
+   --> tests/ui/invalid_intopy_derive.rs:136:16
+    |
+136 |         #[pyo3(into_py_with = into)]
+    |                ^^^^^^^^^^^^
+
+error: `rename_all` is not permitted on `transparent` structs and variants
+   --> tests/ui/invalid_intopy_derive.rs:142:21
+    |
+142 | #[pyo3(transparent, rename_all = "camelCase")]
+    |                     ^^^^^^^^^^
+
+error: `rename_all` is useless on tuple structs and variants.
+   --> tests/ui/invalid_intopy_derive.rs:148:8
+    |
+148 | #[pyo3(rename_all = "camelCase")]
+    |        ^^^^^^^^^^
+
+error: `rename_all` is not permitted on `transparent` structs and variants
+   --> tests/ui/invalid_intopy_derive.rs:153:12
+    |
+153 |     #[pyo3(rename_all = "camelCase")]
+    |            ^^^^^^^^^^
+
+error: `rename_all` is useless on tuple structs and variants.
+   --> tests/ui/invalid_intopy_derive.rs:160:12
+    |
+160 |     #[pyo3(rename_all = "camelCase")]
+    |            ^^^^^^^^^^
+
+error: `rename_all` is not supported at top level for enums
+   --> tests/ui/invalid_intopy_derive.rs:165:8
+    |
+165 | #[pyo3(rename_all = "camelCase")]
+    |        ^^^^^^^^^^
diff --git a/tests/ui/invalid_intopy_with.rs b/tests/ui/invalid_intopy_with.rs
new file mode 100644
index 00000000000..7cc910f57d8
--- /dev/null
+++ b/tests/ui/invalid_intopy_with.rs
@@ -0,0 +1,13 @@
+use pyo3::{IntoPyObject, IntoPyObjectRef};
+
+#[derive(IntoPyObject, IntoPyObjectRef)]
+struct InvalidIntoPyWithFn {
+    #[pyo3(into_py_with = into)]
+    inner: String,
+}
+
+fn into(_a: String, _py: pyo3::Python<'_>) -> pyo3::PyResult<pyo3::Bound<'_, pyo3::PyAny>> {
+    todo!()
+}
+
+fn main() {}
diff --git a/tests/ui/invalid_intopy_with.stderr b/tests/ui/invalid_intopy_with.stderr
new file mode 100644
index 00000000000..bfa3e6ec274
--- /dev/null
+++ b/tests/ui/invalid_intopy_with.stderr
@@ -0,0 +1,23 @@
+error[E0308]: mismatched types
+ --> tests/ui/invalid_intopy_with.rs:5:27
+  |
+3 | #[derive(IntoPyObject, IntoPyObjectRef)]
+  |          ------------ expected due to this
+4 | struct InvalidIntoPyWithFn {
+5 |     #[pyo3(into_py_with = into)]
+  |                           ^^^^ expected fn pointer, found fn item
+  |
+  = note: expected fn pointer `for<'a> fn(Cow<'a, _>, Python<'py>) -> Result<pyo3::Bound<'py, PyAny>, PyErr>`
+                found fn item `for<'a> fn(String, Python<'a>) -> Result<pyo3::Bound<'a, PyAny>, PyErr> {into}`
+
+error[E0308]: mismatched types
+ --> tests/ui/invalid_intopy_with.rs:5:27
+  |
+3 | #[derive(IntoPyObject, IntoPyObjectRef)]
+  |                        --------------- expected due to this
+4 | struct InvalidIntoPyWithFn {
+5 |     #[pyo3(into_py_with = into)]
+  |                           ^^^^ expected fn pointer, found fn item
+  |
+  = note: expected fn pointer `for<'a> fn(Cow<'a, _>, Python<'py>) -> Result<pyo3::Bound<'py, PyAny>, PyErr>`
+                found fn item `for<'a> fn(String, Python<'a>) -> Result<pyo3::Bound<'a, PyAny>, PyErr> {into}`
diff --git a/tests/ui/invalid_property_args.rs b/tests/ui/invalid_property_args.rs
index 3f335952235..f35367df7aa 100644
--- a/tests/ui/invalid_property_args.rs
+++ b/tests/ui/invalid_property_args.rs
@@ -6,7 +6,7 @@ struct ClassWithGetter {}
 #[pymethods]
 impl ClassWithGetter {
     #[getter]
-    fn getter_with_arg(&self, py: Python<'_>, index: u32) {}
+    fn getter_with_arg(&self, _py: Python<'_>, _index: u32) {}
 }
 
 #[pyclass]
@@ -15,13 +15,13 @@ struct ClassWithSetter {}
 #[pymethods]
 impl ClassWithSetter {
     #[setter]
-    fn setter_with_no_arg(&mut self, py: Python<'_>) {}
+    fn setter_with_no_arg(&mut self, _py: Python<'_>) {}
 }
 
 #[pymethods]
 impl ClassWithSetter {
     #[setter]
-    fn setter_with_too_many_args(&mut self, py: Python<'_>, foo: u32, bar: u32) {}
+    fn setter_with_too_many_args(&mut self, _py: Python<'_>, _foo: u32, _bar: u32) {}
 }
 
 #[pyclass]
@@ -39,4 +39,10 @@ struct MultipleName(#[pyo3(name = "foo", name = "bar")] i32);
 #[pyclass]
 struct NameWithoutGetSet(#[pyo3(name = "value")] i32);
 
+#[pyclass]
+struct InvalidGetterType {
+    #[pyo3(get)]
+    value: ::std::marker::PhantomData<i32>,
+}
+
 fn main() {}
diff --git a/tests/ui/invalid_property_args.stderr b/tests/ui/invalid_property_args.stderr
index a41b6c79b3a..047e6709c21 100644
--- a/tests/ui/invalid_property_args.stderr
+++ b/tests/ui/invalid_property_args.stderr
@@ -1,20 +1,20 @@
 error: getter function can only have one argument (of type pyo3::Python)
- --> tests/ui/invalid_property_args.rs:9:54
+ --> tests/ui/invalid_property_args.rs:9:56
   |
-9 |     fn getter_with_arg(&self, py: Python<'_>, index: u32) {}
-  |                                                      ^^^
+9 |     fn getter_with_arg(&self, _py: Python<'_>, _index: u32) {}
+  |                                                        ^^^
 
 error: setter function expected to have one argument
   --> tests/ui/invalid_property_args.rs:18:8
    |
-18 |     fn setter_with_no_arg(&mut self, py: Python<'_>) {}
+18 |     fn setter_with_no_arg(&mut self, _py: Python<'_>) {}
    |        ^^^^^^^^^^^^^^^^^^
 
 error: setter function can have at most two arguments ([pyo3::Python,] and value)
-  --> tests/ui/invalid_property_args.rs:24:76
+  --> tests/ui/invalid_property_args.rs:24:79
    |
-24 |     fn setter_with_too_many_args(&mut self, py: Python<'_>, foo: u32, bar: u32) {}
-   |                                                                            ^^^
+24 |     fn setter_with_too_many_args(&mut self, _py: Python<'_>, _foo: u32, _bar: u32) {}
+   |                                                                               ^^^
 
 error: `get` and `set` with tuple struct fields require `name`
   --> tests/ui/invalid_property_args.rs:28:50
@@ -45,3 +45,31 @@ error: `name` is useless without `get` or `set`
    |
 40 | struct NameWithoutGetSet(#[pyo3(name = "value")] i32);
    |                                 ^^^^^^^^^^^^^^
+
+error[E0277]: `PhantomData<i32>` cannot be converted to a Python object
+  --> tests/ui/invalid_property_args.rs:45:12
+   |
+45 |     value: ::std::marker::PhantomData<i32>,
+   |            ^ required by `#[pyo3(get)]` to create a readable property from a field of type `PhantomData<i32>`
+   |
+   = help: the trait `IntoPyObject<'_>` is not implemented for `PhantomData<i32>`
+   = note: implement `IntoPyObject` for `&PhantomData<i32>` or `IntoPyObject + Clone` for `PhantomData<i32>` to define the conversion
+   = help: the following other types implement trait `IntoPyObject<'py>`:
+             &&'a T
+             &&OsStr
+             &&Path
+             &&str
+             &'a (T0, T1)
+             &'a (T0, T1, T2)
+             &'a (T0, T1, T2, T3)
+             &'a (T0, T1, T2, T3, T4)
+           and $N others
+   = note: required for `PhantomData<i32>` to implement `for<'py> PyO3GetField<'py>`
+note: required by a bound in `PyClassGetterGenerator::<ClassT, FieldT, Offset, false, false, IMPLEMENTS_INTOPYOBJECT>::generate`
+  --> src/impl_/pyclass.rs
+   |
+   |     pub const fn generate(&self, name: &'static CStr, doc: &'static CStr) -> PyMethodDefType
+   |                  -------- required by a bound in this associated function
+...
+   |         for<'py> FieldT: PyO3GetField<'py>,
+   |                          ^^^^^^^^^^^^^^^^^ required by this bound in `PyClassGetterGenerator::<ClassT, FieldT, Offset, false, false, IMPLEMENTS_INTOPYOBJECT>::generate`
diff --git a/tests/ui/invalid_proto_pymethods.rs b/tests/ui/invalid_proto_pymethods.rs
index d370c4fddb5..c40790c3168 100644
--- a/tests/ui/invalid_proto_pymethods.rs
+++ b/tests/ui/invalid_proto_pymethods.rs
@@ -54,11 +54,11 @@ struct EqAndRichcmp;
 
 #[pymethods]
 impl EqAndRichcmp {
-    fn __eq__(&self, other: &Self) -> bool {
+    fn __eq__(&self, _other: &Self) -> bool {
         true
     }
 
-    fn __richcmp__(&self, other: &Self, op: CompareOp) -> bool {
+    fn __richcmp__(&self, _other: &Self, _op: CompareOp) -> bool {
         true
     }
 }
diff --git a/tests/ui/invalid_proto_pymethods.stderr b/tests/ui/invalid_proto_pymethods.stderr
index 275a6b93c46..1f564d18ea0 100644
--- a/tests/ui/invalid_proto_pymethods.stderr
+++ b/tests/ui/invalid_proto_pymethods.stderr
@@ -31,4 +31,40 @@ error[E0592]: duplicate definitions with name `__pymethod___richcmp____`
    | duplicate definitions for `__pymethod___richcmp____`
    | other definition for `__pymethod___richcmp____`
    |
-   = note: this error originates in the macro `_pyo3::impl_::pyclass::generate_pyclass_richcompare_slot` which comes from the expansion of the attribute macro `pymethods` (in Nightly builds, run with -Z macro-backtrace for more info)
+   = note: this error originates in the macro `::pyo3::impl_::pyclass::generate_pyclass_richcompare_slot` which comes from the expansion of the attribute macro `pymethods` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0034]: multiple applicable items in scope
+  --> tests/ui/invalid_proto_pymethods.rs:55:1
+   |
+55 | #[pymethods]
+   | ^^^^^^^^^^^^ multiple `__pymethod___richcmp____` found
+   |
+note: candidate #1 is defined in an impl for the type `EqAndRichcmp`
+  --> tests/ui/invalid_proto_pymethods.rs:55:1
+   |
+55 | #[pymethods]
+   | ^^^^^^^^^^^^
+note: candidate #2 is defined in an impl for the type `EqAndRichcmp`
+  --> tests/ui/invalid_proto_pymethods.rs:55:1
+   |
+55 | #[pymethods]
+   | ^^^^^^^^^^^^
+   = note: this error originates in the macro `::pyo3::impl_::pyclass::generate_pyclass_richcompare_slot` which comes from the expansion of the attribute macro `pymethods` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0034]: multiple applicable items in scope
+  --> tests/ui/invalid_proto_pymethods.rs:55:1
+   |
+55 | #[pymethods]
+   | ^^^^^^^^^^^^ multiple `__pymethod___richcmp____` found
+   |
+note: candidate #1 is defined in an impl for the type `EqAndRichcmp`
+  --> tests/ui/invalid_proto_pymethods.rs:55:1
+   |
+55 | #[pymethods]
+   | ^^^^^^^^^^^^
+note: candidate #2 is defined in an impl for the type `EqAndRichcmp`
+  --> tests/ui/invalid_proto_pymethods.rs:55:1
+   |
+55 | #[pymethods]
+   | ^^^^^^^^^^^^
+   = note: this error originates in the attribute macro `pymethods` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/tests/ui/invalid_pycallargs.rs b/tests/ui/invalid_pycallargs.rs
new file mode 100644
index 00000000000..e3af53d29c2
--- /dev/null
+++ b/tests/ui/invalid_pycallargs.rs
@@ -0,0 +1,8 @@
+use pyo3::prelude::*;
+
+fn main() {
+    Python::attach(|py| {
+        let any = py.None().into_bound(py);
+        any.call1("foo");
+    })
+}
diff --git a/tests/ui/invalid_pycallargs.stderr b/tests/ui/invalid_pycallargs.stderr
new file mode 100644
index 00000000000..78867b6855a
--- /dev/null
+++ b/tests/ui/invalid_pycallargs.stderr
@@ -0,0 +1,33 @@
+error[E0277]: `&str` cannot used as a Python `call` argument
+ --> tests/ui/invalid_pycallargs.rs:6:19
+  |
+6 |         any.call1("foo");
+  |             ----- ^^^^^ the trait `PyCallArgs<'_>` is not implemented for `&str`
+  |             |
+  |             required by a bound introduced by this call
+  |
+  = note: `PyCallArgs` is implemented for Rust tuples, `Bound<'py, PyTuple>` and `Py<PyTuple>`
+  = note: if your type is convertable to `PyTuple` via `IntoPyObject`, call `<arg>.into_pyobject(py)` manually
+  = note: if you meant to pass the type as a single argument, wrap it in a 1-tuple, `(<arg>,)`
+  = help: the following other types implement trait `PyCallArgs<'py>`:
+            &'a (T0, T1)
+            &'a (T0, T1, T2)
+            &'a (T0, T1, T2, T3)
+            &'a (T0, T1, T2, T3, T4)
+            &'a (T0, T1, T2, T3, T4, T5)
+            &'a (T0, T1, T2, T3, T4, T5, T6)
+            &'a (T0, T1, T2, T3, T4, T5, T6, T7)
+            &'a (T0, T1, T2, T3, T4, T5, T6, T7, T8)
+          and $N others
+note: required by a bound in `call1`
+ --> src/types/any.rs
+  |
+  |     fn call1<A>(&self, args: A) -> PyResult<Bound<'py, PyAny>>
+  |        ----- required by a bound in this associated function
+  |     where
+  |         A: PyCallArgs<'py>;
+  |            ^^^^^^^^^^^^^^^ required by this bound in `PyAnyMethods::call1`
+help: use a unary tuple instead
+  |
+6 |         any.call1(("foo",));
+  |                   +     ++
diff --git a/tests/ui/invalid_pyclass_args.rs b/tests/ui/invalid_pyclass_args.rs
index fac21db078c..8817a6f710f 100644
--- a/tests/ui/invalid_pyclass_args.rs
+++ b/tests/ui/invalid_pyclass_args.rs
@@ -1,4 +1,5 @@
 use pyo3::prelude::*;
+use std::fmt::{Display, Formatter};
 
 #[pyclass(extend=pyo3::types::PyDict)]
 struct TypoIntheKey {}
@@ -30,4 +31,166 @@ struct InvalidArg {}
 #[pyclass(mapping, sequence)]
 struct CannotBeMappingAndSequence {}
 
+#[pyclass(eq)]
+struct EqOptRequiresEq {}
+
+#[pyclass(eq)]
+#[derive(PartialEq)]
+struct EqOptAndManualRichCmp {}
+
+#[pymethods]
+impl EqOptAndManualRichCmp {
+    fn __richcmp__(
+        &self,
+        _py: Python,
+        _other: Bound<'_, PyAny>,
+        _op: pyo3::pyclass::CompareOp,
+    ) -> PyResult<Py<PyAny>> {
+        todo!()
+    }
+}
+
+#[pyclass(eq_int)]
+struct NoEqInt {}
+
+#[pyclass(frozen, eq, hash)]
+#[derive(PartialEq)]
+struct HashOptRequiresHash;
+
+#[pyclass(hash)]
+#[derive(Hash)]
+struct HashWithoutFrozenAndEq;
+
+#[pyclass(frozen, eq, hash)]
+#[derive(PartialEq, Hash)]
+struct HashOptAndManualHash {}
+
+#[pymethods]
+impl HashOptAndManualHash {
+    fn __hash__(&self) -> u64 {
+        todo!()
+    }
+}
+
+#[pyclass(ord)]
+struct InvalidOrderedStruct {
+    inner: i32,
+}
+
+#[pyclass]
+struct MultipleErrors {
+    #[pyo3(foo)]
+    #[pyo3(blah)]
+    x: i32,
+    #[pyo3(pop)]
+    y: i32,
+}
+
+#[pyclass(str)]
+struct StrOptAndManualStr {}
+
+impl Display for StrOptAndManualStr {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self)
+    }
+}
+
+#[pymethods]
+impl StrOptAndManualStr {
+    fn __str__(&self) -> String {
+        todo!()
+    }
+}
+
+#[pyclass(str = "{")]
+#[derive(PartialEq)]
+struct Coord(u32, u32, u32);
+
+#[pyclass(str = "{$}")]
+#[derive(PartialEq)]
+struct Coord2(u32, u32, u32);
+
+#[pyclass(str = "X: {aaaa}, Y: {y}, Z: {z}")]
+#[derive(PartialEq, Eq, Clone, PartialOrd)]
+pub struct Point {
+    x: i32,
+    y: i32,
+    z: i32,
+}
+
+#[pyclass(str = "X: {x}, Y: {y}}}, Z: {zzz}")]
+#[derive(PartialEq, Eq, Clone, PartialOrd)]
+pub struct Point2 {
+    x: i32,
+    y: i32,
+    z: i32,
+}
+
+#[pyclass(str = "{0}, {162543}, {2}")]
+#[derive(PartialEq)]
+struct Coord3(u32, u32, u32);
+
+#[pyclass(name = "aaa", str = "unsafe: {unsafe_variable}")]
+struct StructRenamingWithStrFormatter {
+    #[pyo3(name = "unsafe", get, set)]
+    unsafe_variable: usize,
+}
+
+#[pyclass(name = "aaa", str = "unsafe: {unsafe_variable}")]
+struct StructRenamingWithStrFormatter2 {
+    unsafe_variable: usize,
+}
+
+#[pyclass(str = "unsafe: {unsafe_variable}")]
+struct StructRenamingWithStrFormatter3 {
+    #[pyo3(name = "unsafe", get, set)]
+    unsafe_variable: usize,
+}
+
+#[pyclass(rename_all = "SCREAMING_SNAKE_CASE", str = "{a_a}, {b_b}, {c_d_e}")]
+struct RenameAllVariantsStruct {
+    a_a: u32,
+    b_b: u32,
+    c_d_e: String,
+}
+
+#[pyclass(str = "{:?}")]
+#[derive(Debug)]
+struct StructWithNoMember {
+    a: String,
+    b: String,
+}
+
+#[pyclass(str = "{}")]
+#[derive(Debug)]
+struct StructWithNoMember2 {
+    a: String,
+    b: String,
+}
+
+#[pyclass(eq, str = "Stuff...")]
+#[derive(Debug, PartialEq)]
+pub enum MyEnumInvalidStrFmt {
+    Variant,
+    OtherVariant,
+}
+
+impl Display for MyEnumInvalidStrFmt {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{:?}", self)
+    }
+}
+
+#[pyclass(from_py_object, skip_from_py_object)]
+struct StructTooManyFromPyObject {
+    a: String,
+    b: String,
+}
+
+#[pyclass(from_py_object)]
+struct StructFromPyObjectNoClone {
+    a: String,
+    b: String,
+}
+
 fn main() {}
diff --git a/tests/ui/invalid_pyclass_args.stderr b/tests/ui/invalid_pyclass_args.stderr
index 5b2bd24dd3a..98aa1a09118 100644
--- a/tests/ui/invalid_pyclass_args.stderr
+++ b/tests/ui/invalid_pyclass_args.stderr
@@ -1,59 +1,393 @@
-error: expected one of: `crate`, `dict`, `extends`, `freelist`, `frozen`, `get_all`, `mapping`, `module`, `name`, `rename_all`, `sequence`, `set_all`, `subclass`, `unsendable`, `weakref`
- --> tests/ui/invalid_pyclass_args.rs:3:11
+error: expected one of: `crate`, `dict`, `eq`, `eq_int`, `extends`, `freelist`, `frozen`, `get_all`, `hash`, `immutable_type`, `mapping`, `module`, `name`, `ord`, `rename_all`, `sequence`, `set_all`, `str`, `subclass`, `unsendable`, `weakref`, `generic`, `from_py_object`, `skip_from_py_object`
+ --> tests/ui/invalid_pyclass_args.rs:4:11
   |
-3 | #[pyclass(extend=pyo3::types::PyDict)]
+4 | #[pyclass(extend=pyo3::types::PyDict)]
   |           ^^^^^^
 
 error: expected identifier
- --> tests/ui/invalid_pyclass_args.rs:6:21
+ --> tests/ui/invalid_pyclass_args.rs:7:21
   |
-6 | #[pyclass(extends = "PyDict")]
+7 | #[pyclass(extends = "PyDict")]
   |                     ^^^^^^^^
 
 error: expected string literal
- --> tests/ui/invalid_pyclass_args.rs:9:18
-  |
-9 | #[pyclass(name = m::MyClass)]
-  |                  ^
+  --> tests/ui/invalid_pyclass_args.rs:10:18
+   |
+10 | #[pyclass(name = m::MyClass)]
+   |                  ^
 
 error: expected a single identifier in double quotes
-  --> tests/ui/invalid_pyclass_args.rs:12:18
+  --> tests/ui/invalid_pyclass_args.rs:13:18
    |
-12 | #[pyclass(name = "Custom Name")]
+13 | #[pyclass(name = "Custom Name")]
    |                  ^^^^^^^^^^^^^
 
 error: expected string literal
-  --> tests/ui/invalid_pyclass_args.rs:15:18
+  --> tests/ui/invalid_pyclass_args.rs:16:18
    |
-15 | #[pyclass(name = CustomName)]
+16 | #[pyclass(name = CustomName)]
    |                  ^^^^^^^^^^
 
 error: expected string literal
-  --> tests/ui/invalid_pyclass_args.rs:18:24
+  --> tests/ui/invalid_pyclass_args.rs:19:24
    |
-18 | #[pyclass(rename_all = camelCase)]
+19 | #[pyclass(rename_all = camelCase)]
    |                        ^^^^^^^^^
 
 error: expected a valid renaming rule, possible values are: "camelCase", "kebab-case", "lowercase", "PascalCase", "SCREAMING-KEBAB-CASE", "SCREAMING_SNAKE_CASE", "snake_case", "UPPERCASE"
-  --> tests/ui/invalid_pyclass_args.rs:21:24
+  --> tests/ui/invalid_pyclass_args.rs:22:24
    |
-21 | #[pyclass(rename_all = "Camel-Case")]
+22 | #[pyclass(rename_all = "Camel-Case")]
    |                        ^^^^^^^^^^^^
 
 error: expected string literal
-  --> tests/ui/invalid_pyclass_args.rs:24:20
+  --> tests/ui/invalid_pyclass_args.rs:25:20
    |
-24 | #[pyclass(module = my_module)]
+25 | #[pyclass(module = my_module)]
    |                    ^^^^^^^^^
 
-error: expected one of: `crate`, `dict`, `extends`, `freelist`, `frozen`, `get_all`, `mapping`, `module`, `name`, `rename_all`, `sequence`, `set_all`, `subclass`, `unsendable`, `weakref`
-  --> tests/ui/invalid_pyclass_args.rs:27:11
+error: expected one of: `crate`, `dict`, `eq`, `eq_int`, `extends`, `freelist`, `frozen`, `get_all`, `hash`, `immutable_type`, `mapping`, `module`, `name`, `ord`, `rename_all`, `sequence`, `set_all`, `str`, `subclass`, `unsendable`, `weakref`, `generic`, `from_py_object`, `skip_from_py_object`
+  --> tests/ui/invalid_pyclass_args.rs:28:11
    |
-27 | #[pyclass(weakrev)]
+28 | #[pyclass(weakrev)]
    |           ^^^^^^^
 
 error: a `#[pyclass]` cannot be both a `mapping` and a `sequence`
-  --> tests/ui/invalid_pyclass_args.rs:31:8
+  --> tests/ui/invalid_pyclass_args.rs:32:8
    |
-31 | struct CannotBeMappingAndSequence {}
+32 | struct CannotBeMappingAndSequence {}
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: `eq_int` can only be used on simple enums.
+  --> tests/ui/invalid_pyclass_args.rs:53:11
+   |
+53 | #[pyclass(eq_int)]
+   |           ^^^^^^
+
+error: The `hash` option requires the `frozen` option.
+  --> tests/ui/invalid_pyclass_args.rs:60:11
+   |
+60 | #[pyclass(hash)]
+   |           ^^^^
+
+error: The `hash` option requires the `eq` option.
+  --> tests/ui/invalid_pyclass_args.rs:60:11
+   |
+60 | #[pyclass(hash)]
+   |           ^^^^
+
+error: The `ord` option requires the `eq` option.
+  --> tests/ui/invalid_pyclass_args.rs:75:11
+   |
+75 | #[pyclass(ord)]
+   |           ^^^
+
+error: expected one of: `get`, `set`, `name`
+  --> tests/ui/invalid_pyclass_args.rs:82:12
+   |
+82 |     #[pyo3(foo)]
+   |            ^^^
+
+error: expected one of: `get`, `set`, `name`
+  --> tests/ui/invalid_pyclass_args.rs:83:12
+   |
+83 |     #[pyo3(blah)]
+   |            ^^^^
+
+error: expected one of: `get`, `set`, `name`
+  --> tests/ui/invalid_pyclass_args.rs:85:12
+   |
+85 |     #[pyo3(pop)]
+   |            ^^^
+
+error: invalid format string: expected `}` but string was terminated
+   --> tests/ui/invalid_pyclass_args.rs:105:19
+    |
+105 | #[pyclass(str = "{")]
+    |                  -^ expected `}` in format string
+    |                  |
+    |                  because of this opening brace
+    |
+    = note: if you intended to print `{`, you can escape it using `{{`
+
+error: invalid format string: expected `}`, found `$`
+   --> tests/ui/invalid_pyclass_args.rs:109:19
+    |
+109 | #[pyclass(str = "{$}")]
+    |                  -^ expected `}` in format string
+    |                  |
+    |                  because of this opening brace
+    |
+    = note: if you intended to print `{`, you can escape it using `{{`
+
+error: The format string syntax is incompatible with any renaming via `name` or `rename_all`
+   --> tests/ui/invalid_pyclass_args.rs:133:31
+    |
+133 | #[pyclass(name = "aaa", str = "unsafe: {unsafe_variable}")]
+    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: The format string syntax is incompatible with any renaming via `name` or `rename_all`
+   --> tests/ui/invalid_pyclass_args.rs:139:31
+    |
+139 | #[pyclass(name = "aaa", str = "unsafe: {unsafe_variable}")]
+    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: The format string syntax is incompatible with any renaming via `name` or `rename_all`
+   --> tests/ui/invalid_pyclass_args.rs:144:17
+    |
+144 | #[pyclass(str = "unsafe: {unsafe_variable}")]
+    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: The format string syntax is incompatible with any renaming via `name` or `rename_all`
+   --> tests/ui/invalid_pyclass_args.rs:150:54
+    |
+150 | #[pyclass(rename_all = "SCREAMING_SNAKE_CASE", str = "{a_a}, {b_b}, {c_d_e}")]
+    |                                                      ^^^^^^^^^^^^^^^^^^^^^^^
+
+error: No member found, you must provide a named or positionally specified member.
+   --> tests/ui/invalid_pyclass_args.rs:157:17
+    |
+157 | #[pyclass(str = "{:?}")]
+    |                 ^^^^^^
+
+error: No member found, you must provide a named or positionally specified member.
+   --> tests/ui/invalid_pyclass_args.rs:164:17
+    |
+164 | #[pyclass(str = "{}")]
+    |                 ^^^^
+
+error: The format string syntax cannot be used with enums
+   --> tests/ui/invalid_pyclass_args.rs:171:21
+    |
+171 | #[pyclass(eq, str = "Stuff...")]
+    |                     ^^^^^^^^^^
+
+error: `skip_from_py_object` and `from_py_object` are mutually exclusive
+   --> tests/ui/invalid_pyclass_args.rs:184:27
+    |
+184 | #[pyclass(from_py_object, skip_from_py_object)]
+    |                           ^^^^^^^^^^^^^^^^^^^
+
+error[E0277]: the trait bound `StructFromPyObjectNoClone: Clone` is not satisfied
+   --> tests/ui/invalid_pyclass_args.rs:190:11
+    |
+190 | #[pyclass(from_py_object)]
+    |           ^^^^^^^^^^^^^^ the trait `Clone` is not implemented for `StructFromPyObjectNoClone`
+    |
+    = help: see issue #48214
+help: consider annotating `StructFromPyObjectNoClone` with `#[derive(Clone)]`
+    |
+191 + #[derive(Clone)]
+192 | struct StructFromPyObjectNoClone {
+    |
+
+error[E0592]: duplicate definitions with name `__pymethod___richcmp____`
+  --> tests/ui/invalid_pyclass_args.rs:37:1
+   |
+37 | #[pyclass(eq)]
+   | ^^^^^^^^^^^^^^ duplicate definitions for `__pymethod___richcmp____`
+...
+41 | #[pymethods]
+   | ------------ other definition for `__pymethod___richcmp____`
+   |
+   = note: this error originates in the attribute macro `pyclass` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0592]: duplicate definitions with name `__pymethod___hash____`
+  --> tests/ui/invalid_pyclass_args.rs:64:1
+   |
+64 | #[pyclass(frozen, eq, hash)]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ duplicate definitions for `__pymethod___hash____`
+...
+68 | #[pymethods]
+   | ------------ other definition for `__pymethod___hash____`
+   |
+   = note: this error originates in the attribute macro `pyclass` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0592]: duplicate definitions with name `__pymethod___str____`
+  --> tests/ui/invalid_pyclass_args.rs:89:1
+   |
+89 | #[pyclass(str)]
+   | ^^^^^^^^^^^^^^^ duplicate definitions for `__pymethod___str____`
+...
+98 | #[pymethods]
+   | ------------ other definition for `__pymethod___str____`
+   |
+   = note: this error originates in the attribute macro `pyclass` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0369]: binary operation `==` cannot be applied to type `&EqOptRequiresEq`
+  --> tests/ui/invalid_pyclass_args.rs:34:11
+   |
+34 | #[pyclass(eq)]
+   |           ^^
+   |
+note: an implementation of `PartialEq` might be missing for `EqOptRequiresEq`
+  --> tests/ui/invalid_pyclass_args.rs:35:1
+   |
+35 | struct EqOptRequiresEq {}
+   | ^^^^^^^^^^^^^^^^^^^^^^ must implement `PartialEq`
+help: consider annotating `EqOptRequiresEq` with `#[derive(PartialEq)]`
+   |
+35 + #[derive(PartialEq)]
+36 | struct EqOptRequiresEq {}
+   |
+
+error[E0369]: binary operation `!=` cannot be applied to type `&EqOptRequiresEq`
+  --> tests/ui/invalid_pyclass_args.rs:34:11
+   |
+34 | #[pyclass(eq)]
+   |           ^^
+   |
+note: an implementation of `PartialEq` might be missing for `EqOptRequiresEq`
+  --> tests/ui/invalid_pyclass_args.rs:35:1
+   |
+35 | struct EqOptRequiresEq {}
+   | ^^^^^^^^^^^^^^^^^^^^^^ must implement `PartialEq`
+help: consider annotating `EqOptRequiresEq` with `#[derive(PartialEq)]`
+   |
+35 + #[derive(PartialEq)]
+36 | struct EqOptRequiresEq {}
+   |
+
+error[E0034]: multiple applicable items in scope
+  --> tests/ui/invalid_pyclass_args.rs:37:1
+   |
+37 | #[pyclass(eq)]
+   | ^^^^^^^^^^^^^^ multiple `__pymethod___richcmp____` found
+   |
+note: candidate #1 is defined in an impl for the type `EqOptAndManualRichCmp`
+  --> tests/ui/invalid_pyclass_args.rs:37:1
+   |
+37 | #[pyclass(eq)]
+   | ^^^^^^^^^^^^^^
+note: candidate #2 is defined in an impl for the type `EqOptAndManualRichCmp`
+  --> tests/ui/invalid_pyclass_args.rs:41:1
+   |
+41 | #[pymethods]
+   | ^^^^^^^^^^^^
+   = note: this error originates in the attribute macro `pyclass` which comes from the expansion of the attribute macro `pymethods` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0034]: multiple applicable items in scope
+  --> tests/ui/invalid_pyclass_args.rs:41:1
+   |
+41 | #[pymethods]
+   | ^^^^^^^^^^^^ multiple `__pymethod___richcmp____` found
+   |
+note: candidate #1 is defined in an impl for the type `EqOptAndManualRichCmp`
+  --> tests/ui/invalid_pyclass_args.rs:37:1
+   |
+37 | #[pyclass(eq)]
+   | ^^^^^^^^^^^^^^
+note: candidate #2 is defined in an impl for the type `EqOptAndManualRichCmp`
+  --> tests/ui/invalid_pyclass_args.rs:41:1
+   |
+41 | #[pymethods]
+   | ^^^^^^^^^^^^
+   = note: this error originates in the attribute macro `pymethods` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0277]: the trait bound `HashOptRequiresHash: Hash` is not satisfied
+  --> tests/ui/invalid_pyclass_args.rs:56:23
+   |
+56 | #[pyclass(frozen, eq, hash)]
+   |                       ^^^^ the trait `Hash` is not implemented for `HashOptRequiresHash`
+   |
+help: consider annotating `HashOptRequiresHash` with `#[derive(Hash)]`
+   |
+58 + #[derive(Hash)]
+59 | struct HashOptRequiresHash;
+   |
+
+error[E0034]: multiple applicable items in scope
+  --> tests/ui/invalid_pyclass_args.rs:64:1
+   |
+64 | #[pyclass(frozen, eq, hash)]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ multiple `__pymethod___hash____` found
+   |
+note: candidate #1 is defined in an impl for the type `HashOptAndManualHash`
+  --> tests/ui/invalid_pyclass_args.rs:64:1
+   |
+64 | #[pyclass(frozen, eq, hash)]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+note: candidate #2 is defined in an impl for the type `HashOptAndManualHash`
+  --> tests/ui/invalid_pyclass_args.rs:68:1
+   |
+68 | #[pymethods]
+   | ^^^^^^^^^^^^
+   = note: this error originates in the attribute macro `pyclass` which comes from the expansion of the attribute macro `pymethods` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0034]: multiple applicable items in scope
+  --> tests/ui/invalid_pyclass_args.rs:68:1
+   |
+68 | #[pymethods]
+   | ^^^^^^^^^^^^ multiple `__pymethod___hash____` found
+   |
+note: candidate #1 is defined in an impl for the type `HashOptAndManualHash`
+  --> tests/ui/invalid_pyclass_args.rs:64:1
+   |
+64 | #[pyclass(frozen, eq, hash)]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+note: candidate #2 is defined in an impl for the type `HashOptAndManualHash`
+  --> tests/ui/invalid_pyclass_args.rs:68:1
+   |
+68 | #[pymethods]
+   | ^^^^^^^^^^^^
+   = note: this error originates in the attribute macro `pymethods` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0034]: multiple applicable items in scope
+  --> tests/ui/invalid_pyclass_args.rs:89:1
+   |
+89 | #[pyclass(str)]
+   | ^^^^^^^^^^^^^^^ multiple `__pymethod___str____` found
+   |
+note: candidate #1 is defined in an impl for the type `StrOptAndManualStr`
+  --> tests/ui/invalid_pyclass_args.rs:89:1
+   |
+89 | #[pyclass(str)]
+   | ^^^^^^^^^^^^^^^
+note: candidate #2 is defined in an impl for the type `StrOptAndManualStr`
+  --> tests/ui/invalid_pyclass_args.rs:98:1
+   |
+98 | #[pymethods]
+   | ^^^^^^^^^^^^
+   = note: this error originates in the attribute macro `pyclass` which comes from the expansion of the attribute macro `pymethods` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0034]: multiple applicable items in scope
+  --> tests/ui/invalid_pyclass_args.rs:98:1
+   |
+98 | #[pymethods]
+   | ^^^^^^^^^^^^ multiple `__pymethod___str____` found
+   |
+note: candidate #1 is defined in an impl for the type `StrOptAndManualStr`
+  --> tests/ui/invalid_pyclass_args.rs:89:1
+   |
+89 | #[pyclass(str)]
+   | ^^^^^^^^^^^^^^^
+note: candidate #2 is defined in an impl for the type `StrOptAndManualStr`
+  --> tests/ui/invalid_pyclass_args.rs:98:1
+   |
+98 | #[pymethods]
+   | ^^^^^^^^^^^^
+   = note: this error originates in the attribute macro `pymethods` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0609]: no field `aaaa` on type `&Point`
+   --> tests/ui/invalid_pyclass_args.rs:113:17
+    |
+113 | #[pyclass(str = "X: {aaaa}, Y: {y}, Z: {z}")]
+    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^ unknown field
+    |
+    = note: available fields are: `x`, `y`, `z`
+
+error[E0609]: no field `zzz` on type `&Point2`
+   --> tests/ui/invalid_pyclass_args.rs:121:17
+    |
+121 | #[pyclass(str = "X: {x}, Y: {y}}}, Z: {zzz}")]
+    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ unknown field
+    |
+    = note: available fields are: `x`, `y`, `z`
+
+error[E0609]: no field `162543` on type `&Coord3`
+   --> tests/ui/invalid_pyclass_args.rs:129:17
+    |
+129 | #[pyclass(str = "{0}, {162543}, {2}")]
+    |                 ^^^^^^^^^^^^^^^^^^^^ unknown field
+    |
+    = note: available fields are: `0`, `1`, `2`
diff --git a/tests/ui/invalid_pyclass_doc.rs b/tests/ui/invalid_pyclass_doc.rs
new file mode 100644
index 00000000000..55122aa29db
--- /dev/null
+++ b/tests/ui/invalid_pyclass_doc.rs
@@ -0,0 +1,7 @@
+use pyo3::prelude::*;
+
+#[doc = "This \0 contains a nul byte!"]
+#[pyclass]
+struct InvalidDocWithNulByte {}
+
+fn main() {}
diff --git a/tests/ui/invalid_pyclass_doc.stderr b/tests/ui/invalid_pyclass_doc.stderr
new file mode 100644
index 00000000000..7341125f85b
--- /dev/null
+++ b/tests/ui/invalid_pyclass_doc.stderr
@@ -0,0 +1,5 @@
+error: Python doc may not contain nul byte, found nul at position 5
+ --> tests/ui/invalid_pyclass_doc.rs:3:9
+  |
+3 | #[doc = "This \0 contains a nul byte!"]
+  |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/invalid_pyclass_enum.rs b/tests/ui/invalid_pyclass_enum.rs
index 95879c2fbd1..102659e822e 100644
--- a/tests/ui/invalid_pyclass_enum.rs
+++ b/tests/ui/invalid_pyclass_enum.rs
@@ -22,9 +22,84 @@ enum NoUnitVariants {
 }
 
 #[pyclass]
-enum NoTupleVariants {
-    StructVariant { field: i32 },
-    TupleVariant(i32),
+enum SimpleNoSignature {
+    #[pyo3(constructor = (a, b))]
+    A,
+    B,
+}
+
+#[pyclass(eq, eq_int)]
+enum SimpleEqOptRequiresPartialEq {
+    A,
+    B,
+}
+
+#[pyclass(eq)]
+enum ComplexEqOptRequiresPartialEq {
+    A(i32),
+    B { msg: String },
+}
+
+#[pyclass(eq_int)]
+enum SimpleEqIntWithoutEq {
+    A,
+    B,
+}
+
+#[pyclass(eq_int)]
+enum NoEqInt {
+    A(i32),
+    B { msg: String },
+}
+
+#[pyclass(frozen, eq, eq_int, hash)]
+#[derive(PartialEq)]
+enum SimpleHashOptRequiresHash {
+    A,
+    B,
+}
+
+#[pyclass(frozen, eq, hash)]
+#[derive(PartialEq)]
+enum ComplexHashOptRequiresHash {
+    A(i32),
+    B { msg: String },
+}
+
+#[pyclass(hash)]
+#[derive(Hash)]
+enum SimpleHashOptRequiresFrozenAndEq {
+    A,
+    B,
+}
+
+#[pyclass(hash)]
+#[derive(Hash)]
+enum ComplexHashOptRequiresEq {
+    A(i32),
+    B { msg: String },
+}
+
+#[pyclass(ord)]
+enum InvalidOrderedComplexEnum {
+    VariantA (i32),
+    VariantB { msg: String }
+}
+
+#[pyclass(eq,ord)]
+#[derive(PartialEq)]
+enum InvalidOrderedComplexEnum2 {
+    VariantA (i32),
+    VariantB { msg: String }
+}
+
+#[pyclass(eq)]
+#[derive(PartialEq)]
+enum AllEnumVariantsDisabled {
+    #[cfg(any())]
+    DisabledA,
+    #[cfg(not(all()))]
+    DisabledB,
 }
 
 fn main() {}
diff --git a/tests/ui/invalid_pyclass_enum.stderr b/tests/ui/invalid_pyclass_enum.stderr
index a03a0ae2814..80dc9539748 100644
--- a/tests/ui/invalid_pyclass_enum.stderr
+++ b/tests/ui/invalid_pyclass_enum.stderr
@@ -17,17 +17,217 @@ error: #[pyclass] can't be used on enums without any variants
    |                  ^^
 
 error: Unit variant `UnitVariant` is not yet supported in a complex enum
-       = help: change to a struct variant with no fields: `UnitVariant { }`
+       = help: change to an empty tuple variant instead: `UnitVariant()`
        = note: the enum is complex because of non-unit variant `StructVariant`
   --> tests/ui/invalid_pyclass_enum.rs:21:5
    |
 21 |     UnitVariant,
    |     ^^^^^^^^^^^
 
-error: Tuple variant `TupleVariant` is not yet supported in a complex enum
-       = help: change to a struct variant with named fields: `TupleVariant { /* fields */ }`
-       = note: the enum is complex because of non-unit variant `StructVariant`
-  --> tests/ui/invalid_pyclass_enum.rs:27:5
+error: `constructor` can't be used on a simple enum variant
+  --> tests/ui/invalid_pyclass_enum.rs:26:12
+   |
+26 |     #[pyo3(constructor = (a, b))]
+   |            ^^^^^^^^^^^
+
+error: The `eq_int` option requires the `eq` option.
+  --> tests/ui/invalid_pyclass_enum.rs:43:11
+   |
+43 | #[pyclass(eq_int)]
+   |           ^^^^^^
+
+error: `eq_int` can only be used on simple enums.
+  --> tests/ui/invalid_pyclass_enum.rs:49:11
+   |
+49 | #[pyclass(eq_int)]
+   |           ^^^^^^
+
+error: The `hash` option requires the `frozen` option.
+  --> tests/ui/invalid_pyclass_enum.rs:69:11
+   |
+69 | #[pyclass(hash)]
+   |           ^^^^
+
+error: The `hash` option requires the `eq` option.
+  --> tests/ui/invalid_pyclass_enum.rs:69:11
+   |
+69 | #[pyclass(hash)]
+   |           ^^^^
+
+error: The `hash` option requires the `eq` option.
+  --> tests/ui/invalid_pyclass_enum.rs:76:11
+   |
+76 | #[pyclass(hash)]
+   |           ^^^^
+
+error: The `ord` option requires the `eq` option.
+  --> tests/ui/invalid_pyclass_enum.rs:83:11
+   |
+83 | #[pyclass(ord)]
+   |           ^^^
+
+error: #[pyclass] can't be used on enums without any variants - all variants of enum `AllEnumVariantsDisabled` have been configured out by cfg attributes
+  --> tests/ui/invalid_pyclass_enum.rs:98:6
+   |
+98 | enum AllEnumVariantsDisabled {
+   |      ^^^^^^^^^^^^^^^^^^^^^^^
+
+error[E0369]: binary operation `==` cannot be applied to type `&SimpleEqOptRequiresPartialEq`
+  --> tests/ui/invalid_pyclass_enum.rs:31:11
+   |
+31 | #[pyclass(eq, eq_int)]
+   |           ^^
+   |
+note: an implementation of `PartialEq` might be missing for `SimpleEqOptRequiresPartialEq`
+  --> tests/ui/invalid_pyclass_enum.rs:32:1
+   |
+32 | enum SimpleEqOptRequiresPartialEq {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ must implement `PartialEq`
+help: consider annotating `SimpleEqOptRequiresPartialEq` with `#[derive(PartialEq)]`
+   |
+32 + #[derive(PartialEq)]
+33 | enum SimpleEqOptRequiresPartialEq {
+   |
+
+error[E0369]: binary operation `!=` cannot be applied to type `&SimpleEqOptRequiresPartialEq`
+  --> tests/ui/invalid_pyclass_enum.rs:31:11
+   |
+31 | #[pyclass(eq, eq_int)]
+   |           ^^
+   |
+note: an implementation of `PartialEq` might be missing for `SimpleEqOptRequiresPartialEq`
+  --> tests/ui/invalid_pyclass_enum.rs:32:1
+   |
+32 | enum SimpleEqOptRequiresPartialEq {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ must implement `PartialEq`
+help: consider annotating `SimpleEqOptRequiresPartialEq` with `#[derive(PartialEq)]`
+   |
+32 + #[derive(PartialEq)]
+33 | enum SimpleEqOptRequiresPartialEq {
+   |
+
+error[E0369]: binary operation `==` cannot be applied to type `&ComplexEqOptRequiresPartialEq`
+  --> tests/ui/invalid_pyclass_enum.rs:37:11
+   |
+37 | #[pyclass(eq)]
+   |           ^^
+   |
+note: an implementation of `PartialEq` might be missing for `ComplexEqOptRequiresPartialEq`
+  --> tests/ui/invalid_pyclass_enum.rs:38:1
+   |
+38 | enum ComplexEqOptRequiresPartialEq {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ must implement `PartialEq`
+help: consider annotating `ComplexEqOptRequiresPartialEq` with `#[derive(PartialEq)]`
+   |
+38 + #[derive(PartialEq)]
+39 | enum ComplexEqOptRequiresPartialEq {
+   |
+
+error[E0369]: binary operation `!=` cannot be applied to type `&ComplexEqOptRequiresPartialEq`
+  --> tests/ui/invalid_pyclass_enum.rs:37:11
+   |
+37 | #[pyclass(eq)]
+   |           ^^
+   |
+note: an implementation of `PartialEq` might be missing for `ComplexEqOptRequiresPartialEq`
+  --> tests/ui/invalid_pyclass_enum.rs:38:1
+   |
+38 | enum ComplexEqOptRequiresPartialEq {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ must implement `PartialEq`
+help: consider annotating `ComplexEqOptRequiresPartialEq` with `#[derive(PartialEq)]`
+   |
+38 + #[derive(PartialEq)]
+39 | enum ComplexEqOptRequiresPartialEq {
+   |
+
+error[E0277]: the trait bound `SimpleHashOptRequiresHash: Hash` is not satisfied
+  --> tests/ui/invalid_pyclass_enum.rs:55:31
+   |
+55 | #[pyclass(frozen, eq, eq_int, hash)]
+   |                               ^^^^ the trait `Hash` is not implemented for `SimpleHashOptRequiresHash`
+   |
+help: consider annotating `SimpleHashOptRequiresHash` with `#[derive(Hash)]`
+   |
+57 + #[derive(Hash)]
+58 | enum SimpleHashOptRequiresHash {
+   |
+
+error[E0277]: the trait bound `ComplexHashOptRequiresHash: Hash` is not satisfied
+  --> tests/ui/invalid_pyclass_enum.rs:62:23
+   |
+62 | #[pyclass(frozen, eq, hash)]
+   |                       ^^^^ the trait `Hash` is not implemented for `ComplexHashOptRequiresHash`
+   |
+help: consider annotating `ComplexHashOptRequiresHash` with `#[derive(Hash)]`
+   |
+64 + #[derive(Hash)]
+65 | enum ComplexHashOptRequiresHash {
+   |
+
+error[E0369]: binary operation `>` cannot be applied to type `&InvalidOrderedComplexEnum2`
+  --> tests/ui/invalid_pyclass_enum.rs:89:14
+   |
+89 | #[pyclass(eq,ord)]
+   |              ^^^
+   |
+note: an implementation of `PartialOrd` might be missing for `InvalidOrderedComplexEnum2`
+  --> tests/ui/invalid_pyclass_enum.rs:91:1
+   |
+91 | enum InvalidOrderedComplexEnum2 {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ must implement `PartialOrd`
+help: consider annotating `InvalidOrderedComplexEnum2` with `#[derive(PartialEq, PartialOrd)]`
+   |
+91 + #[derive(PartialEq, PartialOrd)]
+92 | enum InvalidOrderedComplexEnum2 {
+   |
+
+error[E0369]: binary operation `<` cannot be applied to type `&InvalidOrderedComplexEnum2`
+  --> tests/ui/invalid_pyclass_enum.rs:89:14
+   |
+89 | #[pyclass(eq,ord)]
+   |              ^^^
+   |
+note: an implementation of `PartialOrd` might be missing for `InvalidOrderedComplexEnum2`
+  --> tests/ui/invalid_pyclass_enum.rs:91:1
+   |
+91 | enum InvalidOrderedComplexEnum2 {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ must implement `PartialOrd`
+help: consider annotating `InvalidOrderedComplexEnum2` with `#[derive(PartialEq, PartialOrd)]`
+   |
+91 + #[derive(PartialEq, PartialOrd)]
+92 | enum InvalidOrderedComplexEnum2 {
+   |
+
+error[E0369]: binary operation `<=` cannot be applied to type `&InvalidOrderedComplexEnum2`
+  --> tests/ui/invalid_pyclass_enum.rs:89:14
+   |
+89 | #[pyclass(eq,ord)]
+   |              ^^^
+   |
+note: an implementation of `PartialOrd` might be missing for `InvalidOrderedComplexEnum2`
+  --> tests/ui/invalid_pyclass_enum.rs:91:1
+   |
+91 | enum InvalidOrderedComplexEnum2 {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ must implement `PartialOrd`
+help: consider annotating `InvalidOrderedComplexEnum2` with `#[derive(PartialEq, PartialOrd)]`
+   |
+91 + #[derive(PartialEq, PartialOrd)]
+92 | enum InvalidOrderedComplexEnum2 {
+   |
+
+error[E0369]: binary operation `>=` cannot be applied to type `&InvalidOrderedComplexEnum2`
+  --> tests/ui/invalid_pyclass_enum.rs:89:14
+   |
+89 | #[pyclass(eq,ord)]
+   |              ^^^
+   |
+note: an implementation of `PartialOrd` might be missing for `InvalidOrderedComplexEnum2`
+  --> tests/ui/invalid_pyclass_enum.rs:91:1
+   |
+91 | enum InvalidOrderedComplexEnum2 {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ must implement `PartialOrd`
+help: consider annotating `InvalidOrderedComplexEnum2` with `#[derive(PartialEq, PartialOrd)]`
+   |
+91 + #[derive(PartialEq, PartialOrd)]
+92 | enum InvalidOrderedComplexEnum2 {
    |
-27 |     TupleVariant(i32),
-   |     ^^^^^^^^^^^^
diff --git a/tests/ui/invalid_pyclass_generic.rs b/tests/ui/invalid_pyclass_generic.rs
new file mode 100644
index 00000000000..dac8c057d81
--- /dev/null
+++ b/tests/ui/invalid_pyclass_generic.rs
@@ -0,0 +1,23 @@
+use pyo3::prelude::*;
+use pyo3::types::PyType;
+
+#[pyclass(generic)]
+struct ClassRedefinesClassGetItem {}
+
+#[pymethods]
+impl ClassRedefinesClassGetItem {
+    #[new]
+    fn new() -> ClassRedefinesClassGetItem {
+        Self {}
+    }
+
+    #[classmethod]
+    pub fn __class_getitem__(
+        cls: &Bound<'_, PyType>,
+        key: &Bound<'_, PyAny>,
+    ) -> PyResult<Py<PyAny>> {
+        pyo3::types::PyGenericAlias::new(cls.py(), cls.as_any(), key)
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/invalid_pyclass_generic.stderr b/tests/ui/invalid_pyclass_generic.stderr
new file mode 100644
index 00000000000..9fb5db15b0a
--- /dev/null
+++ b/tests/ui/invalid_pyclass_generic.stderr
@@ -0,0 +1,132 @@
+error[E0592]: duplicate definitions with name `__pymethod___class_getitem____`
+ --> tests/ui/invalid_pyclass_generic.rs:4:1
+  |
+4 | #[pyclass(generic)]
+  | ^^^^^^^^^^^^^^^^^^^ duplicate definitions for `__pymethod___class_getitem____`
+...
+7 | #[pymethods]
+  | ------------ other definition for `__pymethod___class_getitem____`
+  |
+  = note: this error originates in the attribute macro `pyclass` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0592]: duplicate definitions with name `__class_getitem__`
+  --> tests/ui/invalid_pyclass_generic.rs:4:1
+   |
+ 4 |   #[pyclass(generic)]
+   |   ^^^^^^^^^^^^^^^^^^^ duplicate definitions for `__class_getitem__`
+...
+15 | /     pub fn __class_getitem__(
+16 | |         cls: &Bound<'_, PyType>,
+17 | |         key: &Bound<'_, PyAny>,
+18 | |     ) -> PyResult<Py<PyAny>> {
+   | |____________________________- other definition for `__class_getitem__`
+   |
+   = note: this error originates in the attribute macro `pyclass` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0034]: multiple applicable items in scope
+ --> tests/ui/invalid_pyclass_generic.rs:4:1
+  |
+4 | #[pyclass(generic)]
+  | ^^^^^^^^^^^^^^^^^^^ multiple `__pymethod___class_getitem____` found
+  |
+note: candidate #1 is defined in an impl for the type `ClassRedefinesClassGetItem`
+ --> tests/ui/invalid_pyclass_generic.rs:4:1
+  |
+4 | #[pyclass(generic)]
+  | ^^^^^^^^^^^^^^^^^^^
+note: candidate #2 is defined in an impl for the type `ClassRedefinesClassGetItem`
+ --> tests/ui/invalid_pyclass_generic.rs:7:1
+  |
+7 | #[pymethods]
+  | ^^^^^^^^^^^^
+  = note: this error originates in the attribute macro `pyclass` which comes from the expansion of the attribute macro `pymethods` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0034]: multiple applicable items in scope
+  --> tests/ui/invalid_pyclass_generic.rs:4:1
+   |
+ 4 | #[pyclass(generic)]
+   | ^^^^^^^^^^^^^^^^^^^ multiple `__class_getitem__` found
+   |
+note: candidate #1 is defined in an impl for the type `ClassRedefinesClassGetItem`
+  --> tests/ui/invalid_pyclass_generic.rs:4:1
+   |
+ 4 | #[pyclass(generic)]
+   | ^^^^^^^^^^^^^^^^^^^
+note: candidate #2 is defined in an impl for the type `ClassRedefinesClassGetItem`
+  --> tests/ui/invalid_pyclass_generic.rs:15:5
+   |
+15 | /     pub fn __class_getitem__(
+16 | |         cls: &Bound<'_, PyType>,
+17 | |         key: &Bound<'_, PyAny>,
+18 | |     ) -> PyResult<Py<PyAny>> {
+   | |____________________________^
+   = note: this error originates in the attribute macro `pyclass` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0034]: multiple applicable items in scope
+ --> tests/ui/invalid_pyclass_generic.rs:4:1
+  |
+4 | #[pyclass(generic)]
+  | ^^^^^^^^^^^^^^^^^^^ multiple `wrap` found
+  |
+  = note: candidate #1 is defined in an impl for the type `IntoPyObjectConverter<Result<T, E>>`
+  = note: candidate #2 is defined in an impl for the type `IntoPyObjectConverter<T>`
+  = note: this error originates in the attribute macro `pyclass` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0308]: mismatched types
+  --> tests/ui/invalid_pyclass_generic.rs:19:9
+   |
+18 |     ) -> PyResult<Py<PyAny>> {
+   |          ------------------- expected `Result<pyo3::Py<pyo3::PyAny>, PyErr>` because of return type
+19 |         pyo3::types::PyGenericAlias::new(cls.py(), cls.as_any(), key)
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Result<Py<PyAny>, PyErr>`, found `Result<Bound<'_, PyGenericAlias>, PyErr>`
+   |
+   = note: expected enum `Result<pyo3::Py<pyo3::PyAny>, PyErr>`
+              found enum `Result<pyo3::Bound<'_, PyGenericAlias>, PyErr>`
+
+error[E0034]: multiple applicable items in scope
+  --> tests/ui/invalid_pyclass_generic.rs:15:12
+   |
+15 |     pub fn __class_getitem__(
+   |            ^^^^^^^^^^^^^^^^^ multiple `__pymethod___class_getitem____` found
+   |
+note: candidate #1 is defined in an impl for the type `ClassRedefinesClassGetItem`
+  --> tests/ui/invalid_pyclass_generic.rs:4:1
+   |
+ 4 | #[pyclass(generic)]
+   | ^^^^^^^^^^^^^^^^^^^
+note: candidate #2 is defined in an impl for the type `ClassRedefinesClassGetItem`
+  --> tests/ui/invalid_pyclass_generic.rs:7:1
+   |
+ 7 | #[pymethods]
+   | ^^^^^^^^^^^^
+   = note: this error originates in the attribute macro `pyclass` which comes from the expansion of the attribute macro `pymethods` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0034]: multiple applicable items in scope
+  --> tests/ui/invalid_pyclass_generic.rs:15:12
+   |
+15 |     pub fn __class_getitem__(
+   |            ^^^^^^^^^^^^^^^^^ multiple `__class_getitem__` found
+   |
+note: candidate #1 is defined in an impl for the type `ClassRedefinesClassGetItem`
+  --> tests/ui/invalid_pyclass_generic.rs:4:1
+   |
+ 4 | #[pyclass(generic)]
+   | ^^^^^^^^^^^^^^^^^^^
+note: candidate #2 is defined in an impl for the type `ClassRedefinesClassGetItem`
+  --> tests/ui/invalid_pyclass_generic.rs:15:5
+   |
+15 | /     pub fn __class_getitem__(
+16 | |         cls: &Bound<'_, PyType>,
+17 | |         key: &Bound<'_, PyAny>,
+18 | |     ) -> PyResult<Py<PyAny>> {
+   | |____________________________^
+   = note: this error originates in the attribute macro `pyclass` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0034]: multiple applicable items in scope
+  --> tests/ui/invalid_pyclass_generic.rs:18:10
+   |
+18 |     ) -> PyResult<Py<PyAny>> {
+   |          ^^^^^^^^ multiple `wrap` found
+   |
+   = note: candidate #1 is defined in an impl for the type `IntoPyObjectConverter<Result<T, E>>`
+   = note: candidate #2 is defined in an impl for the type `IntoPyObjectConverter<T>`
diff --git a/tests/ui/invalid_pyfunction_argument.rs b/tests/ui/invalid_pyfunction_argument.rs
new file mode 100644
index 00000000000..0505c2f0ad0
--- /dev/null
+++ b/tests/ui/invalid_pyfunction_argument.rs
@@ -0,0 +1,18 @@
+use pyo3::prelude::*;
+use std::sync::atomic::AtomicPtr;
+
+#[pyfunction]
+fn invalid_pyfunction_argument(arg: AtomicPtr<()>) {
+    let _ = arg;
+}
+
+#[pyclass(skip_from_py_object)]
+#[derive(Clone)]
+struct Foo;
+
+#[pyfunction]
+fn skip_from_py_object_without_custom_from_py_object(arg: Foo) {
+    let _ = arg;
+}
+
+fn main() {}
diff --git a/tests/ui/invalid_pyfunction_argument.stderr b/tests/ui/invalid_pyfunction_argument.stderr
new file mode 100644
index 00000000000..fe867f6a797
--- /dev/null
+++ b/tests/ui/invalid_pyfunction_argument.stderr
@@ -0,0 +1,91 @@
+error[E0277]: `AtomicPtr<()>` cannot be used as a Python function argument
+ --> tests/ui/invalid_pyfunction_argument.rs:5:37
+  |
+5 | fn invalid_pyfunction_argument(arg: AtomicPtr<()>) {
+  |                                     ^^^^^^^^^ the trait `PyClass` is not implemented for `AtomicPtr<()>`
+  |
+  = note: implement `FromPyObject` to enable using `AtomicPtr<()>` as a function argument
+  = note: `Python<'py>` is also a valid argument type to pass the Python token into `#[pyfunction]`s and `#[pymethods]`
+  = help: the trait `PyClass` is implemented for `Foo`
+  = note: required for `AtomicPtr<()>` to implement `FromPyObject<'_, '_>`
+  = note: required for `AtomicPtr<()>` to implement `PyFunctionArgument<'_, '_, '_, true>`
+note: required by a bound in `extract_argument`
+ --> src/impl_/extract_argument.rs
+  |
+  | pub fn extract_argument<'a, 'holder, 'py, T, const IMPLEMENTS_FROMPYOBJECT: bool>(
+  |        ---------------- required by a bound in this function
+...
+  |     T: PyFunctionArgument<'a, 'holder, 'py, IMPLEMENTS_FROMPYOBJECT>,
+  |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `extract_argument`
+
+error[E0277]: `AtomicPtr<()>` cannot be used as a Python function argument
+ --> tests/ui/invalid_pyfunction_argument.rs:5:37
+  |
+5 | fn invalid_pyfunction_argument(arg: AtomicPtr<()>) {
+  |                                     ^^^^^^^^^ the trait `Clone` is not implemented for `AtomicPtr<()>`
+  |
+  = note: implement `FromPyObject` to enable using `AtomicPtr<()>` as a function argument
+  = note: `Python<'py>` is also a valid argument type to pass the Python token into `#[pyfunction]`s and `#[pymethods]`
+  = help: the following other types implement trait `PyFunctionArgument<'a, 'holder, 'py, IMPLEMENTS_FROMPYOBJECT>`:
+            `&'a pyo3::Bound<'py, T>` implements `PyFunctionArgument<'a, '_, 'py, false>`
+            `&'holder T` implements `PyFunctionArgument<'a, 'holder, '_, false>`
+            `&'holder mut T` implements `PyFunctionArgument<'a, 'holder, '_, false>`
+            `Option<T>` implements `PyFunctionArgument<'a, 'holder, 'py, false>`
+  = note: required for `AtomicPtr<()>` to implement `FromPyObject<'_, '_>`
+  = note: required for `AtomicPtr<()>` to implement `PyFunctionArgument<'_, '_, '_, true>`
+note: required by a bound in `extract_argument`
+ --> src/impl_/extract_argument.rs
+  |
+  | pub fn extract_argument<'a, 'holder, 'py, T, const IMPLEMENTS_FROMPYOBJECT: bool>(
+  |        ---------------- required by a bound in this function
+...
+  |     T: PyFunctionArgument<'a, 'holder, 'py, IMPLEMENTS_FROMPYOBJECT>,
+  |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `extract_argument`
+
+error[E0277]: `AtomicPtr<()>` cannot be used as a Python function argument
+ --> tests/ui/invalid_pyfunction_argument.rs:5:37
+  |
+5 | fn invalid_pyfunction_argument(arg: AtomicPtr<()>) {
+  |                                     ^^^^^^^^^ the trait `ExtractPyClassWithClone` is not implemented for `AtomicPtr<()>`
+  |
+  = note: implement `FromPyObject` to enable using `AtomicPtr<()>` as a function argument
+  = note: `Python<'py>` is also a valid argument type to pass the Python token into `#[pyfunction]`s and `#[pymethods]`
+  = help: the following other types implement trait `PyFunctionArgument<'a, 'holder, 'py, IMPLEMENTS_FROMPYOBJECT>`:
+            `&'a pyo3::Bound<'py, T>` implements `PyFunctionArgument<'a, '_, 'py, false>`
+            `&'holder T` implements `PyFunctionArgument<'a, 'holder, '_, false>`
+            `&'holder mut T` implements `PyFunctionArgument<'a, 'holder, '_, false>`
+            `Option<T>` implements `PyFunctionArgument<'a, 'holder, 'py, false>`
+  = note: required for `AtomicPtr<()>` to implement `FromPyObject<'_, '_>`
+  = note: required for `AtomicPtr<()>` to implement `PyFunctionArgument<'_, '_, '_, true>`
+note: required by a bound in `extract_argument`
+ --> src/impl_/extract_argument.rs
+  |
+  | pub fn extract_argument<'a, 'holder, 'py, T, const IMPLEMENTS_FROMPYOBJECT: bool>(
+  |        ---------------- required by a bound in this function
+...
+  |     T: PyFunctionArgument<'a, 'holder, 'py, IMPLEMENTS_FROMPYOBJECT>,
+  |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `extract_argument`
+
+error[E0277]: `Foo` cannot be used as a Python function argument
+  --> tests/ui/invalid_pyfunction_argument.rs:14:59
+   |
+14 | fn skip_from_py_object_without_custom_from_py_object(arg: Foo) {
+   |                                                           ^^^ the trait `ExtractPyClassWithClone` is not implemented for `Foo`
+   |
+   = note: implement `FromPyObject` to enable using `Foo` as a function argument
+   = note: `Python<'py>` is also a valid argument type to pass the Python token into `#[pyfunction]`s and `#[pymethods]`
+   = help: the following other types implement trait `PyFunctionArgument<'a, 'holder, 'py, IMPLEMENTS_FROMPYOBJECT>`:
+             `&'a pyo3::Bound<'py, T>` implements `PyFunctionArgument<'a, '_, 'py, false>`
+             `&'holder T` implements `PyFunctionArgument<'a, 'holder, '_, false>`
+             `&'holder mut T` implements `PyFunctionArgument<'a, 'holder, '_, false>`
+             `Option<T>` implements `PyFunctionArgument<'a, 'holder, 'py, false>`
+   = note: required for `Foo` to implement `FromPyObject<'_, '_>`
+   = note: required for `Foo` to implement `PyFunctionArgument<'_, '_, '_, true>`
+note: required by a bound in `extract_argument`
+  --> src/impl_/extract_argument.rs
+   |
+   | pub fn extract_argument<'a, 'holder, 'py, T, const IMPLEMENTS_FROMPYOBJECT: bool>(
+   |        ---------------- required by a bound in this function
+...
+   |     T: PyFunctionArgument<'a, 'holder, 'py, IMPLEMENTS_FROMPYOBJECT>,
+   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `extract_argument`
diff --git a/tests/ui/invalid_pyfunction_definition.rs b/tests/ui/invalid_pyfunction_definition.rs
new file mode 100644
index 00000000000..2f08ff421b9
--- /dev/null
+++ b/tests/ui/invalid_pyfunction_definition.rs
@@ -0,0 +1,15 @@
+#[pyo3::pymodule]
+mod pyo3_scratch {
+    use pyo3::prelude::*;
+
+    #[pyclass]
+    struct Foo {}
+
+    #[pymethods]
+    impl Foo {
+        #[pyfunction]
+        fn bug() {}
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/invalid_pyfunction_definition.stderr b/tests/ui/invalid_pyfunction_definition.stderr
new file mode 100644
index 00000000000..9c7cac1f0f3
--- /dev/null
+++ b/tests/ui/invalid_pyfunction_definition.stderr
@@ -0,0 +1,5 @@
+error: functions inside #[pymethods] do not need to be annotated with #[pyfunction]
+  --> tests/ui/invalid_pyfunction_definition.rs:11:9
+   |
+11 |         fn bug() {}
+   |         ^^
diff --git a/tests/ui/invalid_pyfunction_signatures.rs b/tests/ui/invalid_pyfunction_signatures.rs
index f5a9bee4e6c..d6799885cbb 100644
--- a/tests/ui/invalid_pyfunction_signatures.rs
+++ b/tests/ui/invalid_pyfunction_signatures.rs
@@ -35,6 +35,7 @@ fn function_with_args_sep_after_args_sep() {}
 #[pyo3(signature = (**kwargs, *args))]
 fn function_with_args_after_kwargs(kwargs: Option<&PyDict>, args: &PyTuple) {
     let _ = args;
+    let _ = kwargs;
 }
 
 #[pyfunction]
@@ -54,9 +55,17 @@ struct MyClass;
 
 #[pymethods]
 impl MyClass {
-    #[args(x)]
-    #[pyo3(signature = (x))]
-    fn method_with_both_args_and_signature(&self, x: i32) {
+    #[pyo3(signature = (**kwargs, *, *args, x))]
+    fn multiple_errors_same_order(kwargs: Option<&PyDict>, args: &PyTuple, x: i32) {
+        let _ = kwargs;
+        let _ = args;
+        let _ = x;
+    }
+
+    #[pyo3(signature = (**kwargs, *, *args, x))]
+    fn multiple_errors_different_order(args: &PyTuple, x: i32, kwargs: Option<&PyDict>) {
+        let _ = kwargs;
+        let _ = args;
         let _ = x;
     }
 }
diff --git a/tests/ui/invalid_pyfunction_signatures.stderr b/tests/ui/invalid_pyfunction_signatures.stderr
index dbca169d8ea..c7ddb11dd37 100644
--- a/tests/ui/invalid_pyfunction_signatures.stderr
+++ b/tests/ui/invalid_pyfunction_signatures.stderr
@@ -16,7 +16,7 @@ error: expected argument from function definition `y` but got argument `x`
 13 | #[pyo3(signature = (x))]
    |                     ^
 
-error: expected one of: `name`, `pass_module`, `signature`, `text_signature`, `crate`
+error: expected one of: `name`, `pass_module`, `signature`, `text_signature`, `crate`, `warn`
   --> tests/ui/invalid_pyfunction_signatures.rs:18:14
    |
 18 | #[pyfunction(x)]
@@ -41,19 +41,25 @@ error: `*args` not allowed after `**kwargs`
    |                               ^
 
 error: `**kwargs_b` not allowed after `**kwargs_a`
-  --> tests/ui/invalid_pyfunction_signatures.rs:41:33
+  --> tests/ui/invalid_pyfunction_signatures.rs:42:33
    |
-41 | #[pyo3(signature = (**kwargs_a, **kwargs_b))]
+42 | #[pyo3(signature = (**kwargs_a, **kwargs_b))]
    |                                 ^
 
 error: arguments of type `Python` must not be part of the signature
-  --> tests/ui/invalid_pyfunction_signatures.rs:47:27
+  --> tests/ui/invalid_pyfunction_signatures.rs:48:27
    |
-47 | #[pyfunction(signature = (py))]
+48 | #[pyfunction(signature = (py))]
    |                           ^^
 
-error: cannot find attribute `args` in this scope
-  --> tests/ui/invalid_pyfunction_signatures.rs:57:7
+error: expected argument from function definition `args` but got argument `kwargs`
+  --> tests/ui/invalid_pyfunction_signatures.rs:58:27
    |
-57 |     #[args(x)]
-   |       ^^^^
+58 |     #[pyo3(signature = (**kwargs, *, *args, x))]
+   |                           ^^^^^^
+
+error: expected argument from function definition `x` but got argument `kwargs`
+  --> tests/ui/invalid_pyfunction_signatures.rs:65:27
+   |
+65 |     #[pyo3(signature = (**kwargs, *, *args, x))]
+   |                           ^^^^^^
diff --git a/tests/ui/invalid_pyfunction_warn.rs b/tests/ui/invalid_pyfunction_warn.rs
new file mode 100644
index 00000000000..fe1b72dbc3f
--- /dev/null
+++ b/tests/ui/invalid_pyfunction_warn.rs
@@ -0,0 +1,47 @@
+use pyo3::prelude::*;
+
+#[pyfunction]
+#[pyo3(warn)]
+fn no_parenthesis_deprecated() {}
+
+#[pyfunction]
+#[pyo3(warn())]
+fn no_message_deprecated() {}
+
+#[pyfunction]
+#[pyo3(warn(category = pyo3::exceptions::PyDeprecationWarning))]
+fn no_message_deprecated_with_category() {}
+
+#[pyfunction]
+#[pyo3(warn(category = pyo3::exceptions::PyDeprecationWarning, message = ,))]
+fn empty_message_deprecated_with_category() {}
+
+#[pyfunction]
+#[pyo3(warn(message = "deprecated function", category = ,))]
+fn empty_category_deprecated_with_message() {}
+
+#[pyfunction]
+#[pyo3(warn(message = "deprecated function", random_key))]
+fn random_key_deprecated() {}
+
+#[pyclass]
+struct DeprecatedMethodContainer {}
+
+#[pymethods]
+impl DeprecatedMethodContainer {
+    #[classattr]
+    #[pyo3(warn(message = "deprecated class attr"))]
+    fn deprecated_class_attr() -> i32 {
+        5
+    }
+}
+
+#[pymethods]
+impl DeprecatedMethodContainer {
+    #[pyo3(warn(message = "deprecated __traverse__"))]
+    fn __traverse__(&self, _visit: pyo3::gc::PyVisit<'_>) -> Result<(), pyo3::PyTraverseError> {
+        Ok(())
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/invalid_pyfunction_warn.stderr b/tests/ui/invalid_pyfunction_warn.stderr
new file mode 100644
index 00000000000..584abfcdeaf
--- /dev/null
+++ b/tests/ui/invalid_pyfunction_warn.stderr
@@ -0,0 +1,47 @@
+error: unexpected end of input, expected parentheses
+ --> tests/ui/invalid_pyfunction_warn.rs:4:12
+  |
+4 | #[pyo3(warn)]
+  |            ^
+
+error: missing `message` in `warn` attribute
+ --> tests/ui/invalid_pyfunction_warn.rs:8:13
+  |
+8 | #[pyo3(warn())]
+  |             ^
+
+error: missing `message` in `warn` attribute
+  --> tests/ui/invalid_pyfunction_warn.rs:12:62
+   |
+12 | #[pyo3(warn(category = pyo3::exceptions::PyDeprecationWarning))]
+   |                                                              ^
+
+error: expected string literal
+  --> tests/ui/invalid_pyfunction_warn.rs:16:74
+   |
+16 | #[pyo3(warn(category = pyo3::exceptions::PyDeprecationWarning, message = ,))]
+   |                                                                          ^
+
+error: expected identifier
+  --> tests/ui/invalid_pyfunction_warn.rs:20:57
+   |
+20 | #[pyo3(warn(message = "deprecated function", category = ,))]
+   |                                                         ^
+
+error: expected `message` or `category`
+  --> tests/ui/invalid_pyfunction_warn.rs:24:46
+   |
+24 | #[pyo3(warn(message = "deprecated function", random_key))]
+   |                                              ^^^^^^^^^^
+
+error: #[classattr] cannot be used with #[pyo3(warn)]
+  --> tests/ui/invalid_pyfunction_warn.rs:33:12
+   |
+33 |     #[pyo3(warn(message = "deprecated class attr"))]
+   |            ^^^^
+
+error: __traverse__ cannot be used with #[pyo3(warn)]
+  --> tests/ui/invalid_pyfunction_warn.rs:41:12
+   |
+41 |     #[pyo3(warn(message = "deprecated __traverse__"))]
+   |            ^^^^
diff --git a/tests/ui/invalid_pyfunctions.rs b/tests/ui/invalid_pyfunctions.rs
index fba7d8b5016..cb59808ecc7 100644
--- a/tests/ui/invalid_pyfunctions.rs
+++ b/tests/ui/invalid_pyfunctions.rs
@@ -1,25 +1,38 @@
 use pyo3::prelude::*;
+use pyo3::types::{PyDict, PyString, PyTuple};
 
 #[pyfunction]
-fn generic_function<T>(value: T) {}
+fn generic_function<T>(_value: T) {}
 
 #[pyfunction]
-fn impl_trait_function(impl_trait: impl AsRef<PyAny>) {}
+fn impl_trait_function(_impl_trait: impl AsRef<PyAny>) {}
 
 #[pyfunction]
 fn wildcard_argument(_: i32) {}
 
 #[pyfunction]
-fn destructured_argument((a, b): (i32, i32)) {}
+fn destructured_argument((_a, _b): (i32, i32)) {}
 
 #[pyfunction]
-fn function_with_required_after_option(_opt: Option<i32>, _x: i32) {}
+#[pyo3(signature=(*args))]
+fn function_with_optional_args(args: Option<Bound<'_, PyTuple>>) {
+    let _ = args;
+}
+
+#[pyfunction]
+#[pyo3(signature=(**kwargs))]
+fn function_with_required_kwargs(kwargs: Bound<'_, PyDict>) {
+    let _ = kwargs;
+}
 
 #[pyfunction(pass_module)]
 fn pass_module_but_no_arguments<'py>() {}
 
 #[pyfunction(pass_module)]
-fn first_argument_not_module<'py>(string: &str, module: &'py PyModule) -> PyResult<&'py str> {
+fn first_argument_not_module<'a, 'py>(
+    _string: &str,
+    module: &'a Bound<'py, PyModule>,
+) -> PyResult<Bound<'py, PyString>> {
     module.name()
 }
 
diff --git a/tests/ui/invalid_pyfunctions.stderr b/tests/ui/invalid_pyfunctions.stderr
index 6576997a3eb..e48c522976a 100644
--- a/tests/ui/invalid_pyfunctions.stderr
+++ b/tests/ui/invalid_pyfunctions.stderr
@@ -1,51 +1,56 @@
 error: Python functions cannot have generic type parameters
- --> tests/ui/invalid_pyfunctions.rs:4:21
+ --> tests/ui/invalid_pyfunctions.rs:5:21
   |
-4 | fn generic_function<T>(value: T) {}
+5 | fn generic_function<T>(_value: T) {}
   |                     ^
 
 error: Python functions cannot have `impl Trait` arguments
- --> tests/ui/invalid_pyfunctions.rs:7:36
+ --> tests/ui/invalid_pyfunctions.rs:8:37
   |
-7 | fn impl_trait_function(impl_trait: impl AsRef<PyAny>) {}
-  |                                    ^^^^
+8 | fn impl_trait_function(_impl_trait: impl AsRef<PyAny>) {}
+  |                                     ^^^^
 
 error: wildcard argument names are not supported
-  --> tests/ui/invalid_pyfunctions.rs:10:22
+  --> tests/ui/invalid_pyfunctions.rs:11:22
    |
-10 | fn wildcard_argument(_: i32) {}
+11 | fn wildcard_argument(_: i32) {}
    |                      ^
 
 error: destructuring in arguments is not supported
-  --> tests/ui/invalid_pyfunctions.rs:13:26
+  --> tests/ui/invalid_pyfunctions.rs:14:26
    |
-13 | fn destructured_argument((a, b): (i32, i32)) {}
-   |                          ^^^^^^
+14 | fn destructured_argument((_a, _b): (i32, i32)) {}
+   |                          ^^^^^^^^
 
-error: required arguments after an `Option<_>` argument are ambiguous
-       = help: add a `#[pyo3(signature)]` annotation on this function to unambiguously specify the default values for all optional parameters
-  --> tests/ui/invalid_pyfunctions.rs:16:63
+error: args cannot be optional
+  --> tests/ui/invalid_pyfunctions.rs:18:32
    |
-16 | fn function_with_required_after_option(_opt: Option<i32>, _x: i32) {}
-   |                                                               ^^^
+18 | fn function_with_optional_args(args: Option<Bound<'_, PyTuple>>) {
+   |                                ^^^^
+
+error: kwargs must be Option<_>
+  --> tests/ui/invalid_pyfunctions.rs:24:34
+   |
+24 | fn function_with_required_kwargs(kwargs: Bound<'_, PyDict>) {
+   |                                  ^^^^^^
 
 error: expected `&PyModule` or `Py<PyModule>` as first argument with `pass_module`
-  --> tests/ui/invalid_pyfunctions.rs:19:37
+  --> tests/ui/invalid_pyfunctions.rs:29:37
    |
-19 | fn pass_module_but_no_arguments<'py>() {}
+29 | fn pass_module_but_no_arguments<'py>() {}
    |                                     ^^
 
-error[E0277]: the trait bound `&str: From<BoundRef<'_, '_, pyo3::prelude::PyModule>>` is not satisfied
-  --> tests/ui/invalid_pyfunctions.rs:22:43
+error[E0277]: the trait bound `&str: From<BoundRef<'_, '_, pyo3::types::PyModule>>` is not satisfied
+  --> tests/ui/invalid_pyfunctions.rs:33:14
    |
-22 | fn first_argument_not_module<'py>(string: &str, module: &'py PyModule) -> PyResult<&'py str> {
-   |                                           ^ the trait `From<BoundRef<'_, '_, pyo3::prelude::PyModule>>` is not implemented for `&str`
+33 |     _string: &str,
+   |              ^ the trait `From<BoundRef<'_, '_, pyo3::types::PyModule>>` is not implemented for `&str`
    |
    = help: the following other types implement trait `From<T>`:
-             <String as From<char>>
-             <String as From<Box<str>>>
-             <String as From<Cow<'a, str>>>
-             <String as From<&str>>
-             <String as From<&mut str>>
-             <String as From<&String>>
-   = note: required for `BoundRef<'_, '_, pyo3::prelude::PyModule>` to implement `Into<&str>`
+             `String` implements `From<&String>`
+             `String` implements `From<&mut str>`
+             `String` implements `From<&str>`
+             `String` implements `From<Box<str>>`
+             `String` implements `From<Cow<'_, str>>`
+             `String` implements `From<char>`
+   = note: required for `BoundRef<'_, '_, pyo3::types::PyModule>` to implement `Into<&str>`
diff --git a/tests/ui/invalid_pymethod_enum.rs b/tests/ui/invalid_pymethod_enum.rs
index 9b596e087ff..5c41d19d4e7 100644
--- a/tests/ui/invalid_pymethod_enum.rs
+++ b/tests/ui/invalid_pymethod_enum.rs
@@ -16,4 +16,20 @@ impl ComplexEnum {
     }
 }
 
+#[pyclass]
+enum TupleEnum {
+    Int(i32),
+    Str(String),
+}
+
+#[pymethods]
+impl TupleEnum {
+    fn mutate_in_place(&mut self) {
+        *self = match self {
+            TupleEnum::Int(int) => TupleEnum::Str(int.to_string()),
+            TupleEnum::Str(string) => TupleEnum::Int(string.len() as i32),
+        }
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/invalid_pymethod_enum.stderr b/tests/ui/invalid_pymethod_enum.stderr
index bb327dccb5d..3c574320cb5 100644
--- a/tests/ui/invalid_pymethod_enum.stderr
+++ b/tests/ui/invalid_pymethod_enum.stderr
@@ -2,10 +2,70 @@ error[E0271]: type mismatch resolving `<ComplexEnum as PyClass>::Frozen == False
   --> tests/ui/invalid_pymethod_enum.rs:11:24
    |
 11 |     fn mutate_in_place(&mut self) {
-   |                        ^ expected `False`, found `True`
+   |                        ^ type mismatch resolving `<ComplexEnum as PyClass>::Frozen == False`
    |
+note: expected this to be `False`
+  --> tests/ui/invalid_pymethod_enum.rs:3:1
+   |
+ 3 | #[pyclass]
+   | ^^^^^^^^^^
 note: required by a bound in `extract_pyclass_ref_mut`
   --> src/impl_/extract_argument.rs
    |
-   | pub fn extract_pyclass_ref_mut<'a, 'py: 'a, T: PyClass<Frozen = False>>(
+   | pub fn extract_pyclass_ref_mut<'a, 'holder, T: PyClass<Frozen = False>>(
    |                                                        ^^^^^^^^^^^^^^ required by this bound in `extract_pyclass_ref_mut`
+   = note: this error originates in the attribute macro `pyclass` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0271]: type mismatch resolving `<ComplexEnum as PyClass>::Frozen == False`
+ --> tests/ui/invalid_pymethod_enum.rs:9:1
+  |
+9 | #[pymethods]
+  | ^^^^^^^^^^^^ type mismatch resolving `<ComplexEnum as PyClass>::Frozen == False`
+  |
+note: expected this to be `False`
+ --> tests/ui/invalid_pymethod_enum.rs:3:1
+  |
+3 | #[pyclass]
+  | ^^^^^^^^^^
+note: required by a bound in `PyClassGuardMut`
+ --> src/pyclass/guard.rs
+  |
+  | pub struct PyClassGuardMut<'a, T: PyClass<Frozen = False>> {
+  |                                           ^^^^^^^^^^^^^^ required by this bound in `PyClassGuardMut`
+  = note: this error originates in the attribute macro `pymethods` which comes from the expansion of the attribute macro `pyclass` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0271]: type mismatch resolving `<TupleEnum as PyClass>::Frozen == False`
+  --> tests/ui/invalid_pymethod_enum.rs:27:24
+   |
+27 |     fn mutate_in_place(&mut self) {
+   |                        ^ type mismatch resolving `<TupleEnum as PyClass>::Frozen == False`
+   |
+note: expected this to be `False`
+  --> tests/ui/invalid_pymethod_enum.rs:19:1
+   |
+19 | #[pyclass]
+   | ^^^^^^^^^^
+note: required by a bound in `extract_pyclass_ref_mut`
+  --> src/impl_/extract_argument.rs
+   |
+   | pub fn extract_pyclass_ref_mut<'a, 'holder, T: PyClass<Frozen = False>>(
+   |                                                        ^^^^^^^^^^^^^^ required by this bound in `extract_pyclass_ref_mut`
+   = note: this error originates in the attribute macro `pyclass` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0271]: type mismatch resolving `<TupleEnum as PyClass>::Frozen == False`
+  --> tests/ui/invalid_pymethod_enum.rs:25:1
+   |
+25 | #[pymethods]
+   | ^^^^^^^^^^^^ type mismatch resolving `<TupleEnum as PyClass>::Frozen == False`
+   |
+note: expected this to be `False`
+  --> tests/ui/invalid_pymethod_enum.rs:19:1
+   |
+19 | #[pyclass]
+   | ^^^^^^^^^^
+note: required by a bound in `PyClassGuardMut`
+  --> src/pyclass/guard.rs
+   |
+   | pub struct PyClassGuardMut<'a, T: PyClass<Frozen = False>> {
+   |                                           ^^^^^^^^^^^^^^ required by this bound in `PyClassGuardMut`
+   = note: this error originates in the attribute macro `pymethods` which comes from the expansion of the attribute macro `pyclass` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/tests/ui/invalid_pymethod_receiver.rs b/tests/ui/invalid_pymethod_receiver.rs
index 77832e12857..4949ff96022 100644
--- a/tests/ui/invalid_pymethod_receiver.rs
+++ b/tests/ui/invalid_pymethod_receiver.rs
@@ -5,7 +5,7 @@ struct MyClass {}
 
 #[pymethods]
 impl MyClass {
-    fn method_with_invalid_self_type(slf: i32, py: Python<'_>, index: u32) {}
+    fn method_with_invalid_self_type(_slf: i32, _py: Python<'_>, _index: u32) {}
 }
 
 fn main() {}
diff --git a/tests/ui/invalid_pymethod_receiver.stderr b/tests/ui/invalid_pymethod_receiver.stderr
index b7a7880dbde..7d81c0fae91 100644
--- a/tests/ui/invalid_pymethod_receiver.stderr
+++ b/tests/ui/invalid_pymethod_receiver.stderr
@@ -1,15 +1,14 @@
-error[E0277]: the trait bound `i32: From<&PyCell<MyClass>>` is not satisfied
- --> tests/ui/invalid_pymethod_receiver.rs:8:43
+error[E0277]: the trait bound `i32: TryFrom<BoundRef<'_, '_, MyClass>>` is not satisfied
+ --> tests/ui/invalid_pymethod_receiver.rs:8:44
   |
-8 |     fn method_with_invalid_self_type(slf: i32, py: Python<'_>, index: u32) {}
-  |                                           ^^^ the trait `From<&PyCell<MyClass>>` is not implemented for `i32`
+8 |     fn method_with_invalid_self_type(_slf: i32, _py: Python<'_>, _index: u32) {}
+  |                                            ^^^ the trait `From<BoundRef<'_, '_, MyClass>>` is not implemented for `i32`
   |
   = help: the following other types implement trait `From<T>`:
-            <i32 as From<bool>>
-            <i32 as From<i8>>
-            <i32 as From<i16>>
-            <i32 as From<u8>>
-            <i32 as From<u16>>
-            <i32 as From<NonZeroI32>>
-  = note: required for `&PyCell<MyClass>` to implement `Into<i32>`
-  = note: required for `i32` to implement `TryFrom<&PyCell<MyClass>>`
+            `i32` implements `From<bool>`
+            `i32` implements `From<i16>`
+            `i32` implements `From<i8>`
+            `i32` implements `From<u16>`
+            `i32` implements `From<u8>`
+  = note: required for `BoundRef<'_, '_, MyClass>` to implement `Into<i32>`
+  = note: required for `i32` to implement `TryFrom<BoundRef<'_, '_, MyClass>>`
diff --git a/tests/ui/invalid_pymethods.rs b/tests/ui/invalid_pymethods.rs
index 00bddfe2fad..372490ca580 100644
--- a/tests/ui/invalid_pymethods.rs
+++ b/tests/ui/invalid_pymethods.rs
@@ -6,44 +6,31 @@ struct MyClass {}
 #[pymethods]
 impl MyClass {
     #[classattr]
-    fn class_attr_with_args(foo: i32) {}
-}
+    fn class_attr_with_args(_foo: i32) {}
 
-#[pymethods]
-impl MyClass {
     #[classattr(foobar)]
     const CLASS_ATTR_WITH_ATTRIBUTE_ARG: i32 = 3;
-}
 
-#[pymethods]
-impl MyClass {
     fn staticmethod_without_attribute() {}
-}
 
-#[pymethods]
-impl MyClass {
     #[staticmethod]
     fn staticmethod_with_receiver(&self) {}
-}
 
-#[pymethods]
-impl MyClass {
     #[classmethod]
     fn classmethod_with_receiver(&self) {}
-}
 
-#[pymethods]
-impl MyClass {
     #[classmethod]
     fn classmethod_missing_argument() -> Self {
         Self {}
     }
 }
 
+struct NotATypeObject;
+
 #[pymethods]
 impl MyClass {
     #[classmethod]
-    fn classmethod_wrong_first_argument(_x: i32) -> Self {
+    fn classmethod_wrong_first_argument(_t: NotATypeObject) -> Self {
         Self {}
     }
 }
@@ -64,37 +51,22 @@ impl MyClass {
 impl MyClass {
     #[pyo3(name = "__call__", text_signature = "()")]
     fn text_signature_on_call() {}
-}
 
-#[pymethods]
-impl MyClass {
     #[getter(x)]
     #[pyo3(text_signature = "()")]
     fn text_signature_on_getter(&self) {}
-}
 
-#[pymethods]
-impl MyClass {
     #[setter(x)]
     #[pyo3(text_signature = "()")]
     fn text_signature_on_setter(&self) {}
-}
 
-#[pymethods]
-impl MyClass {
     #[classattr]
     #[pyo3(text_signature = "()")]
     fn text_signature_on_classattr() {}
-}
 
-#[pymethods]
-impl MyClass {
     #[pyo3(text_signature = 1)]
     fn invalid_text_signature() {}
-}
 
-#[pymethods]
-impl MyClass {
     #[pyo3(text_signature = "()")]
     #[pyo3(text_signature = None)]
     fn duplicate_text_signature() {}
@@ -105,17 +77,11 @@ impl MyClass {
     #[getter(x)]
     #[pyo3(signature = ())]
     fn signature_on_getter(&self) {}
-}
 
-#[pymethods]
-impl MyClass {
     #[setter(x)]
     #[pyo3(signature = ())]
     fn signature_on_setter(&self) {}
-}
 
-#[pymethods]
-impl MyClass {
     #[classattr]
     #[pyo3(signature = ())]
     fn signature_on_classattr() {}
@@ -164,23 +130,20 @@ impl MyClass {
 
 #[pymethods]
 impl MyClass {
-    fn generic_method<T>(value: T) {}
+    fn generic_method<T>(_value: T) {}
 }
 
 #[pymethods]
 impl MyClass {
-    fn impl_trait_method_first_arg(impl_trait: impl AsRef<PyAny>) {}
-}
+    fn impl_trait_method_first_arg(_impl_trait: impl AsRef<PyAny>) {}
 
-#[pymethods]
-impl MyClass {
-    fn impl_trait_method_second_arg(&self, impl_trait: impl AsRef<PyAny>) {}
+    fn impl_trait_method_second_arg(&self, _impl_trait: impl AsRef<PyAny>) {}
 }
 
 #[pymethods]
 impl MyClass {
     #[pyo3(pass_module)]
-    fn method_cannot_pass_module(&self, m: &PyModule) {}
+    fn method_cannot_pass_module(&self, _m: &PyModule) {}
 }
 
 #[pymethods]
@@ -197,4 +160,17 @@ impl MyClass {
     macro_invocation!();
 }
 
+#[pymethods]
+impl MyClass {
+    #[staticmethod]
+    #[classmethod]
+    fn multiple_errors_static_and_class_method() {}
+
+    #[staticmethod]
+    fn multiple_errors_staticmethod_with_receiver(&self) {}
+
+    #[classmethod]
+    fn multiple_errors_classmethod_with_receiver(&self) {}
+}
+
 fn main() {}
diff --git a/tests/ui/invalid_pymethods.stderr b/tests/ui/invalid_pymethods.stderr
index 6a8d6ecab78..66acc374f63 100644
--- a/tests/ui/invalid_pymethods.stderr
+++ b/tests/ui/invalid_pymethods.stderr
@@ -1,195 +1,206 @@
 error: #[classattr] can only have one argument (of type pyo3::Python)
- --> tests/ui/invalid_pymethods.rs:9:34
+ --> tests/ui/invalid_pymethods.rs:9:35
   |
-9 |     fn class_attr_with_args(foo: i32) {}
-  |                                  ^^^
+9 |     fn class_attr_with_args(_foo: i32) {}
+  |                                   ^^^
 
 error: `#[classattr]` does not take any arguments
-  --> tests/ui/invalid_pymethods.rs:14:5
+  --> tests/ui/invalid_pymethods.rs:11:5
    |
-14 |     #[classattr(foobar)]
+11 |     #[classattr(foobar)]
    |     ^
 
 error: static method needs #[staticmethod] attribute
-  --> tests/ui/invalid_pymethods.rs:20:5
+  --> tests/ui/invalid_pymethods.rs:14:5
    |
-20 |     fn staticmethod_without_attribute() {}
+14 |     fn staticmethod_without_attribute() {}
    |     ^^
 
 error: unexpected receiver
-  --> tests/ui/invalid_pymethods.rs:26:35
+  --> tests/ui/invalid_pymethods.rs:17:35
    |
-26 |     fn staticmethod_with_receiver(&self) {}
+17 |     fn staticmethod_with_receiver(&self) {}
    |                                   ^
 
 error: Expected `&Bound<PyType>` or `Py<PyType>` as the first argument to `#[classmethod]`
-  --> tests/ui/invalid_pymethods.rs:32:33
+  --> tests/ui/invalid_pymethods.rs:20:33
    |
-32 |     fn classmethod_with_receiver(&self) {}
+20 |     fn classmethod_with_receiver(&self) {}
    |                                 ^^^^^^^
 
 error: Expected `&Bound<PyType>` or `Py<PyType>` as the first argument to `#[classmethod]`
-  --> tests/ui/invalid_pymethods.rs:38:36
+  --> tests/ui/invalid_pymethods.rs:23:36
    |
-38 |     fn classmethod_missing_argument() -> Self {
+23 |     fn classmethod_missing_argument() -> Self {
    |                                    ^^
 
 error: expected receiver for `#[getter]`
-  --> tests/ui/invalid_pymethods.rs:54:5
+  --> tests/ui/invalid_pymethods.rs:41:5
    |
-54 |     fn getter_without_receiver() {}
+41 |     fn getter_without_receiver() {}
    |     ^^
 
 error: expected receiver for `#[setter]`
-  --> tests/ui/invalid_pymethods.rs:60:5
+  --> tests/ui/invalid_pymethods.rs:47:5
    |
-60 |     fn setter_without_receiver() {}
+47 |     fn setter_without_receiver() {}
    |     ^^
 
 error: static method needs #[staticmethod] attribute
-  --> tests/ui/invalid_pymethods.rs:66:5
+  --> tests/ui/invalid_pymethods.rs:53:5
    |
-66 |     fn text_signature_on_call() {}
+53 |     fn text_signature_on_call() {}
    |     ^^
 
 error: `text_signature` not allowed with `getter`
-  --> tests/ui/invalid_pymethods.rs:72:12
+  --> tests/ui/invalid_pymethods.rs:56:12
    |
-72 |     #[pyo3(text_signature = "()")]
+56 |     #[pyo3(text_signature = "()")]
    |            ^^^^^^^^^^^^^^
 
 error: `text_signature` not allowed with `setter`
-  --> tests/ui/invalid_pymethods.rs:79:12
+  --> tests/ui/invalid_pymethods.rs:60:12
    |
-79 |     #[pyo3(text_signature = "()")]
+60 |     #[pyo3(text_signature = "()")]
    |            ^^^^^^^^^^^^^^
 
 error: `text_signature` not allowed with `classattr`
-  --> tests/ui/invalid_pymethods.rs:86:12
+  --> tests/ui/invalid_pymethods.rs:64:12
    |
-86 |     #[pyo3(text_signature = "()")]
+64 |     #[pyo3(text_signature = "()")]
    |            ^^^^^^^^^^^^^^
 
 error: expected a string literal or `None`
-  --> tests/ui/invalid_pymethods.rs:92:30
+  --> tests/ui/invalid_pymethods.rs:67:30
    |
-92 |     #[pyo3(text_signature = 1)]
+67 |     #[pyo3(text_signature = 1)]
    |                              ^
 
 error: `text_signature` may only be specified once
-  --> tests/ui/invalid_pymethods.rs:99:12
+  --> tests/ui/invalid_pymethods.rs:71:12
    |
-99 |     #[pyo3(text_signature = None)]
+71 |     #[pyo3(text_signature = None)]
    |            ^^^^^^^^^^^^^^
 
 error: `signature` not allowed with `getter`
-   --> tests/ui/invalid_pymethods.rs:106:12
-    |
-106 |     #[pyo3(signature = ())]
-    |            ^^^^^^^^^
+  --> tests/ui/invalid_pymethods.rs:78:12
+   |
+78 |     #[pyo3(signature = ())]
+   |            ^^^^^^^^^
 
 error: `signature` not allowed with `setter`
-   --> tests/ui/invalid_pymethods.rs:113:12
-    |
-113 |     #[pyo3(signature = ())]
-    |            ^^^^^^^^^
+  --> tests/ui/invalid_pymethods.rs:82:12
+   |
+82 |     #[pyo3(signature = ())]
+   |            ^^^^^^^^^
 
 error: `signature` not allowed with `classattr`
-   --> tests/ui/invalid_pymethods.rs:120:12
-    |
-120 |     #[pyo3(signature = ())]
-    |            ^^^^^^^^^
+  --> tests/ui/invalid_pymethods.rs:86:12
+   |
+86 |     #[pyo3(signature = ())]
+   |            ^^^^^^^^^
 
 error: `#[new]` may not be combined with `#[classmethod]` `#[staticmethod]`, `#[classattr]`, `#[getter]`, and `#[setter]`
-   --> tests/ui/invalid_pymethods.rs:126:7
-    |
-126 |     #[new]
-    |       ^^^
+  --> tests/ui/invalid_pymethods.rs:92:7
+   |
+92 |     #[new]
+   |       ^^^
 
 error: `#[new]` does not take any arguments
        = help: did you mean `#[new] #[pyo3(signature = ())]`?
-   --> tests/ui/invalid_pymethods.rs:137:7
+   --> tests/ui/invalid_pymethods.rs:103:7
     |
-137 |     #[new(signature = ())]
+103 |     #[new(signature = ())]
     |       ^^^
 
 error: `#[new]` does not take any arguments
        = note: this was previously accepted and ignored
-   --> tests/ui/invalid_pymethods.rs:143:11
+   --> tests/ui/invalid_pymethods.rs:109:11
     |
-143 |     #[new = ()] // in this form there's no suggestion to move arguments to `#[pyo3()]` attribute
+109 |     #[new = ()] // in this form there's no suggestion to move arguments to `#[pyo3()]` attribute
     |           ^
 
 error: `#[classmethod]` does not take any arguments
        = help: did you mean `#[classmethod] #[pyo3(signature = ())]`?
-   --> tests/ui/invalid_pymethods.rs:149:7
+   --> tests/ui/invalid_pymethods.rs:115:7
     |
-149 |     #[classmethod(signature = ())]
+115 |     #[classmethod(signature = ())]
     |       ^^^^^^^^^^^
 
 error: `#[staticmethod]` does not take any arguments
        = help: did you mean `#[staticmethod] #[pyo3(signature = ())]`?
-   --> tests/ui/invalid_pymethods.rs:155:7
+   --> tests/ui/invalid_pymethods.rs:121:7
     |
-155 |     #[staticmethod(signature = ())]
+121 |     #[staticmethod(signature = ())]
     |       ^^^^^^^^^^^^
 
 error: `#[classattr]` does not take any arguments
        = help: did you mean `#[classattr] #[pyo3(signature = ())]`?
-   --> tests/ui/invalid_pymethods.rs:161:7
+   --> tests/ui/invalid_pymethods.rs:127:7
     |
-161 |     #[classattr(signature = ())]
+127 |     #[classattr(signature = ())]
     |       ^^^^^^^^^
 
 error: Python functions cannot have generic type parameters
-   --> tests/ui/invalid_pymethods.rs:167:23
+   --> tests/ui/invalid_pymethods.rs:133:23
     |
-167 |     fn generic_method<T>(value: T) {}
+133 |     fn generic_method<T>(_value: T) {}
     |                       ^
 
 error: Python functions cannot have `impl Trait` arguments
-   --> tests/ui/invalid_pymethods.rs:172:48
+   --> tests/ui/invalid_pymethods.rs:138:49
     |
-172 |     fn impl_trait_method_first_arg(impl_trait: impl AsRef<PyAny>) {}
-    |                                                ^^^^
+138 |     fn impl_trait_method_first_arg(_impl_trait: impl AsRef<PyAny>) {}
+    |                                                 ^^^^
 
 error: Python functions cannot have `impl Trait` arguments
-   --> tests/ui/invalid_pymethods.rs:177:56
+   --> tests/ui/invalid_pymethods.rs:140:57
     |
-177 |     fn impl_trait_method_second_arg(&self, impl_trait: impl AsRef<PyAny>) {}
-    |                                                        ^^^^
+140 |     fn impl_trait_method_second_arg(&self, _impl_trait: impl AsRef<PyAny>) {}
+    |                                                         ^^^^
 
 error: `pass_module` cannot be used on Python methods
-   --> tests/ui/invalid_pymethods.rs:182:12
+   --> tests/ui/invalid_pymethods.rs:145:12
     |
-182 |     #[pyo3(pass_module)]
+145 |     #[pyo3(pass_module)]
     |            ^^^^^^^^^^^
 
 error: Python objects are shared, so 'self' cannot be moved out of the Python interpreter.
-       Try `&self`, `&mut self, `slf: PyRef<'_, Self>` or `slf: PyRefMut<'_, Self>`.
-   --> tests/ui/invalid_pymethods.rs:188:29
+       Try `&self`, `&mut self, `slf: PyClassGuard<'_, Self>` or `slf: PyClassGuardMut<'_, Self>`.
+   --> tests/ui/invalid_pymethods.rs:151:29
     |
-188 |     fn method_self_by_value(self) {}
+151 |     fn method_self_by_value(self) {}
     |                             ^^^^
 
 error: macros cannot be used as items in `#[pymethods]` impl blocks
        = note: this was previously accepted and ignored
-   --> tests/ui/invalid_pymethods.rs:197:5
+   --> tests/ui/invalid_pymethods.rs:160:5
     |
-197 |     macro_invocation!();
+160 |     macro_invocation!();
     |     ^^^^^^^^^^^^^^^^
 
-error[E0277]: the trait bound `i32: From<BoundRef<'_, '_, PyType>>` is not satisfied
-  --> tests/ui/invalid_pymethods.rs:46:45
+error: `#[staticmethod]` may not be combined with `#[classmethod]`
+   --> tests/ui/invalid_pymethods.rs:165:7
+    |
+165 |     #[staticmethod]
+    |       ^^^^^^^^^^^^
+
+error: unexpected receiver
+   --> tests/ui/invalid_pymethods.rs:170:51
+    |
+170 |     fn multiple_errors_staticmethod_with_receiver(&self) {}
+    |                                                   ^
+
+error: Expected `&Bound<PyType>` or `Py<PyType>` as the first argument to `#[classmethod]`
+   --> tests/ui/invalid_pymethods.rs:173:49
+    |
+173 |     fn multiple_errors_classmethod_with_receiver(&self) {}
+    |                                                 ^^^^^^^
+
+error[E0277]: the trait bound `NotATypeObject: From<BoundRef<'_, '_, PyType>>` is not satisfied
+  --> tests/ui/invalid_pymethods.rs:33:45
    |
-46 |     fn classmethod_wrong_first_argument(_x: i32) -> Self {
-   |                                             ^^^ the trait `From<BoundRef<'_, '_, PyType>>` is not implemented for `i32`
+33 |     fn classmethod_wrong_first_argument(_t: NotATypeObject) -> Self {
+   |                                             ^^^^^^^^^^^^^^ the trait `From<BoundRef<'_, '_, PyType>>` is not implemented for `NotATypeObject`
    |
-   = help: the following other types implement trait `From<T>`:
-             <i32 as From<bool>>
-             <i32 as From<i8>>
-             <i32 as From<i16>>
-             <i32 as From<u8>>
-             <i32 as From<u16>>
-             <i32 as From<NonZeroI32>>
-   = note: required for `BoundRef<'_, '_, PyType>` to implement `Into<i32>`
+   = note: required for `BoundRef<'_, '_, PyType>` to implement `Into<NotATypeObject>`
diff --git a/tests/ui/invalid_pymethods_buffer.rs b/tests/ui/invalid_pymethods_buffer.rs
index 4eb7c28e091..d16eddee37a 100644
--- a/tests/ui/invalid_pymethods_buffer.rs
+++ b/tests/ui/invalid_pymethods_buffer.rs
@@ -6,7 +6,7 @@ struct MyClass {}
 #[pymethods]
 impl MyClass {
     #[pyo3(name = "__getbuffer__")]
-    fn getbuffer_must_be_unsafe(&self, _view: *mut pyo3::ffi::Py_buffer, _flags: std::os::raw::c_int) {}
+    fn getbuffer_must_be_unsafe(&self, _view: *mut pyo3::ffi::Py_buffer, _flags: std::ffi::c_int) {}
 }
 
 #[pymethods]
diff --git a/tests/ui/invalid_pymethods_buffer.stderr b/tests/ui/invalid_pymethods_buffer.stderr
index 3480848f3cb..899d4a569f4 100644
--- a/tests/ui/invalid_pymethods_buffer.stderr
+++ b/tests/ui/invalid_pymethods_buffer.stderr
@@ -1,7 +1,7 @@
 error: `__getbuffer__` must be `unsafe fn`
  --> tests/ui/invalid_pymethods_buffer.rs:9:8
   |
-9 |     fn getbuffer_must_be_unsafe(&self, _view: *mut pyo3::ffi::Py_buffer, _flags: std::os::raw::c_int) {}
+9 |     fn getbuffer_must_be_unsafe(&self, _view: *mut pyo3::ffi::Py_buffer, _flags: std::ffi::c_int) {}
   |        ^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: `__releasebuffer__` must be `unsafe fn`
diff --git a/tests/ui/invalid_pymethods_duplicates.rs b/tests/ui/invalid_pymethods_duplicates.rs
index d05d70959fc..04435dcb64a 100644
--- a/tests/ui/invalid_pymethods_duplicates.rs
+++ b/tests/ui/invalid_pymethods_duplicates.rs
@@ -3,6 +3,7 @@
 
 use pyo3::prelude::*;
 
+#[pyclass]
 struct TwoNew {}
 
 #[pymethods]
@@ -18,6 +19,7 @@ impl TwoNew {
     }
 }
 
+#[pyclass]
 struct DuplicateMethod {}
 
 #[pymethods]
diff --git a/tests/ui/invalid_pymethods_duplicates.stderr b/tests/ui/invalid_pymethods_duplicates.stderr
index 38bb6f8655b..215bc0640cd 100644
--- a/tests/ui/invalid_pymethods_duplicates.stderr
+++ b/tests/ui/invalid_pymethods_duplicates.stderr
@@ -1,18 +1,18 @@
-error[E0119]: conflicting implementations of trait `pyo3::impl_::pyclass::PyClassNewTextSignature<TwoNew>` for type `pyo3::impl_::pyclass::PyClassImplCollector<TwoNew>`
- --> tests/ui/invalid_pymethods_duplicates.rs:8:1
+error[E0119]: conflicting implementations of trait `PyClassNewTextSignature` for type `TwoNew`
+ --> tests/ui/invalid_pymethods_duplicates.rs:9:1
   |
-8 | #[pymethods]
+9 | #[pymethods]
   | ^^^^^^^^^^^^
   | |
   | first implementation here
-  | conflicting implementation for `pyo3::impl_::pyclass::PyClassImplCollector<TwoNew>`
+  | conflicting implementation for `TwoNew`
   |
   = note: this error originates in the attribute macro `pymethods` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0592]: duplicate definitions with name `__pymethod___new____`
- --> tests/ui/invalid_pymethods_duplicates.rs:8:1
+ --> tests/ui/invalid_pymethods_duplicates.rs:9:1
   |
-8 | #[pymethods]
+9 | #[pymethods]
   | ^^^^^^^^^^^^
   | |
   | duplicate definitions for `__pymethod___new____`
@@ -21,9 +21,9 @@ error[E0592]: duplicate definitions with name `__pymethod___new____`
   = note: this error originates in the attribute macro `pymethods` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0592]: duplicate definitions with name `__pymethod_func__`
-  --> tests/ui/invalid_pymethods_duplicates.rs:23:1
+  --> tests/ui/invalid_pymethods_duplicates.rs:25:1
    |
-23 | #[pymethods]
+25 | #[pymethods]
    | ^^^^^^^^^^^^
    | |
    | duplicate definitions for `__pymethod_func__`
diff --git a/tests/ui/invalid_pymethods_warn.rs b/tests/ui/invalid_pymethods_warn.rs
new file mode 100644
index 00000000000..6c6f39f5dc0
--- /dev/null
+++ b/tests/ui/invalid_pymethods_warn.rs
@@ -0,0 +1,21 @@
+use pyo3::prelude::*;
+
+#[pyclass]
+struct WarningMethodContainer {}
+
+#[pymethods]
+impl WarningMethodContainer {
+    #[pyo3(warn(message = "warn on __traverse__"))]
+    fn __traverse__(&self) {}
+}
+
+#[pymethods]
+impl WarningMethodContainer {
+    #[classattr]
+    #[pyo3(warn(message = "warn for class attr"))]
+    fn a_class_attr(_py: pyo3::Python<'_>) -> i64 {
+        5
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/invalid_pymethods_warn.stderr b/tests/ui/invalid_pymethods_warn.stderr
new file mode 100644
index 00000000000..9e0c8f1d7e9
--- /dev/null
+++ b/tests/ui/invalid_pymethods_warn.stderr
@@ -0,0 +1,11 @@
+error: __traverse__ cannot be used with #[pyo3(warn)]
+ --> tests/ui/invalid_pymethods_warn.rs:8:12
+  |
+8 |     #[pyo3(warn(message = "warn on __traverse__"))]
+  |            ^^^^
+
+error: #[classattr] cannot be used with #[pyo3(warn)]
+  --> tests/ui/invalid_pymethods_warn.rs:15:12
+   |
+15 |     #[pyo3(warn(message = "warn for class attr"))]
+   |            ^^^^
diff --git a/tests/ui/invalid_pymodule_args.rs b/tests/ui/invalid_pymodule_args.rs
index ebd229eef2e..4a6e65de150 100644
--- a/tests/ui/invalid_pymodule_args.rs
+++ b/tests/ui/invalid_pymodule_args.rs
@@ -1,8 +1,16 @@
 use pyo3::prelude::*;
 
 #[pymodule(some_arg)]
-fn module(_py: Python<'_>, m: &PyModule) -> PyResult<()> {
+fn module(m: &Bound<'_, PyModule>) -> PyResult<()> {
     Ok(())
 }
 
-fn main(){}
+#[pyo3::pymodule(gil_used = false, gil_used = true, name = "foo", name = "bar")]
+fn module_fn_multiple_errors(m: &Bound<'_, PyModule>) -> PyResult<()> {
+    Ok(())
+}
+
+#[pyo3::pymodule(gil_used = false, gil_used = true, name = "foo", name = "bar")]
+mod pyo3_module_multiple_errors {}
+
+fn main() {}
diff --git a/tests/ui/invalid_pymodule_args.stderr b/tests/ui/invalid_pymodule_args.stderr
index 933b6d6081c..f741d83a82d 100644
--- a/tests/ui/invalid_pymodule_args.stderr
+++ b/tests/ui/invalid_pymodule_args.stderr
@@ -1,5 +1,29 @@
-error: unexpected token
+error: expected one of: `name`, `crate`, `module`, `submodule`, `gil_used`
  --> tests/ui/invalid_pymodule_args.rs:3:12
   |
 3 | #[pymodule(some_arg)]
   |            ^^^^^^^^
+
+error: `gil_used` may only be specified once
+ --> tests/ui/invalid_pymodule_args.rs:8:36
+  |
+8 | #[pyo3::pymodule(gil_used = false, gil_used = true, name = "foo", name = "bar")]
+  |                                    ^^^^^^^^
+
+error: `name` may only be specified once
+ --> tests/ui/invalid_pymodule_args.rs:8:67
+  |
+8 | #[pyo3::pymodule(gil_used = false, gil_used = true, name = "foo", name = "bar")]
+  |                                                                   ^^^^
+
+error: `gil_used` may only be specified once
+  --> tests/ui/invalid_pymodule_args.rs:13:36
+   |
+13 | #[pyo3::pymodule(gil_used = false, gil_used = true, name = "foo", name = "bar")]
+   |                                    ^^^^^^^^
+
+error: `name` may only be specified once
+  --> tests/ui/invalid_pymodule_args.rs:13:67
+   |
+13 | #[pyo3::pymodule(gil_used = false, gil_used = true, name = "foo", name = "bar")]
+   |                                                                   ^^^^
diff --git a/tests/ui/invalid_pymodule_glob.rs b/tests/ui/invalid_pymodule_glob.rs
new file mode 100644
index 00000000000..853493b535e
--- /dev/null
+++ b/tests/ui/invalid_pymodule_glob.rs
@@ -0,0 +1,16 @@
+#![allow(unused_imports)]
+
+use pyo3::prelude::*;
+
+#[pyfunction]
+fn foo() -> usize {
+    0
+}
+
+#[pymodule]
+mod module {
+    #[pymodule_export]
+    use super::*;
+}
+
+fn main() {}
diff --git a/tests/ui/invalid_pymodule_glob.stderr b/tests/ui/invalid_pymodule_glob.stderr
new file mode 100644
index 00000000000..1c033083e0c
--- /dev/null
+++ b/tests/ui/invalid_pymodule_glob.stderr
@@ -0,0 +1,5 @@
+error: #[pymodule] cannot import glob statements
+  --> tests/ui/invalid_pymodule_glob.rs:13:16
+   |
+13 |     use super::*;
+   |                ^
diff --git a/tests/ui/invalid_pymodule_in_root.rs b/tests/ui/invalid_pymodule_in_root.rs
new file mode 100644
index 00000000000..76ced6c3fb6
--- /dev/null
+++ b/tests/ui/invalid_pymodule_in_root.rs
@@ -0,0 +1,7 @@
+use pyo3::prelude::*;
+
+#[pymodule]
+#[path = "empty.rs"] // to silence error related to missing file
+mod invalid_pymodule_in_root_module;
+
+fn main() {}
diff --git a/tests/ui/invalid_pymodule_in_root.stderr b/tests/ui/invalid_pymodule_in_root.stderr
new file mode 100644
index 00000000000..06152161e5d
--- /dev/null
+++ b/tests/ui/invalid_pymodule_in_root.stderr
@@ -0,0 +1,13 @@
+error[E0658]: non-inline modules in proc macro input are unstable
+ --> tests/ui/invalid_pymodule_in_root.rs:5:1
+  |
+5 | mod invalid_pymodule_in_root_module;
+  | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  |
+  = note: see issue #54727 <https://github.com/rust-lang/rust/issues/54727> for more information
+
+error: `#[pymodule]` can only be used on inline modules
+ --> tests/ui/invalid_pymodule_in_root.rs:5:1
+  |
+5 | mod invalid_pymodule_in_root_module;
+  | ^^^
diff --git a/tests/ui/invalid_pymodule_trait.rs b/tests/ui/invalid_pymodule_trait.rs
new file mode 100644
index 00000000000..6649a3547a0
--- /dev/null
+++ b/tests/ui/invalid_pymodule_trait.rs
@@ -0,0 +1,9 @@
+use pyo3::prelude::*;
+
+#[pymodule]
+mod module {
+    #[pymodule_export]
+    trait Foo {}
+}
+
+fn main() {}
diff --git a/tests/ui/invalid_pymodule_trait.stderr b/tests/ui/invalid_pymodule_trait.stderr
new file mode 100644
index 00000000000..f8cfc1b1bdf
--- /dev/null
+++ b/tests/ui/invalid_pymodule_trait.stderr
@@ -0,0 +1,11 @@
+error: `#[pymodule_export]` may only be used on `use` or `const` statements
+ --> tests/ui/invalid_pymodule_trait.rs:5:5
+  |
+5 |     #[pymodule_export]
+  |     ^
+
+error: cannot find attribute `pymodule_export` in this scope
+ --> tests/ui/invalid_pymodule_trait.rs:5:7
+  |
+5 |     #[pymodule_export]
+  |       ^^^^^^^^^^^^^^^
diff --git a/tests/ui/invalid_pymodule_two_pymodule_init.rs b/tests/ui/invalid_pymodule_two_pymodule_init.rs
new file mode 100644
index 00000000000..ed72cbb7237
--- /dev/null
+++ b/tests/ui/invalid_pymodule_two_pymodule_init.rs
@@ -0,0 +1,18 @@
+use pyo3::prelude::*;
+
+#[pymodule]
+mod module {
+    use pyo3::prelude::*;
+
+    #[pymodule_init]
+    fn init(_m: &Bound<'_, PyModule>) -> PyResult<()> {
+        Ok(())
+    }
+
+    #[pymodule_init]
+    fn init2(_m: &Bound<'_, PyModule>) -> PyResult<()> {
+        Ok(())
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/invalid_pymodule_two_pymodule_init.stderr b/tests/ui/invalid_pymodule_two_pymodule_init.stderr
new file mode 100644
index 00000000000..8fbd12f2e45
--- /dev/null
+++ b/tests/ui/invalid_pymodule_two_pymodule_init.stderr
@@ -0,0 +1,5 @@
+error: only one `#[pymodule_init]` may be specified
+  --> tests/ui/invalid_pymodule_two_pymodule_init.rs:13:5
+   |
+13 |     fn init2(_m: &Bound<'_, PyModule>) -> PyResult<()> {
+   |     ^^
diff --git a/tests/ui/invalid_result_conversion.rs b/tests/ui/invalid_result_conversion.rs
index 4cf3e0bd8fc..692ce71f6dd 100644
--- a/tests/ui/invalid_result_conversion.rs
+++ b/tests/ui/invalid_result_conversion.rs
@@ -20,11 +20,13 @@ impl fmt::Display for MyError {
 
 #[pyfunction]
 fn should_not_work() -> Result<(), MyError> {
-    Err(MyError { descr: "something went wrong" })
+    Err(MyError {
+        descr: "something went wrong",
+    })
 }
 
 fn main() {
-    Python::with_gil(|py|{
+    Python::attach(|py| {
         wrap_pyfunction!(should_not_work)(py);
     });
 }
diff --git a/tests/ui/invalid_result_conversion.stderr b/tests/ui/invalid_result_conversion.stderr
index b3e65517e36..f782e00828f 100644
--- a/tests/ui/invalid_result_conversion.stderr
+++ b/tests/ui/invalid_result_conversion.stderr
@@ -1,18 +1,17 @@
 error[E0277]: the trait bound `PyErr: From<MyError>` is not satisfied
-  --> tests/ui/invalid_result_conversion.rs:21:1
+  --> tests/ui/invalid_result_conversion.rs:22:25
    |
-21 | #[pyfunction]
-   | ^^^^^^^^^^^^^ the trait `From<MyError>` is not implemented for `PyErr`
+22 | fn should_not_work() -> Result<(), MyError> {
+   |                         ^^^^^^ the trait `From<MyError>` is not implemented for `PyErr`
    |
    = help: the following other types implement trait `From<T>`:
-             <PyErr as From<std::io::Error>>
-             <PyErr as From<PyBorrowError>>
-             <PyErr as From<PyBorrowMutError>>
-             <PyErr as From<PyDowncastError<'a>>>
-             <PyErr as From<DowncastError<'_, '_>>>
-             <PyErr as From<DowncastIntoError<'_>>>
-             <PyErr as From<NulError>>
-             <PyErr as From<IntoStringError>>
+             `PyErr` implements `From<AddrParseError>`
+             `PyErr` implements `From<DecodeUtf16Error>`
+             `PyErr` implements `From<DowncastError<'_, '_>>`
+             `PyErr` implements `From<DowncastIntoError<'_>>`
+             `PyErr` implements `From<FromUtf16Error>`
+             `PyErr` implements `From<FromUtf8Error>`
+             `PyErr` implements `From<Infallible>`
+             `PyErr` implements `From<IntoInnerError<W>>`
            and $N others
    = note: required for `MyError` to implement `Into<PyErr>`
-   = note: this error originates in the attribute macro `pyfunction` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/tests/ui/missing_intopy.rs b/tests/ui/missing_intopy.rs
index 7a465b14221..36de7bdee78 100644
--- a/tests/ui/missing_intopy.rs
+++ b/tests/ui/missing_intopy.rs
@@ -1,8 +1,8 @@
 struct Blah;
 
 #[pyo3::pyfunction]
-fn blah() -> Blah{
+fn blah() -> Blah {
     Blah
 }
 
-fn main(){}
\ No newline at end of file
+fn main() {}
diff --git a/tests/ui/missing_intopy.stderr b/tests/ui/missing_intopy.stderr
index 26b32b3e742..afa8d9e48a4 100644
--- a/tests/ui/missing_intopy.stderr
+++ b/tests/ui/missing_intopy.stderr
@@ -1,18 +1,36 @@
-error[E0277]: the trait bound `Blah: IntoPy<Py<PyAny>>` is not satisfied
- --> tests/ui/missing_intopy.rs:3:1
+error[E0277]: `Blah` cannot be converted to a Python object
+ --> tests/ui/missing_intopy.rs:4:14
   |
-3 | #[pyo3::pyfunction]
-  | ^^^^^^^^^^^^^^^^^^^ the trait `IntoPy<Py<PyAny>>` is not implemented for `Blah`
+4 | fn blah() -> Blah {
+  |              ^^^^ the trait `IntoPyObject<'_>` is not implemented for `Blah`
   |
-  = help: the following other types implement trait `IntoPy<T>`:
-            <bool as IntoPy<Py<PyAny>>>
-            <char as IntoPy<Py<PyAny>>>
-            <isize as IntoPy<Py<PyAny>>>
-            <i8 as IntoPy<Py<PyAny>>>
-            <i16 as IntoPy<Py<PyAny>>>
-            <i32 as IntoPy<Py<PyAny>>>
-            <i64 as IntoPy<Py<PyAny>>>
-            <i128 as IntoPy<Py<PyAny>>>
+  = note: `IntoPyObject` is automatically implemented by the `#[pyclass]` macro
+  = note: if you do not wish to have a corresponding Python type, implement it manually
+  = note: if you do not own `Blah` you can perform a manual conversion to one of the types in `pyo3::types::*`
+  = help: the following other types implement trait `IntoPyObject<'py>`:
+            &&'a T
+            &&OsStr
+            &&Path
+            &&str
+            &'a (T0, T1)
+            &'a (T0, T1, T2)
+            &'a (T0, T1, T2, T3)
+            &'a (T0, T1, T2, T3, T4)
           and $N others
-  = note: required for `Blah` to implement `OkWrap<Blah>`
-  = note: this error originates in the attribute macro `pyo3::pyfunction` (in Nightly builds, run with -Z macro-backtrace for more info)
+note: required by a bound in `UnknownReturnType::<T>::wrap`
+ --> src/impl_/wrap.rs
+  |
+  |     pub fn wrap<'py>(&self, _: T) -> T
+  |            ---- required by a bound in this associated function
+  |     where
+  |         T: IntoPyObject<'py>,
+  |            ^^^^^^^^^^^^^^^^^ required by this bound in `UnknownReturnType::<T>::wrap`
+
+error[E0599]: no method named `map_err` found for struct `Blah` in the current scope
+ --> tests/ui/missing_intopy.rs:4:14
+  |
+1 | struct Blah;
+  | ----------- method `map_err` not found for this struct
+...
+4 | fn blah() -> Blah {
+  |              ^^^^ method not found in `Blah`
diff --git a/tests/ui/not_send.rs b/tests/ui/not_send.rs
index 6566f2d7de5..926343538aa 100644
--- a/tests/ui/not_send.rs
+++ b/tests/ui/not_send.rs
@@ -1,11 +1,11 @@
 use pyo3::prelude::*;
 
-fn test_not_send_allow_threads(py: Python<'_>) {
-    py.allow_threads(|| { drop(py); });
+fn test_not_send_detach(py: Python<'_>) {
+    py.detach(|| { drop(py); });
 }
 
 fn main() {
-    Python::with_gil(|py| {
-        test_not_send_allow_threads(py);
+    Python::attach(|py| {
+        test_not_send_detach(py);
     })
 }
diff --git a/tests/ui/not_send.stderr b/tests/ui/not_send.stderr
index 5d05b3de059..0cb4039b186 100644
--- a/tests/ui/not_send.stderr
+++ b/tests/ui/not_send.stderr
@@ -1,8 +1,8 @@
 error[E0277]: `*mut pyo3::Python<'static>` cannot be shared between threads safely
- --> tests/ui/not_send.rs:4:22
+ --> tests/ui/not_send.rs:4:15
   |
-4 |     py.allow_threads(|| { drop(py); });
-  |        ------------- ^^^^^^^^^^^^^^^^ `*mut pyo3::Python<'static>` cannot be shared between threads safely
+4 |     py.detach(|| { drop(py); });
+  |        ------ ^^^^^^^^^^^^^^^^ `*mut pyo3::Python<'static>` cannot be shared between threads safely
   |        |
   |        required by a bound introduced by this call
   |
@@ -10,36 +10,35 @@ error[E0277]: `*mut pyo3::Python<'static>` cannot be shared between threads safe
 note: required because it appears within the type `PhantomData<*mut pyo3::Python<'static>>`
  --> $RUST/core/src/marker.rs
   |
-  | pub struct PhantomData<T: ?Sized>;
+  | pub struct PhantomData<T: PointeeSized>;
   |            ^^^^^^^^^^^
-note: required because it appears within the type `impl_::not_send::NotSend`
- --> src/impl_/not_send.rs
+note: required because it appears within the type `pyo3::marker::NotSend`
+ --> src/marker.rs
   |
-  | pub(crate) struct NotSend(PhantomData<*mut Python<'static>>);
-  |                   ^^^^^^^
-  = note: required because it appears within the type `(&pyo3::gil::GILGuard, impl_::not_send::NotSend)`
-note: required because it appears within the type `PhantomData<(&pyo3::gil::GILGuard, impl_::not_send::NotSend)>`
+  | struct NotSend(PhantomData<*mut Python<'static>>);
+  |        ^^^^^^^
+note: required because it appears within the type `PhantomData<pyo3::marker::NotSend>`
  --> $RUST/core/src/marker.rs
   |
-  | pub struct PhantomData<T: ?Sized>;
+  | pub struct PhantomData<T: PointeeSized>;
   |            ^^^^^^^^^^^
 note: required because it appears within the type `pyo3::Python<'_>`
  --> src/marker.rs
   |
-  | pub struct Python<'py>(PhantomData<(&'py GILGuard, NotSend)>);
+  | pub struct Python<'py>(PhantomData<&'py AttachGuard>, PhantomData<NotSend>);
   |            ^^^^^^
   = note: required for `&pyo3::Python<'_>` to implement `Send`
 note: required because it's used within this closure
- --> tests/ui/not_send.rs:4:22
+ --> tests/ui/not_send.rs:4:15
   |
-4 |     py.allow_threads(|| { drop(py); });
-  |                      ^^
-  = note: required for `{closure@$DIR/tests/ui/not_send.rs:4:22: 4:24}` to implement `Ungil`
-note: required by a bound in `pyo3::Python::<'py>::allow_threads`
+4 |     py.detach(|| { drop(py); });
+  |               ^^
+  = note: required for `{closure@$DIR/tests/ui/not_send.rs:4:15: 4:17}` to implement `Ungil`
+note: required by a bound in `pyo3::Python::<'py>::detach`
  --> src/marker.rs
   |
-  |     pub fn allow_threads<T, F>(self, f: F) -> T
-  |            ------------- required by a bound in this associated function
+  |     pub fn detach<T, F>(self, f: F) -> T
+  |            ------ required by a bound in this associated function
   |     where
   |         F: Ungil + FnOnce() -> T,
-  |            ^^^^^ required by this bound in `Python::<'py>::allow_threads`
+  |            ^^^^^ required by this bound in `Python::<'py>::detach`
diff --git a/tests/ui/not_send2.rs b/tests/ui/not_send2.rs
index fa99e602ba0..78c73d5e9c8 100644
--- a/tests/ui/not_send2.rs
+++ b/tests/ui/not_send2.rs
@@ -2,10 +2,10 @@ use pyo3::prelude::*;
 use pyo3::types::PyString;
 
 fn main() {
-    Python::with_gil(|py| {
-        let string = PyString::new_bound(py, "foo");
+    Python::attach(|py| {
+        let string = PyString::new(py, "foo");
 
-        py.allow_threads(|| {
+        py.detach(|| {
             println!("{:?}", string);
         });
     });
diff --git a/tests/ui/not_send2.stderr b/tests/ui/not_send2.stderr
index eec2b644e9a..3d76b5ebc11 100644
--- a/tests/ui/not_send2.stderr
+++ b/tests/ui/not_send2.stderr
@@ -1,11 +1,11 @@
 error[E0277]: `*mut pyo3::Python<'static>` cannot be shared between threads safely
-  --> tests/ui/not_send2.rs:8:26
+  --> tests/ui/not_send2.rs:8:19
    |
-8  |           py.allow_threads(|| {
-   |  ____________-------------_^
+ 8 |           py.detach(|| {
+   |  ____________------_^
    | |            |
    | |            required by a bound introduced by this call
-9  | |             println!("{:?}", string);
+ 9 | |             println!("{:?}", string);
 10 | |         });
    | |_________^ `*mut pyo3::Python<'static>` cannot be shared between threads safely
    |
@@ -13,23 +13,22 @@ error[E0277]: `*mut pyo3::Python<'static>` cannot be shared between threads safe
 note: required because it appears within the type `PhantomData<*mut pyo3::Python<'static>>`
   --> $RUST/core/src/marker.rs
    |
-   | pub struct PhantomData<T: ?Sized>;
+   | pub struct PhantomData<T: PointeeSized>;
    |            ^^^^^^^^^^^
-note: required because it appears within the type `impl_::not_send::NotSend`
-  --> src/impl_/not_send.rs
+note: required because it appears within the type `pyo3::marker::NotSend`
+  --> src/marker.rs
    |
-   | pub(crate) struct NotSend(PhantomData<*mut Python<'static>>);
-   |                   ^^^^^^^
-   = note: required because it appears within the type `(&pyo3::gil::GILGuard, impl_::not_send::NotSend)`
-note: required because it appears within the type `PhantomData<(&pyo3::gil::GILGuard, impl_::not_send::NotSend)>`
+   | struct NotSend(PhantomData<*mut Python<'static>>);
+   |        ^^^^^^^
+note: required because it appears within the type `PhantomData<pyo3::marker::NotSend>`
   --> $RUST/core/src/marker.rs
    |
-   | pub struct PhantomData<T: ?Sized>;
+   | pub struct PhantomData<T: PointeeSized>;
    |            ^^^^^^^^^^^
 note: required because it appears within the type `pyo3::Python<'_>`
   --> src/marker.rs
    |
-   | pub struct Python<'py>(PhantomData<(&'py GILGuard, NotSend)>);
+   | pub struct Python<'py>(PhantomData<&'py AttachGuard>, PhantomData<NotSend>);
    |            ^^^^^^
 note: required because it appears within the type `pyo3::Bound<'_, PyString>`
   --> src/instance.rs
@@ -38,16 +37,16 @@ note: required because it appears within the type `pyo3::Bound<'_, PyString>`
    |            ^^^^^
    = note: required for `&pyo3::Bound<'_, PyString>` to implement `Send`
 note: required because it's used within this closure
-  --> tests/ui/not_send2.rs:8:26
+  --> tests/ui/not_send2.rs:8:19
    |
-8  |         py.allow_threads(|| {
-   |                          ^^
-   = note: required for `{closure@$DIR/tests/ui/not_send2.rs:8:26: 8:28}` to implement `Ungil`
-note: required by a bound in `pyo3::Python::<'py>::allow_threads`
+ 8 |         py.detach(|| {
+   |                   ^^
+   = note: required for `{closure@$DIR/tests/ui/not_send2.rs:8:19: 8:21}` to implement `Ungil`
+note: required by a bound in `pyo3::Python::<'py>::detach`
   --> src/marker.rs
    |
-   |     pub fn allow_threads<T, F>(self, f: F) -> T
-   |            ------------- required by a bound in this associated function
+   |     pub fn detach<T, F>(self, f: F) -> T
+   |            ------ required by a bound in this associated function
    |     where
    |         F: Ungil + FnOnce() -> T,
-   |            ^^^^^ required by this bound in `Python::<'py>::allow_threads`
+   |            ^^^^^ required by this bound in `Python::<'py>::detach`
diff --git a/tests/ui/pyclass_generic_enum.rs b/tests/ui/pyclass_generic_enum.rs
new file mode 100644
index 00000000000..94fd779b2d4
--- /dev/null
+++ b/tests/ui/pyclass_generic_enum.rs
@@ -0,0 +1,15 @@
+use pyo3::prelude::*;
+
+#[pyclass(generic)]
+enum NotGenericForEnum {
+    A,
+    B,
+}
+
+#[pyclass(generic)]
+enum NoGenericForComplexEnum {
+    A { x: f64 },
+    B { y: f64, z: f64 },
+}
+
+fn main() {}
diff --git a/tests/ui/pyclass_generic_enum.stderr b/tests/ui/pyclass_generic_enum.stderr
new file mode 100644
index 00000000000..cfc1e178af3
--- /dev/null
+++ b/tests/ui/pyclass_generic_enum.stderr
@@ -0,0 +1,11 @@
+error: enums do not support #[pyclass(generic)]
+ --> tests/ui/pyclass_generic_enum.rs:3:11
+  |
+3 | #[pyclass(generic)]
+  |           ^^^^^^^
+
+error: enums do not support #[pyclass(generic)]
+ --> tests/ui/pyclass_generic_enum.rs:9:11
+  |
+9 | #[pyclass(generic)]
+  |           ^^^^^^^
diff --git a/tests/ui/pyclass_probe.rs b/tests/ui/pyclass_probe.rs
new file mode 100644
index 00000000000..89b265cddf4
--- /dev/null
+++ b/tests/ui/pyclass_probe.rs
@@ -0,0 +1,37 @@
+#![deny(unused_imports)]
+use pyo3::prelude::*;
+
+#[pyclass]
+pub struct Probe {}
+
+#[pymethods]
+impl Probe {
+    #[new]
+    fn new() -> Self {
+        Self {}
+    }
+}
+
+#[pymodule]
+fn probe(_py: Python<'_>, m: &Bound<'_, PyModule>) -> PyResult<()> {
+    m.add_class::<Probe>()?;
+    Ok(())
+}
+
+#[pyclass]
+struct Check5029();
+
+macro_rules! impl_methods {
+    ($name:ident) => {
+        #[pymethods]
+        impl Check5029 {
+            fn $name(&self, _value: Option<&str>) -> PyResult<()> {
+                Ok(())
+            }
+        }
+    };
+}
+
+impl_methods!(some_method);
+
+fn main() {}
diff --git a/tests/ui/pyclass_send.rs b/tests/ui/pyclass_send.rs
index 533302740d7..1a764f621f0 100644
--- a/tests/ui/pyclass_send.rs
+++ b/tests/ui/pyclass_send.rs
@@ -1,26 +1,28 @@
 use pyo3::prelude::*;
-use std::rc::Rc;
+use std::ffi::c_void;
 
 #[pyclass]
-struct NotThreadSafe {
-    data: Rc<i32>,
-}
-
-fn main() {
-    let obj = Python::with_gil(|py| {
-        PyCell::new(py, NotThreadSafe { data: Rc::new(5) })
-            .unwrap()
-            .to_object(py)
-    });
-
-    std::thread::spawn(move || {
-        Python::with_gil(|py| {
-            // Uh oh, moved Rc to a new thread!
-            let c: &PyCell<NotThreadSafe> = obj.as_ref(py).downcast().unwrap();
-
-            assert_eq!(*c.borrow().data, 5);
-        })
-    })
-    .join()
-    .unwrap();
-}
+struct NotSyncNotSend(*mut c_void);
+
+#[pyclass]
+struct SendNotSync(*mut c_void);
+unsafe impl Send for SendNotSync {}
+
+#[pyclass]
+struct SyncNotSend(*mut c_void);
+unsafe impl Sync for SyncNotSend {}
+
+// None of the `unsendable` forms below should fail to compile
+
+#[pyclass(unsendable)]
+struct NotSyncNotSendUnsendable(*mut c_void);
+
+#[pyclass(unsendable)]
+struct SendNotSyncUnsendable(*mut c_void);
+unsafe impl Send for SendNotSyncUnsendable {}
+
+#[pyclass(unsendable)]
+struct SyncNotSendUnsendable(*mut c_void);
+unsafe impl Sync for SyncNotSendUnsendable {}
+
+fn main() {}
diff --git a/tests/ui/pyclass_send.stderr b/tests/ui/pyclass_send.stderr
index 7a80989b63f..334c36daa13 100644
--- a/tests/ui/pyclass_send.stderr
+++ b/tests/ui/pyclass_send.stderr
@@ -1,39 +1,121 @@
-error[E0277]: `Rc<i32>` cannot be sent between threads safely
+error[E0277]: `*mut c_void` cannot be sent between threads safely
  --> tests/ui/pyclass_send.rs:4:1
   |
 4 | #[pyclass]
-  | ^^^^^^^^^^ `Rc<i32>` cannot be sent between threads safely
+  | ^^^^^^^^^^ `*mut c_void` cannot be sent between threads safely
   |
-  = help: within `NotThreadSafe`, the trait `Send` is not implemented for `Rc<i32>`
-note: required because it appears within the type `NotThreadSafe`
+  = help: within `NotSyncNotSend`, the trait `Send` is not implemented for `*mut c_void`
+  = help: the trait `pyo3::impl_::pyclass::PyClassThreadChecker<T>` is implemented for `SendablePyClass<T>`
+note: required because it appears within the type `NotSyncNotSend`
  --> tests/ui/pyclass_send.rs:5:8
   |
-5 | struct NotThreadSafe {
-  |        ^^^^^^^^^^^^^
-note: required by a bound in `SendablePyClass`
+5 | struct NotSyncNotSend(*mut c_void);
+  |        ^^^^^^^^^^^^^^
+  = note: required for `SendablePyClass<NotSyncNotSend>` to implement `pyo3::impl_::pyclass::PyClassThreadChecker<NotSyncNotSend>`
+note: required by a bound in `PyClassImpl::ThreadChecker`
  --> src/impl_/pyclass.rs
   |
-  | pub struct SendablePyClass<T: Send>(PhantomData<T>);
-  |                               ^^^^ required by this bound in `SendablePyClass`
+  |     type ThreadChecker: PyClassThreadChecker<Self>;
+  |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `PyClassImpl::ThreadChecker`
   = note: this error originates in the attribute macro `pyclass` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error[E0277]: `Rc<i32>` cannot be sent between threads safely
+error[E0277]: `*mut c_void` cannot be sent between threads safely
+  --> tests/ui/pyclass_send.rs:11:1
+   |
+11 | #[pyclass]
+   | ^^^^^^^^^^ `*mut c_void` cannot be sent between threads safely
+   |
+   = help: within `SyncNotSend`, the trait `Send` is not implemented for `*mut c_void`
+   = help: the trait `pyo3::impl_::pyclass::PyClassThreadChecker<T>` is implemented for `SendablePyClass<T>`
+note: required because it appears within the type `SyncNotSend`
+  --> tests/ui/pyclass_send.rs:12:8
+   |
+12 | struct SyncNotSend(*mut c_void);
+   |        ^^^^^^^^^^^
+   = note: required for `SendablePyClass<SyncNotSend>` to implement `pyo3::impl_::pyclass::PyClassThreadChecker<SyncNotSend>`
+note: required by a bound in `PyClassImpl::ThreadChecker`
+  --> src/impl_/pyclass.rs
+   |
+   |     type ThreadChecker: PyClassThreadChecker<Self>;
+   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `PyClassImpl::ThreadChecker`
+   = note: this error originates in the attribute macro `pyclass` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0277]: `*mut c_void` cannot be sent between threads safely
  --> tests/ui/pyclass_send.rs:4:1
   |
 4 | #[pyclass]
-  | ^^^^^^^^^^ `Rc<i32>` cannot be sent between threads safely
+  | ^^^^^^^^^^ `*mut c_void` cannot be sent between threads safely
   |
-  = help: within `NotThreadSafe`, the trait `Send` is not implemented for `Rc<i32>`
-  = help: the trait `pyo3::impl_::pyclass::PyClassThreadChecker<T>` is implemented for `SendablePyClass<T>`
-note: required because it appears within the type `NotThreadSafe`
+  = help: within `NotSyncNotSend`, the trait `Send` is not implemented for `*mut c_void`
+note: required because it appears within the type `NotSyncNotSend`
  --> tests/ui/pyclass_send.rs:5:8
   |
-5 | struct NotThreadSafe {
-  |        ^^^^^^^^^^^^^
-  = note: required for `SendablePyClass<NotThreadSafe>` to implement `pyo3::impl_::pyclass::PyClassThreadChecker<NotThreadSafe>`
-note: required by a bound in `PyClassImpl::ThreadChecker`
+5 | struct NotSyncNotSend(*mut c_void);
+  |        ^^^^^^^^^^^^^^
+note: required by a bound in `SendablePyClass`
  --> src/impl_/pyclass.rs
   |
-  |     type ThreadChecker: PyClassThreadChecker<Self>;
-  |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `PyClassImpl::ThreadChecker`
+  | pub struct SendablePyClass<T: Send>(PhantomData<T>);
+  |                               ^^^^ required by this bound in `SendablePyClass`
   = note: this error originates in the attribute macro `pyclass` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0277]: `*mut c_void` cannot be sent between threads safely
+  --> tests/ui/pyclass_send.rs:11:1
+   |
+11 | #[pyclass]
+   | ^^^^^^^^^^ `*mut c_void` cannot be sent between threads safely
+   |
+   = help: within `SyncNotSend`, the trait `Send` is not implemented for `*mut c_void`
+note: required because it appears within the type `SyncNotSend`
+  --> tests/ui/pyclass_send.rs:12:8
+   |
+12 | struct SyncNotSend(*mut c_void);
+   |        ^^^^^^^^^^^
+note: required by a bound in `SendablePyClass`
+  --> src/impl_/pyclass.rs
+   |
+   | pub struct SendablePyClass<T: Send>(PhantomData<T>);
+   |                               ^^^^ required by this bound in `SendablePyClass`
+   = note: this error originates in the attribute macro `pyclass` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0277]: `*mut c_void` cannot be shared between threads safely
+ --> tests/ui/pyclass_send.rs:5:8
+  |
+5 | struct NotSyncNotSend(*mut c_void);
+  |        ^^^^^^^^^^^^^^ `*mut c_void` cannot be shared between threads safely
+  |
+  = help: within `NotSyncNotSend`, the trait `Sync` is not implemented for `*mut c_void`
+note: required because it appears within the type `NotSyncNotSend`
+ --> tests/ui/pyclass_send.rs:5:8
+  |
+5 | struct NotSyncNotSend(*mut c_void);
+  |        ^^^^^^^^^^^^^^
+note: required by a bound in `assert_pyclass_sync`
+ --> src/impl_/pyclass/assertions.rs
+  |
+  | pub const fn assert_pyclass_sync<T>()
+  |              ------------------- required by a bound in this function
+  | where
+  |     T: PyClassSync + Sync,
+  |                      ^^^^ required by this bound in `assert_pyclass_sync`
+
+error[E0277]: `*mut c_void` cannot be shared between threads safely
+ --> tests/ui/pyclass_send.rs:8:8
+  |
+8 | struct SendNotSync(*mut c_void);
+  |        ^^^^^^^^^^^ `*mut c_void` cannot be shared between threads safely
+  |
+  = help: within `SendNotSync`, the trait `Sync` is not implemented for `*mut c_void`
+note: required because it appears within the type `SendNotSync`
+ --> tests/ui/pyclass_send.rs:8:8
+  |
+8 | struct SendNotSync(*mut c_void);
+  |        ^^^^^^^^^^^
+note: required by a bound in `assert_pyclass_sync`
+ --> src/impl_/pyclass/assertions.rs
+  |
+  | pub const fn assert_pyclass_sync<T>()
+  |              ------------------- required by a bound in this function
+  | where
+  |     T: PyClassSync + Sync,
+  |                      ^^^^ required by this bound in `assert_pyclass_sync`
diff --git a/tests/ui/pymodule_missing_docs.rs b/tests/ui/pymodule_missing_docs.rs
new file mode 100644
index 00000000000..d8bf2eb4d2f
--- /dev/null
+++ b/tests/ui/pymodule_missing_docs.rs
@@ -0,0 +1,16 @@
+#![deny(missing_docs)]
+//! Some crate docs
+
+use pyo3::prelude::*;
+
+/// Some module documentation
+#[pymodule]
+pub fn python_module(_m: &Bound<'_, PyModule>) -> PyResult<()> {
+    Ok(())
+}
+
+/// Some module documentation
+#[pymodule]
+pub mod declarative_python_module {}
+
+fn main() {}
diff --git a/tests/ui/reject_generics.stderr b/tests/ui/reject_generics.stderr
index 2285b9271fa..159d1407f27 100644
--- a/tests/ui/reject_generics.stderr
+++ b/tests/ui/reject_generics.stderr
@@ -1,10 +1,10 @@
-error: #[pyclass] cannot have generic parameters. For an explanation, see https://pyo3.rs/latest/class.html#no-generic-parameters
+error: #[pyclass] cannot have generic parameters. For an explanation, see https://pyo3.rs/v0.27.0/class.html#no-generic-parameters
  --> tests/ui/reject_generics.rs:4:25
   |
 4 | struct ClassWithGenerics<A> {
   |                         ^
 
-error: #[pyclass] cannot have lifetime parameters. For an explanation, see https://pyo3.rs/latest/class.html#no-lifetime-parameters
+error: #[pyclass] cannot have lifetime parameters. For an explanation, see https://pyo3.rs/v0.27.0/class.html#no-lifetime-parameters
  --> tests/ui/reject_generics.rs:9:27
   |
 9 | struct ClassWithLifetimes<'a> {
diff --git a/tests/ui/static_ref.rs b/tests/ui/static_ref.rs
index a426536d499..e8015db2f64 100644
--- a/tests/ui/static_ref.rs
+++ b/tests/ui/static_ref.rs
@@ -2,7 +2,12 @@ use pyo3::prelude::*;
 use pyo3::types::PyList;
 
 #[pyfunction]
-fn static_ref(list: &'static PyList) -> usize {
+fn static_ref(list: &'static Bound<'_, PyList>) -> usize {
+    list.len()
+}
+
+#[pyfunction]
+fn static_py(list: &Bound<'static, PyList>) -> usize {
     list.len()
 }
 
diff --git a/tests/ui/static_ref.stderr b/tests/ui/static_ref.stderr
index 2dd3342e5ba..d32b7508c4b 100644
--- a/tests/ui/static_ref.stderr
+++ b/tests/ui/static_ref.stderr
@@ -1,10 +1,37 @@
-error: lifetime may not live long enough
+error[E0521]: borrowed data escapes outside of function
  --> tests/ui/static_ref.rs:4:1
   |
 4 | #[pyfunction]
   | ^^^^^^^^^^^^^
   | |
+  | `py` is a reference that is only valid in the function body
+  | `py` escapes the function body here
   | lifetime `'py` defined here
-  | cast requires that `'py` must outlive `'static`
+  | argument requires that `'py` must outlive `'static`
+  |
+  = note: this error originates in the attribute macro `pyfunction` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0716]: temporary value dropped while borrowed
+ --> tests/ui/static_ref.rs:4:1
+  |
+4 | #[pyfunction]
+  | ^^^^^^^^^^^^-
+  | |           |
+  | |           temporary value is freed at the end of this statement
+  | creates a temporary value which is freed while still in use
+  | argument requires that borrow lasts for `'static`
+  |
+  = note: this error originates in the attribute macro `pyfunction` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0521]: borrowed data escapes outside of function
+ --> tests/ui/static_ref.rs:9:1
+  |
+9 | #[pyfunction]
+  | ^^^^^^^^^^^^^
+  | |
+  | `py` is a reference that is only valid in the function body
+  | `py` escapes the function body here
+  | lifetime `'py` defined here
+  | argument requires that `'py` must outlive `'static`
   |
   = note: this error originates in the attribute macro `pyfunction` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/tests/ui/traverse.rs b/tests/ui/traverse.rs
index 034224951c9..faa7b5c041d 100644
--- a/tests/ui/traverse.rs
+++ b/tests/ui/traverse.rs
@@ -1,27 +1,67 @@
 use pyo3::prelude::*;
-use pyo3::PyVisit;
 use pyo3::PyTraverseError;
+use pyo3::PyVisit;
 
 #[pyclass]
 struct TraverseTriesToTakePyRef {}
 
 #[pymethods]
 impl TraverseTriesToTakePyRef {
-    fn __traverse__(slf: PyRef<Self>, visit: PyVisit) {}
+    fn __traverse__(_slf: PyRef<Self>, _visit: PyVisit) -> Result<(), PyTraverseError> {
+        Ok(())
+    }
 }
 
 #[pyclass]
-struct Class;
+struct TraverseTriesToTakePyRefMut {}
 
 #[pymethods]
-impl Class {
-    fn __traverse__(&self, py: Python<'_>, visit: PyVisit<'_>) -> Result<(), PyTraverseError> {
+impl TraverseTriesToTakePyRefMut {
+    fn __traverse__(_slf: PyRefMut<Self>, _visit: PyVisit) -> Result<(), PyTraverseError> {
+        Ok(())
+    }
+}
+
+#[pyclass]
+struct TraverseTriesToTakeBound {}
+
+#[pymethods]
+impl TraverseTriesToTakeBound {
+    fn __traverse__(_slf: Bound<'_, Self>, _visit: PyVisit) -> Result<(), PyTraverseError> {
+        Ok(())
+    }
+}
+
+#[pyclass]
+struct TraverseTriesToTakeMutSelf {}
+
+#[pymethods]
+impl TraverseTriesToTakeMutSelf {
+    fn __traverse__(&mut self, _visit: PyVisit) -> Result<(), PyTraverseError> {
         Ok(())
     }
+}
 
-    fn __clear__(&mut self) {
+#[pyclass]
+struct TraverseTriesToTakeSelf {}
+
+#[pymethods]
+impl TraverseTriesToTakeSelf {
+    fn __traverse__(&self, _visit: PyVisit) -> Result<(), PyTraverseError> {
+        Ok(())
     }
 }
 
+#[pyclass]
+struct Class;
+
+#[pymethods]
+impl Class {
+    fn __traverse__(&self, _py: Python<'_>, _visit: PyVisit<'_>) -> Result<(), PyTraverseError> {
+        Ok(())
+    }
+
+    fn __clear__(&mut self) {}
+}
 
 fn main() {}
diff --git a/tests/ui/traverse.stderr b/tests/ui/traverse.stderr
index 4448e67e13a..343a67f5641 100644
--- a/tests/ui/traverse.stderr
+++ b/tests/ui/traverse.stderr
@@ -1,23 +1,29 @@
-error: __traverse__ may not take `Python`. Usually, an implementation of `__traverse__` should do nothing but calls to `visit.call`. Most importantly, safe access to the GIL is prohibited inside implementations of `__traverse__`, i.e. `Python::with_gil` will panic.
-  --> tests/ui/traverse.rs:18:32
+error: __traverse__ may not take a receiver other than `&self`. Usually, an implementation of `__traverse__(&self, visit: PyVisit<'_>) -> Result<(), PyTraverseError>` should do nothing but calls to `visit.call`. Most importantly, safe access to the Python interpreter is prohibited inside implementations of `__traverse__`, i.e. `Python::attach` will panic.
+  --> tests/ui/traverse.rs:10:27
    |
-18 |     fn __traverse__(&self, py: Python<'_>, visit: PyVisit<'_>) -> Result<(), PyTraverseError> {
-   |                                ^^^^^^^^^^
+10 |     fn __traverse__(_slf: PyRef<Self>, _visit: PyVisit) -> Result<(), PyTraverseError> {
+   |                           ^^^^^
 
-error[E0308]: mismatched types
-  --> tests/ui/traverse.rs:9:6
+error: __traverse__ may not take a receiver other than `&self`. Usually, an implementation of `__traverse__(&self, visit: PyVisit<'_>) -> Result<(), PyTraverseError>` should do nothing but calls to `visit.call`. Most importantly, safe access to the Python interpreter is prohibited inside implementations of `__traverse__`, i.e. `Python::attach` will panic.
+  --> tests/ui/traverse.rs:20:27
    |
-8  |   #[pymethods]
-   |   ------------ arguments to this function are incorrect
-9  |   impl TraverseTriesToTakePyRef {
-   |  ______^
-10 | |     fn __traverse__(slf: PyRef<Self>, visit: PyVisit) {}
-   | |___________________^ expected fn pointer, found fn item
+20 |     fn __traverse__(_slf: PyRefMut<Self>, _visit: PyVisit) -> Result<(), PyTraverseError> {
+   |                           ^^^^^^^^
+
+error: __traverse__ may not take a receiver other than `&self`. Usually, an implementation of `__traverse__(&self, visit: PyVisit<'_>) -> Result<(), PyTraverseError>` should do nothing but calls to `visit.call`. Most importantly, safe access to the Python interpreter is prohibited inside implementations of `__traverse__`, i.e. `Python::attach` will panic.
+  --> tests/ui/traverse.rs:30:27
+   |
+30 |     fn __traverse__(_slf: Bound<'_, Self>, _visit: PyVisit) -> Result<(), PyTraverseError> {
+   |                           ^^^^^
+
+error: __traverse__ may not take a receiver other than `&self`. Usually, an implementation of `__traverse__(&self, visit: PyVisit<'_>) -> Result<(), PyTraverseError>` should do nothing but calls to `visit.call`. Most importantly, safe access to the Python interpreter is prohibited inside implementations of `__traverse__`, i.e. `Python::attach` will panic.
+  --> tests/ui/traverse.rs:40:21
    |
-   = note: expected fn pointer `for<'a, 'b> fn(&'a TraverseTriesToTakePyRef, PyVisit<'b>) -> Result<(), PyTraverseError>`
-                 found fn item `for<'a, 'b> fn(pyo3::PyRef<'a, TraverseTriesToTakePyRef, >, PyVisit<'b>) {TraverseTriesToTakePyRef::__traverse__}`
-note: function defined here
-  --> src/impl_/pymethods.rs
+40 |     fn __traverse__(&mut self, _visit: PyVisit) -> Result<(), PyTraverseError> {
+   |                     ^
+
+error: __traverse__ may not take `Python`. Usually, an implementation of `__traverse__(&self, visit: PyVisit<'_>) -> Result<(), PyTraverseError>` should do nothing but calls to `visit.call`. Most importantly, safe access to the Python interpreter is prohibited inside implementations of `__traverse__`, i.e. `Python::attach` will panic.
+  --> tests/ui/traverse.rs:60:33
    |
-   | pub unsafe fn _call_traverse<T>(
-   |               ^^^^^^^^^^^^^^
+60 |     fn __traverse__(&self, _py: Python<'_>, _visit: PyVisit<'_>) -> Result<(), PyTraverseError> {
+   |                                 ^^^^^^^^^^
diff --git a/tests/ui/wrong_aspyref_lifetimes.rs b/tests/ui/wrong_aspyref_lifetimes.rs
index 755b0cf2a2c..b5f050ebcf9 100644
--- a/tests/ui/wrong_aspyref_lifetimes.rs
+++ b/tests/ui/wrong_aspyref_lifetimes.rs
@@ -1,10 +1,10 @@
 use pyo3::{types::PyDict, Bound, Py, Python};
 
 fn main() {
-    let dict: Py<PyDict> = Python::with_gil(|py| PyDict::new_bound(py).unbind());
+    let dict: Py<PyDict> = Python::attach(|py| PyDict::new(py).unbind());
 
-    // Should not be able to get access to Py contents outside of with_gil.
-    let dict: &Bound<'_, PyDict> = Python::with_gil(|py| dict.bind(py));
+    // Should not be able to get access to Py contents outside of `attach`.
+    let dict: &Bound<'_, PyDict> = Python::attach(|py| dict.bind(py));
 
     let _py: Python = dict.py(); // Obtain a Python<'p> without GIL.
 }
diff --git a/tests/ui/wrong_aspyref_lifetimes.stderr b/tests/ui/wrong_aspyref_lifetimes.stderr
index 30e63bb8261..8a9cc553349 100644
--- a/tests/ui/wrong_aspyref_lifetimes.stderr
+++ b/tests/ui/wrong_aspyref_lifetimes.stderr
@@ -1,8 +1,8 @@
 error: lifetime may not live long enough
- --> tests/ui/wrong_aspyref_lifetimes.rs:7:58
+ --> tests/ui/wrong_aspyref_lifetimes.rs:7:56
   |
-7 |     let dict: &Bound<'_, PyDict> = Python::with_gil(|py| dict.bind(py));
-  |                                                      --- ^^^^^^^^^^^^^ returning this value requires that `'1` must outlive `'2`
-  |                                                      | |
-  |                                                      | return type of closure is &'2 pyo3::Bound<'_, PyDict>
-  |                                                      has type `pyo3::Python<'1>`
+7 |     let dict: &Bound<'_, PyDict> = Python::attach(|py| dict.bind(py));
+  |                                                    --- ^^^^^^^^^^^^^ returning this value requires that `'1` must outlive `'2`
+  |                                                    | |
+  |                                                    | return type of closure is &'2 pyo3::Bound<'_, PyDict>
+  |                                                    has type `Python<'1>`